diff -uNr ../stlallocatortestbed.orig/StlAllocatorTestContainer.h ./StlAllocatorTestContainer.h
--- ../stlallocatortestbed.orig/StlAllocatorTestContainer.h	2003-04-11 10:51:56.000000000 +0900
+++ ./StlAllocatorTestContainer.h	2006-03-19 00:11:47.000000000 +0900
@@ -45,11 +45,11 @@
 template< typename Allocator, typename Container >
 void TestVector( const Allocator& a, Container& c )
 {
-    c.push_back( Allocator::value_type() );
+    c.push_back( typename Allocator::value_type() );
     c.clear();
-    c.push_back( Allocator::value_type() );
+    c.push_back( typename Allocator::value_type() );
     c.reserve( 100 );
-    VERIFY( c[0] == Allocator::value_type() );
+    VERIFY( c[0] == typename Allocator::value_type() );
     c.clear();
     USED( a );
     USED( c );
@@ -60,10 +60,10 @@
 template< typename Allocator, typename Container >
 void TestDeque( const Allocator& a, Container& c )
 {
-    c.push_back( Allocator::value_type() );
+    c.push_back( typename Allocator::value_type() );
     c.clear();
-    c.assign( 100, Allocator::value_type() );
-    VERIFY( c.front() == Allocator::value_type() );
+    c.assign( 100, typename Allocator::value_type() );
+    VERIFY( c.front() == typename Allocator::value_type() );
     c.clear();
     USED( a );
     USED( c );
@@ -74,10 +74,10 @@
 template< typename Allocator, typename Container >
 void TestList( const Allocator& a, Container& c )
 {
-    c.push_back( Allocator::value_type() );
+    c.push_back( typename Allocator::value_type() );
     c.clear();
-    c.insert( c.begin(), 100, Allocator::value_type() );
-    VERIFY( c.front() == Allocator::value_type() );
+    c.insert( c.begin(), 100, typename Allocator::value_type() );
+    VERIFY( c.front() == typename Allocator::value_type() );
     c.clear();
     USED( a );
     USED( c );
@@ -88,12 +88,12 @@
 template< typename Allocator, typename Container >
 void TestSet( const Allocator& a, Container& c )
 {
-    c.insert( Allocator::value_type() );
+    c.insert( typename Allocator::value_type() );
     c.clear();
     for( int i = 0; i < 100; ++i )
-        c.insert( Allocator::value_type( i ) );
-    c.insert( Allocator::value_type( 0 ) );        
-    VERIFY( c.find( Allocator::value_type( 0 ) ) == c.begin() );
+        c.insert( typename Allocator::value_type( i ) );
+    c.insert( typename Allocator::value_type( 0 ) );        
+    VERIFY( c.find( typename Allocator::value_type( 0 ) ) == c.begin() );
     c.clear();
     USED( a );
     USED( c );
@@ -104,12 +104,12 @@
 template< typename Allocator, typename Container >
 void TestMap( const Allocator& a, Container& c )
 {
-    c.insert( std::make_pair( Allocator::value_type(), 1 ) );
+    c.insert( std::make_pair( typename Allocator::value_type(), 1 ) );
     c.clear();
     for( int i = 0; i < 100; ++i )
-        c.insert( std::make_pair( Allocator::value_type( i ), i ) );
-    c.insert( std::make_pair( Allocator::value_type( 0 ), 0 ) );
-    VERIFY( c.find( Allocator::value_type( 0 ) ) == c.begin() );
+        c.insert( std::make_pair( typename Allocator::value_type( i ), i ) );
+    c.insert( std::make_pair( typename Allocator::value_type( 0 ), 0 ) );
+    VERIFY( c.find( typename Allocator::value_type( 0 ) ) == c.begin() );
     c.clear();
     USED( a );
     USED( c );
@@ -120,10 +120,10 @@
 template< typename Allocator, typename Container >
 void TestString( const Allocator& a, Container& c )
 {
-    c.push_back( Allocator::value_type() );
+    c.push_back( typename Allocator::value_type() );
     c.clear();
-    c.assign( 100, Allocator::value_type( 1 ) );
-    VERIFY( c.find( Allocator::value_type( 1 ) ) == 0 );
+    c.assign( 100, typename Allocator::value_type( 1 ) );
+    VERIFY( c.find( typename Allocator::value_type( 1 ) ) == 0 );
     c.clear();
     USED( a );
     USED( c );
@@ -137,9 +137,9 @@
     c.push( v );
     c.pop();
     for( int i = 0; i < 100; ++i )
-        c.push( Allocator::value_type( i ) );
+        c.push( typename Allocator::value_type( i ) );
 #if( !defined(_MSC_VER) || _MSC_VER < 1310 )
-    VERIFY( c.top() == Allocator::value_type( 99 ) );
+    VERIFY( c.top() == typename Allocator::value_type( 99 ) );
 #endif    
     for( int i = 0; i < 100; ++i )
         c.pop();
@@ -169,11 +169,11 @@
 template< typename Allocator, typename Container >
 void TestQueue( const Allocator&, Container& c )
 {
-    c.push( Allocator::value_type() );
+    c.push( typename Allocator::value_type() );
     c.pop();
     for( int i = 0; i < 100; ++i )
-        c.push( Allocator::value_type( i ) );
-    VERIFY( c.front() == Allocator::value_type( 0 ) );        
+        c.push( typename Allocator::value_type( i ) );
+    VERIFY( c.front() == typename Allocator::value_type( 0 ) );        
     for( int i = 0; i < 100; ++i )
         c.pop();
     USED( c );
@@ -184,10 +184,10 @@
 template< typename Allocator, typename Container >
 void TestPriorityQueue( const Allocator&, Container& c )
 {
-    c.push( Allocator::value_type() );
+    c.push( typename Allocator::value_type() );
     c.pop();
     for( int i = 0; i < 100; ++i )
-        c.push( Allocator::value_type( i ) );
+        c.push( typename Allocator::value_type( i ) );
     for( int i = 0; i < 100; ++i )
         c.pop();
     USED( c );
@@ -198,10 +198,10 @@
 template< typename Allocator >
 void TestVector( const Allocator& a )
 {
-    typedef std::vector< Allocator::value_type, Allocator > Vector;
+    typedef std::vector< typename Allocator::value_type, Allocator > Vector;
     
-    Vector v1( Policy< Allocator >::GetDefault< Vector >( a ) );
-    Vector v2( Policy< Allocator >::GetCopied< Vector >( a ) );
+    Vector v1( Policy< Allocator >::template GetDefault< Vector >( a ) );
+    Vector v2( Policy< Allocator >::template GetCopied< Vector >( a ) );
     
     TestVector( a, v1 );
     TestVector( a, v2 );
@@ -217,10 +217,10 @@
 template< typename Allocator >
 void TestDeque( const Allocator& a )
 {
-    typedef std::deque< Allocator::value_type, Allocator > Deque;
+    typedef std::deque< typename Allocator::value_type, Allocator > Deque;
     
-    Deque d1( Policy< Allocator >::GetDefault< Deque >( a ) );
-    Deque d2( Policy< Allocator >::GetCopied< Deque >( a ) );
+    Deque d1( Policy< Allocator >::template GetDefault< Deque >( a ) );
+    Deque d2( Policy< Allocator >::template GetCopied< Deque >( a ) );
     
     TestDeque( a, d1 );
     TestDeque( a, d2 );
@@ -236,10 +236,10 @@
 template< typename Allocator >
 void TestList( const Allocator& a )
 {
-    typedef std::list< Allocator::value_type, Allocator > List;
+    typedef std::list< typename Allocator::value_type, Allocator > List;
     
-    List l1( Policy< Allocator >::GetDefault< List >( a ) );
-    List l2( Policy< Allocator >::GetCopied< List >( a ) );
+    List l1( Policy< Allocator >::template GetDefault< List >( a ) );
+    List l2( Policy< Allocator >::template GetCopied< List >( a ) );
     
     TestList( a, l1 );
     TestList( a, l2 );
@@ -260,12 +260,12 @@
 template< typename Allocator >
 void TestSet( const Allocator& a )
 {
-    typedef std::set< Allocator::value_type, 
-                      std::less< Allocator::value_type >,
+    typedef std::set< typename Allocator::value_type, 
+                      std::less< typename Allocator::value_type >,
                       Allocator > Set;
     
-    Set s1( Policy< Allocator >::GetDefaultSet< Set >( a ) );
-    Set s2( Policy< Allocator >::GetCopiedSet< Set >( a ) );
+    Set s1( Policy< Allocator >::template GetDefaultSet< Set >( a ) );
+    Set s2( Policy< Allocator >::template GetCopiedSet< Set >( a ) );
     
     TestSet( a, s1 );
     TestSet( a, s2 );
@@ -281,12 +281,12 @@
 template< typename Allocator >
 void TestMultiset( const Allocator& a )
 {
-    typedef std::multiset< Allocator::value_type, 
-                           std::less< Allocator::value_type >,
+    typedef std::multiset< typename Allocator::value_type, 
+                           std::less< typename Allocator::value_type >,
                            Allocator > Multiset;
     
-    Multiset s1( Policy< Allocator >::GetDefaultSet< Multiset >( a ) );
-    Multiset s2( Policy< Allocator >::GetCopiedSet< Multiset >( a ) );
+    Multiset s1( Policy< Allocator >::template GetDefaultSet< Multiset >( a ) );
+    Multiset s2( Policy< Allocator >::template GetCopiedSet< Multiset >( a ) );
     
     TestSet( a, s1 );
     TestSet( a, s2 );
@@ -303,15 +303,15 @@
 void TestMap( const Allocator& a )
 {
     // map allocators are pair allocators
-    typedef std::pair< const Allocator::value_type, int > Pair;
+    typedef std::pair< const typename Allocator::value_type, int > Pair;
     typedef typename Allocator::template rebind< Pair >::other Alloc;
 
-    typedef std::map< Allocator::value_type, int,
-                      std::less< Allocator::value_type >,
+    typedef std::map< typename Allocator::value_type, int,
+                      std::less< typename Allocator::value_type >,
                       Alloc > Map;
     
-    Map m1( Policy< Allocator >::GetDefaultMap< Map >( a ) );
-    Map m2( Policy< Allocator >::GetCopiedMap< Map >( a ) );
+    Map m1( Policy< Allocator >::template GetDefaultMap< Map >( a ) );
+    Map m2( Policy< Allocator >::template GetCopiedMap< Map >( a ) );
     
     TestMap( a, m1 );
     TestMap( a, m2 );
@@ -328,15 +328,15 @@
 void TestMultimap( const Allocator& a )
 {
     // map allocators are pair allocators
-    typedef std::pair< const Allocator::value_type, int > Pair;
+    typedef std::pair< const typename Allocator::value_type, int > Pair;
     typedef typename Allocator::template rebind< Pair >::other Alloc;
 
-    typedef std::multimap< Allocator::value_type, int,
-                           std::less< Allocator::value_type >,
+    typedef std::multimap< typename Allocator::value_type, int,
+                           std::less< typename Allocator::value_type >,
                            Alloc > Multimap;
     
-    Multimap m1( Policy< Allocator >::GetDefaultMap< Multimap >( a ) );
-    Multimap m2( Policy< Allocator >::GetCopiedMap< Multimap >( a ) );
+    Multimap m1( Policy< Allocator >::template GetDefaultMap< Multimap >( a ) );
+    Multimap m2( Policy< Allocator >::template GetCopiedMap< Multimap >( a ) );
     
     TestMap( a, m1 );
     TestMap( a, m2 );
@@ -366,8 +366,8 @@
     // string
     CharAlloc a( aIn );
 
-    String s1( Policy< Allocator >::GetDefault< String >( a ) );
-    String s2( Policy< Allocator >::GetCopied< String >( a ) );
+    String s1( Policy< Allocator >::template GetDefault< String >( a ) );
+    String s2( Policy< Allocator >::template GetCopied< String >( a ) );
     
     TestString( a, s1 );
     TestString( a, s2 );
@@ -379,8 +379,8 @@
     
     // wstring
     WCharAlloc wa( aIn );
-    WString w1( Policy< Allocator >::GetDefault< WString >( wa ) );
-    WString w2( Policy< Allocator >::GetCopied< WString >( wa ) );
+    WString w1( Policy< Allocator >::template GetDefault< WString >( wa ) );
+    WString w2( Policy< Allocator >::template GetCopied< WString >( wa ) );
     
     TestString( wa, w1 );
     TestString( wa, w2 );
@@ -397,26 +397,26 @@
 void TestStack( const Allocator& a )
 {
     // A stack can be made out of deque or vector
-    typedef std::deque< Allocator::value_type, Allocator > Deque;
-    typedef std::vector< Allocator::value_type, Allocator > Vector;
+    typedef std::deque< typename Allocator::value_type, Allocator > Deque;
+    typedef std::vector< typename Allocator::value_type, Allocator > Vector;
 
-    typedef std::stack< Allocator::value_type, Deque > DStack;
-    typedef std::stack< Allocator::value_type, Vector > VStack;
+    typedef std::stack< typename Allocator::value_type, Deque > DStack;
+    typedef std::stack< typename Allocator::value_type, Vector > VStack;
     
-    DStack d1( Policy< Allocator >::GetDefaultAdapter< DStack, Deque >( a ) );
-    DStack d2( Policy< Allocator >::GetCopiedAdapter< DStack, Deque >( a ) );
-    VStack v1( Policy< Allocator >::GetDefaultAdapter< VStack, Vector >( a ) );
-    VStack v2( Policy< Allocator >::GetCopiedAdapter< VStack, Vector >( a ) );
+    DStack d1( Policy< Allocator >::template GetDefaultAdapter< DStack, Deque >( a ) );
+    DStack d2( Policy< Allocator >::template GetCopiedAdapter< DStack, Deque >( a ) );
+    VStack v1( Policy< Allocator >::template GetDefaultAdapter< VStack, Vector >( a ) );
+    VStack v2( Policy< Allocator >::template GetCopiedAdapter< VStack, Vector >( a ) );
 
-    Allocator::value_type v;
+    typename Allocator::value_type v;
     
     // Test deque stacks
-    TestStack< Allocator::value_type >( v, a, d1 );
-    TestStack< Allocator::value_type >( v, a, d2 );
+    TestStack< typename Allocator::value_type >( v, a, d1 );
+    TestStack< typename Allocator::value_type >( v, a, d2 );
 
     // Test vector stacks    
-    TestStack< Allocator::value_type >( v, a, v1 );
-    TestStack< Allocator::value_type >( v, a, v2 );
+    TestStack< typename Allocator::value_type >( v, a, v1 );
+    TestStack< typename Allocator::value_type >( v, a, v2 );
 }
 
 //-----------------------------------------------------------------------------
@@ -425,16 +425,16 @@
 void TestQueue( const Allocator& a )
 {
     // A queue can be made out of deque or list
-    typedef std::deque< Allocator::value_type, Allocator > Deque;
-    typedef std::list< Allocator::value_type, Allocator > List;
+    typedef std::deque< typename Allocator::value_type, Allocator > Deque;
+    typedef std::list< typename Allocator::value_type, Allocator > List;
 
-    typedef std::queue< Allocator::value_type, Deque > DQueue;
-    typedef std::queue< Allocator::value_type, List > LQueue;
+    typedef std::queue< typename Allocator::value_type, Deque > DQueue;
+    typedef std::queue< typename Allocator::value_type, List > LQueue;
     
-    DQueue d1( Policy< Allocator >::GetDefaultAdapter< DQueue, Deque >( a ) );
-    DQueue d2( Policy< Allocator >::GetCopiedAdapter< DQueue, Deque >( a ) );
-    LQueue l1( Policy< Allocator >::GetDefaultAdapter< LQueue, List >( a ) );
-    LQueue l2( Policy< Allocator >::GetCopiedAdapter< LQueue, List >( a ) );
+    DQueue d1( Policy< Allocator >::template GetDefaultAdapter< DQueue, Deque >( a ) );
+    DQueue d2( Policy< Allocator >::template GetCopiedAdapter< DQueue, Deque >( a ) );
+    LQueue l1( Policy< Allocator >::template GetDefaultAdapter< LQueue, List >( a ) );
+    LQueue l2( Policy< Allocator >::template GetCopiedAdapter< LQueue, List >( a ) );
 
     // Test deque queues
     TestQueue( a, d1 );
@@ -451,16 +451,16 @@
 void TestPriorityQueue( const Allocator& a )
 {
     // A priority queue can be made out of vector or deque
-    typedef std::vector< Allocator::value_type, Allocator > Vector;
-    typedef std::deque< Allocator::value_type, Allocator > Deque;
+    typedef std::vector< typename Allocator::value_type, Allocator > Vector;
+    typedef std::deque< typename Allocator::value_type, Allocator > Deque;
 
-    typedef std::priority_queue< Allocator::value_type, Vector > VQueue;
-    typedef std::priority_queue< Allocator::value_type, Deque > DQueue;
+    typedef std::priority_queue< typename Allocator::value_type, Vector > VQueue;
+    typedef std::priority_queue< typename Allocator::value_type, Deque > DQueue;
     
-    VQueue v1( Policy< Allocator >::GetDefaultPriorityQueue< VQueue, Vector >( a ) );
-    VQueue v2( Policy< Allocator >::GetCopiedPriorityQueue< VQueue, Vector >( a ) );
-    DQueue d1( Policy< Allocator >::GetDefaultPriorityQueue< DQueue, Deque >( a ) );
-    DQueue d2( Policy< Allocator >::GetCopiedPriorityQueue< DQueue, Deque >( a ) );
+    VQueue v1( Policy< Allocator >::template GetDefaultPriorityQueue< VQueue, Vector >( a ) );
+    VQueue v2( Policy< Allocator >::template GetCopiedPriorityQueue< VQueue, Vector >( a ) );
+    DQueue d1( Policy< Allocator >::template GetDefaultPriorityQueue< DQueue, Deque >( a ) );
+    DQueue d2( Policy< Allocator >::template GetCopiedPriorityQueue< DQueue, Deque >( a ) );
 
     // Test vector queues
     TestPriorityQueue( a, v1 );
diff -uNr ../stlallocatortestbed.orig/StlAllocatorTestMain.h ./StlAllocatorTestMain.h
--- ../stlallocatortestbed.orig/StlAllocatorTestMain.h	2003-04-11 10:57:48.000000000 +0900
+++ ./StlAllocatorTestMain.h	2006-03-19 00:11:47.000000000 +0900
@@ -32,11 +32,14 @@
 
 #if !defined( STL_ALLOCATOR_TEST_MAIN_H )
 #define STL_ALLOCATOR_TEST_MAIN_H
+
+#if defined(_MSC_VER)
 #pragma once
 
 #pragma warning( disable: 4127 ) // ignore conditional expression constant
 #pragma warning( disable: 4702 ) // ignore unreachable code
 #pragma warning( disable: 4800 ) // allow forcing int to bool
+#endif	// _MSC_VER
 
 #include "StlAllocatorTestTypes.h"
 #include "StlAllocatorTestMembers.h"
@@ -51,14 +54,14 @@
 void TestAlloc( const Allocator& a )
 {
     // Verify functionality with a variety of types
-    Allocator::rebind< bool >::other   b( a ); // tests vector<bool> specialization
-    Allocator::rebind< C >::other      c( a ); // POD types
-    Allocator::rebind< D >::other      d( a ); // allocated internal type
-    Allocator::rebind< E >::other      e( a ); // complicated type
-    Allocator::rebind< int >::other    i( a ); // simple test
-    Allocator::rebind< void* >::other  v( a ); // void pointers
-    Allocator::rebind< char* >::other  p( a ); // regular pointers
-    Allocator::rebind< void >::other   x( a ); // must provide this specialization
+    typename Allocator::template rebind< bool >::other   b( a ); // tests vector<bool> specialization
+    typename Allocator::template rebind< C >::other      c( a ); // POD types
+    typename Allocator::template rebind< D >::other      d( a ); // allocated internal type
+    typename Allocator::template rebind< E >::other      e( a ); // complicated type
+    typename Allocator::template rebind< int >::other    i( a ); // simple test
+    typename Allocator::template rebind< void* >::other  v( a ); // void pointers
+    typename Allocator::template rebind< char* >::other  p( a ); // regular pointers
+    //typename Allocator::template rebind< void >::other   x( a ); // must provide this specialization
 
     TestMemberFunctionPresence( a ); // in StlAllocatorTestMembers.h
     
diff -uNr ../stlallocatortestbed.orig/StlAllocatorTestMembers.h ./StlAllocatorTestMembers.h
--- ../stlallocatortestbed.orig/StlAllocatorTestMembers.h	2003-04-11 10:58:52.000000000 +0900
+++ ./StlAllocatorTestMembers.h	2006-03-19 00:11:47.000000000 +0900
@@ -31,13 +31,13 @@
 void TestMemberFunctionPresence( const Allocator& a )
 {
     // Typedefs
-    Allocator::size_type       st;
-    Allocator::difference_type dt;
-    Allocator::pointer         p;
-    Allocator::const_pointer   cp;
-    Allocator::value_type      v;
-    Allocator::reference       r = v;   // Note: must be initialized
-    Allocator::const_reference cr = v;  // Note: must be initialized
+    typename Allocator::size_type       st;
+    typename Allocator::difference_type dt;
+    typename Allocator::pointer         p;
+    typename Allocator::const_pointer   cp;
+    typename Allocator::value_type      v;
+    typename Allocator::reference       r = v;   // Note: must be initialized
+    typename Allocator::const_reference cr = v;  // Note: must be initialized
     
     // allocator()
     Allocator b( Policy< Allocator >::Construct( a ) );
@@ -47,7 +47,7 @@
     Allocator c(a);
     
     // allocator( const allocator<U>& ) and rebind
-    Allocator::rebind< C >::other d( c );
+    typename Allocator::template rebind< C >::other d( c );
     
     // Although operator=() may be implemented by an allocator, it is 
     // not required by the C++ Standard, nor is it to be used by 
@@ -123,10 +123,10 @@
 void TestMemberFunctions( const Allocator& a )
 {
     // Typedefs
-    Allocator::pointer         p = NULL;
-    Allocator::value_type      v;
-    Allocator::reference       r = v;   // Note: must be initialized
-    Allocator::const_reference cr = v;  // Note: must be initialized
+    typename Allocator::pointer         p = NULL;
+    typename Allocator::value_type      v;
+    typename Allocator::reference       r = v;   // Note: must be initialized
+    typename Allocator::const_reference cr = v;  // Note: must be initialized
 
     // allocator()
     Allocator b( Policy< Allocator >::Construct( a ) );
@@ -139,8 +139,8 @@
     VERIFY( c == a );
     
     // allocator( const allocator<U>& ) and rebind
-    Allocator::rebind< C >::other d( c );
-    Allocator::rebind< Allocator::value_type >::other e( d );
+    typename Allocator::template rebind< C >::other d( c );
+    typename Allocator::template rebind< typename Allocator::value_type >::other e( d );
     VERIFY( c == e );
     
     // address( reference )
@@ -164,7 +164,7 @@
     VERIFY( p != NULL );
     
     // Write to allocated memory
-    memset( p, 'x', sizeof( Allocator::value_type ) );
+    memset( p, 'x', sizeof( typename Allocator::value_type ) );
 
     // deallocate( pointer, size_type )
     c.deallocate( p, 1 );
@@ -181,7 +181,7 @@
     VERIFY( p != NULL );
     
     // Write to allocated memory
-    memset( p, 'x', sizeof( Allocator::value_type ) );
+    memset( p, 'x', sizeof( typename Allocator::value_type ) );
     
     // construct( pointer, const T& )
     c.construct( p, v );
@@ -205,7 +205,7 @@
     VERIFY( p != NULL );
     
     // Write to allocated memory
-    memset( p, 'x', sizeof( Allocator::value_type ) * 2 );
+    memset( p, 'x', sizeof( typename Allocator::value_type ) * 2 );
     
     // construct( pointer, const T& )
     c.construct( p, v );
diff -uNr ../stlallocatortestbed.orig/StlAllocatorTestOutput.h ./StlAllocatorTestOutput.h
--- ../stlallocatortestbed.orig/StlAllocatorTestOutput.h	2003-04-11 10:56:14.000000000 +0900
+++ ./StlAllocatorTestOutput.h	2006-03-19 00:13:52.000000000 +0900
@@ -26,7 +26,7 @@
 
 #if defined( _XBOX )
     #include "xtl.h"
-#else if defined( WIN32 )
+#elif defined( WIN32 )
     #include "windows.h"    
 #endif    
 
@@ -49,6 +49,7 @@
 
 // This function forces the compiler to believe that the optional parameters
 // are important and cannot be optimized away
+#if 0
 void Used( int i, ... )
 {
     va_list Marker;
@@ -56,6 +57,13 @@
     i = va_arg( Marker, int );
     va_end( Marker );
 }
+#else
+template < typename T >
+void Used(int, T a)
+{
+	write(1, &a, 0);
+}
+#endif
 
 //-----------------------------------------------------------------------------
 
diff -uNr ../stlallocatortestbed.orig/StlAllocatorTestPolicy.h ./StlAllocatorTestPolicy.h
--- ../stlallocatortestbed.orig/StlAllocatorTestPolicy.h	2003-04-10 15:59:46.000000000 +0900
+++ ./StlAllocatorTestPolicy.h	2006-03-19 00:11:47.000000000 +0900
@@ -20,6 +20,8 @@
 #define STL_ALLOCATOR_TEST_POLICY_H
 #pragma once
 
+#include <functional>
+
 namespace StlAllocatorTestbed
 {
 
@@ -92,7 +94,7 @@
     {
         // Sets require a comparison functor prior to the allocator 
         // object in the container ctor
-        return Set( std::less< Allocator::value_type >(), a );
+        return Set( std::less< typename Allocator::value_type >(), a );
     }
 
     // Construct a map by specifying the allocator
@@ -100,13 +102,13 @@
     static Map GetCopiedMap( const Allocator& aIn )
     {
         // map allocators are pair allocators
-        typedef std::pair< const Allocator::value_type, int > Pair;
+        typedef std::pair< const typename Allocator::value_type, int > Pair;
         typedef typename Allocator::template rebind< Pair >::other Alloc;
         Alloc a( aIn );
         
         // Maps require a comparison functor prior to the allocator 
         // object in the map ctor.
-        return Map( std::less< Allocator::value_type >(), a );
+        return Map( std::less< typename Allocator::value_type >(), a );
     }
 
     // Construct an adapter (stack, queue) by specifying the allocator
@@ -123,7 +125,7 @@
     {
         // Priority queues require a comparison functor prior to the 
         // allocator object in the container ctor.
-        return PriorityQueue( std::less< Allocator::value_type >(), Container( a ) );
+        return PriorityQueue( std::less< typename Allocator::value_type >(), Container( a ) );
     }
 
 };
