自学教程：C++ AST_Decl类代码示例

void be_exception::GenerateAssignmentOperator (be_ClientImplementation& source){   ostream & os = source.Stream ();   DDS_StdString that ("");   be_Type * btype;   if (nmembers ())   {      that = " that";   }   os << ScopedName () << " & "      << ScopedName () << "::operator = (const "      << LocalName () << " &" << that << ")" << nl;   os << "{" << nl;   UTL_Scope * s = (UTL_Scope*)narrow((long) & UTL_Scope::type_id);   assert (s);   UTL_ScopeActiveIterator *it;   // Iterate through decls   for    (      it = new UTL_ScopeActiveIterator (s, UTL_Scope::IK_decls);      ! it->is_done ();      it->next ()   )   {      AST_Decl * adecl = it->item ();      assert (adecl);      be_field *bfield = (be_field *) adecl->narrow ((long) & be_field::type_id);      if (bfield)      {         btype = bfield->get_be_type ();         if (btype && btype->IsArrayType ())         {            // Need to copy array elements            os << "   "               << (char*) BE_Globals::RelativeScope (ScopedName (), bfield->StructMemberTypeName ())               << "_copy (" << bfield->get_local_name ()                << ", that." << bfield->get_local_name () << ");" << nl;         }         else         {            os << "   " << bfield->get_local_name () << " = that."               << bfield->get_local_name() << ";" << nl;         }      }   }   delete it;   os << "   return *this;" << nl;   os << "}" << nl << nl;}

voidbe_enum::FinishProtoTypeCode(){   // flesh out typecode   // since enums names are all in a scope and not added directly   // we go through the scope and add them all here   UTL_Scope* s = (UTL_Scope*)narrow((long) & UTL_Scope::type_id);   assert(s);   UTL_ScopeActiveIterator* i = 0;   i = new UTL_ScopeActiveIterator(s, UTL_Scope::IK_decls);   if (s->nmembers() > 0)   {      for ( ; !(i->is_done()); i->next())      {         AST_Decl* d = i->item();         assert(d);         m_typecode->member_names.push_back(d->local_name()->get_string());      }      delete i;   }}

intbe_visitor_executor_exh::visit_provides (be_provides *node){  ACE_CString prefix (this->ctx_->port_prefix ());  prefix += node->local_name ()->get_string ();  const char *port_name = prefix.c_str ();  be_type *impl = node->provides_type ();  AST_Decl *scope = ScopeAsDecl (impl->defined_in ());  ACE_CString sname_str (scope->full_name ());  const char *sname = sname_str.c_str ();  // No '_cxx_' prefix.  const char *lname =    impl->original_local_name ()->get_string ();  const char *global = (sname_str == "" ? "" : "::");  os_ << be_nl_2      << "/// Factory method and getter for " << port_name << " facet" << be_nl      << "/// @return existing instance of facet if one exists, else creates one" << be_nl      << "virtual " << global << sname << "::CCM_"      << lname << "_ptr" << be_nl      << "get_" << port_name << " (void);";  return 0;}

void be_root::GenerateGlobalDecls (be_ClientHeader & source){   UTL_ScopeActiveIterator * i;   be_CodeGenerator * cg;   AST_Decl * d;   UTL_Scope * s = (UTL_Scope*) narrow ((long) & UTL_Scope::type_id);   if (s)   {      // Iterate through decls      i = new UTL_ScopeActiveIterator (s, UTL_Scope::IK_decls);      while (!(i->is_done ()))      {         d = i->item ();         if (!d->imported ())         {            cg = (be_CodeGenerator*) d->narrow               ((long) & be_CodeGenerator::type_id);            if (cg)            {               cg->Generate (source);            }         }         i->next ();      }      delete i;   }}

voidbe_CodeGenerator::Generate(be_ClientImplementation& source){   UTL_ScopeActiveIterator* i;   AST_Decl * d;   UTL_Scope * s = (UTL_Scope*)narrow((long) & UTL_Scope::type_id);   if (s)   {      i = new UTL_ScopeActiveIterator(s, UTL_Scope::IK_decls);      while (!(i->is_done()))      {         be_CodeGenerator * cg;         d = i->item();         if (!d->imported() &&             (cg = (be_CodeGenerator*)d->narrow((long) & be_CodeGenerator::type_id)))         {            cg->Generate(source);         }         i->next();      }      delete i;   }   else   {      assert(pbfalse);   }}

// Dump this AST_Factory node to the ostream o.voidAST_Finder::dump (ACE_OSTREAM_TYPE &o){  AST_Decl *d = 0;  this->dump_i (o, "finder ");  this->local_name ()->dump (o);  this->dump_i (o, "(");  // Iterator must be explicitly advanced inside the loop.  for (UTL_ScopeActiveIterator i (this, IK_decls);       !i.is_done ();)    {      d = i.item ();      d->dump (o);      i.next ();      if (!i.is_done())        {          this->dump_i (o, ", ");        }    }  this->dump_i (o, ")");}

unsigned long be_sequence::isRecursive (){   UTL_Scope * scope = 0;   be_Type * btype = 0;   AST_Decl * adecl = (AST_Decl *)this->narrow((long) & AST_Decl::type_id);   assert(adecl);   be_Type * base = (be_Type *)base_type()->narrow((long) & be_Type::type_id);   assert(base);   unsigned long offset = 1;   for (      offset = 1;      adecl &&      (scope = adecl->defined_in()) &&      (btype = (be_Type *)scope->narrow((long) & be_Type::type_id));      ++offset   )   {      adecl = (AST_Decl *)scope->narrow((long) & AST_Decl::type_id);      if (btype->TypeCodeTypeName() == base->TypeCodeTypeName())      {         break;      }   }   if (scope && btype)   {      return offset;   }   return 0;}

intidl2jni_visitor::visit_scope(UTL_Scope *node){  if (node->nmembers() > 0) {    UTL_ScopeActiveIterator si(node, UTL_Scope::IK_decls);    AST_Decl *d = 0;    while (!si.is_done()) {      d = si.item();      if (d == 0) {        ACE_ERROR_RETURN((LM_ERROR,                          ACE_TEXT("(%N:%l) idl2jni_visitor::visit_")                          ACE_TEXT("scope - bad node in this scope/n")), -1);      }      if (d->node_type() == AST_Decl::NT_pre_defined) {        si.next();        continue;      }      if (d->ast_accept(this) == -1) {        ACE_ERROR_RETURN((LM_ERROR,                          ACE_TEXT("(%N:%l) idl2jni_visitor::visit_")                          ACE_TEXT("scope - failed to accept visitor/n")), -1);      }      si.next();    }  }  return 0;}

boolAST_illegal_interface_recursion (AST_Decl *t){  // Can't be 0 since we know we have an interface or valuetype.  AST_Decl *d = 0;  // If we encounter the argument in an enclosing scope, it's illegal.  for (UTL_ScopeStackActiveIterator i (idl_global->scopes ());       !i.is_done ();       i.next ())    {      d = ScopeAsDecl (i.item ());      // Exceptions cannot be recursive, but may contain a reference      // to the interface they are defined in.      if (d->node_type () == AST_Decl::NT_except)        {          return false;        }      if (d == t)        {          return true;        }    }  return false;}

intast_visitor_tmpl_module_inst::visit_scope (UTL_Scope *node){  for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls);       !si.is_done ();       si.next ())    {      AST_Decl *d = si.item ();      if (d == 0)        {          ACE_ERROR_RETURN ((LM_ERROR,                             ACE_TEXT ("ast_visitor_tmpl_module_inst::")                             ACE_TEXT ("visit_scope - ")                             ACE_TEXT ("bad node in this scope/n")),                            -1);        }      // Send the visitor.      if (d == 0 || d->ast_accept (this) == -1)        {          ACE_ERROR_RETURN ((LM_ERROR,                             ACE_TEXT ("ast_visitor_tmpl_module_inst::")                             ACE_TEXT ("visit_scope - ")                             ACE_TEXT ("codegen for scope failed/n")),                            -1);        }    }  return 0;}

// Compute the size type of the node in question.intAST_Structure::compute_size_type (void){  for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls);       !si.is_done ();       si.next ())    {      // Get the next AST decl node.      AST_Decl *d = si.item ();      if (d->node_type () == AST_Decl::NT_enum_val)        {          continue;        }      AST_Field *f = AST_Field::narrow_from_decl (d);      AST_Type *t = f->field_type ();      if (t != 0)        {          this->size_type (t->size_type ());          // While we're iterating, we might as well do this one too.          this->has_constructor (t->has_constructor ());        }      else        {          ACE_DEBUG ((LM_DEBUG,                      "WARNING (%N:%l) be_structure::compute_size_type - "                      "narrow_from_decl returned 0/n"));        }    }  return 0;}

DDS_StdStringbe_Type::EnclosingScopeString(AST_Decl * decl){   DDS_StdString ret;   assert(decl);   if (decl)   {      UTL_Scope * enclosingScope = decl->defined_in();      AST_Decl * enclosingDecl;      if (enclosingScope)      {         if ((enclosingDecl = (AST_Decl*)enclosingScope->narrow((long) & AST_Decl::type_id)))         {            ret = NameToString(enclosingDecl->name(), 0);         }         else         {            DDSError((DDS_StdString)"Can't narrow enclosing scope for " + NameToString(decl->name(), 0));         }      }   }   return ret;}

be_argument::be_argument (AST_Argument::Direction d,                          AST_Type *ft,                          UTL_ScopedName *n)  : COMMON_Base (),    AST_Decl (AST_Decl::NT_argument,              n),    AST_Field (AST_Decl::NT_argument,               ft,               n),    AST_Argument (d,                  ft,                  n),    be_decl (AST_Decl::NT_argument,             n){  AST_Decl *dcl = ScopeAsDecl (this->defined_in ());  // If there have been previous errors, dcl may be 0,  // and we don't want to crash, so we check for non-zero.  // Also, we don't want to set the bit if the operation is  // declared in an included file UNLESS the enclosing  // interface is abstract, in which case we regenerate the  // operation.  if (dcl != 0      && !dcl->is_local ()      && (idl_global->in_main_file () || dcl->is_abstract ()))    {      be_type *bt = be_type::narrow_from_decl (ft);      bt->seen_in_operation (true);      be_util::set_arg_seen_bit (bt);      idl_global->need_skeleton_includes_ = true;    }}

// Look up the default branch in union.AST_UnionBranch *AST_Union::lookup_default (void){  AST_UnionBranch *b = 0;  AST_Decl *d = 0;  for (UTL_ScopeActiveIterator i (this, UTL_Scope::IK_both);       !i.is_done();       i.next ())    {      d = i.item ();      if (d->node_type () == AST_Decl::NT_union_branch)        {          b = AST_UnionBranch::narrow_from_decl (d);          if (b == 0)            {              continue;            }          if (b->label () != 0              && b->label ()->label_kind () == AST_UnionLabel::UL_default)            {              idl_global->err ()->error2 (UTL_Error::EIDL_MULTIPLE_BRANCH,                                          this,                                          b);              return b;            }        }    }  return 0;}

voidbe_type::gen_fwd_helper_name (void){  AST_Decl *parent = ScopeAsDecl (this->defined_in ());  Identifier *segment = 0;  char *tmp = 0;  this->fwd_helper_name_.clear (true);  if (parent != 0 && parent->node_type () != AST_Decl::NT_root)    {      for (UTL_IdListActiveIterator i (parent->name ());           !i.is_done ();           i.next ())        {          segment = i.item ();          tmp = segment->get_string ();          if (ACE_OS::strcmp (tmp, "") == 0)            {              continue;            }          this->fwd_helper_name_ += tmp;          this->fwd_helper_name_ += "::";        }    }  else    {      this->fwd_helper_name_= "";    }  this->fwd_helper_name_ += "tao_";  this->fwd_helper_name_ += this->local_name ()->get_string ();}

// Compute total number of members.intAST_Operation::compute_argument_attr (void){  if (this->argument_count_ != -1)    {      return 0;    }  AST_Decl *d = 0;  AST_Type *type = 0;  AST_Argument *arg = 0;  this->argument_count_ = 0;  // If there are elements in this scope.  if (this->nmembers () > 0)    {      // Instantiate a scope iterator.      for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls);           !si.is_done ();           si.next ())        {          // Get the next AST decl node.          d = si.item ();          if (d->node_type () == AST_Decl::NT_argument)            {              this->argument_count_++;              arg = AST_Argument::narrow_from_decl (d);              if (arg->direction() == AST_Argument::dir_IN ||                  arg->direction() == AST_Argument::dir_INOUT)                {                  this->has_in_arguments_ = true;                }              type = AST_Type::narrow_from_decl (arg->field_type ());              if (type->node_type () == AST_Decl::NT_native)                {                  this->has_native_ = 1;                }            }        }    }  type = AST_Type::narrow_from_decl (this->return_type ());  if (type->node_type () == AST_Decl::NT_native)    {      this->has_native_ = 1;    }  return 0;}

intast_visitor_reifying::visit_param_holder (AST_Param_Holder *node){  size_t i = 0;  FE_Utils::T_ARGLIST const *t_args =    this->ctx_->template_args ();  for (FE_Utils::T_PARAMLIST_INFO::ITERATOR iter (         *this->ctx_->template_params ());       !iter.done ();       iter.advance (), ++i)    {      FE_Utils::T_Param_Info *item = 0;      iter.next (item);      ACE_CString name (item->name_);      /// The param holder's info->name_ may be the same as the      /// node's local name, but if the node comes from an      /// alias, info->name_ will be the name of the alias's      /// referenced template module parameter, while the local      /// name will be that of the corresponding alias param      /// name, which is what we want.      if (name == node->local_name ()->get_string ())        {          AST_Decl **ret_ptr = 0;          if (t_args->get (ret_ptr, i) == 0)            {              AST_Decl *candidate = *ret_ptr;              return candidate->ast_accept (this);            }          else            {              ACE_ERROR_RETURN ((LM_ERROR,                                 ACE_TEXT ("ast_visitor_reifying::")                                 ACE_TEXT ("visit_param_holder() - access of ")                                 ACE_TEXT ("current template arglist failed - ")                                 ACE_TEXT ("param=%C scope=%C index=%d/n"),                                 item->name_.c_str (),                                 ScopeAsDecl (idl_global->scopes ().top ())->full_name (),                                 i),                                -1);            }        }    }  ACE_ERROR_RETURN ((LM_ERROR,                     ACE_TEXT ("ast_visitor_reifying::")                     ACE_TEXT ("visit_param_holder() - no match for ")                     ACE_TEXT ("template param %C in %C/n"),                     node->local_name ()->get_string (),                     ScopeAsDecl (idl_global->scopes ().top ())->full_name ()),                    -1);}

/* * Add this AST_InterfaceFwd node (a forward declaration of an IDL * interface) to this scope */AST_InterfaceFwd * AST_Module::fe_add_interface_fwd (AST_InterfaceFwd * i){   AST_Decl * d = lookup_for_add (i);   AST_Interface * itf;   /*    * Already defined and cannot be redefined? Or already used?    */   if (d)   {      if (d->node_type() == AST_Decl::NT_interface && d->defined_in() == this)      {         itf = AST_Interface::narrow_from_decl (d);         if (itf == 0)         {            return 0;         }         i->set_full_definition (itf);         return i;      }      if (!can_be_redefined (d))      {         idl_global->err()->error3(UTL_Error::EIDL_REDEF, i, this, d);         return NULL;      }      if (referenced (d))      {         idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, i, this, d);         return NULL;      }      if (i->has_ancestor (d))      {         idl_global->err()->redefinition_in_scope(i, d);         return NULL;      }   }   /*    * Add it to scope    */   add_to_scope (i);   /*    * Add it to set of locally referenced symbols    */   add_to_referenced (i, false);   return i;}

AST_ValueFwd *AST_Module::fe_add_valuetype_fwd(AST_ValueFwd *v){   AST_Decl *d;   AST_Value *val;   /*    * Already defined and cannot be redefined? Or already used?    */   if ((d = lookup_for_add (v)) != NULL)   {      if (d->node_type() == AST_Decl::NT_value && d->defined_in() == this)      {         val = AST_Value::narrow_from_decl(d);         if (val == NULL)            return NULL;         v->set_full_definition(val);         return v;      }      if (!can_be_redefined(d))      {         idl_global->err()->error3(UTL_Error::EIDL_REDEF, v, this, d);         return NULL;      }      if (referenced(d))      {         idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, d);         return NULL;      }      if (v->has_ancestor(d))      {         idl_global->err()->redefinition_in_scope(v, d);         return NULL;      }   }   /*    * Add it to scope    */   add_to_scope(v);   /*    * Add it to set of locally referenced symbols    */   add_to_referenced(v, I_FALSE);   return v;}

// NOTE: No attempt is made to ensure that exceptions are mentioned//       only once..UTL_NameList *AST_Attribute::fe_add_get_exceptions (UTL_NameList *t){  UTL_ScopedName *nl_n = 0;  AST_Type *fe = 0;  AST_Decl *d = 0;  this->pd_get_exceptions = 0;  for (UTL_NamelistActiveIterator nl_i (t);       !nl_i.is_done ();       nl_i.next ())    {      nl_n = nl_i.item ();      d = this->defined_in ()->lookup_by_name (nl_n, true);      if (d == 0)        {          idl_global->err ()->lookup_error (nl_n);          return 0;        }      AST_Decl::NodeType nt = d->node_type ();      if (nt != AST_Decl::NT_except          && nt != AST_Decl::NT_param_holder)        {          idl_global->err ()->error1 (UTL_Error::EIDL_ILLEGAL_RAISES,                                      this);          return 0;        }      fe = AST_Type::narrow_from_decl (d);      UTL_ExceptList *el = 0;      ACE_NEW_RETURN (el,                      UTL_ExceptList (fe, 0),                      0);      if (this->pd_get_exceptions == 0)        {          this->pd_get_exceptions = el;        }      else        {          this->pd_get_exceptions->nconc (el);        }    }  return t;}

//// visit_scope//int Provides_Svnt_Impl::visit_scope (UTL_Scope * node){  // Interfaces could be in a different IDL file, so we don't want to  // skip them as the default visit_scope implementation does  for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls);       !si.is_done (); si.next ())  {    AST_Decl * d = si.item ();    if (0 != d->ast_accept (this))      return -1;  }  return 0;}

voidbe_component::mirror_scan (AST_PortType *pt){  AST_Uses *u = 0;  AST_Provides *p = 0;  AST_Attribute *a = 0;  for (UTL_ScopeActiveIterator i (pt, UTL_Scope::IK_decls);       !i.is_done ();       i.next ())    {      AST_Decl *d = i.item ();      switch (d->node_type ())        {          case AST_Decl::NT_provides:            ++this->n_uses_;            p = AST_Provides::narrow_from_decl (d);            if (!p->provides_type ()->is_local ())              {                ++this->n_remote_uses_;              }            continue;          case AST_Decl::NT_uses:            ++this->n_provides_;            u = AST_Uses::narrow_from_decl (d);            if (!u->uses_type ()->is_local ())              {                ++this->n_remote_provides_;              }            continue;          case AST_Decl::NT_attr:            a = AST_Attribute::narrow_from_decl (d);;            if (!a->readonly ())              {                this->has_rw_attributes_ = true;              }            continue;          default:            continue;        }    }}

voidbe_util::gen_nesting_close (TAO_OutStream &os, AST_Decl *node){  AST_Decl *d = ScopeAsDecl (node->defined_in ());  AST_Decl::NodeType nt = d->node_type ();  while (nt != AST_Decl::NT_root)    {      os << be_uidt_nl         << "};";      d = ScopeAsDecl (d->defined_in ());      nt = d->node_type ();    }}

intbe_visitor_executor_exs::visit_provides (be_provides *node){  ACE_CString prefix (this->ctx_->port_prefix ());  prefix += node->local_name ()->get_string ();  const char *port_name = prefix.c_str ();  be_type *obj = node->provides_type ();  const char *iname =    obj->original_local_name ()->get_string ();  AST_Decl *scope = ScopeAsDecl (obj->defined_in ());  ACE_CString sname_str (scope->full_name ());  const char *sname = sname_str.c_str ();  const char *global = (sname_str == "" ? "" : "::");  ACE_CString lname_str (this->ctx_->port_prefix ());  lname_str += node->original_local_name ()->get_string ();  const char *lname = lname_str.c_str ();  os_ << be_nl_2      << global << sname << "::CCM_"      << iname << "_ptr" << be_nl      << node_->local_name () << "_exec_i::get_"      << port_name << " (void)" << be_nl      << "{" << be_idt_nl      << "if ( ::CORBA::is_nil (this->ciao_" << port_name      << "_.in ()))" << be_idt_nl      << "{" << be_idt_nl      << lname << "_exec_i *tmp = 0;" << be_nl      << "ACE_NEW_RETURN (" << be_idt_nl      << "tmp," << be_nl      << lname << "_exec_i (" << be_idt_nl      << "this->ciao_context_.in ())," << be_nl      << global << sname << "::CCM_" << iname << "::_nil ());"      << be_uidt << be_nl_2      << "this->ciao_" << port_name << "_ = tmp;" << be_uidt << be_uidt_nl      << "}" << be_uidt << be_nl_2      << "return" << be_idt_nl      << global << sname << "::CCM_" << iname      << "::_duplicate (" << be_idt_nl      << "this->ciao_" << port_name << "_.in ());"      << be_uidt << be_uidt << be_uidt_nl      << "}";  return 0;}

voidAST_Root::destroy (void){  long i = 0;  AST_Decl *d = 0;  // Just destroy and delete everything but the CORBA  // module, and the 'void' keyword, in case we are  // processing multiple IDL files.  // Final cleanup will be done in fini().  long end = this->pd_decls_used;  for (i = 2; i < end; ++i)    {      d = this->pd_decls[i];      d->destroy ();      delete d;      d = 0;      --this->pd_decls_used;    }  // Same goes for the references and the name  // references, leave the first 2.  // This array of pointers holds references, no need  // for destruction. The array itself will be cleaned  // up when AST_Root::fini() calls UTL_Scope::destroy ().  for (i = 2; i < this->pd_referenced_used; ++i)    {      this->pd_referenced[i] = 0;    }  this->pd_referenced_used = 2;  for (i = 2; i < this->pd_name_referenced_used; ++i)    {      Identifier *id = this->pd_name_referenced[i];      id->destroy ();      delete id;      id = 0;    }  this->pd_name_referenced_used = 2;}

voidFE_ComponentHeader::compile_inheritance (UTL_ScopedName *base_component){  // If there is a base component, look up the decl and assign our member.  // We also inherit its supported interfaces.  if (base_component == 0)    {      return;    }  UTL_Scope *s = idl_global->scopes ().top_non_null ();  AST_Decl *d = s->lookup_by_name (base_component,                                   true);  if (d == 0)    {      idl_global->err ()->lookup_error (base_component);      // This is probably the result of bad IDL.      // We will crash if we continue from here.      throw Bailout ();    }  if (d->node_type () == AST_Decl::NT_typedef)    {      d = AST_Typedef::narrow_from_decl (d)->primitive_base_type ();    }  this->base_component_ = AST_Component::narrow_from_decl (d);  if (this->base_component_ == 0)    {      idl_global->err ()->error1 (UTL_Error::EIDL_ILLEGAL_USE,                                  d);    }  else if (!this->base_component_->is_defined ())    {      idl_global->err ()->inheritance_fwd_error (                              this->name (),                              this->base_component_                            );      this->base_component_ = 0;    }}

intdds_visitor::visit_constant(AST_Constant* node){  const char* name = node->local_name()->get_string();  BE_Comment_Guard g("CONST", name);  ACE_UNUSED_ARG(g);  AST_Decl* d = ScopeAsDecl(node->defined_in());  bool nested = d && (d->node_type() == AST_Decl::NT_interface);  if (!java_ts_only_) {    error_ |= !gen_target_.gen_const(node->name(), nested, node);  }  return 0;}