diff options
50 files changed, 376 insertions, 176 deletions
diff --git a/ChangeLog b/ChangeLog index b1d6786345c..26c8a9a738a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,53 @@ +Wed Apr 19 11:48:12 UTC 2006 Johnny Willemsen <jwillemsen@remedy.nl> + + Merged ACE changes from sendfile branch. Also made a lot of const + improvements throughout ACE. + + Tue Apr 4 10:20:36 2006 Ossama Othman <ossama@dre.vanderbilt.edu> + + * ace/Mem_Map.cpp (open): + + Only copy the filename to the ACE_Mem_Map::filename_ member + if the call to open() succeeds. + + * ace/PI_Malloc.h (ACE_Malloc_Header): + + Added missing private and undefined copy constructor. The + corresponding assignment operator was already there. + + Wed Mar 29 14:51:12 2006 Johnny Willemsen <jwillemsen@remedy.nl> + + * ace/config-sunos5.8.h: + Solaris 8 and newer also support sendfile. It seems HPUX also + supports it but with a different signature and semantics, so just + don't try it there yet. + + Wed Mar 29 13:06:12 2006 Johnny Willemsen <jwillemsen@remedy.nl> + + * ace/MMAP_Memory_Pool.{h,cpp,inl}: + Added new .inl file to implement the new mmap accessors, include + this new file in the header and implementation file + + Wed Mar 29 08:00:12 2006 Ossama Othman <ossama@dre.vanderbilt.edu> + + * ace/OS_NS_sys_sendfile.cpp + * ace/OS_NS_sys_sendfile.h + * ace/OS_NS_sys_sendfile.inl + New sendfile wrapper + + * ace/MMAP_Memory_Pool.h: + Added accessors for mmap + + * ace/ace.mpc + Added OS_NS_sys_sendfile + + * ace/config-linux-common.h + Added ACE_HAS_SENDFILE + Wed Apr 19 07:48:12 UTC 2006 Johnny Willemsen <jwillemsen@remedy.nl> + Merged ACE changes from sequpdate3 branch + * ace/config-osf1-3.2.h: Removed, very old diff --git a/TAO/performance-tests/Throughput/Receiver.cpp b/TAO/performance-tests/Throughput/Receiver.cpp index 79ac824f5d4..f4a90012325 100644 --- a/TAO/performance-tests/Throughput/Receiver.cpp +++ b/TAO/performance-tests/Throughput/Receiver.cpp @@ -39,7 +39,7 @@ Receiver::receive_data (const Test::Message &the_message } this->last_message_id_ = the_message.message_id; } - this->message_count_++; + ++this->message_count_; this->byte_count_ += the_message.the_payload.length (); this->last_message_time_ = now; } diff --git a/TAO/performance-tests/Throughput/Receiver_Factory.cpp b/TAO/performance-tests/Throughput/Receiver_Factory.cpp index c804588b9b6..c101aeee34e 100644 --- a/TAO/performance-tests/Throughput/Receiver_Factory.cpp +++ b/TAO/performance-tests/Throughput/Receiver_Factory.cpp @@ -15,7 +15,7 @@ Test::Receiver_ptr Receiver_Factory::create_receiver (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - Receiver *receiver_impl; + Receiver *receiver_impl = 0; ACE_NEW_THROW_EX (receiver_impl, Receiver, CORBA::NO_MEMORY ()); diff --git a/TAO/performance-tests/Throughput/Throughput.mpc b/TAO/performance-tests/Throughput/Throughput.mpc index fbf91754ef9..ca5e5b74cac 100644 --- a/TAO/performance-tests/Throughput/Throughput.mpc +++ b/TAO/performance-tests/Throughput/Throughput.mpc @@ -8,7 +8,7 @@ project(*idl): taoidldefaults { custom_only = 1 } -project(*server): taoexe, portableserver, strategies { +project(*server): taoserver, strategies { after += *idl Source_Files { Receiver_Factory.cpp @@ -21,7 +21,7 @@ project(*server): taoexe, portableserver, strategies { } } -project(*client):taoexe, strategies { +project(*client): taoclient, strategies { after += *idl Source_Files { TestC.cpp diff --git a/TAO/performance-tests/Throughput/run_test.pl b/TAO/performance-tests/Throughput/run_test.pl index 216081e452d..38adfa5b275 100755 --- a/TAO/performance-tests/Throughput/run_test.pl +++ b/TAO/performance-tests/Throughput/run_test.pl @@ -23,7 +23,12 @@ $CL = new PerlACE::Process ("client", " -ORBSvcConf $svc_conf -ORBNoDelay 1" . " -x"); -$SV->Spawn (); +$server = $SV->Spawn (); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + exit 1; +} if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { print STDERR "ERROR: cannot find file <$iorfile>\n"; diff --git a/TAO/tests/Big_Oneways/run_test.pl b/TAO/tests/Big_Oneways/run_test.pl index bfafef483b6..45175d43e98 100755 --- a/TAO/tests/Big_Oneways/run_test.pl +++ b/TAO/tests/Big_Oneways/run_test.pl @@ -38,8 +38,12 @@ $CL1 = new PerlACE::Process ("client", " -k file://$iorfile"); $CL2 = new PerlACE::Process ("client", " -k file://$iorfile"); $CL3 = new PerlACE::Process ("client", " -k file://$iorfile"); +$server = $SV->Spawn (); -$SV->Spawn (); +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + exit 1; +} if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { print STDERR "ERROR: cannot find file <$iorfile>\n"; diff --git a/TAO/tests/Hello/run_test.pl b/TAO/tests/Hello/run_test.pl index 5d02e3606f1..cb77b93fe3e 100755 --- a/TAO/tests/Hello/run_test.pl +++ b/TAO/tests/Hello/run_test.pl @@ -21,7 +21,12 @@ else { } $CL = new PerlACE::Process ("client", " -k file://$iorfile"); -$SV->Spawn (); +$server = $SV->Spawn (); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + exit 1; +} if (PerlACE::waitforfile_timed ($iorfile, $PerlACE::wait_interval_for_process_creation) == -1) { diff --git a/ace/Activation_Queue.cpp b/ace/Activation_Queue.cpp index 20a1c48df47..28b91b82bd9 100644 --- a/ace/Activation_Queue.cpp +++ b/ace/Activation_Queue.cpp @@ -61,7 +61,7 @@ ACE_Activation_Queue::~ACE_Activation_Queue (void) ACE_Method_Request * ACE_Activation_Queue::dequeue (ACE_Time_Value *tv) { - ACE_Message_Block *mb; + ACE_Message_Block *mb = 0; // Dequeue the message. if (this->queue_->dequeue_head (mb, tv) != -1) @@ -81,7 +81,7 @@ int ACE_Activation_Queue::enqueue (ACE_Method_Request *mr, ACE_Time_Value *tv) { - ACE_Message_Block *mb; + ACE_Message_Block *mb = 0; // We pass sizeof (*mr) here so that flow control will work // correctly. Since we also pass <mr> note that no unnecessary @@ -102,7 +102,7 @@ ACE_Activation_Queue::enqueue (ACE_Method_Request *mr, -1); // Enqueue in priority order. - int result = this->queue_->enqueue_prio (mb, tv); + int const result = this->queue_->enqueue_prio (mb, tv); // Free ACE_Message_Block if enqueue_prio failed. if (result == -1) diff --git a/ace/Caching_Utility_T.cpp b/ace/Caching_Utility_T.cpp index c1b5e52993a..e7f81882af9 100644 --- a/ace/Caching_Utility_T.cpp +++ b/ace/Caching_Utility_T.cpp @@ -56,7 +56,7 @@ ACE_Pair_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::clear_cac // Calculate the no of entries to remove from the cache depending // upon the <purge_percent>. - size_t entries_to_remove + size_t const entries_to_remove = ACE_MAX (static_cast<size_t> (1), static_cast<size_t> (static_cast<double> (purge_percent) / 100 * current_map_size)); @@ -156,7 +156,7 @@ ACE_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUT // Calculate the no of entries to remove from the cache depending // upon the <purge_percent>. - size_t entries_to_remove + size_t const entries_to_remove = ACE_MAX (static_cast<size_t> (1), static_cast<size_t> (static_cast<double> (purge_percent) / 100 * current_map_size)); @@ -266,7 +266,8 @@ ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATO return 0; // Get the number of entries in the container which can be considered for purging. - size_t available_entries = container.current_size () - this->marked_as_closed_entries_; + size_t const available_entries = + container.current_size () - this->marked_as_closed_entries_; // Also whether the number of entries in the cache zero. // Oops! then there is no way out but exiting. @@ -275,7 +276,7 @@ ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATO // Calculate the no of entries to remove from the cache depending // upon the <purge_percent>. - size_t entries_to_remove + size_t const entries_to_remove = ACE_MAX (static_cast<size_t> (1), static_cast<size_t> (static_cast<double> (purge_percent) / 100 * available_entries)); diff --git a/ace/Cleanup.cpp b/ace/Cleanup.cpp index 7bc3c29e523..a2b67825e72 100644 --- a/ace/Cleanup.cpp +++ b/ace/Cleanup.cpp @@ -101,7 +101,7 @@ ACE_Cleanup_Info_Node::~ACE_Cleanup_Info_Node (void) ACE_Cleanup_Info_Node * ACE_Cleanup_Info_Node::insert (const ACE_Cleanup_Info &new_info) { - ACE_Cleanup_Info_Node *new_node; + ACE_Cleanup_Info_Node *new_node = 0; ACE_NEW_RETURN (new_node, ACE_Cleanup_Info_Node (new_info, this), @@ -136,7 +136,7 @@ ACE_OS_Exit_Info::at_exit_i (void *object, // Return -1 and sets errno if unable to allocate storage. Enqueue // at the head and dequeue from the head to get LIFO ordering. - ACE_Cleanup_Info_Node *new_node; + ACE_Cleanup_Info_Node *new_node = 0; if ((new_node = registered_objects_->insert (new_info)) == 0) return -1; diff --git a/ace/Hash_Map_Manager_T.h b/ace/Hash_Map_Manager_T.h index 34533e1d311..903284099d6 100644 --- a/ace/Hash_Map_Manager_T.h +++ b/ace/Hash_Map_Manager_T.h @@ -103,9 +103,9 @@ class ACE_Allocator; * This implementation of a map uses a hash table. Key hashing * is achieved through the HASH_KEY object and key comparison is * achieved through the COMPARE_KEYS object. - * This class uses an <ACE_Allocator> to allocate memory. The + * This class uses an ACE_Allocator to allocate memory. The * user can make this a persistent class by providing an - * <ACE_Allocator> with a persistable memory pool. + * ACE_Allocator with a persistable memory pool. */ template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> class ACE_Hash_Map_Manager_Ex diff --git a/ace/IO_Cntl_Msg.cpp b/ace/IO_Cntl_Msg.cpp index aab5bd3c124..9d64f05dd66 100644 --- a/ace/IO_Cntl_Msg.cpp +++ b/ace/IO_Cntl_Msg.cpp @@ -36,7 +36,7 @@ public: ACE_Module *lower (void) { return this->mod_lower_; } void lower (ACE_Module *l) { this->mod_lower_ = l; } - int count (void) { return this->count_; } + int count (void) const { return this->count_; } void count (int c) { this->count_ = c; } private: diff --git a/ace/Local_Name_Space_T.cpp b/ace/Local_Name_Space_T.cpp index 1523370d947..b626f990dbb 100644 --- a/ace/Local_Name_Space_T.cpp +++ b/ace/Local_Name_Space_T.cpp @@ -330,7 +330,7 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve_i ( size_t len = ACE_OS::strlen (ns_internal.type ()); // Makes a copy here. Caller needs to call delete to free up // memory. - char *new_type; + char *new_type = 0; ACE_NEW_RETURN (new_type, char [len + 1], -1); diff --git a/ace/MMAP_Memory_Pool.cpp b/ace/MMAP_Memory_Pool.cpp index 6ddec5d7621..4cce9fff7d3 100644 --- a/ace/MMAP_Memory_Pool.cpp +++ b/ace/MMAP_Memory_Pool.cpp @@ -13,7 +13,13 @@ #include "ace/Based_Pointer_Repository.h" #endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1 */ -ACE_RCSID(ace, MMAP_Memory_Pool, "$Id$") +#if !defined (__ACE_INLINE__) +#include "ace/MMAP_Memory_Pool.inl" +#endif /* __ACE_INLINE__ */ + +ACE_RCSID(ace, + MMAP_Memory_Pool, + "$Id$") ACE_BEGIN_VERSIONED_NAMESPACE_DECL @@ -222,7 +228,7 @@ ACE_MMAP_Memory_Pool::commit_backing_store_name (size_t rounded_bytes, #endif // Increment by one to put us at the beginning of the next chunk... - map_size++; + ++map_size; #endif /* CHORUS */ return 0; } @@ -473,7 +479,7 @@ ACE_MMAP_Memory_Pool::handle_signal (int signum, siginfo_t *siginfo, ucontext_t if (guess_on_fault_) { // Check if the current mapping is up to date. - off_t current_map_size = ACE_OS::filesize (this->mmap_.handle ()); + off_t const current_map_size = ACE_OS::filesize (this->mmap_.handle ()); if (static_cast<size_t> (current_map_size) == this->mmap_.size ()) { diff --git a/ace/MMAP_Memory_Pool.h b/ace/MMAP_Memory_Pool.h index 0b81e015896..91162b5863c 100644 --- a/ace/MMAP_Memory_Pool.h +++ b/ace/MMAP_Memory_Pool.h @@ -201,6 +201,12 @@ public: /// Dump the state of an object. virtual void dump (void) const; + /// Get reference to underlying ACE_Mem_Map object. + ACE_Mem_Map const & mmap (void) const; + + /// Get reference to underlying ACE_Mem_Map object. + ACE_Mem_Map & mmap (void); + /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -267,10 +273,10 @@ protected: /** * @class ACE_Lite_MMAP_Memory_Pool * - * @brief Make a ``lighter-weight'' memory pool based <ACE_Mem_Map>. + * @brief Make a ``lighter-weight'' memory pool based ACE_Mem_Map. * * This implementation allows memory to be shared between - * processes. However, unlike the <ACE_MMAP_Memory_Pool> + * processes. However, unlike the ACE_MMAP_Memory_Pool * the <sync> methods are no-ops, which means that we don't pay * for the price of flushing the memory to the backing store on * every update. Naturally, this trades off increased @@ -295,5 +301,9 @@ public: ACE_END_VERSIONED_NAMESPACE_DECL +#if defined (__ACE_INLINE__) +#include "ace/MMAP_Memory_Pool.inl" +#endif /* __ACE_INLINE__ */ + #include /**/ "ace/post.h" #endif /* ACE_MMAP_MEMORY_POOL_H */ diff --git a/ace/MMAP_Memory_Pool.inl b/ace/MMAP_Memory_Pool.inl new file mode 100644 index 00000000000..db3f5a7ba0f --- /dev/null +++ b/ace/MMAP_Memory_Pool.inl @@ -0,0 +1,21 @@ +// -*- C++ -*- +// +// $Id$ + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +ACE_INLINE +ACE_Mem_Map const & +ACE_MMAP_Memory_Pool::mmap (void) const +{ + return mmap_; +} + +ACE_INLINE +ACE_Mem_Map & +ACE_MMAP_Memory_Pool::mmap (void) +{ + return mmap_; +} + +ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ace/Malloc.cpp b/ace/Malloc.cpp index 644f8543a4c..acee3942367 100644 --- a/ace/Malloc.cpp +++ b/ace/Malloc.cpp @@ -171,9 +171,9 @@ ACE_Malloc_Stats::dump (void) const ACE_TRACE ("ACE_Malloc_Stats::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - int nblocks = this->nblocks_.value (); - int ninuse = this->ninuse_.value (); - int nchunks = this->nchunks_.value (); + int const nblocks = this->nblocks_.value (); + int const ninuse = this->ninuse_.value (); + int const nchunks = this->nchunks_.value (); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("nblocks = %d"), nblocks)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("\nninuse = %d"), ninuse)); diff --git a/ace/Malloc_Base.h b/ace/Malloc_Base.h index 491e832d59a..048123ad13f 100644 --- a/ace/Malloc_Base.h +++ b/ace/Malloc_Base.h @@ -41,10 +41,10 @@ class ACE_Export ACE_Allocator public: // = Memory Management - /// Get pointer to a default <ACE_Allocator>. + /// Get pointer to a default ACE_Allocator. static ACE_Allocator *instance (void); - /// Set pointer to a process-wide <ACE_Allocator> and return existing + /// Set pointer to a process-wide ACE_Allocator and return existing /// pointer. static ACE_Allocator *instance (ACE_Allocator *); @@ -119,14 +119,14 @@ public: // backing store). /** - * Sync <len> bytes of the memory region to the backing store - * starting at <this->base_addr_>. If <len> == -1 then sync the + * Sync @a len bytes of the memory region to the backing store + * starting at @c this->base_addr_. If @a len == -1 then sync the * whole region. */ virtual int sync (ssize_t len = -1, int flags = MS_SYNC) = 0; - /// Sync <len> bytes of the memory region to the backing store - /// starting at <addr_>. + /// Sync @a len bytes of the memory region to the backing store + /// starting at @a addr. virtual int sync (void *addr, size_t len, int flags = MS_SYNC) = 0; /** @@ -151,7 +151,7 @@ private: // DO NOT ADD ANY STATE (DATA MEMBERS) TO THIS CLASS!!!! See the // <ACE_Allocator::instance> implementation for explanation. - /// Pointer to a process-wide <ACE_Allocator> instance. + /// Pointer to a process-wide ACE_Allocator instance. static ACE_Allocator *allocator_; /// Must delete the <allocator_> if non-0. diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp index 63e33324201..d59436ac2b6 100644 --- a/ace/Malloc_T.cpp +++ b/ace/Malloc_T.cpp @@ -474,7 +474,8 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::open (void) template <ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB> ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ACE_Malloc_T (const ACE_TCHAR *pool_name) - : memory_pool_ (pool_name), + : cb_ptr_ (0), + memory_pool_ (pool_name), bad_flag_ (0) { ACE_TRACE ("ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ACE_Malloc_T"); @@ -496,7 +497,8 @@ template <ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB> ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ACE_Malloc_T (const ACE_TCHAR *pool_name, const ACE_TCHAR *lock_name, const ACE_MEM_POOL_OPTIONS *options) - : memory_pool_ (pool_name, options), + : cb_ptr_ (0), + memory_pool_ (pool_name, options), bad_flag_ (0) { ACE_TRACE ("ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ACE_Malloc_T"); @@ -520,7 +522,8 @@ template <ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB> ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ACE_Malloc_T (const ACE_TCHAR *pool_name, const ACE_MEM_POOL_OPTIONS *options, ACE_LOCK *lock) - : memory_pool_ (pool_name, options), + : cb_ptr_ (0), + memory_pool_ (pool_name, options), lock_ (lock), delete_lock_ (0), bad_flag_ (0) @@ -546,7 +549,8 @@ template <ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB> ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ACE_Malloc_T (const ACE_TCHAR *pool_name, const ACE_TCHAR *lock_name, const void *options) - : memory_pool_ (pool_name, + : cb_ptr_ (0), + memory_pool_ (pool_name, (const ACE_MEM_POOL_OPTIONS *) options), bad_flag_ (0) { @@ -584,7 +588,6 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::remove (void) { ACE_TRACE ("ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::remove"); // ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) destroying ACE_Malloc_T\n"))); - int result = 0; #if defined (ACE_HAS_MALLOC_STATS) this->print_stats (); @@ -595,7 +598,7 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::remove (void) this->lock_->remove (); // Give the memory pool a chance to release its resources. - result = this->memory_pool_.release (); + int const result = this->memory_pool_.release (); // Reset this->cb_ptr_ as it is no longer valid. // There's also no need to keep the reference counter as the @@ -621,7 +624,7 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::shared_malloc (size_t nbytes) return 0; // Round up request to a multiple of the MALLOC_HEADER size. - size_t nunits = + size_t const nunits = (nbytes + sizeof (MALLOC_HEADER) - 1) / sizeof (MALLOC_HEADER) + 1; // Add one for the <MALLOC_HEADER> itself. @@ -778,7 +781,6 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::shared_free (void *ap) if (ap == 0 || this->cb_ptr_ == 0) return; - // Adjust AP to point to the block MALLOC_HEADER MALLOC_HEADER *blockp = ((MALLOC_HEADER *) ap) - 1; MALLOC_HEADER *currp = this->cb_ptr_->freep_; diff --git a/ace/Malloc_T.inl b/ace/Malloc_T.inl index 2de748456af..dee20160cb2 100644 --- a/ace/Malloc_T.inl +++ b/ace/Malloc_T.inl @@ -61,7 +61,7 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::release (int close) ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1); if (this->cb_ptr_ != 0) { - int retv = --this->cb_ptr_->ref_counter_; + int const retv = --this->cb_ptr_->ref_counter_; #if 0 ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P) ACE_Malloc_T::release ->%d\n"), diff --git a/ace/Map_Manager.h b/ace/Map_Manager.h index e4f52edc099..847c7167e2c 100644 --- a/ace/Map_Manager.h +++ b/ace/Map_Manager.h @@ -116,9 +116,9 @@ class ACE_Map_Reverse_Iterator; * The <EXT_ID> must support <operator==>. This constraint can * be alleviated via template specialization, as shown in the * $ACE_ROOT/tests/Conn_Test.cpp test. - * This class uses an <ACE_Allocator> to allocate memory. The + * This class uses an ACE_Allocator to allocate memory. The * user can make this a persistant class by providing an - * <ACE_Allocator> with a persistable memory pool. + * ACE_Allocator with a persistable memory pool. * This implementation of a map uses an array, which is searched * linearly. For more efficient searching you should use the * <ACE_Hash_Map_Manager>. diff --git a/ace/Mem_Map.cpp b/ace/Mem_Map.cpp index 3202d04bc06..32fd2161d60 100644 --- a/ace/Mem_Map.cpp +++ b/ace/Mem_Map.cpp @@ -248,10 +248,6 @@ ACE_Mem_Map::open (const ACE_TCHAR *file_name, { ACE_TRACE ("ACE_Mem_Map::open"); - ACE_OS::strsncpy (this->filename_, - file_name, - MAXPATHLEN); - #if defined (CHORUS) || defined(INTEGRITY) || defined (__QNXNTO__) this->handle_ = ACE_OS::shm_open (file_name, flags, mode, sa); #elif defined (ACE_OPENVMS) @@ -264,6 +260,10 @@ ACE_Mem_Map::open (const ACE_TCHAR *file_name, return -1; else { + ACE_OS::strsncpy (this->filename_, + file_name, + MAXPATHLEN); + this->close_handle_ = 1; return 0; } diff --git a/ace/Message_Block.cpp b/ace/Message_Block.cpp index dc1bfd8f6c7..6e73653de2a 100644 --- a/ace/Message_Block.cpp +++ b/ace/Message_Block.cpp @@ -637,7 +637,7 @@ ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb, // Actual offset for the incoming message block assuming that it // is also aligned to the same "align" byte - size_t wr_offset = mb.wr_ptr_ - (start - mb.base ()); + size_t const wr_offset = mb.wr_ptr_ - (start - mb.base ()); // Copy wr_offset amount of data in to <this->data_block> (void) ACE_OS::memcpy (this->wr_ptr (), @@ -753,7 +753,7 @@ ACE_Data_Block::release_i (void) ACE_Data_Block *result = 0; // decrement reference count - this->reference_count_--; + --this->reference_count_; if (this->reference_count_ == 0) // this will cause deletion of this @@ -965,10 +965,10 @@ ACE_Data_Block::duplicate (void) { // We need to acquire the lock before incrementing the count. ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->locking_strategy_, 0); - this->reference_count_++; + ++this->reference_count_; } else - this->reference_count_++; + ++this->reference_count_; return this; } @@ -1220,6 +1220,7 @@ ACE_Data_Block::base (char *msg_data, if (ACE_BIT_DISABLED (this->flags_, ACE_Message_Block::DONT_DELETE)) this->allocator_strategy_->free (this->base_); + this->max_size_ = msg_length; this->cur_size_ = msg_length; this->base_ = msg_data; diff --git a/ace/Message_Block_T.cpp b/ace/Message_Block_T.cpp index 4c20ed48a6b..d2cf9464ab0 100644 --- a/ace/Message_Block_T.cpp +++ b/ace/Message_Block_T.cpp @@ -28,7 +28,7 @@ ACE_Locked_Data_Block<ACE_LOCK>::clone_nocopy (ACE_Message_Block::Message_Flags const ACE_Message_Block::Message_Flags always_clear = ACE_Message_Block::DONT_DELETE; - ACE_Locked_Data_Block<ACE_LOCK> *nb; + ACE_Locked_Data_Block<ACE_LOCK> *nb = 0; ACE_NEW_MALLOC_RETURN (nb, static_cast<ACE_Locked_Data_Block<ACE_LOCK>*> ( diff --git a/ace/Message_Queue.cpp b/ace/Message_Queue.cpp index fcdee0e14d2..599f5e6b05e 100644 --- a/ace/Message_Queue.cpp +++ b/ace/Message_Queue.cpp @@ -253,7 +253,7 @@ ACE_Message_Queue_Vx::enqueue_tail_i (ACE_Message_Block *new_item) // Don't try to send a composite message!!!! Only the first // block will be sent. - this->cur_count_++; + ++this->cur_count_; // Always use this method to actually send a message on the queue. if (::msgQSend (msgq (), @@ -428,8 +428,8 @@ ACE_Message_Queue_NT::enqueue (ACE_Message_Block *new_item, ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); if (this->state_ != ACE_Message_Queue_Base::DEACTIVATED) { - size_t msize = new_item->total_size (); - size_t mlength = new_item->total_length (); + size_t const msize = new_item->total_size (); + size_t const mlength = new_item->total_length (); // Note - we send ACTIVATED in the 3rd arg to tell the completion // routine it's _NOT_ being woken up because of deactivate(). ULONG_PTR state_to_post; @@ -504,7 +504,7 @@ ACE_Message_Queue_NT::deactivate (void) ACE_TRACE ("ACE_Message_Queue_NT::deactivate"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - int previous_state = this->state_; + int const previous_state = this->state_; if (previous_state != ACE_Message_Queue_Base::DEACTIVATED) { this->state_ = ACE_Message_Queue_Base::DEACTIVATED; @@ -527,7 +527,7 @@ ACE_Message_Queue_NT::activate (void) { ACE_TRACE ("ACE_Message_Queue_NT::activate"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - int previous_status = this->state_; + int const previous_status = this->state_; this->state_ = ACE_Message_Queue_Base::ACTIVATED; return previous_status; } @@ -538,7 +538,7 @@ ACE_Message_Queue_NT::pulse (void) ACE_TRACE ("ACE_Message_Queue_NT::pulse"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - int previous_state = this->state_; + int const previous_state = this->state_; if (previous_state != ACE_Message_Queue_Base::DEACTIVATED) { this->state_ = ACE_Message_Queue_Base::PULSED; diff --git a/ace/Message_Queue_T.cpp b/ace/Message_Queue_T.cpp index 9bfcd5cc5f2..859e8b64e68 100644 --- a/ace/Message_Queue_T.cpp +++ b/ace/Message_Queue_T.cpp @@ -112,7 +112,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::peek_dequeue_head (ACE_ME ACE_Message_Block *mb = 0; - int cur_count = this->queue_.peek_dequeue_head (mb, timeout); + int const cur_count = this->queue_.peek_dequeue_head (mb, timeout); if (cur_count != -1) first_item = reinterpret_cast<ACE_MESSAGE_TYPE *> (mb->base ()); @@ -134,7 +134,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::enqueue_head (ACE_MESSAGE ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::DEFAULT_PRIORITY), -1); - int result = this->queue_.enqueue_head (mb, timeout); + int const result = this->queue_.enqueue_head (mb, timeout); if (result == -1) // Zap the message. mb->release (); @@ -168,7 +168,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::enqueue_prio (ACE_MESSAGE ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::DEFAULT_PRIORITY), -1); - int result = this->queue_.enqueue_prio (mb, timeout); + int const result = this->queue_.enqueue_prio (mb, timeout); if (result == -1) // Zap the message. mb->release (); @@ -190,7 +190,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::enqueue_deadline (ACE_MES ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::DEFAULT_PRIORITY ), -1); - int result = this->queue_.enqueue_deadline (mb, timeout); + int const result = this->queue_.enqueue_deadline (mb, timeout); if (result == -1) // Zap the message. mb->release (); @@ -215,7 +215,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::enqueue_tail (ACE_MESSAGE ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::DEFAULT_PRIORITY), -1); - int result = this->queue_.enqueue_tail (mb, timeout); + int const result = this->queue_.enqueue_tail (mb, timeout); if (result == -1) // Zap the message. mb->release (); @@ -234,7 +234,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_head (ACE_MESSAGE ACE_Message_Block *mb = 0; - int cur_count = this->queue_.dequeue_head (mb, timeout); + int const cur_count = this->queue_.dequeue_head (mb, timeout); // Dequeue the message. if (cur_count != -1) @@ -242,10 +242,9 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_head (ACE_MESSAGE first_item = reinterpret_cast<ACE_MESSAGE_TYPE *> (mb->base ()); // Delete the message block. mb->release (); - return cur_count; } - else - return -1; + + return cur_count; } // Remove the item with the lowest priority from the queue. If timeout == 0 @@ -260,7 +259,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_prio (ACE_MESSAGE ACE_Message_Block *mb = 0; - int cur_count = this->queue_.dequeue_prio (mb, timeout); + int const cur_count = this->queue_.dequeue_prio (mb, timeout); // Dequeue the message. if (cur_count != -1) @@ -268,10 +267,9 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_prio (ACE_MESSAGE dequeued = reinterpret_cast<ACE_MESSAGE_TYPE *> (mb->base ()); // Delete the message block. mb->release (); - return cur_count; } - else - return -1; + + return cur_count; } // Remove an item from the end of the queue. If timeout == 0 block @@ -286,7 +284,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_tail (ACE_MESSAGE ACE_Message_Block *mb = 0; - int cur_count = this->queue_.dequeue_tail (mb, timeout); + int const cur_count = this->queue_.dequeue_tail (mb, timeout); // Dequeue the message. if (cur_count != -1) @@ -294,10 +292,9 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_tail (ACE_MESSAGE dequeued = reinterpret_cast<ACE_MESSAGE_TYPE *> (mb->base ()); // Delete the message block. mb->release (); - return cur_count; } - else - return -1; + + return cur_count; } // Remove an item with the lowest deadline time. If timeout == 0 block @@ -312,7 +309,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_deadline (ACE_MES ACE_Message_Block *mb = 0; - int cur_count = this->queue_.dequeue_deadline (mb, timeout); + int const cur_count = this->queue_.dequeue_deadline (mb, timeout); // Dequeue the message. if (cur_count != -1) @@ -320,10 +317,9 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue_deadline (ACE_MES dequeued = reinterpret_cast<ACE_MESSAGE_TYPE *> (mb->base ()); // Delete the message block. mb->release (); - return cur_count; } - else - return -1; + + return cur_count; } template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int @@ -899,7 +895,7 @@ template <ACE_SYNCH_DECL> int ACE_Message_Queue<ACE_SYNCH_USE>::deactivate_i (int pulse) { ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::deactivate_i"); - int previous_state = this->state_; + int const previous_state = this->state_; if (previous_state != ACE_Message_Queue_Base::DEACTIVATED) { @@ -919,7 +915,7 @@ template <ACE_SYNCH_DECL> int ACE_Message_Queue<ACE_SYNCH_USE>::activate_i (void) { ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::activate_i"); - int previous_state = this->state_; + int const previous_state = this->state_; this->state_ = ACE_Message_Queue_Base::ACTIVATED; return previous_state; } @@ -942,7 +938,7 @@ ACE_Message_Queue<ACE_SYNCH_USE>::close (void) ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::close"); ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); - int result = this->deactivate_i (); + int const result = this->deactivate_i (); // Free up the remaining messages on the queue. this->flush_i (); diff --git a/ace/Metrics_Cache_T.cpp b/ace/Metrics_Cache_T.cpp index 3868df80269..a3850eb2237 100644 --- a/ace/Metrics_Cache_T.cpp +++ b/ace/Metrics_Cache_T.cpp @@ -45,7 +45,7 @@ ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::ACE_Metrics_Timeprobe (u_int id, name = ""; } - char * name_tmp; + char * name_tmp = 0; ACE_NEW_MALLOC_ARRAY (name_tmp, (char *) this->allocator ()->malloc (strlen(name)+1), char, @@ -73,9 +73,8 @@ ACE_Metrics_Timeprobe (ALLOCATOR *alloc, name = ""; } - char * name_tmp; + char * name_tmp = 0; ACE_NEW_MALLOC_ARRAY (name_tmp, -// (char *) this->allocator ()->malloc (strlen(name)+1), (char *) alloc->malloc(strlen(name)+1), char, strlen(name)+1); @@ -101,11 +100,11 @@ ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::~ACE_Metrics_Timeprobe () template <class ACE_LOCK, class ALLOCATOR> int ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::is_event (const ACE_Metrics_Timeprobe<ACE_LOCK, - ALLOCATOR>:: - ACE_METRICS_TIMEPROBE_DATA_TYPE &t, + ALLOCATOR>:: + ACE_METRICS_TIMEPROBE_DATA_TYPE &t, ACE_Metrics_Timeprobe<ACE_LOCK, - ALLOCATOR>:: - event_id id) + ALLOCATOR>:: + event_id id) { return (t.event_.event_number_ == (u_long) id) ? 1 : 0; } @@ -121,7 +120,7 @@ template <class ACE_LOCK, class ALLOCATOR> void ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::probe_name (char * name) { - char * name_tmp; + char * name_tmp = 0; ACE_NEW_MALLOC_ARRAY (name_tmp, (char *) this->allocator ()->malloc (strlen(name)+1), char, diff --git a/ace/Msg_WFMO_Reactor.cpp b/ace/Msg_WFMO_Reactor.cpp index ee6fe44c144..aaedb391b51 100644 --- a/ace/Msg_WFMO_Reactor.cpp +++ b/ace/Msg_WFMO_Reactor.cpp @@ -73,7 +73,7 @@ ACE_Msg_WFMO_Reactor::dispatch_window_messages (void) } ::DispatchMessage (&msg); - number_of_messages++; + ++number_of_messages; } return number_of_messages; diff --git a/ace/Multihomed_INET_Addr.cpp b/ace/Multihomed_INET_Addr.cpp index 33430262e9d..b8d84679e35 100644 --- a/ace/Multihomed_INET_Addr.cpp +++ b/ace/Multihomed_INET_Addr.cpp @@ -119,9 +119,9 @@ ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr(u_short port_number, size_t next_empty_slot = 0; for (size_t i = 0; i < size; ++i) { - int ret = this->secondaries_[next_empty_slot].set(port_number, - secondary_ip_addrs[i], - encode); + int const ret = this->secondaries_[next_empty_slot].set(port_number, + secondary_ip_addrs[i], + encode); if (ret) { ACE_DEBUG ((LM_DEBUG, @@ -150,10 +150,10 @@ ACE_Multihomed_INET_Addr::set (u_short port_number, for (size_t i = 0; i < size; ++i) { - int ret = this->secondaries_[i].set(port_number, - secondary_host_names[i], - encode, - address_family); + int const ret = this->secondaries_[i].set(port_number, + secondary_host_names[i], + encode, + address_family); if (ret) { return ret; } diff --git a/ace/OS_NS_sys_sendfile.cpp b/ace/OS_NS_sys_sendfile.cpp new file mode 100644 index 00000000000..ba731a71acd --- /dev/null +++ b/ace/OS_NS_sys_sendfile.cpp @@ -0,0 +1,37 @@ +// $Id$ + +#include "ace/OS_NS_sys_sendfile.h" +#include "ace/OS_NS_sys_mman.h" +#include "ace/OS_NS_unistd.h" + +#ifndef ACE_HAS_INLINED_OSCALLS +# include "ace/OS_NS_sys_sendfile.inl" +#endif /* ACE_HAS_INLINED_OS_CALLS */ + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +#ifndef ACE_HAS_SENDFILE +ssize_t +ACE_OS::sendfile_emulation (ACE_HANDLE out_fd, + ACE_HANDLE in_fd, + ACE_LOFF_T * offset, + size_t count) +{ + // @@ We may want set up a signal lease (or oplock) if supported by + // the platform so that we don't get a bus error if the mmap()ed + // file is truncated. + void * const buf = + ACE_OS::mmap (0, count, PROT_READ, MAP_PRIVATE, in_fd, *offset); + + ssize_t const r = ACE_OS::write (out_fd, buf, count); + + (void) ACE_OS::munmap (buf, count); + + if (r > 0) + *offset += static_cast<ACE_LOFF_T> (r); + + return r; +} +#endif /* !ACE_HAS_SENDFILE */ + +ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ace/OS_NS_sys_sendfile.h b/ace/OS_NS_sys_sendfile.h new file mode 100644 index 00000000000..3f89c64f2d5 --- /dev/null +++ b/ace/OS_NS_sys_sendfile.h @@ -0,0 +1,64 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file OS_NS_sys_sendfile.h + * + * $Id$ + * + * @author Ossama Othman <ossama@dre.vanderbilt.edu> + */ +//============================================================================= + +#ifndef ACE_OS_NS_SYS_SENDFILE_H +#define ACE_OS_NS_SYS_SENDFILE_H + +#include /**/ "ace/pre.h" + +#include "ace/ACE_export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "ace/Basic_Types.h" /* For ssize_t and off_t. */ + +#if defined (ACE_EXPORT_MACRO) +# undef ACE_EXPORT_MACRO +#endif +#define ACE_EXPORT_MACRO ACE_Export + + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +namespace ACE_OS +{ + /// Finds the length of a string (char version). + ACE_NAMESPACE_INLINE_FUNCTION + ssize_t sendfile (ACE_HANDLE out_fd, + ACE_HANDLE in_fd, + ACE_LOFF_T * offset, + size_t count); + +#ifndef ACE_HAS_SENDFILE + extern ssize_t sendfile_emulation (ACE_HANDLE out_fd, + ACE_HANDLE in_fd, + ACE_LOFF_T * offset, + size_t count); +#endif /* !ACE_HAS_SENDFILE */ + +} + +ACE_END_VERSIONED_NAMESPACE_DECL + +# if defined (ACE_HAS_INLINED_OSCALLS) +# if defined (ACE_INLINE) +# undef ACE_INLINE +# endif /* ACE_INLINE */ +# define ACE_INLINE inline +# include "ace/OS_NS_sys_sendfile.inl" +# endif /* ACE_HAS_INLINED_OSCALLS */ + +#include /**/ "ace/post.h" + +#endif /* ACE_OS_NS_SYS_SENDFILE_H */ diff --git a/ace/OS_NS_sys_sendfile.inl b/ace/OS_NS_sys_sendfile.inl new file mode 100644 index 00000000000..3a1a03b32da --- /dev/null +++ b/ace/OS_NS_sys_sendfile.inl @@ -0,0 +1,20 @@ +// -*- C++ -*- +// +// $Id$ + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +ACE_INLINE ssize_t +ACE_OS::sendfile (ACE_HANDLE out_fd, + ACE_HANDLE in_fd, + ACE_LOFF_T * offset, + size_t count) +{ +#ifdef ACE_HAS_SENDFILE + return sendfile (out_fd, in_fd, offset, count); +#else + return ACE_OS::sendfile_emulation (out_fd, in_fd, offset, count); +#endif /* ACE_HAS_SENDFILE */ +} + +ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ace/PI_Malloc.h b/ace/PI_Malloc.h index b3937a7ff85..07b830e3607 100644 --- a/ace/PI_Malloc.h +++ b/ace/PI_Malloc.h @@ -84,8 +84,9 @@ public: private: - // Disallow assignment. - void operator= (const ACE_Malloc_Header &); + // Disallow copy construction and assignment. + ACE_Malloc_Header (ACE_Malloc_Header const &); + void operator= (ACE_Malloc_Header const &); }; diff --git a/ace/SSL/SSL_Asynch_BIO.cpp b/ace/SSL/SSL_Asynch_BIO.cpp index 9d4c75ad930..972a20e441b 100644 --- a/ace/SSL/SSL_Asynch_BIO.cpp +++ b/ace/SSL/SSL_Asynch_BIO.cpp @@ -13,27 +13,13 @@ ACE_RCSID (ACE_SSL, "$Id$") -#if (defined (ACE_HAS_VERSIONED_NAMESPACE) \ - && ACE_HAS_VERSIONED_NAMESPACE == 1) \ - && !(defined (_MSC_VER) && _MSC_VER <= 1200) -// MSVC++ 6's preprocessor can't handle macro expansions required by -// the versioned namespace support. *sigh* - +#if (defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1) # define ACE_ASYNCH_BIO_WRITE_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_write) # define ACE_ASYNCH_BIO_READ_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_read) # define ACE_ASYNCH_BIO_PUTS_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_puts) # define ACE_ASYNCH_BIO_CTRL_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_ctrl) # define ACE_ASYNCH_BIO_NEW_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_new) # define ACE_ASYNCH_BIO_FREE_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_free) -#else - -# define ACE_ASYNCH_BIO_WRITE_NAME ACE_Asynch_BIO_write -# define ACE_ASYNCH_BIO_READ_NAME ACE_Asynch_BIO_read -# define ACE_ASYNCH_BIO_PUTS_NAME ACE_Asynch_BIO_puts -# define ACE_ASYNCH_BIO_CTRL_NAME ACE_Asynch_BIO_ctrl -# define ACE_ASYNCH_BIO_NEW_NAME ACE_Asynch_BIO_new -# define ACE_ASYNCH_BIO_FREE_NAME ACE_Asynch_BIO_free - #endif /* ACE_HAS_VERSIONED_NAMESPACE == 1 */ diff --git a/ace/SSL/SSL_Context.cpp b/ace/SSL/SSL_Context.cpp index 54ce70a6d2c..f99d97dc017 100644 --- a/ace/SSL/SSL_Context.cpp +++ b/ace/SSL/SSL_Context.cpp @@ -49,20 +49,9 @@ namespace #ifdef ACE_HAS_THREADS -# if (defined (ACE_HAS_VERSIONED_NAMESPACE) \ - && ACE_HAS_VERSIONED_NAMESPACE == 1) \ - && !(defined (_MSC_VER) && _MSC_VER <= 1200) -// MSVC++ 6's preprocessor can't handle macro expansions required by -// the versioned namespace support. *sigh* - +# if (defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1) # define ACE_SSL_LOCKING_CALLBACK_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_SSL_locking_callback) # define ACE_SSL_THREAD_ID_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_SSL_thread_id) - -# else - -# define ACE_SSL_LOCKING_CALLBACK_NAME ACE_SSL_locking_callback -# define ACE_SSL_THREAD_ID_NAME ACE_SSL_thread_id - # endif /* ACE_HAS_VERSIONED_NAMESPACE == 1 */ diff --git a/ace/TLI_Stream.h b/ace/TLI_Stream.h index fc1c93107f4..fe54f76f30b 100644 --- a/ace/TLI_Stream.h +++ b/ace/TLI_Stream.h @@ -124,10 +124,10 @@ private: int rwflag_; /// Get rwflag - int get_rwflag (void); + int get_rwflag (void) const; /// Set rwflag - void set_rwflag (int); + void set_rwflag (int value); }; ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ace/TLI_Stream.inl b/ace/TLI_Stream.inl index a0d03db13c6..8ef7265f8cd 100644 --- a/ace/TLI_Stream.inl +++ b/ace/TLI_Stream.inl @@ -16,7 +16,7 @@ ACE_TLI_Stream::set_rwflag (int value) ACE_INLINE int -ACE_TLI_Stream::get_rwflag (void) +ACE_TLI_Stream::get_rwflag (void) const { ACE_TRACE ("ACE_TLI_Stream::get_rwflag"); return this->rwflag_; diff --git a/ace/Thread_Manager.cpp b/ace/Thread_Manager.cpp index c0b86bef841..46631d312a6 100644 --- a/ace/Thread_Manager.cpp +++ b/ace/Thread_Manager.cpp @@ -638,15 +638,15 @@ ACE_Thread_Manager::spawn_i (ACE_THR_FUNC func, // removing this Thread Descriptor before it gets put into our // thread table. - int result = ACE_Thread::spawn (func, - args, - flags, - t_id, - &thr_handle, - priority, - stack, - stack_size, - thread_args); + int const result = ACE_Thread::spawn (func, + args, + flags, + t_id, + &thr_handle, + priority, + stack, + stack_size, + thread_args); if (result != 0) { @@ -1031,7 +1031,7 @@ ACE_Thread_Manager::suspend_thr (ACE_Thread_Descriptor *td, int) { ACE_TRACE ("ACE_Thread_Manager::suspend_thr"); - int result = ACE_Thread::suspend (td->thr_handle_); + int const result = ACE_Thread::suspend (td->thr_handle_); if (result == -1) { if (errno != ENOTSUP) this->thr_to_be_removed_.enqueue_tail (td); @@ -1048,7 +1048,7 @@ ACE_Thread_Manager::resume_thr (ACE_Thread_Descriptor *td, int) { ACE_TRACE ("ACE_Thread_Manager::resume_thr"); - int result = ACE_Thread::resume (td->thr_handle_); + int const result = ACE_Thread::resume (td->thr_handle_); if (result == -1) { if (errno != ENOTSUP) this->thr_to_be_removed_.enqueue_tail (td); @@ -1087,7 +1087,7 @@ ACE_Thread_Manager::kill_thr (ACE_Thread_Descriptor *td, int signum) tid += tid[0] == ACE_THR_ID_ALLOCATED ? 1 : 0; #endif /* VXWORKS */ - int result = ACE_Thread::kill (tid, signum); + int const result = ACE_Thread::kill (tid, signum); if (result != 0) { diff --git a/ace/Timeprobe_T.cpp b/ace/Timeprobe_T.cpp index c9d971602ff..c148d3acdb9 100644 --- a/ace/Timeprobe_T.cpp +++ b/ace/Timeprobe_T.cpp @@ -47,7 +47,7 @@ ACE_Timeprobe_Ex (ALLOCATOR *allocator, report_buffer_full_ (0), allocator_ (allocator) { - ACE_timeprobe_t *temp; + ACE_timeprobe_t *temp = 0; ACE_NEW_MALLOC_ARRAY (temp, (ACE_timeprobe_t *) this->allocator ()-> malloc (this->max_size_*sizeof(ACE_timeprobe_t)), @@ -99,7 +99,7 @@ ACE_Timeprobe_Ex<ACE_LOCK, ALLOCATOR>::timeprobe (u_long event) this->timeprobes_[this->current_size_].time_ = ACE_OS::gethrtime (); this->timeprobes_[this->current_size_].thread_ = ACE_OS::thr_self (); - this->current_size_++; + ++this->current_size_; } @@ -115,7 +115,7 @@ ACE_Timeprobe_Ex<ACE_LOCK, ALLOCATOR>::timeprobe (const char *event) this->timeprobes_[this->current_size_].time_ = ACE_OS::gethrtime (); this->timeprobes_[this->current_size_].thread_ = ACE_OS::thr_self (); - this->current_size_++; + ++this->current_size_; } template <class ACE_LOCK, class ALLOCATOR> void @@ -134,7 +134,7 @@ ACE_Timeprobe_Ex<ACE_LOCK, ALLOCATOR>::increase_size (u_long size) if (size > this->max_size_) { - ACE_timeprobe_t *temp; + ACE_timeprobe_t *temp = 0; ACE_NEW_MALLOC_ARRAY (temp, (ACE_timeprobe_t *) this->allocator ()-> malloc (this->max_size_ @@ -341,7 +341,7 @@ ACE_Timeprobe_Ex<ACE_LOCK, ALLOCATOR>::find_description_i (u_long i) iterator++, j++) { EVENT_DESCRIPTIONS::iterator next_event_descriptions = iterator; - next_event_descriptions++; + ++next_event_descriptions; if (this->timeprobes_[i].event_.event_number_ < (*next_event_descriptions).minimum_id_) break; diff --git a/ace/Timer_Hash_T.cpp b/ace/Timer_Hash_T.cpp index c0f147cd09e..9f5d51fb8d6 100644 --- a/ace/Timer_Hash_T.cpp +++ b/ace/Timer_Hash_T.cpp @@ -514,9 +514,9 @@ ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET>::cancel (long timer_id, reinterpret_cast<Hash_Token<TYPE> *> (timer_id); #endif /* ACE_WIN64 */ - int result = this->table_[h->pos_]->cancel (h->orig_id_, - 0, - dont_call); + int const result = this->table_[h->pos_]->cancel (h->orig_id_, + 0, + dont_call); if (result == 1) { @@ -591,7 +591,7 @@ ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET>::cancel (const TYPE &type, for (i = 0; i < pos; ++i) { - int result = + int const result = this->table_[timer_ids[i]->pos_]->cancel (timer_ids[i]->orig_id_, 0, dont_call); @@ -678,7 +678,7 @@ template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET>::dispatch_info_i (const ACE_Time_Value &cur_time, ACE_Timer_Node_Dispatch_Info_T<TYPE> &info) { - int result = + int const result = ACE_Timer_Queue_T<TYPE,FUNCTOR,ACE_LOCK>::dispatch_info_i (cur_time, info); diff --git a/ace/Timer_Queue_T.cpp b/ace/Timer_Queue_T.cpp index 749a4e09be8..82030315aab 100644 --- a/ace/Timer_Queue_T.cpp +++ b/ace/Timer_Queue_T.cpp @@ -222,7 +222,7 @@ ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::schedule (const TYPE &type, ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Schedule the timer. - long result = + long const result = this->schedule_i (type, act, future_time, diff --git a/ace/Token.cpp b/ace/Token.cpp index e373a078027..1d4a3b3fe9d 100644 --- a/ace/Token.cpp +++ b/ace/Token.cpp @@ -2,12 +2,12 @@ #include "ace/Token.h" -ACE_RCSID(ace, Token, "$Id$") - #if !defined (__ACE_INLINE__) #include "ace/Token.inl" #endif /* __ACE_INLINE__ */ +ACE_RCSID(ace, Token, "$Id$") + #if defined (ACE_HAS_THREADS) #include "ace/Thread.h" @@ -395,7 +395,7 @@ ACE_Token::renew (int requeue_position, ++this->waiters_; // Remember nesting level... - int save_nesting_level_ = this->nesting_level_; + int const save_nesting_level_ = this->nesting_level_; // Reset state for new owner. this->nesting_level_ = 0; @@ -525,7 +525,7 @@ ACE_Token::wakeup_next_waiter (void) } // Wakeup next waiter. - ACE_Token_Queue *queue; + ACE_Token_Queue *queue = 0; // Writer threads get priority to run first. if (this->writers_.head_ != 0) diff --git a/ace/WFMO_Reactor.cpp b/ace/WFMO_Reactor.cpp index 7ccd0c254f2..ac4d9f88023 100644 --- a/ace/WFMO_Reactor.cpp +++ b/ace/WFMO_Reactor.cpp @@ -194,7 +194,7 @@ ACE_WFMO_Reactor_Handler_Repository::unbind_i (ACE_HANDLE handle, // Remember this value; only if it changes do we need to wakeup // the other threads - size_t original_handle_count = this->handles_to_be_deleted_; + size_t const original_handle_count = this->handles_to_be_deleted_; int result = 0; size_t i; diff --git a/ace/WFMO_Reactor.inl b/ace/WFMO_Reactor.inl index adf8ca96634..bbfdcef7deb 100644 --- a/ace/WFMO_Reactor.inl +++ b/ace/WFMO_Reactor.inl @@ -432,9 +432,9 @@ ACE_WFMO_Reactor_Handler_Repository::unbind (ACE_HANDLE handle, ACE_GUARD_RETURN (ACE_Process_Mutex, ace_mon, this->wfmo_reactor_.lock_, -1); int changes_required = 0; - int result = this->unbind_i (handle, - mask, - changes_required); + int const result = this->unbind_i (handle, + mask, + changes_required); if (changes_required) // Wake up all threads in WaitForMultipleObjects so that they can @@ -685,7 +685,7 @@ ACE_WFMO_Reactor::suspend_handler (ACE_HANDLE handle) ACE_GUARD_RETURN (ACE_Process_Mutex, ace_mon, this->lock_, -1); int changes_required = 0; - int result = + int const result = this->handler_rep_.suspend_handler_i (handle, changes_required); diff --git a/ace/WIN32_Asynch_IO.cpp b/ace/WIN32_Asynch_IO.cpp index d638761d121..55486591de1 100644 --- a/ace/WIN32_Asynch_IO.cpp +++ b/ace/WIN32_Asynch_IO.cpp @@ -177,7 +177,7 @@ ACE_WIN32_Asynch_Operation::cancel (void) // @@ This API returns 0 on failure. So, I am returning -1 in that // case. Is that right? (Alex). - int result = (int) ::CancelIo (this->handle_); + int const result = (int) ::CancelIo (this->handle_); if (result == 0) // Couldnt cancel the operations. @@ -413,7 +413,7 @@ ACE_WIN32_Asynch_Read_Stream::read (ACE_Message_Block &message_block, -1); // Shared read - int return_val = this->shared_read (result); + int const return_val = this->shared_read (result); // Upon errors if (return_val == -1) @@ -470,7 +470,7 @@ ACE_WIN32_Asynch_Read_Stream::readv (ACE_Message_Block &message_block, // Increment iovec counter if there's more to do. if (msg_space > 0) - iovcnt++; + ++iovcnt; } if (msg_space > 0) // Ran out of iovecs before msg_space exhausted { @@ -595,7 +595,7 @@ ACE_WIN32_Asynch_Read_Stream::shared_read (ACE_WIN32_Asynch_Read_Stream_Result * ACE_OS::set_errno_to_last_error (); switch (errno) { - case ERROR_IO_PENDING: + case ERROR_IO_PENDING: /* FALLTHRU */ case ERROR_MORE_DATA: // The IO will complete proactively: the OVERLAPPED will still diff --git a/ace/XTI_ATM_Mcast.cpp b/ace/XTI_ATM_Mcast.cpp index 3ab9dcdad3a..854e2a36489 100644 --- a/ace/XTI_ATM_Mcast.cpp +++ b/ace/XTI_ATM_Mcast.cpp @@ -49,8 +49,7 @@ ACE_XTI_ATM_Mcast::add_leaf (ACE_TLI_Stream ¤t_stream, // Check for asynchronous event if (t_errno == TLOOK) { - int event; - event = ACE_OS::t_look(current_stream.get_handle()); + int const event = ACE_OS::t_look(current_stream.get_handle()); if (event != TNODATA && event != T_DATA) return -1; else diff --git a/ace/XtReactor.cpp b/ace/XtReactor.cpp index d1ed38af310..ab4612c9472 100644 --- a/ace/XtReactor.cpp +++ b/ace/XtReactor.cpp @@ -378,7 +378,7 @@ ACE_XtReactor::reset_timer_interval ACE_TRACE ("ACE_XtReactor::reset_timer_interval"); ACE_MT (ACE_GUARD_RETURN (ACE_Select_Reactor_Token, ace_mon, this->token_, -1)); - int result = ACE_Select_Reactor::timer_queue_->reset_interval + int const result = ACE_Select_Reactor::timer_queue_->reset_interval (timer_id, interval); @@ -400,10 +400,10 @@ ACE_XtReactor::schedule_timer (ACE_Event_Handler *event_handler, ACE_TRACE ("ACE_XtReactor::schedule_timer"); ACE_MT (ACE_GUARD_RETURN (ACE_Select_Reactor_Token, ace_mon, this->token_, -1)); - long result = ACE_Select_Reactor::schedule_timer (event_handler, - arg, - delay, - interval); + long const result = ACE_Select_Reactor::schedule_timer (event_handler, + arg, + delay, + interval); if (result == -1) return -1; else diff --git a/ace/ace.mpc b/ace/ace.mpc index 88b399626f7..4d10b8f77d5 100644 --- a/ace/ace.mpc +++ b/ace/ace.mpc @@ -155,6 +155,7 @@ project(ACE) : acedefaults, core, other, codecs, token, svcconf, uuid, filecache OS_NS_sys_msg.cpp OS_NS_sys_resource.cpp OS_NS_sys_select.cpp + OS_NS_sys_sendfile.cpp OS_NS_sys_shm.cpp OS_NS_sys_socket.cpp OS_NS_sys_stat.cpp diff --git a/ace/config-linux-common.h b/ace/config-linux-common.h index 0352d866371..a0f91d1f175 100644 --- a/ace/config-linux-common.h +++ b/ace/config-linux-common.h @@ -397,6 +397,9 @@ // Platform has POSIX terminal interface. #define ACE_HAS_TERMIOS +// Linux implements sendfile(). +#define ACE_HAS_SENDFILE + #if !defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) // Detect if getsockname() and getpeername() returns random values in // the sockaddr_in::sin_zero field by evaluation of the kernel diff --git a/ace/config-sunos5.8.h b/ace/config-sunos5.8.h index 423fb1de7c4..3d87e08d32b 100644 --- a/ace/config-sunos5.8.h +++ b/ace/config-sunos5.8.h @@ -19,6 +19,8 @@ # define ACE_HAS_TIMEZONE #endif +#define ACE_HAS_SENDFILE + // The range of thread priorities for 5.8 differs from 5.7 in the // minimum priority for the SCHED_OTHER policy (i.e., // ACE_THR_PRI_OTHER_MIN) |