TAO/TAO_IDL/fe/fe_home_header.cpp

   1 #include "fe_home_header.h"
   2
   3 #include "global_extern.h"
   4 #include "utl_err.h"
   5 #include "fe_extern.h"
   6
   7 #include "ast_home.h"
   8 #include "ast_component.h"
   9 #include "ast_valuetype.h"
  10 #include "ast_param_holder.h"
  11
  12 FE_HomeHeader::FE_HomeHeader (UTL_ScopedName *n,
  13                               UTL_ScopedName *base_home,
  14                               UTL_NameList *supports,
  15                               UTL_ScopedName *managed_component,
  16                               UTL_ScopedName *primary_key)
  17   : FE_ComponentHeader (n,
  18                         0,
  19                         supports,
  20                         false),
  21     base_home_ (0),
  22     primary_key_ (0)
  23 {
  24   // No need to call compile_supports(), it got done in
  25   // the call to the base class FE_ComponentHeader.
  26   this->compile_inheritance (base_home);
  27   this->compile_managed_component (managed_component);
  28   this->compile_primary_key (primary_key);
  29 }
  30
  31 FE_HomeHeader::~FE_HomeHeader (void)
  32 {
  33 }
  34
  35 AST_Home *
  36 FE_HomeHeader::base_home (void) const
  37 {
  38   return this->base_home_;
  39 }
  40
  41 AST_Component *
  42 FE_HomeHeader::managed_component (void) const
  43 {
  44   return this->managed_component_;
  45 }
  46
  47 AST_Type *
  48 FE_HomeHeader::primary_key (void) const
  49 {
  50   return this->primary_key_;
  51 }
  52
  53 void
  54 FE_HomeHeader::compile_inheritance (UTL_ScopedName *base_home)
  55 {
  56   if (base_home == 0)
  57     {
  58       return;
  59     }
  60
  61   UTL_Scope *s = idl_global->scopes ().top_non_null ();
  62   AST_Decl *d = s->lookup_by_name (base_home,
  63                                    true);
  64
  65   if (d == 0)
  66     {
  67       idl_global->err ()->lookup_error (base_home);
  68
  69       // This is probably the result of bad IDL.
  70       // We will crash if we continue from here.
  71       throw Bailout ();
  72     }
  73
  74   if (d->node_type () == AST_Decl::NT_typedef)
  75     {
  76       d = dynamic_cast<AST_Typedef*> (d)->primitive_base_type ();
  77     }
  78
  79   this->base_home_ = dynamic_cast<AST_Home*> (d);
  80
  81   if (this->base_home_ == 0)
  82     {
  83       idl_global->err ()->inheritance_error (this->name (), d);
  84     }
  85 }
  86
  87 void
  88 FE_HomeHeader::compile_managed_component (
  89   UTL_ScopedName *mc_name)
  90 {
  91   if (mc_name == 0)
  92     {
  93       return;
  94     }
  95
  96   UTL_Scope *s = idl_global->scopes ().top_non_null ();
  97   AST_Decl *d = s->lookup_by_name (mc_name,
  98                                    true);
  99
 100   if (d == 0)
 101     {
 102       idl_global->err ()->lookup_error (mc_name);
 103
 104       // This is probably the result of bad IDL.
 105       // We will crash if we continue from here.
 106       throw Bailout ();
 107     }
 108
 109   if (d->node_type () == AST_Decl::NT_typedef)
 110     {
 111       d = dynamic_cast<AST_Typedef*> (d)->primitive_base_type ();
 112     }
 113
 114   this->managed_component_ = dynamic_cast<AST_Component*> (d);
 115
 116   if (this->managed_component_ == 0)
 117     {
 118       idl_global->err ()->error1 (UTL_Error::EIDL_ILLEGAL_USE,
 119                                   d);
 120     }
 121 }
 122
 123 void
 124 FE_HomeHeader::compile_primary_key (UTL_ScopedName *primary_key)
 125 {
 126   if (primary_key == 0)
 127     {
 128       return;
 129     }
 130
 131   UTL_Scope *s = idl_global->scopes ().top_non_null ();
 132   AST_Decl *d = s->lookup_by_name (primary_key,
 133                                    true);
 134
 135   if (d == 0)
 136     {
 137       idl_global->err ()->lookup_error (primary_key);
 138
 139       // This is probably the result of bad IDL.
 140       // We will crash if we continue from here.
 141       throw Bailout ();
 142     }
 143
 144   AST_Decl::NodeType nt = d->node_type ();
 145
 146   if (nt == AST_Decl::NT_typedef)
 147     {
 148       d = dynamic_cast<AST_Typedef*> (d)->primitive_base_type ();
 149     }
 150
 151   this->primary_key_ = dynamic_cast<AST_Type*> (d);
 152
 153   if (this->primary_key_ == 0)
 154     {
 155       idl_global->err ()->valuetype_expected (d);
 156     }
 157   else
 158     {
 159       switch (nt)
 160         {
 161           case AST_Decl::NT_valuetype:
 162             break;
 163           case AST_Decl::NT_param_holder:
 164             {
 165               AST_Param_Holder *ph =
 166                 dynamic_cast<AST_Param_Holder*> (d);
 167
 168               nt = ph->info ()->type_;
 169
 170               if (nt != AST_Decl::NT_type
 171                   && nt != AST_Decl::NT_valuetype)
 172                 {
 173                   idl_global->err ()->mismatched_template_param (
 174                     ph->info ()->name_.c_str ());
 175                 }
 176
 177               break;
 178             }
 179           default:
 180             idl_global->err ()->valuetype_expected (d);
 181             break;
 182         };
 183     }
 184 }
 185