[Boost-commit] svn:boost r68864 - sandbox/guild/pool/boost/pool/detail

Subject: [Boost-commit] svn:boost r68864 - sandbox/guild/pool/boost/pool/detail
From: john_at_[hidden]
Date: 2011-02-14 11:41:23

Author: johnmaddock
Date: 2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
New Revision: 68864
URL: http://svn.boost.org/trac/boost/changeset/68864

Log:
Rename *.inc file to *.ipp.
Added:
   sandbox/guild/pool/boost/pool/detail/pool_construct.ipp
      - copied unchanged from r68863, /sandbox/guild/pool/boost/pool/detail/pool_construct.inc
   sandbox/guild/pool/boost/pool/detail/pool_construct_simple.ipp
      - copied unchanged from r68863, /sandbox/guild/pool/boost/pool/detail/pool_construct_simple.inc
Removed:
   sandbox/guild/pool/boost/pool/detail/pool_construct.inc
   sandbox/guild/pool/boost/pool/detail/pool_construct_simple.inc
Text files modified: 
   sandbox/guild/pool/boost/pool/detail/pool_construct.bat        |     6 +++---                                  
   sandbox/guild/pool/boost/pool/detail/pool_construct.sh         |     3 ++-                                     
   sandbox/guild/pool/boost/pool/detail/pool_construct_simple.bat |     6 +++---                                  
   sandbox/guild/pool/boost/pool/detail/pool_construct_simple.sh  |     3 ++-                                     
   4 files changed, 10 insertions(+), 8 deletions(-)

Modified: sandbox/guild/pool/boost/pool/detail/pool_construct.bat
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/pool_construct.bat	(original)
+++ sandbox/guild/pool/boost/pool/detail/pool_construct.bat	2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
@@ -11,7 +11,7 @@
 if %OS%==Windows_NT goto NT
 
 rem Not NT - run m4 as normal, then exit
-m4 -P -E -DNumberOfArguments=%1 pool_construct.m4 > pool_construct.inc
+m4 -P -E -DNumberOfArguments=%1 pool_construct.m4 > pool_construct.ipp
 goto end
 
 rem DJGPP programs (including m4) running on Windows/NT do NOT support long
@@ -19,6 +19,6 @@
 rem Note that the output doesn't have to be a short name because it's an
 rem  argument to the command shell, not m4.
 :NT
-m4 -P -E -DNumberOfArguments=%1 < pool_construct.m4 > pool_construct.inc
+m4 -P -E -DNumberOfArguments=%1 < pool_construct.m4 > pool_construct.ipp
 
-:end
\ No newline at end of file
+:end

Deleted: sandbox/guild/pool/boost/pool/detail/pool_construct.inc
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/pool_construct.inc	2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
+++ (empty file)
@@ -1,852 +0,0 @@
-// Copyright (C) 2000 Stephen Cleary
-//
-// 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 "stdin"
-//  Do NOT include directly!
-//  Do NOT edit!
-
-template <typename T0>
-element_type * construct(T0 & a0)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0>
-element_type * construct(const T0 & a0)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0>
-element_type * construct(volatile T0 & a0)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0>
-element_type * construct(const volatile T0 & a0)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0, typename T1>
-element_type * construct(T0 & a0, T1 & a1)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0, typename T1>
-element_type * construct(const T0 & a0, T1 & a1)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0, typename T1>
-element_type * construct(volatile T0 & a0, T1 & a1)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0, typename T1>
-element_type * construct(T0 & a0, const T1 & a1)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-template <typename T0, typename T1>
-element_type * construct(T0 & a0, volatile T1 & a1)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-

Modified: sandbox/guild/pool/boost/pool/detail/pool_construct.sh
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/pool_construct.sh	(original)
+++ sandbox/guild/pool/boost/pool/detail/pool_construct.sh	2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
@@ -8,4 +8,5 @@
 # See http://www.boost.org for updates, documentation, and revision history.
 #
 
-m4 -P -E -DNumberOfArguments=$1 pool_construct.m4 > pool_construct.inc
+m4 -P -E -DNumberOfArguments=$1 pool_construct.m4 > pool_construct.ipp
+

Modified: sandbox/guild/pool/boost/pool/detail/pool_construct_simple.bat
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/pool_construct_simple.bat	(original)
+++ sandbox/guild/pool/boost/pool/detail/pool_construct_simple.bat	2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
@@ -12,7 +12,7 @@
 if %OS%==Windows_NT goto NT
 
 rem Not NT - run m4 as normal, then exit
-m4 -P -E -DNumberOfArguments=%1 pool_construct_simple.m4 > pool_construct_simple.inc
+m4 -P -E -DNumberOfArguments=%1 pool_construct_simple.m4 > pool_construct_simple.ipp
 goto end
 
 rem DJGPP programs (including m4) running on Windows/NT do NOT support long
@@ -20,6 +20,6 @@
 rem Note that the output doesn't have to be a short name because it's an
 rem  argument to the command shell, not m4.
 :NT
-m4 -P -E -DNumberOfArguments=%1 < pool_construct_simple.m4 > pool_construct_simple.inc
+m4 -P -E -DNumberOfArguments=%1 < pool_construct_simple.m4 > pool_construct_simple.ipp
 
-:end
\ No newline at end of file
+:end

Deleted: sandbox/guild/pool/boost/pool/detail/pool_construct_simple.inc
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/pool_construct_simple.inc	2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
+++ (empty file)
@@ -1,43 +0,0 @@
-// 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)
-//
-// See http://www.boost.org for updates, documentation, and revision history.
-
-// This file was AUTOMATICALLY GENERATED from "stdin"
-//  Do NOT include directly!
-//  Do NOT edit!
-
-template <typename T0>
-element_type * construct(const T0 & a0)
-{
-  element_type * const ret = (malloc)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1); }
-  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)();
-  if (ret == 0)
-    return ret;
-  try { new (ret) element_type(a0, a1, a2); }
-  catch (...) { (free)(ret); throw; }
-  return ret;
-}
-

Modified: sandbox/guild/pool/boost/pool/detail/pool_construct_simple.sh
==============================================================================
--- sandbox/guild/pool/boost/pool/detail/pool_construct_simple.sh	(original)
+++ sandbox/guild/pool/boost/pool/detail/pool_construct_simple.sh	2011-02-14 11:41:20 EST (Mon, 14 Feb 2011)
@@ -8,4 +8,5 @@
 # See http://www.boost.org for updates, documentation, and revision history.
 #
 
-m4 -P -E -DNumberOfArguments=$1 pool_construct_simple.m4 > pool_construct_simple.inc
+m4 -P -E -DNumberOfArguments=$1 pool_construct_simple.m4 > pool_construct_simple.ipp
+