自学教程：C++ ACE_NEW_RETURN函数代码示例

intbe_visitor_interface_ss::gen_abstract_ops_helper (  be_interface *node,  be_interface *base,  TAO_OutStream *os){  if (!base->is_abstract ())    {      return 0;    }  AST_Decl *d = 0;  be_visitor_context ctx;  ctx.stream (os);  ctx.state (TAO_CodeGen::TAO_ROOT_SS);  for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls);       !si.is_done ();       si.next ())    {      d = si.item ();      if (d == 0)        {          ACE_ERROR_RETURN ((LM_ERROR,                             ACE_TEXT ("be_visitor_interface_ss::")                             ACE_TEXT ("gen_abstract_ops_helper - ")                             ACE_TEXT ("bad node in this scope/n")),                            -1);        }      AST_Decl::NodeType nt = d->node_type ();      UTL_ScopedName *item_new_name = 0;      UTL_ScopedName *new_name = 0;      if (AST_Decl::NT_op == nt || AST_Decl::NT_attr == nt)        {          ACE_NEW_RETURN (item_new_name,                          UTL_ScopedName (d->local_name ()->copy (),                                          0),                          -1);          new_name = (UTL_ScopedName *) node->name ()->copy ();          new_name->nconc (item_new_name);        }      else        {          continue;        }      // We pass the node's is_abstract flag to the operation      // constructor so we will get the right generated operation      // body if we are regenerating an operation from an      // abstract interface in a concrete interface or component.      if (AST_Decl::NT_op == nt)        {          be_operation *op = be_operation::narrow_from_decl (d);          UTL_ScopedName *old_name =            (UTL_ScopedName *) op->name ()->copy ();          op->set_name (new_name);          op->set_defined_in (node);          op->is_abstract (node->is_abstract ());          be_visitor_operation_ss op_visitor (&ctx);          op_visitor.visit_operation (op);          op->set_name (old_name);          op->set_defined_in (base);          op->is_abstract (base->is_abstract ());        }      else if (AST_Decl::NT_attr == nt)        {          AST_Attribute *attr =            AST_Attribute::narrow_from_decl (d);          be_attribute new_attr (attr->readonly (),                                 attr->field_type (),                                 0,                                 attr->is_local (),                                 attr->is_abstract ());          new_attr.set_defined_in (node);          new_attr.set_name (new_name);          UTL_ExceptList *get_exceptions =            attr->get_get_exceptions ();          if (0 != get_exceptions)            {              new_attr.be_add_get_exceptions (get_exceptions->copy ());            }          UTL_ExceptList *set_exceptions =            attr->get_set_exceptions ();          if (0 != set_exceptions)            {              new_attr.be_add_set_exceptions (set_exceptions->copy ());            }          be_visitor_attribute attr_visitor (&ctx);//.........这里部分代码省略.........

ACE_Message_Block *ACE_Message_Block::clone (Message_Flags mask) const{  ACE_TRACE ("ACE_Message_Block::clone");  // Get a pointer to a "cloned" <ACE_Data_Block> (will copy the  // values rather than increment the reference count).  ACE_Data_Block *db = this->data_block ()->clone (mask);  if (db == 0)    return 0;  ACE_Message_Block *nb = 0;  if(message_block_allocator_ == 0)    {      ACE_NEW_RETURN (nb,                      ACE_Message_Block (0, // size                                         ACE_Message_Type (0), // type                                         0, // cont                                         0, // data                                         0, // allocator                                         0, // locking strategy                                         0, // flags                                         this->priority_, // priority                                         ACE_EXECUTION_TIME, // execution time                                         ACE_DEADLINE_TIME, // absolute time to deadline                                         // Get a pointer to a                                         // "duplicated" <ACE_Data_Block>                                         // (will simply increment the                                         // reference count).                                         db,                                         db->data_block_allocator (),                                         this->message_block_allocator_),                      0);    }  else    {      // This is the ACE_NEW_MALLOC macro with the return check removed.      // We need to do it this way because if it fails we need to release      // the cloned data block that was created above.  If we used      // ACE_NEW_MALLOC_RETURN, there would be a memory leak because the      // above db pointer would be left dangling.      nb = static_cast<ACE_Message_Block*> (message_block_allocator_->malloc (sizeof (ACE_Message_Block)));      if(nb != 0)        new (nb) ACE_Message_Block (0, // size                                    ACE_Message_Type (0), // type                                    0, // cont                                    0, // data                                    0, // allocator                                    0, // locking strategy                                    0, // flags                                    this->priority_, // priority                                    ACE_EXECUTION_TIME, // execution time                                    ACE_DEADLINE_TIME, // absolute time to deadline                                    db,                                    db->data_block_allocator (),                                    this->message_block_allocator_);    }  if (nb == 0)    {      db->release ();      return 0;    }  // Set the read and write pointers in the new <Message_Block> to the  // same relative offset as in the existing <Message_Block>.  nb->rd_ptr (this->rd_ptr_);  nb->wr_ptr (this->wr_ptr_);  // Clone all the continuation messages if necessary.  if (this->cont () != 0      && (nb->cont_ = this->cont ()->clone (mask)) == 0)    {      nb->release ();      return 0;    }  return nb;}

intACE_TMAIN (int argc, ACE_TCHAR *argv[]){  ACE_LOG_MSG->open (argv[0] ? argv[0] : ACE_TEXT("preempt"));#if defined (ACE_HAS_THREADS) || !defined (ACE_LACKS_FORK)  u_int i;  if (get_options (argc, argv))    ACE_OS::exit (-1);  // Enable FIFO scheduling, e.g., RT scheduling class on Solaris.  if (ACE_OS::sched_params (        ACE_Sched_Params (          ACE_SCHED_FIFO,          ACE_Sched_Params::priority_min (ACE_SCHED_FIFO),          ACE_SCOPE_PROCESS)) != 0)    {      if (ACE_OS::last_error () == EPERM)        ACE_DEBUG ((LM_MAX, "preempt: user is not superuser, "                    "so remain in time-sharing class/n"));      else        ACE_ERROR_RETURN ((LM_ERROR, "%n: ACE_OS::sched_params failed/n%a"),                          -1);    }  High_Priority_Task *high_priority_task;  ACE_NEW_RETURN (high_priority_task, High_Priority_Task [high_priority_tasks],                  1);  Low_Priority_Task low_priority_task (high_priority_task[0]);  if (! use_fork)    {      ACE_DEBUG ((LM_DEBUG,                  "(%P|%t) main (), wait for threads to exit . . ./n"));    }  // Save the start time, so that deltas can be displayed later.  starttime = ACE_OS::gethrtime ();  // Spawn the threads/processes . . .  pid_t child = 0;  if (use_fork == 1)    {      switch ((child = ACE_OS::fork (ACE_TEXT("preempt-low_priority_process"))))        {        case -1:          ACE_ERROR ((LM_ERROR, "%p/n%a", "fork failed"));          return -1;        case 0: // In child          {            low_priority_task.open (0);            break;          }        default: // In parent          for (i = 0; i < high_priority_tasks; ++i)            {              high_priority_task[i].open (0);            }          break;        }    }  else    {      for (i = 0; i < high_priority_tasks; ++i)        {          high_priority_task[i].open (0);        }      low_priority_task.open (0);#if defined (ACE_HAS_THREADS)     // Wait for all threads to exit.     ACE_Thread_Manager::instance ()->wait ();#endif /* ACE_HAS_THREADS */    }  // Display the time deltas.  They should be about a half second apart.  if (child || ! use_fork)    {      for (i = 0; i < high_priority_tasks; ++i)        {          ACE_DEBUG ((LM_DEBUG, "High priority task %u:/n", i + 1));          high_priority_task[i].print_times ();        }    }  delete [] high_priority_task;#else  /* ! ACE_HAS_THREADS && ACE_LACKS_FORK */  ACE_UNUSED_ARG (argc);  ACE_UNUSED_ARG (argv);  ACE_ERROR ((LM_ERROR, "threads and fork not supported on this platform/n"));#endif /* ! ACE_HAS_THREADS && ACE_LACKS_FORK */  return 0;}

intACE_TMAIN (int argc, ACE_TCHAR *argv[]){  CORBA::ORB_var orb;  try    {      PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =        PortableInterceptor::ORBInitializer::_nil ();      PortableInterceptor::ORBInitializer_var orb_initializer;      // Register the ClientRequest_Interceptor ORBInitializer.      ACE_NEW_RETURN (temp_orb_initializer,                      ClientORBInitializer,                      -1);      orb_initializer = temp_orb_initializer;      PortableInterceptor::register_orb_initializer (orb_initializer.in ());      orb = CORBA::ORB_init (argc, argv);      if (parse_args (argc, argv) != 0)        return 1;      CORBA::Object_var tmp =        orb->string_to_object (ior);      Test::Hello_var hello =        Test::Hello::_narrow(tmp.in () );      if (CORBA::is_nil (hello.in ()))        {          ACE_ERROR_RETURN ((LM_DEBUG,                             "Nil Test::Hello reference <%s>/n",                             ior),                            1);        }      ACE_DEBUG ((LM_DEBUG, "Client about to make method call that is doomed to failure.../n"));      CORBA::String_var the_string =        hello->get_string ();      ACE_ERROR_RETURN ((LM_DEBUG,                            "Error - the remote call succeeded which is bloody miraculous given that no server is running !!/n"),                            1);      orb->destroy ();    }  catch (const CORBA::Exception&)    {      orb->destroy ();      if (ClientRequest_Interceptor::success_flag_)        {          ACE_DEBUG ((LM_DEBUG, "Success - the server was unreachable and PI receive_exception was invoked./n"));          return 0;        }      else        {          ACE_ERROR_RETURN ((LM_DEBUG,                             "Error: regression failed - interceptor receive_exception interception point was not invoked !!/n"),                            1);        }    }  return 1;}

intBE_init(int&, ACE_TCHAR*[]){    ACE_NEW_RETURN(be_global, BE_GlobalData, -1);    return 0;}

intPeriodic_Task::init_task (ACE_Arg_Shifter& arg_shifter){  const ACE_TCHAR *current_arg = 0;  while (arg_shifter.is_anything_left ())    {      if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-JobName"))))        {          name_ = ACE_TEXT_ALWAYS_CHAR(current_arg);          arg_shifter.consume_arg ();        }      else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Priority"))))        {          task_priority_ = ACE_OS::atoi (current_arg);          arg_shifter.consume_arg ();        }      else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Period"))))        {          period_ = ACE_OS::atoi (current_arg);          arg_shifter.consume_arg ();        }      else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ExecTime"))))        {          exec_time_ = ACE_OS::atoi (current_arg);          arg_shifter.consume_arg ();        }      else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Phase"))))        {          phase_ = ACE_OS::atoi (current_arg);          arg_shifter.consume_arg ();        }      else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Iter"))))        {          iter_ = ACE_OS::atoi (current_arg);          arg_shifter.consume_arg ();          // create the stat object.          ACE_NEW_RETURN (task_stats_, Task_Stats (iter_), -1);          if (task_stats_->init () == -1)            return -1;        }      else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Load"))))        {          load_ = ACE_OS::atoi (current_arg);          arg_shifter.consume_arg ();          return 0;        }      else        {          ACE_DEBUG ((LM_DEBUG, "parse Task unknown option %s/n",                      arg_shifter.get_current ()));          if (TAO_debug_level > 0)            ACE_DEBUG ((LM_DEBUG, "name %s, priority %d, period %duS, exec_time %duS, phase %duS, iter %d, load %d/n",                        name_.c_str(), task_priority_, period_, exec_time_, phase_, iter_, load_));          break;        }    }  return 0;}

int WorldSocket::SendPacket(WorldPacket const& pct){    ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);    if (closing_)        return -1;    // Dump outgoing packet    if (sPacketLog->CanLogPacket())        sPacketLog->LogPacket(pct, SERVER_TO_CLIENT);    WorldPacket const* pkt = &pct;    // Empty buffer used in case packet should be compressed    // Disable compression for now :)   /* WorldPacket buff;    if (m_Session && pkt->size() > 0x400)    {        buff.Compress(m_Session->GetCompressionStream(), pkt);        pkt = &buff;    }*/    if (m_Session)        TC_LOG_TRACE("network.opcode", "S->C: %s %s", m_Session->GetPlayerInfo().c_str(), GetOpcodeNameForLogging(pkt->GetOpcode()).c_str());    sScriptMgr->OnPacketSend(this, *pkt);    ServerPktHeader header(!m_Crypt.IsInitialized() ? pkt->size() + 2 : pct.size(), pkt->GetOpcode(), &m_Crypt);    if (m_OutBuffer->space() >= pkt->size() + header.getHeaderLength() && msg_queue()->is_empty())    {        // Put the packet on the buffer.        if (m_OutBuffer->copy((char*) header.header, header.getHeaderLength()) == -1)            ACE_ASSERT (false);        if (!pkt->empty())            if (m_OutBuffer->copy((char*) pkt->contents(), pkt->size()) == -1)                ACE_ASSERT (false);    }    else    {        // Enqueue the packet.        ACE_Message_Block* mb;        ACE_NEW_RETURN(mb, ACE_Message_Block(pkt->size() + header.getHeaderLength()), -1);        mb->copy((char*) header.header, header.getHeaderLength());        if (!pkt->empty())            mb->copy((const char*)pkt->contents(), pkt->size());        if (msg_queue()->enqueue_tail(mb, (ACE_Time_Value*)&ACE_Time_Value::zero) == -1)        {            TC_LOG_ERROR("network", "WorldSocket::SendPacket enqueue_tail failed");            mb->release();            return -1;        }    }    return 0;}

//// begin//CUTS_Action_Iterator * CUTS_Worker::begin (void){  CUTS_Action_Iterator * iter = 0;  ACE_NEW_RETURN (iter, CUTS_Action_Iterator (), 0);  return iter;}

ACE_BEGIN_VERSIONED_NAMESPACE_DECLintACE_OS::argv_to_string (ACE_TCHAR **argv,                        ACE_TCHAR *&buf,                        int substitute_env_args){  if (argv == 0 || argv[0] == 0)    return 0;  size_t buf_len = 0;  // Determine the length of the buffer.  for (int i = 0; argv[i] != 0; i++)    {#if !defined (ACE_LACKS_ENV)      // Account for environment variables.      if (substitute_env_args && argv[i][0] == ACE_LIB_TEXT ('$'))        {#  if defined (ACE_WIN32) || !defined (ACE_HAS_WCHAR)          ACE_TCHAR *temp = 0;          // Win32 is the only platform with a wide-char ACE_OS::getenv().          if ((temp = ACE_OS::getenv (&argv[i][1])) != 0)            buf_len += ACE_OS::strlen (temp);          else            buf_len += ACE_OS::strlen (argv[i]);#  else          // This is an ACE_HAS_WCHAR platform and not ACE_WIN32.          // Convert the env variable name for getenv(), then add          // the length of the returned char *string. Later, when we          // actually use the returned env variable value, convert it          // as well.          char *ctemp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&argv[i][1]));          if (ctemp == 0)            buf_len += ACE_OS::strlen (argv[i]);          else            buf_len += ACE_OS::strlen (ctemp);#  endif /* ACE_WIN32 || !ACE_HAS_WCHAR */        }      else#endif /* ACE_LACKS_ENV */        buf_len += ACE_OS::strlen (argv[i]);      // Add one for the extra space between each string.      buf_len++;    }  // Step through all argv params and copy each one into buf; separate  // each param with white space.  ACE_NEW_RETURN (buf,                  ACE_TCHAR[buf_len + 1],                  0);  // Initial null charater to make it a null string.  buf[0] = '/0';  ACE_TCHAR *end = buf;  int j;  for (j = 0; argv[j] != 0; j++)    {#if !defined (ACE_LACKS_ENV)      // Account for environment variables.      if (substitute_env_args && argv[j][0] == ACE_LIB_TEXT ('$'))        {#  if defined (ACE_WIN32) || !defined (ACE_HAS_WCHAR)          // Win32 is the only platform with a wide-char ACE_OS::getenv().          ACE_TCHAR *temp = ACE_OS::getenv (&argv[j][1]);          if (temp != 0)            end = ACE_OS::strecpy (end, temp);          else            end = ACE_OS::strecpy (end, argv[j]);#  else          // This is an ACE_HAS_WCHAR platform and not ACE_WIN32.          // Convert the env variable name for getenv(), then convert          // the returned char *string back to wchar_t.          char *ctemp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&argv[j][1]));          if (ctemp == 0)            end = ACE_OS::strecpy (end, argv[j]);          else            end = ACE_OS::strecpy (end, ACE_TEXT_CHAR_TO_TCHAR (ctemp));#  endif /* ACE_WIN32 || !ACE_HAS_WCHAR */        }      else#endif /* ACE_LACKS_ENV */        end = ACE_OS::strecpy (end, argv[j]);      // Replace the null char that strecpy put there with white      // space.      end[-1] = ' ';    }  // Null terminate the string.  *end = '/0';  // The number of arguments.  return j;}

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> intACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::open(creation_strategy_type *cre_s, ACE_Concurrency_Strategy<SVC_HANDLER> *con_s, ACE_Recycling_Strategy<SVC_HANDLER> *rec_s){  // Initialize the creation strategy.  // First we decide if we need to clean up.  if (this->creation_strategy_ != 0 &&      this->delete_creation_strategy_ != 0 &&      cre_s != 0)    {      delete this->creation_strategy_;      this->creation_strategy_ = 0;      this->delete_creation_strategy_ = 0;    }  if (cre_s != 0)    this->creation_strategy_ = cre_s;  else if (this->creation_strategy_ == 0)    {      ACE_NEW_RETURN (this->creation_strategy_,                      CREATION_STRATEGY, -1);      this->delete_creation_strategy_ = 1;    }  // Initialize the concurrency strategy.  if (this->concurrency_strategy_ != 0 &&      this->delete_concurrency_strategy_ != 0 &&      con_s != 0)    {      delete this->concurrency_strategy_;      this->concurrency_strategy_ = 0;      this->delete_concurrency_strategy_ = 0;    }  if (con_s != 0)    this->concurrency_strategy_ = con_s;  else if (this->concurrency_strategy_ == 0)    {      ACE_NEW_RETURN (this->concurrency_strategy_,                      CONCURRENCY_STRATEGY, -1);      this->delete_concurrency_strategy_ = 1;    }  // Initialize the recycling strategy.  if (this->recycling_strategy_ != 0 &&      this->delete_recycling_strategy_ != 0 &&      rec_s != 0)    {      delete this->recycling_strategy_;      this->recycling_strategy_ = 0;      this->delete_recycling_strategy_ = 0;    }  if (rec_s != 0)    this->recycling_strategy_ = rec_s;  else if (this->recycling_strategy_ == 0)    {      ACE_NEW_RETURN (this->recycling_strategy_,                      RECYCLING_STRATEGY, -1);      this->delete_recycling_strategy_ = 1;    }  return 0;}

TAO::CSD::Strategy_Base::DispatchResultTAO_DTP_POA_Strategy::dispatch_collocated_request_i                             (TAO_ServerRequest&              server_request,                              const PortableServer::ObjectId& object_id,                              PortableServer::POA_ptr         poa,                              const char*                     operation,                              PortableServer::Servant         servant){  TAO::CSD::TP_Servant_State::HandleType servant_state =                        this->get_servant_state (servant);  bool is_sync_with_server = server_request.sync_with_server ();  bool is_synchronous      = server_request.response_expected ();  TAO::CSD::TP_Collocated_Synch_Request_Handle    synch_request;  TAO::CSD::TP_Collocated_Synch_With_Server_Request_Handle    synch_with_server_request;  TAO::CSD::TP_Request_Handle    request;  // Create the request object using the appropriate concrete type.  if (is_sync_with_server)    {      TAO::CSD::TP_Collocated_Synch_With_Server_Request *req_ptr;      ACE_NEW_RETURN (req_ptr,                      TAO::CSD::TP_Collocated_Synch_With_Server_Request                        (server_request,                         object_id,                         poa,                         operation,                         servant,                         servant_state.in ()),                      DISPATCH_REJECTED);      synch_with_server_request = req_ptr;      // Give the request handle its own "copy".      synch_with_server_request->_add_ref ();      request = synch_with_server_request.in ();    }  else if (is_synchronous)    {      TAO::CSD::TP_Collocated_Synch_Request *req_ptr;      ACE_NEW_RETURN (req_ptr,                      TAO::CSD::TP_Collocated_Synch_Request (                                   server_request,                                   object_id,                                   poa,                                   operation,                                   servant,                                   servant_state.in ()),                      DISPATCH_REJECTED);      synch_request = req_ptr;      // Give the request handle its own "copy".      synch_request->_add_ref ();      request = synch_request.in ();    }  else    {      TAO::CSD::TP_Collocated_Asynch_Request *req_ptr;      ACE_NEW_RETURN (req_ptr,                      TAO::CSD::TP_Collocated_Asynch_Request (server_request,                                                              object_id,                                                              poa,                                                              operation,                                                              servant,                                                              servant_state.in ()),                      DISPATCH_REJECTED);      // Just use the (base) request handle to hold the request object.      request = req_ptr;    }  // Hand the request object to our task so that it can add the request  // to its "request queue".  if (!this->dtp_task_.add_request (request.in ()))    {      // Return the DISPATCH_REJECTED return code so that the caller (our      // base class' dispatch_request() method) knows that we did      // not handle the request, and that it should be rejected.      return DISPATCH_REJECTED;    }  // We need to wait on the request object if the request type is a  // synchronous request.  if (!synch_request.is_nil ())    {      int srw = synch_request->wait ();      if (srw == false)        {          // Raise exception when request was cancelled.          throw ::CORBA::NO_IMPLEMENT ();        }    }//.........这里部分代码省略.........

intACE_TMAIN(int argc, ACE_TCHAR *argv[]){  try    {      CORBA::ORB_var orb =        CORBA::ORB_init (argc, argv);      CORBA::Object_var poa_object =        orb->resolve_initial_references("RootPOA");      PortableServer::POA_var root_poa =        PortableServer::POA::_narrow (poa_object.in ());      if (CORBA::is_nil (root_poa.in ()))        ACE_ERROR_RETURN ((LM_ERROR,                           " (%P|%t) Panic: nil RootPOA/n"),                          1);      PortableServer::POAManager_var poa_manager =        root_poa->the_POAManager ();      // Make all oneways "reliable."      {        CORBA::Object_var manager_object =          orb->resolve_initial_references("ORBPolicyManager");        CORBA::PolicyManager_var policy_manager =          CORBA::PolicyManager::_narrow(manager_object.in());        if (CORBA::is_nil (policy_manager.in ()))          ACE_ERROR_RETURN ((LM_ERROR,                             " (%P|%t) Panic: nil PolicyManager/n"),                            1);        CORBA::Any policy_value;        policy_value <<= Messaging::SYNC_WITH_SERVER;        CORBA::PolicyList policies(1); policies.length(1);        policies[0] =          orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,                              policy_value);        policy_manager->set_policy_overrides (policies,                                              CORBA::ADD_OVERRIDE);        policies[0]->destroy ();      }      if (parse_args (argc, argv) != 0)        return 1;      Service *service_impl;      ACE_NEW_RETURN (service_impl,                      Service(orb.in ()),                      1);      PortableServer::ServantBase_var owner_transfer(service_impl);      PortableServer::ObjectId_var id =        root_poa->activate_object (service_impl);      CORBA::Object_var object = root_poa->id_to_reference (id.in ());      Test::Service_var service =        Test::Service::_narrow (object.in ());      CORBA::String_var ior =        orb->object_to_string (service.in ());      // If the ior_output_file exists, output the ior to it      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");      if (output_file == 0)        ACE_ERROR_RETURN ((LM_ERROR,                           "Cannot open output file for writing IOR: %s",                           ior_output_file),                              1);      ACE_OS::fprintf (output_file, "%s", ior.in ());      ACE_OS::fclose (output_file);      poa_manager->activate ();      orb->run ();      ACE_DEBUG ((LM_DEBUG, "Event loop finished/n"));      service_impl->dump_results ();      root_poa->destroy (1, 1);      orb->destroy ();    }  catch (const CORBA::Exception& ex)    {      ex._tao_print_exception ("Exception caught:");      return 1;    }  return 0;}

static inttest_active_map_manager (size_t table_size,                         size_t iterations,                         int test_iterators){  ACTIVE_MAP_MANAGER map (table_size);  TYPE i;  TYPE j = 0;  ssize_t k;  ACTIVE_MAP_MANAGER::key_type *active_keys;  ACE_NEW_RETURN (active_keys,                  ACTIVE_MAP_MANAGER::key_type[iterations],                  1);  for (i = 0;       i < iterations;       i++)    ACE_TEST_ASSERT (map.bind (i, active_keys[i]) != -1);  if (test_iterators)    {      {        i = 0;        ACTIVE_MAP_MANAGER::iterator end = map.end ();        for (ACTIVE_MAP_MANAGER::iterator iter = map.begin ();             iter != end;             ++iter)          {            ACTIVE_MAP_MANAGER::ENTRY &entry = *iter;            ACE_DEBUG ((LM_DEBUG,                        ACE_TEXT ("(%d|%d-%d|%d)"),                        i,                        entry.ext_id_.slot_index (),                        entry.ext_id_.slot_generation (),                        entry.int_id_));            ++i;          }        ACE_DEBUG ((LM_DEBUG,                    ACE_TEXT ("/n")));        ACE_TEST_ASSERT (i == iterations);      }      {        k = iterations - 1;        ACTIVE_MAP_MANAGER::reverse_iterator rend = map.rend ();        for (ACTIVE_MAP_MANAGER::reverse_iterator iter = map.rbegin ();             iter != rend;             ++iter)          {            ACTIVE_MAP_MANAGER::ENTRY &entry = *iter;            ACE_UNUSED_ARG (entry);            ACE_DEBUG ((LM_DEBUG,                        ACE_TEXT ("(%d|%d-%d|%d)"),                        k,                        entry.ext_id_.slot_index (),                        entry.ext_id_.slot_generation (),                        entry.int_id_));            k--;          }        ACE_DEBUG ((LM_DEBUG,                    ACE_TEXT ("/n")));        ACE_TEST_ASSERT (k == -1);      }    }  for (i = 0; i < iterations; ++i)    {      ACE_TEST_ASSERT (map.find (active_keys[i], j) != -1);      ACE_TEST_ASSERT (i == j);    }  size_t remaining_entries = iterations;  for (i = 0; i < iterations; ++i)    {      ACE_TEST_ASSERT (map.unbind (active_keys[i]) != -1);      --remaining_entries;      ACE_TEST_ASSERT (map.current_size () == remaining_entries);    }  delete [] active_keys;  return 0;}

int test_orb (CORBA::ORB_ptr orb){  int errors = 0;  POA_TestModule::test* test = 0;  ACE_NEW_RETURN (test,                  test_i, 1);  PortableServer::ServantBase_var safe (test);  CORBA::Object_var object = test->_this ();  orb->register_initial_reference ("ORBMyService",                                    object.in ());  bool invalid_name = false;  try    {      // Registering with an empty string should give an exception      orb->register_initial_reference ("",                                       object.in ());    }  catch (const CORBA::ORB::InvalidName&)    {      invalid_name = true;    }  catch (const CORBA::Exception&)    {    }  if (!invalid_name)    {      errors++;      ACE_ERROR ((LM_ERROR, "ERROR: Registering with an empty string with the ORB"                            "doesn't throw an exception/n"));    }  bool duplicate_name = false;  try    {      // Registering with an duplicate string should give an exception      orb->register_initial_reference ("ORBMyService",                                        object.in ());    }  catch (const CORBA::ORB::InvalidName&)    {      duplicate_name = true;    }  catch (const CORBA::Exception&)    {    }  if (!duplicate_name)    {      errors++;      ACE_ERROR ((LM_ERROR, "ERROR: Registering with a duplicate with ORB "                            "doesn't throw the expected exception/n"));    }  bool invalid_object = false;  try    {      // Registering with a nil object      orb->register_initial_reference ("ORBNilServer",                                       CORBA::Object::_nil());    }  catch (const CORBA::BAD_PARAM& ex)    {      if ((ex.minor() & 0xFFFU) == 27)        {          invalid_object = true;        }    }  catch (const CORBA::Exception&)    {    }  if (!invalid_object)    {      errors++;      ACE_ERROR ((LM_ERROR, "ERROR: Registering with a nil object to ORB "                            "doesn't throw bad param with minor code 27/n"));    }  return errors;}

intACE_OS::string_to_argv (ACE_TCHAR *buf,                        int &argc,                        ACE_TCHAR **&argv,                        int substitute_env_args){  // Reset the number of arguments  argc = 0;  if (buf == 0)    return -1;  ACE_TCHAR *cp = buf;  // First pass: count arguments.  // '#' is the start-comment token..  while (*cp != ACE_LIB_TEXT ('/0') && *cp != ACE_LIB_TEXT ('#'))    {      // Skip whitespace..      while (ACE_OS::ace_isspace (*cp))        cp++;      // Increment count and move to next whitespace..      if (*cp != ACE_LIB_TEXT ('/0'))        argc++;      while (*cp != ACE_LIB_TEXT ('/0') && !ACE_OS::ace_isspace (*cp))        {          // Grok quotes....          if (*cp == ACE_LIB_TEXT ('/'') || *cp == ACE_LIB_TEXT ('"'))            {              ACE_TCHAR quote = *cp;              // Scan past the string..              for (cp++; *cp != ACE_LIB_TEXT ('/0') && *cp != quote; cp++)                continue;              // '/0' implies unmatched quote..              if (*cp == ACE_LIB_TEXT ('/0'))                {                  argc--;                  break;                }              else                cp++;            }          else            cp++;        }    }  // Second pass: copy arguments.  ACE_TCHAR arg[ACE_DEFAULT_ARGV_BUFSIZ];  ACE_TCHAR *argp = arg;  // Make sure that the buffer we're copying into is always large  // enough.  if (cp - buf >= ACE_DEFAULT_ARGV_BUFSIZ)    ACE_NEW_RETURN (argp,                    ACE_TCHAR[cp - buf + 1],                    -1);  // Make a new argv vector of argc + 1 elements.  ACE_NEW_RETURN (argv,                  ACE_TCHAR *[argc + 1],                  -1);  ACE_TCHAR *ptr = buf;  for (int i = 0; i < argc; i++)    {      // Skip whitespace..      while (ACE_OS::ace_isspace (*ptr))        ptr++;      // Copy next argument and move to next whitespace..      cp = argp;      while (*ptr != ACE_LIB_TEXT ('/0') && !ACE_OS::ace_isspace (*ptr))        if (*ptr == ACE_LIB_TEXT ('/'') || *ptr == ACE_LIB_TEXT ('"'))          {            ACE_TCHAR quote = *ptr++;            while (*ptr != ACE_LIB_TEXT ('/0') && *ptr != quote)              *cp++ = *ptr++;            if (*ptr == quote)              ptr++;          }        else          *cp++ = *ptr++;      *cp = ACE_LIB_TEXT ('/0');#if !defined (ACE_LACKS_ENV)      // Check for environment variable substitution here.      if (substitute_env_args) {          argv[i] = ACE_OS::strenvdup(argp);          if (argv[i] == 0)//.........这里部分代码省略.........

intACE_TMAIN(int argc, ACE_TCHAR *argv[]){  Fixed_Priority_Scheduler* scheduler=0;  RTScheduling::Current_var current;  long flags;  int sched_policy = ACE_SCHED_RR;  int sched_scope = ACE_SCOPE_THREAD;  if (sched_policy == ACE_SCHED_RR)    flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_RR;  else    flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_FIFO;  task_stats.init (100000);  try    {      RTScheduling::Scheduler_var sched_owner;      CORBA::ORB_var orb =        CORBA::ORB_init (argc, argv);      CORBA::Object_var poa_object =        orb->resolve_initial_references("RootPOA");      if (CORBA::is_nil (poa_object.in ()))        ACE_ERROR_RETURN ((LM_ERROR,                           " (%P|%t) Unable to initialize the POA./n"),                          1);      PortableServer::POA_var root_poa =        PortableServer::POA::_narrow (poa_object.in ());      PortableServer::POAManager_var poa_manager =        root_poa->the_POAManager ();      if (parse_args (argc, argv) != 0)        return 1;      if (enable_dynamic_scheduling)        {          CORBA::Object_var manager_obj =            orb->resolve_initial_references ("RTSchedulerManager");          TAO_RTScheduler_Manager_var manager =            TAO_RTScheduler_Manager::_narrow (manager_obj.in ());          Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type;          if (enable_yield)            {              disp_impl_type = Kokyu::DSRT_CV_BASED;            }          else            {              disp_impl_type = Kokyu::DSRT_OS_BASED;            }          ACE_NEW_RETURN (scheduler,                          Fixed_Priority_Scheduler (orb.in (),                                         disp_impl_type,                                         sched_policy,                                         sched_scope), -1);          sched_owner = scheduler;          manager->rtscheduler (scheduler);          CORBA::Object_var object =            orb->resolve_initial_references ("RTScheduler_Current");          current  =            RTScheduling::Current::_narrow (object.in ());        }      Simple_Server_i server_impl (orb.in (),                                   current.in (),                                   task_stats,                                   enable_yield);      Simple_Server_var server =        server_impl._this ();      CORBA::String_var ior =        orb->object_to_string (server.in ());      ACE_DEBUG ((LM_DEBUG, "Activated as <%C>/n", ior.in ()));      // If the ior_output_file exists, output the ior to it      if (ior_output_file != 0)        {          FILE *output_file= ACE_OS::fopen (ior_output_file, "w");          if (output_file == 0)            ACE_ERROR_RETURN ((LM_ERROR,                               "Cannot open output file for writing IOR: %s",                               ior_output_file),                              1);          ACE_OS::fprintf (output_file, "%s", ior.in ());          ACE_OS::fclose (output_file);        }//.........这里部分代码省略.........

intACE_Capabilities::fillent (const ACE_TCHAR *buf){  this->resetcaps ();  while (*buf)    {      ACE_TString s;      int n;      ACE_TString name;      ACE_CapEntry *ce;      // Skip blanks      while (*buf && ACE_OS::ace_isspace(*buf)) buf++;      // If we get end of line return      if (*buf == ACE_TEXT ('/0'))        break;      if (*buf == ACE_TEXT ('#'))        {          while (*buf && *buf != ACE_TEXT ('/n'))            buf++;          if (*buf == ACE_TEXT ('/n'))            buf++;          continue;        }      while(*buf && *buf != ACE_TEXT ('=')            && *buf!= ACE_TEXT ('#')            && *buf != ACE_TEXT (','))        name += *buf++;      // If name is null.      switch (*buf)        {        case ACE_TEXT ('='):          // String property          buf = this->parse (buf + 1, s);          ACE_NEW_RETURN (ce,                          ACE_StringCapEntry (s),                          -1);          if (this->caps_.bind (name, ce) == -1)            {              delete ce;              return -1;            }          break;        case ACE_TEXT ('#'):          // Integer property          buf = this->parse (buf + 1, n);          ACE_NEW_RETURN (ce,                          ACE_IntCapEntry (n),                          -1);          if (this->caps_.bind (name, ce) == -1)            {              delete ce;              return -1;            }          break;        case ACE_TEXT (','):          // Boolean          ACE_NEW_RETURN (ce,                          ACE_BoolCapEntry (1),                          -1);          if (this->caps_.bind (name, ce) == -1)            {              delete ce;              return -1;            }          break;        default:          return 0;        }      if (*buf++ != ACE_TEXT (','))        return -1;    }  return 0;}

template <ACE_SYNCH_DECL> intACE_Stream<ACE_SYNCH_USE>::open (void *a,                                 ACE_Module<ACE_SYNCH_USE> *head,                                 ACE_Module<ACE_SYNCH_USE> *tail){    ACE_TRACE ("ACE_Stream<ACE_SYNCH_USE>::open");    ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1);    ACE_Task<ACE_SYNCH_USE> *h1 = 0, *h2 = 0;    ACE_Task<ACE_SYNCH_USE> *t1 = 0, *t2 = 0;    if (head == 0)    {        ACE_NEW_RETURN (h1,                        ACE_Stream_Head<ACE_SYNCH_USE>,                        -1);        ACE_NEW_RETURN (h2,                        ACE_Stream_Head<ACE_SYNCH_USE>,                        -1);        ACE_NEW_RETURN (head,                        ACE_Module<ACE_SYNCH_USE> (ACE_TEXT ("ACE_Stream_Head"),                                h1, h2,                                a,                                M_DELETE),                        -1);    }    if (tail == 0)    {        ACE_NEW_RETURN (t1,                        ACE_Stream_Tail<ACE_SYNCH_USE>,                        -1);        ACE_NEW_RETURN (t2,                        ACE_Stream_Tail<ACE_SYNCH_USE>,                        -1);        ACE_NEW_RETURN (tail,                        ACE_Module<ACE_SYNCH_USE> (ACE_TEXT ("ACE_Stream_Tail"),                                t1, t2,                                a,                                M_DELETE),                        -1);    }    // Make sure *all* the allocation succeeded!    if ((head == 0 && (h1 == 0 || h2 == 0))            || (tail == 0 && (t1 == 0 || t2 == 0)))    {        delete h1;        delete h2;        delete t1;        delete t2;        delete head;        delete tail;        errno = ENOMEM;        return -1;    }    this->stream_head_ = head;    this->stream_tail_ = tail;    if (this->push_module (this->stream_tail_) == -1)        return -1;    else if (this->push_module (this->stream_head_,                                this->stream_tail_,                                this->stream_head_) == -1)        return -1;    return 0;}

intACE_TMAIN(int argc, ACE_TCHAR *argv[]){  try    {      CORBA::ORB_var orb =        CORBA::ORB_init (argc, argv);      CORBA::Object_var poa_object =        orb->resolve_initial_references ("RootPOA");      if (CORBA::is_nil (poa_object.in ()))        ACE_ERROR_RETURN ((LM_ERROR,                           ACE_TEXT ("SERVER: Unable to initialize the POA./n")),                          1);      PortableServer::POA_var root_poa =        PortableServer::POA::_narrow (poa_object.in ());      PortableServer::POAManager_var poa_manager =        root_poa->the_POAManager ();      if (::parse_args (argc, argv) != 0)        return -1;      // Servant      test_i *servant = 0;      ACE_NEW_RETURN (servant,                      test_i (0, orb.in ()),                      -1);      PortableServer::ServantBase_var safe (servant);      PortableServer::ObjectId_var oid =        root_poa->activate_object (servant);      CORBA::Object_var obj =        root_poa->servant_to_reference (servant);      CORBA::String_var ior =        orb->object_to_string (obj.in ());      ACE_DEBUG ((LM_DEBUG,                  ACE_TEXT ("SERVER: test_i servant: <%C>/n"),                  ior.in ()));      poa_manager->activate ();      // IOR      FILE *output_file= ACE_OS::fopen (ior_file, "w");      if (output_file == 0)        ACE_ERROR_RETURN ((LM_ERROR,                           ACE_TEXT ("SERVER: Cannot open output file <%s> ")                           ACE_TEXT ("for writting IOR: %C"),                           ior_file,                           ior.in ()),                          1);      ACE_OS::fprintf (output_file, "%s", ior.in ());      ACE_OS::fclose (output_file);      // Run the ORB event loop.      orb->run ();      root_poa->destroy (1, 1);      orb->destroy ();      ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("SERVER: Event loop finished./n")));    }  catch (const CORBA::Exception& ex)    {      ex._tao_print_exception ("Caught exception:");      return -1;    }  return 0;}

 virtual PSession*  create_session(PSessionManager & /*manager*/)   {     PSession * p = 0;     ACE_NEW_RETURN (p, Sender, 0);     return p;   }

intLoad_Balancing_Service::init (int argc, ACE_TCHAR* argv[]){  int result;  CORBA::String_var ior;  try    {      result = this->orb_manager_.init (argc, argv);      if (result == -1)        return result;      // Check the non-ORB arguments.      result = this->parse_args (argc, argv);      if (result < 0)        return result;      CORBA::PolicyList policies (2);      policies.length (2);      // Lifespan policy      policies[0] =        this->orb_manager_.root_poa()->create_lifespan_policy (PortableServer::PERSISTENT);      policies[1] =        this->orb_manager_.root_poa()->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);      PortableServer::POA_var persistent_POA =        this->orb_manager_.root_poa()->create_POA ("persistent",                                                   this->orb_manager_.poa_manager (),                                                   policies);      // Destroy policy objects      for (CORBA::ULong i = 0;           i < policies.length ();           ++i)        {          policies[i]->destroy ();        }      // Create, ref. count, and activate the servant.      Object_Group_Factory_i * factory_servant;      ACE_NEW_RETURN (factory_servant,                      Object_Group_Factory_i (this->orb_manager_.orb (),                                              persistent_POA.in ()),                      -1);      // Activate the POA manager      //PortableServer::ServantBase_var s = factory_servant;      this->orb_manager_.activate_poa_manager ();      CORBA::Object_var objref = factory_servant->_this ();      ior = this->orb_manager_.orb ()->object_to_string (objref.in ());      if (ior.in () == 0)        return -1;      else if (TAO_debug_level > 0)        ACE_DEBUG ((LM_DEBUG,                    "Object Group Factory ior: %s/n",                    ior.in ()));    }  catch (const CORBA::Exception& ex)    {      ex._tao_print_exception ("Load_Balancing_Service::init");      return -1;    }  if (this->ior_output_file_ != 0)    {      ACE_OS::fprintf (this->ior_output_file_,                       "%s",                       ior.in ());      ACE_OS::fclose (this->ior_output_file_);    }  return 0;}

intACE_TMAIN(int argc, ACE_TCHAR *argv[]){  try    {      CORBA::ORB_var orb =        CORBA::ORB_init (argc, argv);      CORBA::Object_var poa_object =        orb->resolve_initial_references("RootPOA");      PortableServer::POA_var root_poa =        PortableServer::POA::_narrow (poa_object.in ());      if (CORBA::is_nil (root_poa.in ()))        ACE_ERROR_RETURN ((LM_ERROR,                           " (%P|%t) Panic: nil RootPOA/n"),                          1);      PortableServer::POAManager_var poa_manager =        root_poa->the_POAManager ();      // Make all oneways "reliable."      {        CORBA::Object_var manager_object =          orb->resolve_initial_references("ORBPolicyManager");        CORBA::PolicyManager_var policy_manager =          CORBA::PolicyManager::_narrow(manager_object.in());        if (CORBA::is_nil (policy_manager.in ()))          ACE_ERROR_RETURN ((LM_ERROR,                             " (%P|%t) Panic: nil PolicyManager/n"),                            1);        CORBA::Any policy_value;        policy_value <<= Messaging::SYNC_WITH_SERVER;        CORBA::PolicyList policies(1); policies.length(1);        policies[0] =          orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,                              policy_value);        policy_manager->set_policy_overrides (policies,                                              CORBA::ADD_OVERRIDE);        policies[0]->destroy ();      }      if (parse_args (argc, argv) != 0)        return 1;      CORBA::Object_var tmp =        orb->string_to_object(ior);      Test::Service_var service =        Test::Service::_narrow(tmp.in ());      if (CORBA::is_nil (service.in ()))        {          ACE_ERROR_RETURN ((LM_DEBUG,                             "Nil service reference <%s>/n",                             ior),                            1);        }      Callback *callback_impl;      ACE_NEW_RETURN (callback_impl,                      Callback(orb.in ()),                      1);      PortableServer::ServantBase_var owner_transfer(callback_impl);      PortableServer::ObjectId_var id =        root_poa->activate_object (callback_impl);      CORBA::Object_var object = root_poa->id_to_reference (id.in ());      Test::Callback_var callback =        Test::Callback::_narrow (object.in ());      poa_manager->activate ();      ACE_DEBUG ((LM_DEBUG,                  "(%P|%t) client - starting test/n"));      service->run_test (callback.in ());      ACE_DEBUG ((LM_DEBUG,                  "(%P|%t) client - running ORB/n"));      orb->run ();      root_poa->destroy (1, 1);      orb->destroy ();    }  catch (const CORBA::Exception& ex)    {      ex._tao_print_exception ("Exception caught:");      return 1;    }  return 0;//.........这里部分代码省略.........

intACE_TMAIN (int, ACE_TCHAR *[]){  // Construct a new thread manager for the input device task.  Auto  // ptr ensures memory is freed when we exit this scope.  ACE_Thread_Manager *input_task_mgr;  ACE_NEW_RETURN (input_task_mgr,                  ACE_Thread_Manager,                  -1);  auto_ptr <ACE_Thread_Manager> mgr (input_task_mgr);  // Construct a new input device wrapper.  Auto ptr ensures memory is  // freed when we exit this scope.  Text_Input_Device_Wrapper *input_device;  ACE_NEW_RETURN (input_device,                  Text_Input_Device_Wrapper (input_task_mgr,                                             sizeof (input_text),                                             input_text),                  -1);  auto_ptr <Text_Input_Device_Wrapper> input (input_device);  // Construct a new output device wrapper.  Auto ptr ensures memory  // is freed when we exit this scope.  Text_Output_Device_Wrapper *output_device = 0;  ACE_NEW_RETURN (output_device,                  Text_Output_Device_Wrapper,                  -1);  auto_ptr <Text_Output_Device_Wrapper> output (output_device);  // Construct a new bounded packet relay.  Auto ptr ensures memory is  // freed when we exit this scope.  Bounded_Packet_Relay *packet_relay = 0;  ACE_NEW_RETURN (packet_relay,                  Bounded_Packet_Relay (input_task_mgr,                                        input_device,                                        output_device),                  -1);  auto_ptr <Bounded_Packet_Relay> relay (packet_relay);  // Construct a receive input callback command for the relay, and register  // it with the input device.  Auto ptr ensures memory is freed when we exit  // this scope.  INPUT_CALLBACK *input_callback = 0;  ACE_NEW_RETURN (input_callback,                  INPUT_CALLBACK (*packet_relay,                                  &Bounded_Packet_Relay::receive_input),                  -1);  auto_ptr <INPUT_CALLBACK> callback (input_callback);  if (input_device->set_send_input_msg_cmd (input_callback) < 0)    {      ACE_ERROR_RETURN ((LM_ERROR,                         "failed to register input callback"),                        -1);    }  // Construct a new bounded packet relay driver.  Auto ptr ensures  // memory is freed when we exit this scope.  THREAD_BOUNDED_PACKET_RELAY_DRIVER *tbprd = 0;  ACE_NEW_RETURN (tbprd,                  Thread_Bounded_Packet_Relay_Driver (packet_relay),                  -1);  auto_ptr <THREAD_BOUNDED_PACKET_RELAY_DRIVER> driver (tbprd);  return driver->run ();  // All dynamically allocated memory is released when main() returns.}

/// Gets a list of the files in the archive.int ZIP_Wrapper::file_list_info (char* zip_name,                                 ACE_Double_Linked_List<ZIP_File_Info> &list){  unzFile uf=0;  char filename_try[MAXFILENAME+16] = "";  if (zip_name!=0)    {      ACE_OS::strncpy(filename_try, zip_name, MAXFILENAME-1);      /* strncpy doesnt append the trailing NULL, if the string is too long. */      filename_try[ MAXFILENAME ] = '/0';      /* open the zip file */      uf = unzOpen(zip_name);      /* if zipfile could not be opened, try appending .zip to name */      if (uf==0)        {          ACE_OS::strcat(filename_try, ".zip");          uf = unzOpen(filename_try);        }    }  /* If zipfile could not be opened still, return */  if (uf==0)    {      DANCE_ERROR (DANCE_LOG_ERROR,                   (LM_DEBUG, ACE_TEXT("There is some problem in opening")                    ACE_TEXT(" %s or %s.zip using unzOpen/n"), zip_name, zip_name));      return 1;    }  unz_global_info gi;  /* get information about all the files in zip file*/  int err = unzGetGlobalInfo(uf, &gi);  if (err!=UNZ_OK)    DANCE_ERROR (DANCE_LOG_ERROR,                 (LM_DEBUG, ACE_TEXT("unzGetGlobalInfo failed while trying")                  ACE_TEXT(" to get global information about zipfile/n"), err));  /* gi.number_entry corresponds to the number of directory entries     in the zip file */  for (uLong i=0;i<gi.number_entry;i++)    {      char filename_inzip[256];      unz_file_info file_info;      /* get information about the current file in zip file */      err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip,                                  sizeof(filename_inzip), 0, 0, 0, 0);      if (err!=UNZ_OK)        {          DANCE_ERROR (DANCE_LOG_ERROR,                       (LM_DEBUG, ACE_TEXT("unzGetCurrentFileInfo failed")                        ACE_TEXT(" while trying to get information")                        ACE_TEXT(" about current file/n"), err));          break;        }      ZIP_File_Info* next = 0;      ACE_NEW_RETURN (next, ZIP_File_Info (filename_inzip,                      sizeof(filename_inzip)), -1);      /* add information about current file to the list */      list.insert_tail (next);      if ((i+1)<gi.number_entry)        {          err = unzGoToNextFile(uf);          if (err!=UNZ_OK)          {            DANCE_ERROR (DANCE_LOG_ERROR,                         (LM_DEBUG,                          ACE_TEXT(" unzGoToNextFile failed")                          ACE_TEXT(" while trying to go to next file/n"),                          err));            break;          }        }    }  unzCloseCurrentFile(uf);  return gi.number_entry;}

pid_tACE_Process_Manager::wait (pid_t pid,                           const ACE_Time_Value &timeout,                           ACE_exitcode *status){  ACE_TRACE ("ACE_Process_Manager::wait");  ACE_exitcode local_stat = 0;  if (status == 0)    status = &local_stat;  *status = 0;  ssize_t idx = -1;  ACE_Process *proc = 0;  {    // fake context after which the lock is released    ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, -1));    if (pid != 0)      {        idx = this->find_proc (pid);        if (idx == -1)          return ACE_INVALID_PID;        else          proc = process_table_[idx].process_;      }    // release the lock.  }  if (proc != 0)    pid = proc->wait (timeout, status);  else    {      ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, -1));      // Wait for any Process spawned by this Process_Manager.#if defined (ACE_WIN32)      HANDLE *handles = 0;      ACE_NEW_RETURN (handles,                      HANDLE[this->current_count_],                      ACE_INVALID_PID);      for (size_t i = 0;           i < this->current_count_;           ++i)        handles[i] =          process_table_[i].process_->gethandle ();      DWORD handle_count = static_cast<DWORD> (this->current_count_);      DWORD result = ::WaitForMultipleObjects (handle_count,                                               handles,                                               FALSE,                                               timeout == ACE_Time_Value::max_time                                               ? INFINITE                                               : timeout.msec ());      if (result == WAIT_FAILED)        pid = ACE_INVALID_PID;      else if (result == WAIT_TIMEOUT)        pid = 0;      else        {          // Green Hills produces a warning that result >=          // WAIT_OBJECT_0 is a pointless comparison because          // WAIT_OBJECT_0 is zero and DWORD is unsigned long, so this          // test is skipped for Green Hills.  Same for mingw.# if defined (__MINGW32__) || defined (_MSC_VER)          ACE_ASSERT (result < WAIT_OBJECT_0 + this->current_count_);# else          ACE_ASSERT (result >= WAIT_OBJECT_0                      && result < WAIT_OBJECT_0 + this->current_count_);# endif          idx = this->find_proc (handles[result - WAIT_OBJECT_0]);          if (idx != -1)            {              pid = process_table_[idx].process_->getpid ();              result = ::GetExitCodeProcess (handles[result - WAIT_OBJECT_0],                                             status);              if (result == 0)                {                  // <GetExitCodeProcess> failed!                  this->remove_proc (idx);                  pid = ACE_INVALID_PID;                }            }          else            {              // uh oh...handle removed from process_table_, even though              // we're holding a lock!              delete [] handles;              ACELIB_ERROR_RETURN ((LM_ERROR,                                 ACE_TEXT ("Process removed")                                 ACE_TEXT (" -- somebody's ignoring the lock!/n")),                                -1);            }        }      delete [] handles;//.........这里部分代码省略.........

intACE_SOCK_SEQPACK_Association::get_local_addrs (ACE_INET_Addr *addrs, size_t &size) const{  ACE_TRACE ("ACE_SOCK_SEQPACK_Association::get_local_addrs");#if defined (ACE_HAS_LKSCTP)  /*    The size of ACE_INET_Addr must be large enough to hold the number of    local addresses on the machine.  If the array is too small, the function    will only return the number of addresses that will fit.  If the array is    too large, the 'size' parameter will be modified to indicate the number    of addrs.    We will call sctp_getladdrs() which accepts 3 parameters    1. a socket fd    2. a sctp association_id which will be ignored since we are using       tcp sockets    3. a pointer to sockaddr    lksctp/draft will allocate memory and we are responsible for freeing    it by calling sctp_freeladdrs().  */  sockaddr_in *si = 0;  sockaddr *laddrs = 0;  int err = 0;  size_t len = 0;#ifndef ACE_HAS_VOID_PTR_SCTP_GETLADDRS  err = sctp_getladdrs(this->get_handle(), 0, &laddrs);#else  err = sctp_getladdrs(this->get_handle(), 0, reinterpret_cast<void**>(&laddrs));#endif /* ACE_HAS_VOID_PTR_SCTP_GETPADDRS */  if (err > 0)  {    len = err;    // check to see if we have more addresses than we have    // space in our ACE_INET_Addr array    if (len > size)    {      // since our array is too small, we will only copy the first      // few that fit      len = size;    }    for (size_t i = 0; i < len; i++)    {      // first we cast the sockaddr to sockaddr_in      // since we only support ipv4 at this time.      si = (sockaddr_in *) (&(laddrs[i]));      // now we fillup the ace_inet_addr array      addrs[i].set_addr(si, sizeof(sockaddr_in));      addrs[i].set_type(si->sin_family);      addrs[i].set_size(sizeof(sockaddr_in));    }  }  else /* err < 0 */  {    // sctp_getladdrs will return -1 on error    return -1;  }  // indicate the num of addrs returned to the calling function  size = len;  // make sure we free the struct using the system function  sctp_freeladdrs(laddrs);#else  /*    We will be calling ACE_OS::getsockname, which accepts (and    potentially modifies) two reference parameters:    1.  a sockaddr_in* that points to a buffer    2.  an int* that points to the size of this buffer    The OpenSS7 implementation of SCTP copies an array of ipv4    sockaddr_in into the buffer.  Then, if the size of the buffer is    greater than the size used, the size parameter is reduced    accordingly.  */  // The array of sockaddr_in will be stored in an ACE_Auto_Array_Ptr,  // which causes dynamically-allocated memory to be released as soon  // as the ACE_Auto_Array_Ptr goes out of scope.  ACE_Auto_Array_Ptr<sockaddr_in> addr_structs;  // Allocate memory for this array.  Return -1 if the memory cannot  // be allocated.  (This activity requires a temporary variable---a  // bare sockaddr_in* --- because ACE_NEW_RETURN cannot act directory on  // an ACE_Auto_Array_Ptr.)  {    sockaddr_in *addr_structs_bootstrap = 0;    ACE_NEW_RETURN (addr_structs_bootstrap, sockaddr_in[size], -1);    addr_structs.reset(addr_structs_bootstrap);  }//.........这里部分代码省略.........

ACE_Message_Block *ACE_Message_Block::duplicate (void) const{  ACE_TRACE ("ACE_Message_Block::duplicate");  ACE_Message_Block *nb = 0;  // Create a new <ACE_Message_Block> that contains unique copies of  // the message block fields, but a reference counted duplicate of  // the <ACE_Data_Block>.  // If there is no allocator, use the standard new and delete calls.  if (this->message_block_allocator_ == 0)    ACE_NEW_RETURN (nb,                    ACE_Message_Block (0, // size                                       ACE_Message_Type (0), // type                                       0, // cont                                       0, // data                                       0, // allocator                                       0, // locking strategy                                       0, // flags                                       this->priority_, // priority                                       ACE_EXECUTION_TIME,                                       ACE_DEADLINE_TIME,                                       // Get a pointer to a                                       // "duplicated" <ACE_Data_Block>                                       // (will simply increment the                                       // reference count).                                       this->data_block ()->duplicate  (),                                       this->data_block ()->data_block_allocator (),                                       this->message_block_allocator_),                  0);  else // Otherwise, use the message_block_allocator passed in.    ACE_NEW_MALLOC_RETURN (nb,                           static_cast<ACE_Message_Block*> (                             message_block_allocator_->malloc (sizeof (ACE_Message_Block))),                           ACE_Message_Block (0, // size                                              ACE_Message_Type (0), // type                                              0, // cont                                              0, // data                                              0, // allocator                                              0, // locking strategy                                              0, // flags                                              this->priority_, // priority                                              ACE_EXECUTION_TIME,                                              ACE_DEADLINE_TIME,                                              // Get a pointer to a                                              // "duplicated" <ACE_Data_Block>                                              // (will simply increment the                                              // reference count).                                              this->data_block ()->duplicate  (),                                              this->data_block ()->data_block_allocator (),                                              this->message_block_allocator_),                           0);  // Set the read and write pointers in the new <Message_Block> to the  // same relative offset as in the existing <Message_Block>.  Note  // that we are assuming that the data_block()->base() pointer  // doesn't change when it's duplicated.  nb->rd_ptr (this->rd_ptr_);  nb->wr_ptr (this->wr_ptr_);  // Increment the reference counts of all the continuation messages.  if (this->cont_)    {      nb->cont_ = this->cont_->duplicate ();      // If things go wrong, release all of our resources and return      // 0.      if (nb->cont_ == 0)        {          nb->release ();          nb = 0;        }    }  return nb;}

int CellAcceptor::handle_input(ACE_HANDLE fd) {    //ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)CellAcceptor::handle_input - New incoming connection/n")));    CellSvcHandler *client;    ThreadPerConnection *tpc = new ThreadPerConnection();    //ACE_Strong_Bound_Ptr<ThreadPerConnection, ACE_Recursive_Thread_Mutex>* tpcPrt = new      //      ACE_Strong_Bound_Ptr<ThreadPerConnection, ACE_Recursive_Thread_Mutex > (tpc);    ExecutionModelPtr* tpcPrt = new ExecutionModelPtr (tpc);    ACE_NEW_RETURN(client,            CellSvcHandler(m_cell,  tpcPrt, 0, 0, 0), -1);    auto_ptr<CellSvcHandler> p(client);    if (this->m_acceptor.accept(client->peer()) == -1)        ACE_ERROR_RETURN((LM_ERROR,            ACE_TEXT("(%T) failed to accept/n")),            -1);    p.release();    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO CellAcceptor::handle_input - new connection %d!/n"), client->get_handle()));    CPUPriorityQoS* cpuQoS = new CPUPriorityQoS(CPUQoS::SCHEDULE_RT_DEFAULT, CPUQoS::MAX_RT_PRIO);    CPUReservation* reserve = 0;    if (m_cell->getQoSManager() != 0) {        reserve = m_cell->getQoSManager()->createCPUReservation("HRT", cpuQoS);    }    //printf("==================== %p %p /n/n/n/n",cpuQoS,reserve);    tpc->bind(client);    tpc->open(reserve, cpuQoS);    if (client->open() == -1) {        printf("CellAcceptor: failed to eopn client == -1/n");        delete client;        return 0;    }    UUIDPtr uuid;    m_cell->getPID(uuid);    UUIDPtr fid;    m_cell->getFID(fid);    CellIDPtr cellID;    m_cell->getCellID(cellID);    if (client->isLeaf()) {        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: CellAcceptor::handle_input() - Add new children peer (%s,%s)/n"),                cellID->toString().c_str(), client->getCellID()->toString().c_str()));        if(m_leafGroup->add(client) == -1){            return 0;        }    } else {        if (client->isChildren()) {            CellIDPtr runtimeCellID;            m_cell->getCellID(runtimeCellID);            ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: CellAcceptor::handle_input() - Add new children peer (%s,%s)/n"),                    runtimeCellID->toString().c_str(), client->getCellID()->toString().c_str()));            if(m_childrenGroup->add(client)==-1){                return 0;            }        } else {            ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: CellAcceptor::handle_input() - Add group peer/n")));            if(m_cellGroup->add(client) == -1){                return 0;            }            ACE_Connector<CellFollowerClientHandler, ACE_SOCK_Connector> connector;            ThreadPerConnection *tpc = new ThreadPerConnection();            //ACE_Strong_Bound_Ptr<ThreadPerConnection, ACE_Recursive_Thread_Mutex>* tpcPrt = new            //        ACE_Strong_Bound_Ptr<ThreadPerConnection, ACE_Recursive_Thread_Mutex > (tpc);            ExecutionModelPtr* tpcPrt = new ExecutionModelPtr(tpc);            CellFollowerClientHandler* followerClient = new CellFollowerClientHandler(                    client->getPID(), client->getFID(), m_cell,                    //true, false,                    false,false,                    tpcPrt,                    0, 0, 0);            CPUQoS* followerCPUQoS = new CPUPriorityQoS(CPUQoS::SCHEDULE_RT_DEFAULT, CPUQoS::MAX_RT_PRIO);            CPUReservation* followerReserve = 0;            if (m_cell->getQoSManager() != 0) {                followerReserve = m_cell->getQoSManager()->createCPUReservation("HRT", cpuQoS);            }            tpc->bind(followerClient);            tpc->open(followerReserve,followerCPUQoS);            connector.reactor(tpc->getResources()->getReactor());            ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: Connecting to follower...(%s)!/n"), client->getPID()->toString().c_str()));            if (connector.connect(followerClient, client->getFollowerEndpoint()->getAddr()) == -1) {                ACE_ERROR((LM_ERROR, ACE_TEXT("CellAcceptor::handle_input follower connection failed/n")));                followerClient->close();                throw ServiceException("Error connecting to follower!");            } else {                ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: Cell:joinNonCoordinator() - Connect OK!/n")));            }            if(m_cellFollowerGroup->add(followerClient) == -1){                client->close();                return 0;            }            if (followerClient->asynchronous(true, false)) {                followerClient->close();            }        }    }//.........这里部分代码省略.........