colouringcode-passenger 0.1

data/ext/apache2/Hooks.h

@@ -0,0 +1,45 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2008, 2009 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_HOOKS_H_
+#define _PASSENGER_HOOKS_H_
+
+#include <apr_pools.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup Hooks Apache hooks
+ * @ingroup Core
+ */
+
+extern void passenger_register_hooks(apr_pool_t *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _PASSENGER_HOOKS_H_ */

data/ext/apache2/LICENSE-CNRI.TXT

@@ -0,0 +1,79 @@
+A few functions in ext/apache2/Hooks.cpp are based on the source code of
+mod_scgi version 1.9. Its license is included in this file.
+Please note that these licensing terms *only* encompass those few
+functions, and not Passenger as a whole.
+
+The functions which are based on mod_scgi's code are as follows:
+- Hooks::prepareRequest(). Although our version looks nothing like the
+  original, the idea of checking for the file's existance from the
+  map_to_storage/fixups hook is inspired by mod_scgi's code.
+- Hooks::handleRequest(). Although our version looks nothing like the original,
+  the idea of passing the backend process's socket file descriptor up to the
+  bucket brigade chain is inspired by mod_scgi's code.
+- Hooks::http2env(), Hooks::lookupName(), Hooks::lookupHeader(),
+  Hooks::lookupEnv(), Hooks::addHeader(): Copied from mod_scgi's functions that
+  are named similarly. Slightly modified to make the coding style consistent
+  with the rest of Phusion Passenger.
+- Hooks::sendHeaders(): Based for the most part on mod_scgi's send_headers()
+  function.
+
+------------------------------------------------------------------------
+CNRI OPEN SOURCE LICENSE AGREEMENT
+
+IMPORTANT: PLEASE READ THE FOLLOWING AGREEMENT CAREFULLY.  BY
+COPYING, INSTALLING OR OTHERWISE USING SCGI-1.9 SOFTWARE, YOU ARE
+DEEMED TO HAVE AGREED TO THE TERMS AND CONDITIONS OF THIS LICENSE
+AGREEMENT.
+
+1. This LICENSE AGREEMENT is between Corporation for National
+   Research Initiatives, having an office at 1895 Preston White
+   Drive, Reston, VA 20191 ("CNRI"), and the Individual or
+   Organization ("Licensee") copying, installing or otherwise using
+   scgi-1.9 software in source or binary form and its associated
+   documentation ("scgi-1.9").
+
+2. Subject to the terms and conditions of this License Agreement,
+   CNRI hereby grants Licensee a nonexclusive, royalty-free, world-
+   wide license to reproduce, analyze, test, perform and/or display
+   publicly, prepare derivative works, distribute, and otherwise use
+   scgi-1.9 alone or in any derivative version, provided, however,
+   that CNRI's License Agreement and CNRI's notice of copyright,
+   i.e., "Copyright (c) 2004 Corporation for National Research
+   Initiatives; All Rights Reserved" are retained in scgi-1.9 alone
+   or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+   or incorporates scgi-1.9 or any part thereof, and wants to make
+   the derivative work available to others as provided herein, then
+   Licensee hereby agrees to include in any such work a brief
+   summary of the changes made to scgi-1.9.
+
+4. CNRI is making scgi-1.9 available to Licensee on an "AS IS"
+   basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+   IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO
+   AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY
+   OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF SCGI-1.9
+   WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF SCGI-
+   1.9 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+   AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING SCGI-
+   1.9, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE
+   POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a
+   material breach of its terms and conditions.
+
+7. This License Agreement shall be governed by and interpreted in
+   all respects by the law of the State of Virginia, excluding
+   Virginia's conflict of law provisions.  Nothing in this License
+   Agreement shall be deemed to create any relationship of agency,
+   partnership, or joint venture between CNRI and Licensee.  This
+   License Agreement does not grant permission to use CNRI
+   trademarks or trade name in a trademark sense to endorse or
+   promote products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using scgi-1.9, Licensee
+   agrees to be bound by the terms and conditions of this License
+   Agreement.
+

data/ext/apache2/mod_passenger.c

@@ -0,0 +1,38 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2008, 2009 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#include <httpd.h>
+#include <http_config.h>
+#include "Configuration.h"
+#include "Hooks.h"
+
+module AP_MODULE_DECLARE_DATA passenger_module = {
+	STANDARD20_MODULE_STUFF,
+	passenger_config_create_dir,        /* create per-dir config structs */
+	passenger_config_merge_dir,         /* merge per-dir config structs */
+	passenger_config_create_server,     /* create per-server config structs */
+	passenger_config_merge_server,      /* merge per-server config structs */
+	passenger_commands,                 /* table of config file commands */
+	passenger_register_hooks,           /* register hooks */
+};

data/ext/boost/LICENSE.TXT

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/ext/boost/VERSION.TXT

@@ -0,0 +1 @@
+Boost version 1.35.0 (March 29, 2008)

data/ext/boost/algorithm/string/case_conv.hpp

@@ -0,0 +1,176 @@
+//  Boost string_algo library case_conv.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// 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.
+
+#ifndef BOOST_STRING_CASE_CONV_HPP
+#define BOOST_STRING_CASE_CONV_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <algorithm>
+#include <locale>
+#include <boost/iterator/transform_iterator.hpp>
+
+#include <boost/range/as_literal.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/algorithm/string/detail/case_conv.hpp>
+
+/*! \file
+    Defines sequence case-conversion algorithms.
+    Algorithms convert each element in the input sequence to the
+    desired case using provided locales.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  to_lower  -----------------------------------------------//
+
+        //! Convert to lower case
+        /*!
+            Each element of the input sequence is converted to lower
+            case. The result is a copy of the input converted to lower case.
+            It is returned as a sequence or copied to the output iterator.
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
+            \param Loc A locale used for conversion
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+                
+        */
+        template<typename OutputIteratorT, typename RangeT>
+        inline OutputIteratorT 
+        to_lower_copy(
+            OutputIteratorT Output,
+            const RangeT& Input,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::detail::transform_range_copy( 
+               Output,
+               as_literal(Input),
+               ::boost::algorithm::detail::to_lowerF<
+                    typename range_value<RangeT>::type >(Loc));
+        }
+
+        //! Convert to lower case
+        /*!
+            \overload
+        */
+        template<typename SequenceT>
+        inline SequenceT to_lower_copy( 
+            const SequenceT& Input, 
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
+                Input,
+                ::boost::algorithm::detail::to_lowerF<
+                    typename range_value<SequenceT>::type >(Loc));
+        }
+
+        //! Convert to lower case
+        /*!
+            Each element of the input sequence is converted to lower
+            case. The input sequence is modified in-place.
+
+            \param Input A range
+            \param Loc a locale used for conversion
+        */
+        template<typename WritableRangeT>
+        inline void to_lower( 
+            WritableRangeT& Input, 
+            const std::locale& Loc=std::locale())
+        {
+            ::boost::algorithm::detail::transform_range(
+                as_literal(Input),
+                ::boost::algorithm::detail::to_lowerF<
+                    typename range_value<WritableRangeT>::type >(Loc));
+        }
+        
+//  to_upper  -----------------------------------------------//
+
+        //! Convert to upper case
+        /*!
+            Each element of the input sequence is converted to upper
+            case. The result is a copy of the input converted to upper case.
+            It is returned as a sequence or copied to the output iterator
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
+            \param Loc A locale used for conversion
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<typename OutputIteratorT, typename RangeT>
+        inline OutputIteratorT 
+        to_upper_copy(
+            OutputIteratorT Output,
+            const RangeT& Input,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::detail::transform_range_copy( 
+               Output,
+               as_literal(Input),
+               ::boost::algorithm::detail::to_upperF<
+                    typename range_value<RangeT>::type >(Loc));
+        }
+
+        //! Convert to upper case
+        /*!
+            \overload
+        */
+        template<typename SequenceT>
+        inline SequenceT to_upper_copy( 
+            const SequenceT& Input, 
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
+                Input,
+                ::boost::algorithm::detail::to_upperF<
+                    typename range_value<SequenceT>::type >(Loc));
+        }
+
+        //! Convert to upper case
+        /*!
+            Each element of the input sequence is converted to upper
+            case. The input sequence is modified in-place.
+
+            \param Input An input range
+            \param Loc a locale used for conversion
+        */
+        template<typename WritableRangeT>
+        inline void to_upper( 
+            WritableRangeT& Input, 
+            const std::locale& Loc=std::locale())
+        {
+            ::boost::algorithm::detail::transform_range(
+                as_literal(Input),
+                ::boost::algorithm::detail::to_upperF<
+                    typename range_value<WritableRangeT>::type >(Loc));
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::to_lower;
+    using algorithm::to_lower_copy;
+    using algorithm::to_upper;
+    using algorithm::to_upper_copy;
+
+} // namespace boost
+
+#endif  // BOOST_STRING_CASE_CONV_HPP

data/ext/boost/algorithm/string/compare.hpp

@@ -0,0 +1,199 @@
+//  Boost string_algo library compare.hpp header file  -------------------------//
+
+//  Copyright Pavol Droba 2002-2006.
+//
+// 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.
+
+#ifndef BOOST_STRING_COMPARE_HPP
+#define BOOST_STRING_COMPARE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <locale>
+
+/*! \file
+    Defines element comparison predicates. Many algorithms in this library can
+    take an additional argument with a predicate used to compare elements.
+    This makes it possible, for instance, to have case insensitive versions
+    of the algorithms.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+        //  is_equal functor  -----------------------------------------------//
+
+        //! is_equal functor
+        /*!
+            Standard STL equal_to only handle comparison between arguments
+            of the same type. This is a less restrictive version which wraps operator ==.
+        */
+        struct is_equal
+        {
+            //! Function operator
+            /*!
+                Compare two operands for equality
+            */
+            template< typename T1, typename T2 >
+                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+            {
+                return Arg1==Arg2;
+            }
+        };
+
+        //! case insensitive version of is_equal
+        /*!
+            Case insensitive comparison predicate. Comparison is done using
+            specified locales.
+        */
+        struct is_iequal
+        {
+            //! Constructor
+            /*!
+                \param Loc locales used for comparison
+            */
+            is_iequal( const std::locale& Loc=std::locale() ) :
+                m_Loc( Loc ) {}
+
+            //! Function operator
+            /*!
+                Compare two operands. Case is ignored.
+            */
+            template< typename T1, typename T2 >
+                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+            {
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    return std::toupper(Arg1)==std::toupper(Arg2);
+                #else
+                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
+                #endif
+            }
+
+        private:
+            std::locale m_Loc;
+        };
+
+        //  is_less functor  -----------------------------------------------//
+
+        //! is_less functor
+        /*!
+            Convenient version of standard std::less. Operation is templated, therefore it is 
+            not required to specify the exact types upon the construction
+         */
+        struct is_less
+        {
+            //! Functor operation
+            /*!
+                Compare two operands using > operator
+             */
+            template< typename T1, typename T2 >
+                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+            {
+                return Arg1<Arg2;
+            }
+        };
+
+
+        //! case insensitive version of is_less
+        /*!
+            Case insensitive comparison predicate. Comparison is done using
+            specified locales.
+        */
+        struct is_iless
+        {
+            //! Constructor
+            /*!
+                \param Loc locales used for comparison
+            */
+            is_iless( const std::locale& Loc=std::locale() ) :
+                m_Loc( Loc ) {}
+
+            //! Function operator
+            /*!
+                Compare two operands. Case is ignored.
+            */
+            template< typename T1, typename T2 >
+                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+            {
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    return std::toupper(Arg1)<std::toupper(Arg2);
+                #else
+                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
+                #endif
+            }
+
+        private:
+            std::locale m_Loc;
+        };
+
+        //  is_not_greater functor  -----------------------------------------------//
+
+        //! is_not_greater functor
+        /*!
+            Convenient version of standard std::not_greater_to. Operation is templated, therefore it is 
+            not required to specify the exact types upon the construction
+         */
+        struct is_not_greater
+        {
+            //! Functor operation
+            /*!
+                Compare two operands using > operator
+             */
+            template< typename T1, typename T2 >
+                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+            {
+                return Arg1<=Arg2;
+            }
+        };
+
+
+        //! case insensitive version of is_not_greater
+        /*!
+            Case insensitive comparison predicate. Comparison is done using
+            specified locales.
+        */
+        struct is_not_igreater
+        {
+            //! Constructor
+            /*!
+                \param Loc locales used for comparison
+            */
+            is_not_igreater( const std::locale& Loc=std::locale() ) :
+                m_Loc( Loc ) {}
+
+            //! Function operator
+            /*!
+                Compare two operands. Case is ignored.
+            */
+            template< typename T1, typename T2 >
+                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+            {
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    return std::toupper(Arg1)<=std::toupper(Arg2);
+                #else
+                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
+                #endif
+            }
+
+        private:
+            std::locale m_Loc;
+        };
+
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::is_equal;
+    using algorithm::is_iequal;
+    using algorithm::is_less;
+    using algorithm::is_iless;
+    using algorithm::is_not_greater;
+    using algorithm::is_not_igreater;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_COMPARE_HPP

data/ext/boost/algorithm/string/concept.hpp

@@ -0,0 +1,83 @@
+//  Boost string_algo library concept.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// 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.
+
+#ifndef BOOST_STRING_CONCEPT_HPP
+#define BOOST_STRING_CONCEPT_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+/*! \file 
+    Defines concepts used in string_algo library
+*/
+
+namespace boost {
+    namespace algorithm {
+
+        //! Finder concept
+        /*!
+            Defines the Finder concept. Finder is a functor which selects
+            an arbitrary part of a string. Search is performed on
+            the range specified by starting and ending iterators.
+
+            Result of the find operation must be convertible to iterator_range.
+        */
+        template<typename FinderT, typename IteratorT>
+        struct FinderConcept
+        {
+        private:
+            typedef iterator_range<IteratorT> range;
+        public:
+            void constraints()
+            {
+                // Operation
+                r=(*pF)(i,i);
+            }
+        private:
+            range r;
+            IteratorT i;
+            FinderT* pF;    
+        }; // Finder_concept
+
+        
+        //! Formatter concept
+        /*!
+            Defines the Formatter concept. Formatter is a functor, which
+            takes a result from a finder operation and transforms it
+            in a specific way.
+
+            Result must be a container supported by container_traits, 
+            or a reference to it.
+        */
+        template<typename FormatterT, typename FinderT, typename IteratorT>
+        struct FormatterConcept
+        {
+        public:
+            void constraints()
+            {
+                // Operation
+                begin((*pFo)( (*pF)(i,i) ));
+                end((*pFo)( (*pF)(i,i) ));
+            }
+        private:
+            IteratorT i;
+            FinderT* pF;
+            FormatterT *pFo;
+        }; // FormatterConcept;
+
+    } // namespace algorithm
+} // namespace boost
+
+
+
+
+#endif  // BOOST_STRING_CONCEPT_HPP

data/ext/boost/algorithm/string/config.hpp

@@ -0,0 +1,28 @@
+//  Boost string_algo library config.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// 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.
+
+#ifndef BOOST_STRING_CONFIG_HPP
+#define BOOST_STRING_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#ifdef BOOST_STRING_DEDUCED_TYPENAME
+#   error "macro already defined!"
+#endif
+
+#define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME
+
+// Metrowerks workaround
+#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+#pragma parse_func_templ off
+#endif
+
+#endif  // BOOST_STRING_CONFIG_HPP