Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r63009 - in trunk: boost/pool boost/pool/detail libs/pool/test
From: steven_at_[hidden]
Date: 2010-06-15 22:27:19


Author: steven_watanabe
Date: 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
New Revision: 63009
URL: http://svn.boost.org/trac/boost/changeset/63009

Log:
Protect Boost.Pool from evil #defines of malloc and free. Fixes #4346.
Text files modified:
   trunk/boost/pool/detail/pool_construct.inc | 343 +++++++++++++++++++--------------------
   trunk/boost/pool/detail/pool_construct.m4 | 4
   trunk/boost/pool/detail/pool_construct_simple.inc | 12
   trunk/boost/pool/detail/pool_construct_simple.m4 | 11
   trunk/boost/pool/object_pool.hpp | 12
   trunk/boost/pool/pool.hpp | 34 +-
   trunk/boost/pool/pool_alloc.hpp | 20 +-
   trunk/boost/pool/simple_segregated_storage.hpp | 6
   trunk/boost/pool/singleton_pool.hpp | 12
   trunk/libs/pool/test/test_pool_alloc.cpp | 14
   10 files changed, 233 insertions(+), 235 deletions(-)

Modified: trunk/boost/pool/detail/pool_construct.inc
==============================================================================
--- trunk/boost/pool/detail/pool_construct.inc (original)
+++ trunk/boost/pool/detail/pool_construct.inc 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -1,853 +1,852 @@
 // Copyright (C) 2000 Stephen Cleary
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org for updates, documentation, and revision history.
 
-// This file was AUTOMATICALLY GENERATED from "pool_c~1.m4"
+// This file was AUTOMATICALLY GENERATED from "stdin"
 // Do NOT include directly!
 // Do NOT edit!
 
 template <typename T0>
 element_type * construct(T0 & a0)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0>
 element_type * construct(const T0 & a0)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0>
 element_type * construct(volatile T0 & a0)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0>
 element_type * construct(const volatile T0 & a0)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(T0 & a0, T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const T0 & a0, T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(volatile T0 & a0, T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const volatile T0 & a0, T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(T0 & a0, const T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const T0 & a0, const T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(volatile T0 & a0, const T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const volatile T0 & a0, const T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(T0 & a0, volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const T0 & a0, volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(volatile T0 & a0, volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const volatile T0 & a0, volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(T0 & a0, const volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const T0 & a0, const volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(volatile T0 & a0, const volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const volatile T0 & a0, const volatile T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 

Modified: trunk/boost/pool/detail/pool_construct.m4
==============================================================================
--- trunk/boost/pool/detail/pool_construct.m4 (original)
+++ trunk/boost/pool/detail/pool_construct.m4 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -74,11 +74,11 @@
 element_type * construct(BOOST_M4_FOR(i, 0, N,
     `cv_qual(m4_eval((cv >> (i * 2)) % 4))T`'i & a`'i', `, '))
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(BOOST_M4_FOR(i, 0, N, `a`'i', `, ')); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 ')')

Modified: trunk/boost/pool/detail/pool_construct_simple.inc
==============================================================================
--- trunk/boost/pool/detail/pool_construct_simple.inc (original)
+++ trunk/boost/pool/detail/pool_construct_simple.inc 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -13,31 +13,31 @@
 template <typename T0>
 element_type * construct(const T0 & a0)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1>
 element_type * construct(const T0 & a0, const T1 & a1)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 template <typename T0, typename T1, typename T2>
 element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(a0, a1, a2); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 

Modified: trunk/boost/pool/detail/pool_construct_simple.m4
==============================================================================
--- trunk/boost/pool/detail/pool_construct_simple.m4 (original)
+++ trunk/boost/pool/detail/pool_construct_simple.m4 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -40,10 +40,9 @@
 m4_dnl
 // Copyright (C) 2000 Stephen Cleary
 //
-// This file can be redistributed and/or modified under the terms found
-// in "copyright.html"
-// This software and its documentation is provided "as is" without express or
-// implied warranty, and with no claim as to its suitability for any purpose.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org for updates, documentation, and revision history.
 
@@ -63,11 +62,11 @@
 element_type * construct(BOOST_M4_FOR(i, 0, N,
     `const T`'i & a`'i', `, '))
 {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
   if (ret == 0)
     return ret;
   try { new (ret) element_type(BOOST_M4_FOR(i, 0, N, `a`'i', `, ')); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
   return ret;
 }
 ')

Modified: trunk/boost/pool/object_pool.hpp
==============================================================================
--- trunk/boost/pool/object_pool.hpp (original)
+++ trunk/boost/pool/object_pool.hpp 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -59,20 +59,20 @@
     ~object_pool();
 
     // Returns 0 if out-of-memory
- element_type * malloc()
+ element_type * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
     { return static_cast<element_type *>(store().ordered_malloc()); }
- void free(element_type * const chunk)
+ void free BOOST_PREVENT_MACRO_SUBSTITUTION(element_type * const chunk)
     { store().ordered_free(chunk); }
     bool is_from(element_type * const chunk) const
     { return store().is_from(chunk); }
 
     element_type * construct()
     {
- element_type * const ret = malloc();
+ element_type * const ret = (malloc)();
       if (ret == 0)
         return ret;
       try { new (ret) element_type(); }
- catch (...) { free(ret); throw; }
+ catch (...) { (free)(ret); throw; }
       return ret;
     }
 
@@ -87,7 +87,7 @@
     void destroy(element_type * const chunk)
     {
       chunk->~T();
- free(chunk);
+ (free)(chunk);
     }
 
     // These functions are extensions!
@@ -136,7 +136,7 @@
     }
 
     // free storage
- UserAllocator::free(iter.begin());
+ (UserAllocator::free)(iter.begin());
 
     // increment iter
     iter = next;

Modified: trunk/boost/pool/pool.hpp
==============================================================================
--- trunk/boost/pool/pool.hpp (original)
+++ trunk/boost/pool/pool.hpp 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -51,9 +51,9 @@
   typedef std::size_t size_type;
   typedef std::ptrdiff_t difference_type;
 
- static char * malloc(const size_type bytes)
+ static char * malloc BOOST_PREVENT_MACRO_SUBSTITUTION(const size_type bytes)
   { return new (std::nothrow) char[bytes]; }
- static void free(char * const block)
+ static void free BOOST_PREVENT_MACRO_SUBSTITUTION(char * const block)
   { delete [] block; }
 };
 
@@ -62,9 +62,9 @@
   typedef std::size_t size_type;
   typedef std::ptrdiff_t difference_type;
 
- static char * malloc(const size_type bytes)
+ static char * malloc BOOST_PREVENT_MACRO_SUBSTITUTION(const size_type bytes)
   { return static_cast<char *>(std::malloc(bytes)); }
- static void free(char * const block)
+ static void free BOOST_PREVENT_MACRO_SUBSTITUTION(char * const block)
   { std::free(block); }
 };
 
@@ -218,11 +218,11 @@
     // free chunks. Only if we need to get another memory block do we call
     // the non-inlined *_need_resize() functions.
     // Returns 0 if out-of-memory
- void * malloc()
+ void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
     {
       // Look for a non-empty storage
       if (!store().empty())
- return store().malloc();
+ return (store().malloc)();
       return malloc_need_resize();
     }
 
@@ -230,7 +230,7 @@
     {
       // Look for a non-empty storage
       if (!store().empty())
- return store().malloc();
+ return (store().malloc)();
       return ordered_malloc_need_resize();
     }
 
@@ -240,8 +240,8 @@
 
     // pre: 'chunk' must have been previously
     // returned by *this.malloc().
- void free(void * const chunk)
- { store().free(chunk); }
+ void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const chunk)
+ { (store().free)(chunk); }
 
     // pre: 'chunk' must have been previously
     // returned by *this.malloc().
@@ -250,7 +250,7 @@
 
     // pre: 'chunk' must have been previously
     // returned by *this.malloc(n).
- void free(void * const chunks, const size_type n)
+ void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const chunks, const size_type n)
     {
       const size_type partition_size = alloc_size();
       const size_type total_req_size = n * requested_size;
@@ -390,7 +390,7 @@
         this->first = free_p;
 
       // And release memory
- UserAllocator::free(ptr.begin());
+ (UserAllocator::free)(ptr.begin());
       ret = true;
     }
 
@@ -416,7 +416,7 @@
     const details::PODptr<size_type> next = iter.next();
 
     // delete the storage
- UserAllocator::free(iter.begin());
+ (UserAllocator::free)(iter.begin());
 
     // increment iter
     iter = next;
@@ -436,7 +436,7 @@
   const size_type partition_size = alloc_size();
   const size_type POD_size = next_size * partition_size +
       details::pool::ct_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type);
- char * const ptr = UserAllocator::malloc(POD_size);
+ char * const ptr = (UserAllocator::malloc)(POD_size);
   if (ptr == 0)
     return 0;
   const details::PODptr<size_type> node(ptr, POD_size);
@@ -450,7 +450,7 @@
   list = node;
 
   // and return a chunk from it.
- return store().malloc();
+ return (store().malloc)();
 }
 
 template <typename UserAllocator>
@@ -460,7 +460,7 @@
   const size_type partition_size = alloc_size();
   const size_type POD_size = next_size * partition_size +
       details::pool::ct_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type);
- char * const ptr = UserAllocator::malloc(POD_size);
+ char * const ptr = (UserAllocator::malloc)(POD_size);
   if (ptr == 0)
     return 0;
   const details::PODptr<size_type> node(ptr, POD_size);
@@ -499,7 +499,7 @@
   }
 
   // and return a chunk from it.
- return store().malloc();
+ return (store().malloc)();
 }
 
 template <typename UserAllocator>
@@ -520,7 +520,7 @@
   next_size = max BOOST_PREVENT_MACRO_SUBSTITUTION(next_size, num_chunks);
   const size_type POD_size = next_size * partition_size +
       details::pool::ct_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type);
- char * const ptr = UserAllocator::malloc(POD_size);
+ char * const ptr = (UserAllocator::malloc)(POD_size);
   if (ptr == 0)
     return 0;
   const details::PODptr<size_type> node(ptr, POD_size);

Modified: trunk/boost/pool/pool_alloc.hpp
==============================================================================
--- trunk/boost/pool/pool_alloc.hpp (original)
+++ trunk/boost/pool/pool_alloc.hpp 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -222,8 +222,8 @@
     {
       const pointer ret = (n == 1) ?
           static_cast<pointer>(
- singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::malloc() ) :
+ (singleton_pool<fast_pool_allocator_tag, sizeof(T),
+ UserAllocator, Mutex, NextSize>::malloc)() ) :
           static_cast<pointer>(
               singleton_pool<fast_pool_allocator_tag, sizeof(T),
                   UserAllocator, Mutex, NextSize>::ordered_malloc(n) );
@@ -236,8 +236,8 @@
     static pointer allocate()
     {
       const pointer ret = static_cast<pointer>(
- singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::malloc() );
+ (singleton_pool<fast_pool_allocator_tag, sizeof(T),
+ UserAllocator, Mutex, NextSize>::malloc)() );
       if (ret == 0)
         boost::throw_exception(std::bad_alloc());
       return ret;
@@ -249,16 +249,16 @@
         return;
 #endif
       if (n == 1)
- singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::free(ptr);
+ (singleton_pool<fast_pool_allocator_tag, sizeof(T),
+ UserAllocator, Mutex, NextSize>::free)(ptr);
       else
- singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::free(ptr, n);
+ (singleton_pool<fast_pool_allocator_tag, sizeof(T),
+ UserAllocator, Mutex, NextSize>::free)(ptr, n);
     }
     static void deallocate(const pointer ptr)
     {
- singleton_pool<fast_pool_allocator_tag, sizeof(T),
- UserAllocator, Mutex, NextSize>::free(ptr);
+ (singleton_pool<fast_pool_allocator_tag, sizeof(T),
+ UserAllocator, Mutex, NextSize>::free)(ptr);
     }
 };
 

Modified: trunk/boost/pool/simple_segregated_storage.hpp
==============================================================================
--- trunk/boost/pool/simple_segregated_storage.hpp (original)
+++ trunk/boost/pool/simple_segregated_storage.hpp 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -96,7 +96,7 @@
     bool empty() const { return (first == 0); }
 
     // pre: !empty()
- void * malloc()
+ void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
     {
       void * const ret = first;
 
@@ -108,7 +108,7 @@
     // pre: chunk was previously returned from a malloc() referring to the
     // same free list
     // post: !empty()
- void free(void * const chunk)
+ void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const chunk)
     {
       nextof(chunk) = first;
       first = chunk;
@@ -127,7 +127,7 @@
 
       // Place either at beginning or in middle/end
       if (loc == 0)
- free(chunk);
+ (free)(chunk);
       else
       {
         nextof(chunk) = nextof(loc);

Modified: trunk/boost/pool/singleton_pool.hpp
==============================================================================
--- trunk/boost/pool/singleton_pool.hpp (original)
+++ trunk/boost/pool/singleton_pool.hpp 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -52,11 +52,11 @@
     singleton_pool();
 
   public:
- static void * malloc()
+ static void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
     {
       pool_type & p = singleton::instance();
       details::pool::guard<Mutex> g(p);
- return p.p.malloc();
+ return (p.p.malloc)();
     }
     static void * ordered_malloc()
     {
@@ -76,11 +76,11 @@
       details::pool::guard<Mutex> g(p);
       return p.p.is_from(ptr);
     }
- static void free(void * const ptr)
+ static void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const ptr)
     {
       pool_type & p = singleton::instance();
       details::pool::guard<Mutex> g(p);
- p.p.free(ptr);
+ (p.p.free)(ptr);
     }
     static void ordered_free(void * const ptr)
     {
@@ -88,11 +88,11 @@
       details::pool::guard<Mutex> g(p);
       p.p.ordered_free(ptr);
     }
- static void free(void * const ptr, const size_type n)
+ static void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const ptr, const size_type n)
     {
       pool_type & p = singleton::instance();
       details::pool::guard<Mutex> g(p);
- p.p.free(ptr, n);
+ (p.p.free)(ptr, n);
     }
     static void ordered_free(void * const ptr, const size_type n)
     {

Modified: trunk/libs/pool/test/test_pool_alloc.cpp
==============================================================================
--- trunk/libs/pool/test/test_pool_alloc.cpp (original)
+++ trunk/libs/pool/test/test_pool_alloc.cpp 2010-06-15 22:27:17 EDT (Tue, 15 Jun 2010)
@@ -236,18 +236,18 @@
 
   static std::set<char *> allocated_blocks;
 
- static char * malloc(const size_type bytes)
+ static char * malloc BOOST_PREVENT_MACRO_SUBSTITUTION(const size_type bytes)
   {
- char * const ret = UserAllocator::malloc(bytes);
+ char * const ret = (UserAllocator::malloc)(bytes);
     allocated_blocks.insert(ret);
     return ret;
   }
- static void free(char * const block)
+ static void free BOOST_PREVENT_MACRO_SUBSTITUTION(char * const block)
   {
     if (allocated_blocks.find(block) == allocated_blocks.end())
       std::cout << "Free'd non-malloc'ed block: " << (void *) block << std::endl;
     allocated_blocks.erase(block);
- UserAllocator::free(block);
+ (UserAllocator::free)(block);
   }
 
   static bool ok() { return allocated_blocks.empty(); }
@@ -276,7 +276,7 @@
       std::cout << "Pool purged memory" << std::endl;
 
     // Should allocate from system
- pool.free(pool.malloc());
+ (pool.free)((pool.malloc)());
     if (track_alloc::ok())
       std::cout << "Memory error" << std::endl;
 
@@ -287,7 +287,7 @@
       std::cout << "Memory error" << std::endl;
 
     // Should allocate from system again
- pool.malloc(); // loses the pointer to the returned chunk (*A*)
+ (pool.malloc)(); // loses the pointer to the returned chunk (*A*)
 
     // Ask pool to give up memory it's not using; this should fail
     if (pool.release_memory())
@@ -301,7 +301,7 @@
       std::cout << "Memory error" << std::endl;
 
     // Should allocate from system again
- pool.malloc(); // loses the pointer to the returned chunk (*B*)
+ (pool.malloc)(); // loses the pointer to the returned chunk (*B*)
 
     // pool's destructor should purge the memory
     // This will clean up the memory leak from (*B*)


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk