Release 1.48.0

[SVN r75495]
Merge Boost.Config changes from Trunk - numerous small bug fixes plus a new Cray C++ config.
2011-11-15 15:44:44 +00:00 · 2011-10-10 11:50:55 +00:00 · 2011-07-16 20:12:46 +00:00 · 2011-07-12 13:53:58 +00:00 · 2011-06-29 18:00:59 +00:00 · 2011-05-30 15:01:59 +00:00
626 changed files with 46290 additions and 939 deletions
@@ -0,0 +1,15 @@
 <html>
   <head>
      <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
   </head>
   <body>
      <P>
         Automatic redirection failed, please go to <a href="doc/html/index.html">doc/html/index.html</a>.
      </P>
      <P>Copyright&nbsp;John Maddock 2001</P>
      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
   </body>
 </html>
@@ -1,115 +0,0 @@
 //  Boost config.hpp configuration test program file  ------------------------------//
 //  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //  See http://www.boost.org for the most recent version.
 #include <boost/config.hpp>
 #include <iostream>
 using std::cout;
 int main()
 {
 #   ifdef BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
        cout << "BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS defined\n";
 #   endif
 #   ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZER
        cout << "BOOST_NO_INCLASS_MEMBER_INITIALIZER defined\n";
 #   endif
 #   ifdef BOOST_NO_MEMBER_TEMPLATES
        cout << "BOOST_NO_MEMBER_TEMPLATES defined\n";
 #   endif
 #   ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
        cout << "BOOST_NO_MEMBER_TEMPLATE_FRIENDS defined\n";
 #   endif
 #   ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
        cout << "BOOST_NO_OPERATORS_IN_NAMESPACE defined\n";
 #   endif
 #   ifdef BOOST_NO_STD_ITERATOR
        cout << "BOOST_NO_STD_ITERATOR defined\n";
 #   endif
 #   ifdef BOOST_NO_STD_ITERATOR_TRAITS
        cout << "BOOST_NO_STD_ITERATOR_TRAITS defined\n";
 #   endif
 #   ifdef BOOST_NO_STDC_NAMESPACE
        cout << "BOOST_NO_STDC_NAMESPACE defined\n";
 #   endif
 #   ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        cout << "BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION defined\n";
 #   endif
 #   ifdef BOOST_NO_USING_TEMPLATE
        cout << "BOOST_NO_USING_TEMPLATE defined\n";
 #   endif
 #   ifdef BOOST_DECL_EXPORTS
        cout << "BOOST_DECL_EXPORTS defined\n";
 #   endif
 #   ifdef BOOST_SYSTEM_HAS_STDINT_H
        cout << "BOOST_SYSTEM_HAS_STDINT_H defined\n";
 #   endif
 #   ifdef __GNUC__
        cout << "__GNUC__ defined as " << __GNUC__ << "\n";
 #   endif
 #   ifdef __BORLANDC__
        cout << "__BORLANDC__ defined as " << __BORLANDC__ << "\n";
 #   endif
 #   ifdef __MWERKS__
        cout << "__MWERKS__ defined as " << __MWERKS__ << "\n";
 #   endif
 #   ifdef __SUNPRO_CC
        cout << "__SUNPRO_CC defined as " << __SUNPRO_CC << "\n";
 #   endif
 #   ifdef _MSC_VER
        cout << "_MSC_VER defined as " << _MSC_VER << "\n";
 #   endif
 #   ifdef BOOST_MSVC
        cout << "BOOST_MSVC defined as " << BOOST_MSVC << "\n";
 #   endif
 #   ifdef BOOST_MSVC6_MEMBER_TEMPLATES
        cout << "BOOST_MSVC6_MEMBER_TEMPLATES defined\n";
 #   endif
 #   ifdef BOOST_MSVC_STD_ITERATOR
        cout << "BOOST_MSVC_STD_ITERATOR defined\n";
 #   endif
 #   ifdef __SGI_STL_PORT
        cout << "__SGI_STL_PORT defined\n";
 #   endif
 #   ifdef __STL_NO_NAMESPACES
        cout << "__STL_NO_NAMESPACES defined\n";
 #   endif
 #   ifdef __STL_USE_NAMESPACES
        cout << "__STL_USE_NAMESPACES defined\n";
 #   endif
 #   ifdef __STL_IMPORT_VENDOR_CSTD
        cout << "__STL_IMPORT_VENDOR_CSTD defined\n";
 #   endif
    return 0;
 }
@@ -0,0 +1,61 @@
 # Boost.Config
 #
 # Copyright (c) 2001 Beman Dawes
 # Copyright (c) 2001 Vesa Karvonen
 # Copyright (c) 2001 John Maddock
 #
 # 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)
 # Quickbook
 # -----------------------------------------------------------------------------
 import quickbook ;
 path-constant boost-images : ../../../doc/src/images ;
 xml config
    :
        config.qbk
    ;
 boostbook standalone
    :
        config
    :
        <xsl:param>toc.max.depth=2
        <xsl:param>toc.section.depth=2
        <xsl:param>chunk.section.depth=1
        <xsl:param>boost.root=../../../..
        # PDF Options:
        <format>pdf:<xsl:param>xep.extensions=1
        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
        <format>pdf:<xsl:param>fop.extensions=0
        <format>pdf:<xsl:param>fop1.extensions=0
        # No indent on body text:
        <format>pdf:<xsl:param>body.start.indent=0pt
        # Margin size:
        <format>pdf:<xsl:param>page.margin.inner=0.5in
        # Margin size:
        <format>pdf:<xsl:param>page.margin.outer=0.5in
        # Paper type = A4
        <format>pdf:<xsl:param>paper.type=A4
        # Yes, we want graphics for admonishments:
        <xsl:param>admon.graphics=1
        # Set this one for PDF generation *only*:
        # default pnd graphics are awful in PDF form,
        # better use SVG's instead:
        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
        <format>pdf:<xsl:param>use.role.for.mediaobject=1 
        <format>pdf:<xsl:param>preferred.mediaobject.role=print
        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/config/doc/html
    ;
 install pdf-install : standalone : <location>. <install-type>PDF ;
@@ -0,0 +1,32 @@
 [/
    Boost.Config
    Copyright (c) 2001 Beman Dawes
    Copyright (c) 2001 Vesa Karvonen
    Copyright (c) 2001 John Maddock
    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)
 ]
 [section Acknowledgements]
 Beman Dawes provided the original `config.hpp` and part of this document.
 Vesa Karvonen provided a description of the principles (see
 [link boost_config.rationale rationale]) and put together an early version of
 the current configuration setup.
 John Maddock put together the configuration current code, the test
 programs, the configuration script and the reference section of this
 document.
 Matias Capeletto converted the docs to quickbook format.
 Numerous boost members, past and present, have contributed fixes to boost's
 configuration.
 [endsect]
@@ -0,0 +1,60 @@
 [article Boost.Config
    [quickbook 1.4]
    [authors [Beman Dawes, Vesa Karvonen, John Maddock] ]
    [copyright 2001-2007 Beman Dawes, Vesa Karvonen, John Maddock]
    [category broken compiler workarounds]
    [id config]
    [dirname config]
    [purpose
        Helps boost library developers adapt to compiler idiosyncrasies; not intended for library users.
    ]
    [source-mode c++]
    [license
 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])
    ]
 ]
 [/ Cited Boost resources ]
 [def __BOOST_REGRESSION_TEST_DRIVER__ [@../../../../tools/regression/doc/index.html boost regression test driver]]
 [def __BOOST_CONFIG_HEADER__ [@../../../../boost/config.hpp <boost/config.hpp>]]
 [def __BOOST_CONFIG_USER_HEADER__ [@../../../../boost/config/user.hpp <boost/config/user.hpp>]]
 [def __BOOST_CONFIG_SUFFIX_HEADER__ [@../../../../boost/config/user.hpp <boost/config/suffix.hpp>]]
 [def __BOOST_CONFIG_DIR__ ['<boost-root>]`/boost/config/`]
 [/ Other web resources ]
 [def __STL_PORT__ [@http://stlport.sourceforge.net STLport]]
 [def __BOOST_TRACKER__ [@https://svn.boost.org/trac/boost/newticket Trac]]
 [def __CORE_LANGUAGE_DR337__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#337 Core Language DR337]]
 [def __PRINCIPLES_AND_PATTERNS_ARTICLE__ [@http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf following article]]
 [/ Icons ]
 [def __NOTE__ [$images/note.png]]
 [def __ALERT__ [$images/caution.png]]
 [def __DETAIL__ [$images/note.png]]
 [def __TIP__ [$images/tip.png]]
 [def __QUESTION_MARK__ [$images/question.png]]
 [def __SPACE__ [$images/space.png]]
 [def __GO_TO__ [$images/callouts/R.png]]
 [/ Document files ]
 [include configuring_boost.qbk]
 [include macro_reference.qbk]
 [include guidelines.qbk]
 [include rationale.qbk]
 [include acknowledgements.qbk]
@@ -0,0 +1,434 @@
 [/
    Boost.Config
    Copyright (c) 2001 Beman Dawes
    Copyright (c) 2001 Vesa Karvonen
    Copyright (c) 2001 John Maddock
    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)
 ]
 [section Configuring Boost for Your Platform]
 [section Using the default boost configuration]
 Boost comes already configured for most common compilers and platforms; you
 should be able to use boost "as is". Since the compiler is configured
 separately from the standard library, the default configuration should work
 even if you replace the compiler's standard library with a third-party
 standard library (like __STL_PORT__).
 Using boost "as is" without trying to reconfigure is the recommended method
 for using boost. You can, however, run the configure script if you want to,
 and there are regression tests provided that allow you to test the current
 boost configuration with your particular compiler setup.
 Boost library users can request support for additional compilers or platforms
 by visiting our __BOOST_TRACKER__ and submitting a support request.
 [endsect]
 [section The <boost/config.hpp> header]
 Boost library implementations access configuration macros via
    #include ``__BOOST_CONFIG_HEADER__``
 While Boost library users are not required to include that file directly, or
 use those configuration macros, such use is acceptable. The configuration
 macros are documented as to their purpose, usage, and limitations which makes
 them usable by both Boost library and user code.
 Boost [link config_info_macros informational] or [link config_helpers helper]
 macros are designed for use by Boost users as well as for our own internal use.
 Note however, that the [link config_features feature test] and
 [link config_defects defect test] macros were designed for internal use by
 Boost libraries, not user code, so they can change at any time (though no
 gratuitous changes are made to them). Boost library problems resulting from
 changes to the configuration macros are caught by the Boost regression tests,
 so the Boost libraries are updated to account for those changes. By contrast,
 Boost library user code can be adversely affected by changes to the macros
 without warning. The best way to keep abreast of changes to the macros used in
 user code is to monitor the discussions on the Boost developers list.
 [endsect]
 [#config_config_script]
 [section Using the configure script]
 [important
 This configure script only sets up the Boost headers for use with a particular
 compiler. It has no effect on Boost.Build, or how the libraries are built.
 ]
 If you know that boost is incorrectly configured for your particular setup, and
 you are on a UNIX like platform, then you may want to try and improve things by
 running the boost configure script. From a shell command prompt you will need to
 cd into ['<boost-root>]`/libs/config/` and type:
 [: `sh ./configure` ]
 you will see a list of the items being checked as the script works its way
 through the regression tests. Note that the configure script only really
 auto-detects your compiler if it's called g++, c++ or CC. If you are using
 some other compiler you will need to set one or more of the following
 environment variables:
 [table
 [[Variable][Description                                       ]]
 [[CXX     ][The name of the compiler, for example `c++`.      ]]
 [[CXXFLAGS][The compiler flags to use, for example `-O2`.     ]]
 [[LDFLAGS ][The linker flags to use, for example `-L/mypath`. ]]
 [[LIBS    ][Any libraries to link in, for example `-lpthread`.]]
 ]
 For example to run the configure script with HP aCC, you might use something
 like:
    export CXX="aCC"
    export CXXFLAGS="-Aa -DAportable -D__HPACC_THREAD_SAFE_RB_TREE \
       -DRWSTD_MULTI_THREAD -DRW_MULTI_THREAD -D_REENTRANT -D_THREAD_SAFE"
    export LDFLAGS="-DAportable"
    export LIBS="-lpthread" 
    sh ./configure
 However you run the configure script, when it finishes you will find a
 new header -`user.hpp`- located in the ['<boost-root>]`/libs/config/`
 directory. [*Note that configure does not install this header into your
 boost include path by default]. This header contains all the options
 generated by the configure script, plus a header-section that contains
 the user settable options from the default version of
 __BOOST_CONFIG_USER_HEADER__ (located under __BOOST_CONFIG_DIR__).
 There are two ways you can use this header:
 * [*Option 1:] copy the header into __BOOST_CONFIG_DIR__ so that it replaces
 the default user.hpp provided by boost. This option allows only one
 configure-generated setup; boost developers should avoid this option,
 as it incurs the danger of accidentally committing a configure-modified
 __BOOST_CONFIG_USER_HEADER__ to the cvs repository (something you will not
 be thanked for!).
 * [*Option 2:]  give the header a more memorable name, and place it somewhere
 convenient; then, define the macro `BOOST_USER_CONFIG` to point to it. For
 example create a new sub-directory __BOOST_CONFIG_DIR__ `user/`, and copy
 the header there; for example as `multithread-gcc-config.hpp`. Then, when
 compiling add the command line option:
 `-DBOOST_USER_CONFIG="<boost/config/user/multithread-gcc-config.hpp>"`, and
 boost will use the new configuration header. This option allows you to
 generate more than one configuration header, and to keep them separate
 from the boost source - so that updates to the source do not interfere
 with your configuration.
 [endsect]
 [#config_user_settable]
 [section User settable options]
 There are some configuration-options that represent user choices, rather
 than compiler defects or platform specific options. These are listed in
 `<boost/config/user.hpp>` and at the start of a configure-generated `user.hpp`
 header. You can define these on the command line, or by editing
 `<boost/config/user.hpp>`, they are listed in the following table: 
 [table
 [[Macro         ][Description       ]]
 [[`BOOST_USER_CONFIG`][
 When defined, it should point to the name of the user configuration file
 to include prior to any boost configuration files. When not defined,
 defaults to [@../../../../boost/config/user.hpp `<boost/config/user.hpp>`].
 ]]
 [[`BOOST_COMPILER_CONFIG`][
 When defined, it should point to the name of the compiler configuration
 file to use. Defining this cuts out the compiler selection logic, and
 eliminates the dependency on the header containing that logic. For
 example if you are using gcc, then you could define BOOST_COMPILER_CONFIG
 to [@../../../../boost/config/compiler/gcc.hpp `<boost/config/compiler/gcc.hpp>`].
 ]]
 [[`BOOST_STDLIB_CONFIG`][
 When defined, it should point to the name of the standard library
 configuration file to use. Defining this cuts out the standard library
 selection logic, and eliminates the dependency on the header containing
 that logic. For example if you are using STLport, then you could define
 `BOOST_STDLIB_CONFIG` to
 [@../../../../boost/config/stdlib/stlport.hpp `<boost/config/stdlib/stlport.hpp>`].
 ]]
 [[`BOOST_PLATFORM_CONFIG`][
 When defined, it should point to the name of the platform configuration
 file to use. Defining this cuts out the platform selection logic, and
 eliminates the dependency on the header containing that logic. For example
 if you are compiling on linux, then you could define `BOOST_PLATFORM_CONFIG`
 to [@../../../../boost/config/platform/linux.hpp `<boost/config/platform/linux.hpp>`].
 ]]
 [[`BOOST_NO_COMPILER_CONFIG`][
 When defined, no compiler configuration file is selected or included,
 define when the compiler is fully conformant with the standard, or where
 the user header (see `BOOST_USER_CONFIG`), has had any options necessary
 added to it, for example by an autoconf generated configure script.
 ]]
 [[`BOOST_NO_STDLIB_CONFIG` ][
 When defined, no standard library configuration file is selected or included,
 define when the standard library is fully conformant with the standard, or
 where the user header (see `BOOST_USER_CONFIG`), has had any options necessary
 added to it, for example by an autoconf generated configure script.
 ]]
 [[`BOOST_NO_PLATFORM_CONFIG` ][
 When defined, no platform configuration file is selected or included,
 define when the platform is fully conformant with the standard (and has
 no useful extra features), or where the user header (see
 `BOOST_USER_CONFIG`), has had any options necessary added to it, for example
 by an autoconf generated configure script.
 ]]
 [[`BOOST_NO_CONFIG` ][
 Equivalent to defining all of `BOOST_NO_COMPILER_CONFIG`,
 `BOOST_NO_STDLIB_CONFIG` and `BOOST_NO_PLATFORM_CONFIG`.
 ]]
 [[`BOOST_STRICT_CONFIG` ][
 The normal behavior for compiler versions that are newer than the last
 known version, is to assume that they have all the same defects as the
 last known version. By setting this define, then compiler versions that
 are newer than the last known version are assumed to be fully conforming
 with the standard. This is probably most useful for boost developers or
 testers, and for those who want to use boost to test beta compiler versions.
 ]]
 [[`BOOST_ASSERT_CONFIG` ][
 When this flag is set, if the config finds anything unknown, then it will
 stop with a #error rather than continue. Boost regression testers should
 set this define, as should anyone who wants to quickly check whether boost
 is supported on their platform.
 ]]
 [[`BOOST_DISABLE_THREADS` ][
 When defined, disables threading support, even if the compiler in its
 current translation mode supports multiple threads.
 ]]
 [[`BOOST_DISABLE_WIN32` ][
 When defined, disables the use of Win32 specific API's, even when these
 are available. Also has the effect of setting `BOOST_DISABLE_THREADS` unless
 `BOOST_HAS_PTHREADS` is set. This option may be set automatically by the
 config system when it detects that the compiler is in "strict mode".
 ]]
 [[`BOOST_DISABLE_ABI_HEADERS`][
 Stops boost headers from including any prefix/suffix headers that normally
 control things like struct packing and alignment.
 ]]
 [[`BOOST_ABI_PREFIX`][
 A prefix header to include in place of whatever boost.config would normally
 select, any replacement should set up struct packing and alignment options
 as required.
 ]]
 [[`BOOST_ABI_SUFFIX` ][
 A suffix header to include in place of whatever boost.config would normally
 select, any replacement should undo the effects of the prefix header.
 ]]
 [[`BOOST_ALL_DYN_LINK`][
 Forces all libraries that have separate source, to be linked as dll's rather
 than static libraries on Microsoft Windows (this macro is used to turn on
 `__declspec(dllimport)` modifiers, so that the compiler knows which symbols
 to look for in a dll rather than in a static library).
 Note that there may be some libraries that can only be statically linked
 (Boost.Test for example) and others which may only be dynamically linked
 (Boost.Threads for example), in these cases this macro has no effect.
 ]]
 [[`BOOST_`['WHATEVER]`_DYN_LINK`][
 Forces library "whatever" to be linked as a dll rather than a static library
 on Microsoft Windows: replace the ['WHATEVER] part of the macro name with the
 name of the library that you want to dynamically link to, for example use
 `BOOST_DATE_TIME_DYN_LINK` or `BOOST_REGEX_DYN_LINK` etc (this macro is used
 to turn on `__declspec(dllimport)` modifiers, so that the compiler knows
 which symbols to look for in a dll rather than in a static library).
 Note that there may be some libraries that can only be statically linked
 (Boost.Test for example) and others which may only be dynamically linked
 (Boost.Threads for example), in these cases this macro is unsupported.
 ]]
 [[`BOOST_ALL_NO_LIB`][
 Tells the config system not to automatically select which libraries to link
 against.
 Normally if a compiler supports #pragma lib, then the correct library build
 variant will be automatically selected and linked against, simply by the act
 of including one of that library's headers. This macro turns that
 feature off.
 ]]
 [[`BOOST_`['WHATEVER]`_NO_LIB`][
 Tells the config system not to automatically select which library to link
 against for library "whatever", replace ['WHATEVER] in the macro name with the
 name of the library; for example `BOOST_DATE_TIME_NO_LIB` or `BOOST_REGEX_NO_LIB`.
 Normally if a compiler supports `#pragma lib`, then the correct library build
 variant will be automatically selected and linked against, simply by the
 act of including one of that library's headers.  This macro turns that
 feature off.
 ]]
 [[`BOOST_LIB_DIAGNOSTIC`][
 Causes the auto-linking code to output diagnostic messages indicating the
 name of the library that is selected for linking.
 ]]
 [[`BOOST_LIB_TOOLSET`][
 Overrides the name of the toolset part of the name of library being linked
 to; note if defined this must be defined to a quoted string literal, for
 example "abc".
 ]]
 ]
 [endsect]
 [section Advanced configuration usage]
 By setting various macros on the compiler command line or by editing
 __BOOST_CONFIG_USER_HEADER__, the boost configuration setup can be optimised
 in a variety of ways.
 Boost's configuration is structured so that the user-configuration is
 included first (defaulting to __BOOST_CONFIG_USER_HEADER__ if `BOOST_USER_CONFIG`
 is not defined). This sets up any user-defined policies, and gives the
 user-configuration a chance to influence what happens next.
 Next the compiler, standard library, and platform configuration files are
 included. These are included via macros (`BOOST_COMPILER_CONFIG` etc,
 [link config_user_settable see user settable macros]), and if the corresponding
 macro is undefined then a separate header that detects which compiler/standard
 library/platform is in use is included in order to set these. The config
 can be told to ignore these headers altogether if the corresponding
 `BOOST_NO_XXX` macro is set (for example `BOOST_NO_COMPILER_CONFIG` to
 disable including any compiler configuration file -
 [link config_user_settable see user settable macros]).
 Finally the boost configuration header, includes __BOOST_CONFIG_SUFFIX_HEADER__;
 this header contains any boiler plate configuration code - for example where one
 boost macro being set implies that another must be set also.
 The following usage examples represent just a few of the possibilities:
 [section Example 1, creating our own frozen configuration]
 Lets suppose that we're building boost with Visual C++ 6, and STLport 4.0. Lets
 suppose also that we don't intend to update our compiler or standard library
 any time soon. In order to avoid breaking dependencies when we update boost,
 we may want to "freeze" our configuration headers, so that we only have to
 rebuild our project if the boost code itself has changed, and not because the
 boost config has been updated for more recent versions of Visual C++ or STLport.
 We'll start by realising that the configuration files in use are:
 [@../../../../boost/config/compiler/visualc.hpp `<boost/config/compiler/visualc.hpp>`]
 for the compiler,
 [@../../../../boost/config/stdlib/stlport.hpp `<boost/config/stdlib/stlport.hpp>`]
 for the standard library, and
 [@../../../../boost/config/platform/win32.hpp `<boost/config/platform/win32.hpp>`]
 for the platform. Next we'll create our own private configuration directory:
 `boost/config/mysetup/`, and copy the configuration files into there. Finally,
 open up __BOOST_CONFIG_USER_HEADER__ and edit the following defines:
    #define BOOST_COMPILER_CONFIG "boost/config/mysetup/visualc.hpp"
    #define BOOST_STDLIB_CONFIG "boost/config/mysetup/stlport.hpp"
    #define BOOST_USER_CONFIG "boost/config/mysetup/win32.hpp"
 Now when you use boost, its configuration header will go straight to our "frozen"
 versions, and ignore the default versions, you will now be insulated from any
 configuration changes when you update boost. This technique is also useful if
 you want to modify some of the boost configuration files; for example if you are
 working with a beta compiler release not yet supported by boost.
 [endsect]
 [section Example 2: skipping files that you don't need]
 Lets suppose that you're using boost with a compiler that is fully conformant with
 the standard; you're not interested in the fact that older versions of your compiler
 may have had bugs, because you know that your current version does not need any
 configuration macros setting. In a case like this, you can define
 `BOOST_NO_COMPILER_CONFIG` either on the command line, or in __BOOST_CONFIG_USER_HEADER__,
 and miss out the compiler configuration header altogether (actually you miss out
 two headers, one which works out what the compiler is, and one that configures
 boost for it). This has two consequences: the first is that less code has to be c
 ompiled, and the second that you have removed a dependency on two boost headers.
 [endsect]
 [section Example 3: using configure script to freeze the boost configuration]
 If you are working on a unix-like platform then you can use the configure script to
 generate a "frozen" configuration based on your current compiler setup -
 [link config_config_script see using the configure script for more details].
 [endsect]
 [endsect]
 [section Testing the boost configuration]
 The boost configuration library provides a full set of regression test programs
 under the __BOOST_CONFIG_DIR__ `test/` sub-directory:
 [table
 [[File][Description]]
 [[`config_info.cpp`][
 Prints out a detailed description of your compiler/standard library/platform
 setup, plus your current boost configuration. The information provided by this
 program useful in setting up the boost configuration files. If you report that
 boost is incorrectly configured for your compiler/library/platform then please
 include the output from this program when reporting the changes required.
 ]]
 [[`config_test.cpp`][
 A monolithic test program that includes most of the individual test cases.
 This provides a quick check to see if boost is correctly configured for your
 compiler/library/platform.
 ]]
 [[`limits_test.cpp`][
 Tests your standard library's `std::numeric_limits` implementation (or its boost
 provided replacement if `BOOST_NO_LIMITS` is defined). This test file fails with
 most versions of numeric_limits, mainly due to the way that some compilers
 treat NAN's and infinity.
 ]]
 [[`no_*pass.cpp`][
 Individual compiler defect test files. Each of these should compile, if one
 does not then the corresponding `BOOST_NO_XXX` macro needs to be defined - see
 each test file for specific details.
 ]]
 [[`no_*fail.cpp`][
 Individual compiler defect test files. Each of these should not compile, if
 one does then the corresponding `BOOST_NO_XXX` macro is defined when it need
 not be - see each test file for specific details.
 ]]
 [[`has_*pass.cpp`][
 Individual feature test files. If one of these does not compile then the
 corresponding `BOOST_HAS_XXX` macro is defined when it should not be - see
 each test file for specific details.
 ]]
 [[`has_*fail.cpp`][
 Individual feature test files. If one of these does compile then the
 corresponding `BOOST_HAS_XXX` macro can be safely defined - see each test
 file for specific details.
 ]]
 ]
 Although you can run the configuration regression tests as individual test
 files, there are rather a lot of them, so there are a couple of shortcuts to
 help you out:
 If you have built the __BOOST_REGRESSION_TEST_DRIVER__, then you can use this to
 produce a nice html formatted report of the results using the supplied test file.
 Alternatively you can run the configure script like this:
 [: `./configure --enable-test`]
 in which case the script will test the current configuration rather than
 creating a new one from scratch.
 If you are reporting the results of these tests for a new
 platform/library/compiler then please include a log of the full compiler output,
 the output from `config_info.cpp`, and the pass/fail test results.
 [endsect]
 [endsect]
@@ -0,0 +1,219 @@
 [/
    Boost.Config
    Copyright (c) 2001 Beman Dawes
    Copyright (c) 2001 Vesa Karvonen
    Copyright (c) 2001 John Maddock
    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)
 ]
 [section Guidelines for Boost Authors]
 The __BOOST_CONFIG_HEADER__ header is used to pass configuration information
 to other boost files, allowing them to cope with platform dependencies such
 as arithmetic byte ordering, compiler pragmas, or compiler shortcomings.
 Without such configuration information, many current compilers would not work
 with the Boost libraries.
 Centralizing configuration information in this header reduces the number of
 files that must be modified when porting libraries to new platforms, or when
 compilers are updated. Ideally, no other files would have to be modified when
 porting to a new platform.
 Configuration headers are controversial because some view them as condoning
 broken compilers and encouraging non-standard subsets. Adding settings for
 additional platforms and maintaining existing settings can also be a problem.
 In other words, configuration headers are a necessary evil rather than a
 desirable feature. The boost config.hpp policy is designed to minimize the
 problems and maximize the benefits of a configuration header.
 Note that:
 * Boost library implementers are not required to "`#include <boost/config.hpp>`",
 and are not required in any way to support compilers that do not comply
 with the C++ Standard (ISO/IEC 14882). 
 * If a library implementer wishes to support some non-conforming compiler,
 or to support some platform specific feature, "`#include <boost/config.hpp>`"
 is the preferred way to obtain configuration information not available from
 the standard headers such as `<climits>`, etc.
 * If configuration information can be deduced from standard headers such as
 `<climits>`, use those standard headers rather than `<boost/config.hpp>`.
 * Boost files that use macros defined in `<boost/config.hpp>` should have
 sensible, standard conforming, default behavior if the macro is not defined.
 This means that the starting point for porting `<boost/config.hpp>` to a new
 platform is simply to define nothing at all specific to that platform. In
 the rare case where there is no sensible default behavior, an #error message
 should describe the problem.
 * If a Boost library implementer wants something added to `config.hpp`, post
 a request on the Boost mailing list. There is no guarantee such a request
 will be honored; the intent is to limit the complexity of config.hpp.
 * The intent is to support only compilers which appear on their way to
 becoming C++ Standard compliant, and only recent releases of those compilers
 at that.
 * The intent is not to disable mainstream features now well-supported by the
 majority of compilers, such as namespaces, exceptions, RTTI, or templates.
 [section:warnings Disabling Compiler Warnings]
 The header `<boost/config/warning_disable.hpp>` can be used to disable
 certain compiler warings that are hard or impossible to otherwise remove.
 Note that:
 * This header [*['should never be included by another Boost header]], it should
 only ever be used by a library source file or a test case.
 * The header should be included [*['before you include any other header]].
 * This header only disables warnings that are hard or impossible to otherwise
 deal with, and which are typically emitted by one compiler only, or
 in one compilers own standard library headers.
 Currently it disables the following warnings:
 [table
 [[Compiler][Warning]]
 [[Visual C++ 8 and later][[@http://msdn2.microsoft.com/en-us/library/ttcz0bys(VS.80).aspx C4996]: Error 'function': was declared deprecated]]
 [[Intel C++][Warning 1786: relates to the use of "deprecated" standard 
   library functions rather like C4996 in Visual C++.]]
 ]
 [endsect]
 [section Adding New Defect Macros]
 When you need to add a new defect macro - either to fix a problem with an
 existing library, or when adding a new library - distil the issue down to
 a simple test case; often, at this point other (possibly better) workarounds
 may become apparent. Secondly always post the test case code to the boost
 mailing list and invite comments; remember that C++ is complex and that
 sometimes what may appear a defect, may in fact turn out to be a problem
 with the authors understanding of the standard.
 When you name the macro, follow the `BOOST_NO_`['SOMETHING] naming
 convention, so that it's obvious that this is a macro reporting a defect.
 Finally, add the test program to the regression tests. You will need to
 place the test case in a `.ipp` file with the following comments near the top:
    //  MACRO:         BOOST_NO_FOO
    //  TITLE:         foo
    //  DESCRIPTION:   If the compiler fails to support foo
 These comments are processed by the autoconf script, so make sure the format
 follows the one given. The file should be named "`boost_no_foo.ipp`", where foo
 is the defect description - try and keep the file name under the Mac 30 character
 filename limit though. You will also need to provide a function prototype
 "`int test()`" that is declared in a namespace with the same name as the macro,
 but in all lower case, and which returns zero on success:
    namespace boost_no_foo {
    int test()
    {
        // test code goes here:
        //
        return 0;
    }
    }
 Once the test code is in place in libs/config/test, updating the configuration
 test system proceeds as:
 * cd into `libs/config/tools` and run `bjam`. This generates the `.cpp`
 file test cases from the `.ipp` file, updates the 
 libs/config/test/all/Jamfile.v2, `config_test.cpp` and `config_info.cpp`.[br][br]
 * cd into `libs/config/test/all` and run `bjam `['MACRONAME` compiler-list`], where
 ['MACRONAME] is the name of the new macro, and ['`compiler-list`] is a space separated list of
 compilers to test with.[br][br]
 The xxx_pass_test and the xxx_fail_test [*should both report `**passed**`].[br][br]
 If ['MACRONAME] is not defined when it should be defined, xxx_pass_test will not report `**passed**`.
 If ['MACRONAME] is defined when it should not be defined, xxx_fail_test will not report `**passed**`.[br][br] 
 * cd into `libs/config/test` and run `bjam config_info config_test `['`compiler-list`].
 `config_info` should build and run cleanly for all the compilers in ['`compiler-list`]
 while `config_test` should fail for those that have the defect, and pass for those
 that do not.
 Then you should:
 * Define the defect macro in those config headers that require it.
 * Document the macro in this documentation (please do not forget this step!!)
 * Commit everything.
 * Keep an eye on the regression tests for new failures in Boost.Config caused by
 the addition.
 * Start using the macro.
 [endsect]
 [section Adding New Feature Test Macros]
 When you need to add a macro that describes a feature that the standard does
 not require, follow the convention for adding a new defect macro (above), but
 call the macro `BOOST_HAS_FOO`, and name the test file "`boost_has_foo.ipp`".
 Try not to add feature test macros unnecessarily, if there is a platform
 specific macro that can already be used (for example `_WIN32`, `__BEOS__`, or
 `__linux`) to identify the feature then use that. Try to keep the macro to a
 feature group, or header name, rather than one specific API (for example
 `BOOST_HAS_NL_TYPES_H` rather than `BOOST_HAS_CATOPEN`). If the macro
 describes a POSIX feature group, then add boilerplate code to
 __BOOST_CONFIG_SUFFIX_HEADER__ to auto-detect the feature where possible
 (if you are wondering why we can't use POSIX feature test macro directly,
 remember that many of these features can be added by third party libraries,
 and are not therefore identified inside `<unistd.h>`).
 [endsect]
 [section Modifying the Boost Configuration Headers]
 The aim of boost's configuration setup is that the configuration headers should
 be relatively stable - a boost user should not have to recompile their code
 just because the configuration for some compiler that they're not interested
 in has changed. Separating the configuration into separate compiler/standard
 library/platform sections provides for part of this stability, but boost
 authors require some amount of restraint as well, in particular:
 __BOOST_CONFIG_HEADER__ should never change, don't alter this file.
 __BOOST_CONFIG_USER_HEADER__ is included by default, don't add extra code to
 this file unless you have to. If you do, please remember to update
 [@../../tools/configure.in libs/config/tools/configure.in] as well.
 __BOOST_CONFIG_SUFFIX_HEADER__ is always included so be careful about
 modifying this file as it breaks dependencies for everyone. This file should
 include only "boilerplate" configuration code, and generally should change
 only when new macros are added.
 [@../../../../boost/config/select_compiler_config.hpp <boost/config/select_compiler_config.hpp>],
 [@../../../../boost/config/select_platform_config.hpp <boost/config/select_platform_config.hpp>] and
 [@../../../../boost/config/select_stdlib_config.hpp <boost/config/select_stdlib_config.hpp>]
 are included by default and should change only if support for a new
 compiler/standard library/platform is added.
 The compiler/platform/standard library selection code is set up so that unknown
 platforms are ignored and assumed to be fully standards compliant - this gives
 unknown platforms a "sporting chance" of working "as is" even without running
 the configure script.
 When adding or modifying the individual mini-configs, assume that future, as
 yet unreleased versions of compilers, have all the defects of the current
 version. Although this is perhaps unnecessarily pessimistic, it cuts down on
 the maintenance of these files, and experience suggests that pessimism is
 better placed than optimism here!
 [endsect]
 [endsect]
@@ -0,0 +1,5 @@
 index.html
 boost_config/boost_macro_reference.html
 boost_config/guidelines_for_boost_authors.html
 boost_config/rationale.html
 boost_config/acknowledgements.html
@@ -0,0 +1,62 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Acknowledgements</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
 <link rel="home" href="../index.html" title="Boost.Config">
 <link rel="up" href="../index.html" title="Boost.Config">
 <link rel="prev" href="rationale.html" title="Rationale">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="rationale.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_config.acknowledgements"></a><a class="link" href="acknowledgements.html" title="Acknowledgements">Acknowledgements</a>
 </h2></div></div></div>
 <p>
      Beman Dawes provided the original <code class="computeroutput"><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span></code> and
      part of this document.
    </p>
 <p>
      Vesa Karvonen provided a description of the principles (see <a class="link" href="rationale.html" title="Rationale">rationale</a>)
      and put together an early version of the current configuration setup.
    </p>
 <p>
      John Maddock put together the configuration current code, the test programs,
      the configuration script and the reference section of this document.
    </p>
 <p>
      Matias Capeletto converted the docs to quickbook format.
    </p>
 <p>
      Numerous boost members, past and present, have contributed fixes to boost's
      configuration.
    </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001-2007 Beman Dawes, Vesa Karvonen, John
      Maddock<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="rationale.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>
@@ -0,0 +1,377 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Guidelines for Boost Authors</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
 <link rel="home" href="../index.html" title="Boost.Config">
 <link rel="up" href="../index.html" title="Boost.Config">
 <link rel="prev" href="boost_macro_reference.html" title="Boost Macro Reference">
 <link rel="next" href="rationale.html" title="Rationale">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="boost_macro_reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_config.guidelines_for_boost_authors"></a><a class="link" href="guidelines_for_boost_authors.html" title="Guidelines for Boost Authors">Guidelines for
    Boost Authors</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.warnings">Disabling
      Compiler Warnings</a></span></dt>
 <dt><span class="section"><a href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.adding_new_defect_macros">Adding
      New Defect Macros</a></span></dt>
 <dt><span class="section"><a href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.adding_new_feature_test_macros">Adding
      New Feature Test Macros</a></span></dt>
 <dt><span class="section"><a href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.modifying_the_boost_configuration_headers">Modifying
      the Boost Configuration Headers</a></span></dt>
 </dl></div>
 <p>
      The <a href="../../../../../boost/config.hpp" target="_top">&lt;boost/config.hpp&gt;</a>
      header is used to pass configuration information to other boost files, allowing
      them to cope with platform dependencies such as arithmetic byte ordering, compiler
      pragmas, or compiler shortcomings. Without such configuration information,
      many current compilers would not work with the Boost libraries.
    </p>
 <p>
      Centralizing configuration information in this header reduces the number of
      files that must be modified when porting libraries to new platforms, or when
      compilers are updated. Ideally, no other files would have to be modified when
      porting to a new platform.
    </p>
 <p>
      Configuration headers are controversial because some view them as condoning
      broken compilers and encouraging non-standard subsets. Adding settings for
      additional platforms and maintaining existing settings can also be a problem.
      In other words, configuration headers are a necessary evil rather than a desirable
      feature. The boost config.hpp policy is designed to minimize the problems and
      maximize the benefits of a configuration header.
    </p>
 <p>
      Note that:
    </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
          Boost library implementers are not required to "<code class="computeroutput"><span class="preprocessor">#include</span>
          <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>", and are not required in any
          way to support compilers that do not comply with the C++ Standard (ISO/IEC
          14882).
        </li>
 <li class="listitem">
          If a library implementer wishes to support some non-conforming compiler,
          or to support some platform specific feature, "<code class="computeroutput"><span class="preprocessor">#include</span>
          <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>" is the preferred way to obtain
          configuration information not available from the standard headers such
          as <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">climits</span><span class="special">&gt;</span></code>, etc.
        </li>
 <li class="listitem">
          If configuration information can be deduced from standard headers such
          as <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">climits</span><span class="special">&gt;</span></code>, use those standard headers rather
          than <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
        </li>
 <li class="listitem">
          Boost files that use macros defined in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
          should have sensible, standard conforming, default behavior if the macro
          is not defined. This means that the starting point for porting <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> to a new platform is simply to define
          nothing at all specific to that platform. In the rare case where there
          is no sensible default behavior, an #error message should describe the
          problem.
        </li>
 <li class="listitem">
          If a Boost library implementer wants something added to <code class="computeroutput"><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span></code>,
          post a request on the Boost mailing list. There is no guarantee such a
          request will be honored; the intent is to limit the complexity of config.hpp.
        </li>
 <li class="listitem">
          The intent is to support only compilers which appear on their way to becoming
          C++ Standard compliant, and only recent releases of those compilers at
          that.
        </li>
 <li class="listitem">
          The intent is not to disable mainstream features now well-supported by
          the majority of compilers, such as namespaces, exceptions, RTTI, or templates.
        </li>
 </ul></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.guidelines_for_boost_authors.warnings"></a><a class="link" href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.warnings" title="Disabling Compiler Warnings">Disabling
      Compiler Warnings</a>
 </h3></div></div></div>
 <p>
        The header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">warning_disable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        can be used to disable certain compiler warings that are hard or impossible
        to otherwise remove.
      </p>
 <p>
        Note that:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            This header <span class="bold"><strong><span class="emphasis"><em>should never be included
            by another Boost header</em></span></strong></span>, it should only ever be
            used by a library source file or a test case.
          </li>
 <li class="listitem">
            The header should be included <span class="bold"><strong><span class="emphasis"><em>before
            you include any other header</em></span></strong></span>.
          </li>
 <li class="listitem">
            This header only disables warnings that are hard or impossible to otherwise
            deal with, and which are typically emitted by one compiler only, or in
            one compilers own standard library headers.
          </li>
 </ul></div>
 <p>
        Currently it disables the following warnings:
      </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  Compiler
                </p>
              </th>
 <th>
                <p>
                  Warning
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  Visual C++ 8 and later
                </p>
              </td>
 <td>
                <p>
                  <a href="http://msdn2.microsoft.com/en-us/library/ttcz0bys(VS.80).aspx" target="_top">C4996</a>:
                  Error 'function': was declared deprecated
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  Intel C++
                </p>
              </td>
 <td>
                <p>
                  Warning 1786: relates to the use of "deprecated" standard
                  library functions rather like C4996 in Visual C++.
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.guidelines_for_boost_authors.adding_new_defect_macros"></a><a class="link" href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.adding_new_defect_macros" title="Adding New Defect Macros">Adding
      New Defect Macros</a>
 </h3></div></div></div>
 <p>
        When you need to add a new defect macro - either to fix a problem with an
        existing library, or when adding a new library - distil the issue down to
        a simple test case; often, at this point other (possibly better) workarounds
        may become apparent. Secondly always post the test case code to the boost
        mailing list and invite comments; remember that C++ is complex and that sometimes
        what may appear a defect, may in fact turn out to be a problem with the authors
        understanding of the standard.
      </p>
 <p>
        When you name the macro, follow the <code class="computeroutput"><span class="identifier">BOOST_NO_</span></code><span class="emphasis"><em>SOMETHING</em></span>
        naming convention, so that it's obvious that this is a macro reporting a
        defect.
      </p>
 <p>
        Finally, add the test program to the regression tests. You will need to place
        the test case in a <code class="computeroutput"><span class="special">.</span><span class="identifier">ipp</span></code>
        file with the following comments near the top:
      </p>
 <pre class="programlisting"><span class="comment">//  MACRO:         BOOST_NO_FOO</span>
 <span class="comment">//  TITLE:         foo</span>
 <span class="comment">//  DESCRIPTION:   If the compiler fails to support foo</span>
 </pre>
 <p>
        These comments are processed by the autoconf script, so make sure the format
        follows the one given. The file should be named "<code class="computeroutput"><span class="identifier">boost_no_foo</span><span class="special">.</span><span class="identifier">ipp</span></code>",
        where foo is the defect description - try and keep the file name under the
        Mac 30 character filename limit though. You will also need to provide a function
        prototype "<code class="computeroutput"><span class="keyword">int</span> <span class="identifier">test</span><span class="special">()</span></code>" that is declared in a namespace with
        the same name as the macro, but in all lower case, and which returns zero
        on success:
      </p>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost_no_foo</span> <span class="special">{</span>
 <span class="keyword">int</span> <span class="identifier">test</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="comment">// test code goes here:</span>
    <span class="comment">//</span>
    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 <span class="special">}</span>
 </pre>
 <p>
        Once the test code is in place in libs/config/test, updating the configuration
        test system proceeds as:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            cd into <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">tools</span></code> and run <code class="computeroutput"><span class="identifier">bjam</span></code>.
            This generates the <code class="computeroutput"><span class="special">.</span><span class="identifier">cpp</span></code>
            file test cases from the <code class="computeroutput"><span class="special">.</span><span class="identifier">ipp</span></code> file, updates the libs/config/test/all/Jamfile.v2,
            <code class="computeroutput"><span class="identifier">config_test</span><span class="special">.</span><span class="identifier">cpp</span></code> and <code class="computeroutput"><span class="identifier">config_info</span><span class="special">.</span><span class="identifier">cpp</span></code>.<br>
            <br>
          </li>
 <li class="listitem">
            cd into <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">test</span><span class="special">/</span><span class="identifier">all</span></code> and run <code class="computeroutput"><span class="identifier">bjam</span>
            </code><span class="emphasis"><em>MACRONAME<code class="computeroutput"> <span class="identifier">compiler</span><span class="special">-</span><span class="identifier">list</span></code></em></span>,
            where <span class="emphasis"><em>MACRONAME</em></span> is the name of the new macro, and
            <span class="emphasis"><em><code class="computeroutput"><span class="identifier">compiler</span><span class="special">-</span><span class="identifier">list</span></code></em></span> is a space separated
            list of compilers to test with.<br> <br> The xxx_pass_test and the
            xxx_fail_test <span class="bold"><strong>should both report <code class="computeroutput"><span class="special">**</span><span class="identifier">passed</span><span class="special">**</span></code></strong></span>.<br> <br> If <span class="emphasis"><em>MACRONAME</em></span>
            is not defined when it should be defined, xxx_pass_test will not report
            <code class="computeroutput"><span class="special">**</span><span class="identifier">passed</span><span class="special">**</span></code>. If <span class="emphasis"><em>MACRONAME</em></span>
            is defined when it should not be defined, xxx_fail_test will not report
            <code class="computeroutput"><span class="special">**</span><span class="identifier">passed</span><span class="special">**</span></code>.<br> <br>
          </li>
 <li class="listitem">
            cd into <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">test</span></code> and run <code class="computeroutput"><span class="identifier">bjam</span>
            <span class="identifier">config_info</span> <span class="identifier">config_test</span>
            </code><span class="emphasis"><em><code class="computeroutput"><span class="identifier">compiler</span><span class="special">-</span><span class="identifier">list</span></code></em></span>.
            <code class="computeroutput"><span class="identifier">config_info</span></code> should build
            and run cleanly for all the compilers in <span class="emphasis"><em><code class="computeroutput"><span class="identifier">compiler</span><span class="special">-</span><span class="identifier">list</span></code></em></span>
            while <code class="computeroutput"><span class="identifier">config_test</span></code> should
            fail for those that have the defect, and pass for those that do not.
          </li>
 </ul></div>
 <p>
        Then you should:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            Define the defect macro in those config headers that require it.
          </li>
 <li class="listitem">
            Document the macro in this documentation (please do not forget this step!!)
          </li>
 <li class="listitem">
            Commit everything.
          </li>
 <li class="listitem">
            Keep an eye on the regression tests for new failures in Boost.Config
            caused by the addition.
          </li>
 <li class="listitem">
            Start using the macro.
          </li>
 </ul></div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.guidelines_for_boost_authors.adding_new_feature_test_macros"></a><a class="link" href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.adding_new_feature_test_macros" title="Adding New Feature Test Macros">Adding
      New Feature Test Macros</a>
 </h3></div></div></div>
 <p>
        When you need to add a macro that describes a feature that the standard does
        not require, follow the convention for adding a new defect macro (above),
        but call the macro <code class="computeroutput"><span class="identifier">BOOST_HAS_FOO</span></code>,
        and name the test file "<code class="computeroutput"><span class="identifier">boost_has_foo</span><span class="special">.</span><span class="identifier">ipp</span></code>".
        Try not to add feature test macros unnecessarily, if there is a platform
        specific macro that can already be used (for example <code class="computeroutput"><span class="identifier">_WIN32</span></code>,
        <code class="computeroutput"><span class="identifier">__BEOS__</span></code>, or <code class="computeroutput"><span class="identifier">__linux</span></code>) to identify the feature then use
        that. Try to keep the macro to a feature group, or header name, rather than
        one specific API (for example <code class="computeroutput"><span class="identifier">BOOST_HAS_NL_TYPES_H</span></code>
        rather than <code class="computeroutput"><span class="identifier">BOOST_HAS_CATOPEN</span></code>).
        If the macro describes a POSIX feature group, then add boilerplate code to
        <a href="../../../../../boost/config/user.hpp" target="_top">&lt;boost/config/suffix.hpp&gt;</a>
        to auto-detect the feature where possible (if you are wondering why we can't
        use POSIX feature test macro directly, remember that many of these features
        can be added by third party libraries, and are not therefore identified inside
        <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">unistd</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>).
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.guidelines_for_boost_authors.modifying_the_boost_configuration_headers"></a><a class="link" href="guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.modifying_the_boost_configuration_headers" title="Modifying the Boost Configuration Headers">Modifying
      the Boost Configuration Headers</a>
 </h3></div></div></div>
 <p>
        The aim of boost's configuration setup is that the configuration headers
        should be relatively stable - a boost user should not have to recompile their
        code just because the configuration for some compiler that they're not interested
        in has changed. Separating the configuration into separate compiler/standard
        library/platform sections provides for part of this stability, but boost
        authors require some amount of restraint as well, in particular:
      </p>
 <p>
        <a href="../../../../../boost/config.hpp" target="_top">&lt;boost/config.hpp&gt;</a>
        should never change, don't alter this file.
      </p>
 <p>
        <a href="../../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>
        is included by default, don't add extra code to this file unless you have
        to. If you do, please remember to update <a href="../../../tools/configure.in" target="_top">libs/config/tools/configure.in</a>
        as well.
      </p>
 <p>
        <a href="../../../../../boost/config/user.hpp" target="_top">&lt;boost/config/suffix.hpp&gt;</a>
        is always included so be careful about modifying this file as it breaks dependencies
        for everyone. This file should include only "boilerplate" configuration
        code, and generally should change only when new macros are added.
      </p>
 <p>
        <a href="../../../../../boost/config/select_compiler_config.hpp" target="_top">&lt;boost/config/select_compiler_config.hpp&gt;</a>,
        <a href="../../../../../boost/config/select_platform_config.hpp" target="_top">&lt;boost/config/select_platform_config.hpp&gt;</a>
        and <a href="../../../../../boost/config/select_stdlib_config.hpp" target="_top">&lt;boost/config/select_stdlib_config.hpp&gt;</a>
        are included by default and should change only if support for a new compiler/standard
        library/platform is added.
      </p>
 <p>
        The compiler/platform/standard library selection code is set up so that unknown
        platforms are ignored and assumed to be fully standards compliant - this
        gives unknown platforms a "sporting chance" of working "as
        is" even without running the configure script.
      </p>
 <p>
        When adding or modifying the individual mini-configs, assume that future,
        as yet unreleased versions of compilers, have all the defects of the current
        version. Although this is perhaps unnecessarily pessimistic, it cuts down
        on the maintenance of these files, and experience suggests that pessimism
        is better placed than optimism here!
      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001-2007 Beman Dawes, Vesa Karvonen, John
      Maddock<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="boost_macro_reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
@@ -0,0 +1,124 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Rationale</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
 <link rel="home" href="../index.html" title="Boost.Config">
 <link rel="up" href="../index.html" title="Boost.Config">
 <link rel="prev" href="guidelines_for_boost_authors.html" title="Guidelines for Boost Authors">
 <link rel="next" href="acknowledgements.html" title="Acknowledgements">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="guidelines_for_boost_authors.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_config.rationale"></a><a class="link" href="rationale.html" title="Rationale">Rationale</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="rationale.html#boost_config.rationale.the_problem">The problem</a></span></dt>
 <dt><span class="section"><a href="rationale.html#boost_config.rationale.the_solution">The solution</a></span></dt>
 </dl></div>
 <p>
      The problem with many traditional "textbook" implementations of configuration
      headers (where all the configuration options are in a single "monolithic"
      header) is that they violate certain fundamental software engineering principles
      which would have the effect of making boost more fragile, more difficult to
      maintain and more difficult to use safely. You can find a description of the
      principles from the <a href="http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf" target="_top">following
      article</a>.
    </p>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.rationale.the_problem"></a><a class="link" href="rationale.html#boost_config.rationale.the_problem" title="The problem">The problem</a>
 </h3></div></div></div>
 <p>
        Consider a situation in which you are concurrently developing on multiple
        platforms. Then consider adding a new platform or changing the platform definitions
        of an existing platform. What happens? Everything, and this does literally
        mean everything, recompiles. Isn't it quite absurd that adding a new platform,
        which has absolutely nothing to do with previously existing platforms, means
        that all code on all existing platforms needs to be recompiled?
      </p>
 <p>
        Effectively, there is an imposed physical dependency between platforms that
        have nothing to do with each other. Essentially, the traditional solution
        employed by configuration headers does not conform to the Open-Closed Principle:
      </p>
 <div class="blockquote"><blockquote class="blockquote"><p>
          <span class="bold"><strong>"A module should be open for extension but closed
          for modification."</strong></span>
        </p></blockquote></div>
 <p>
        Extending a traditional configuration header implies modifying existing code.
      </p>
 <p>
        Furthermore, consider the complexity and fragility of the platform detection
        code. What if a simple change breaks the detection on some minor platform?
        What if someone accidentally or on purpose (as a workaround for some other
        problem) defines some platform dependent macros that are used by the detection
        code? A traditional configuration header is one of the most volatile headers
        of the entire library, and more stable elements of Boost would depend on
        it. This violates the Stable Dependencies Principle:
      </p>
 <div class="blockquote"><blockquote class="blockquote"><p>
          <span class="bold"><strong>"Depend in the direction of stability."</strong></span>
        </p></blockquote></div>
 <p>
        After even a minor change to a traditional configuration header on one minor
        platform, almost everything on every platform should be tested if we follow
        sound software engineering practice.
      </p>
 <p>
        Another important issue is that it is not always possible to submit changes
        to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
        Some boost users are currently working on platforms using tools and libraries
        that are under strict Non-Disclosure Agreements. In this situation it is
        impossible to submit changes to a traditional monolithic configuration header,
        instead some method by which the user can insert their own configuration
        code must be provided.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.rationale.the_solution"></a><a class="link" href="rationale.html#boost_config.rationale.the_solution" title="The solution">The solution</a>
 </h3></div></div></div>
 <p>
        The approach taken by boost's configuration headers is to separate configuration
        into three orthogonal parts: the compiler, the standard library and the platform.
        Each compiler/standard library/platform gets its own mini-configuration header,
        so that changes to one compiler's configuration (for example) does not affect
        other compilers. In addition there are measures that can be taken both to
        omit the compiler/standard library/platform detection code (so that adding
        support to a new platform does not break dependencies), or to freeze the
        configuration completely; providing almost complete protection against dependency
        changes.
      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001-2007 Beman Dawes, Vesa Karvonen, John
      Maddock<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="guidelines_for_boost_authors.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
@@ -0,0 +1,956 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Boost.Config</title>
 <link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
 <link rel="home" href="index.html" title="Boost.Config">
 <link rel="next" href="boost_config/boost_macro_reference.html" title="Boost Macro Reference">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
 <td align="center"><a href="../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="boost_config/boost_macro_reference.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
 <div class="article">
 <div class="titlepage">
 <div>
 <div><h2 class="title">
 <a name="config"></a>Boost.Config</h2></div>
 <div><div class="authorgroup"><div class="author"><h3 class="author">
 <span class="firstname">Vesa Karvonen, John Maddock</span> <span class="surname">Beman Dawes</span>
 </h3></div></div></div>
 <div><p class="copyright">Copyright &#169; 2001-2007 Beman Dawes, Vesa Karvonen, John
      Maddock</p></div>
 <div><div class="legalnotice">
 <a name="id910601"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></div>
 </div>
 <hr>
 </div>
 <div class="toc">
 <p><b>Table of Contents</b></p>
 <dl>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform">Configuring
    Boost for Your Platform</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.using_the_default_boost_configuration">Using
      the default boost configuration</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.the__boost_config_hpp__header">The
      &lt;boost/config.hpp&gt; header</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.using_the_configure_script">Using
      the configure script</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.user_settable_options">User
      settable options</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage">Advanced
      configuration usage</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.testing_the_boost_configuration">Testing
      the boost configuration</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html">Boost Macro Reference</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_defects">Macros
      that describe defects</a></span></dt>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_optional_features">Macros
      that describe optional features</a></span></dt>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_possible_c__0x_features">Macros
      that describe possible C++0x features</a></span></dt>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__0x_features_not_supported">Macros
      that describe C++0x features not supported</a></span></dt>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.boost_helper_macros">Boost
      Helper Macros</a></span></dt>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.boost_informational_macros">Boost
      Informational Macros</a></span></dt>
 <dt><span class="section"><a href="boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_for_libraries_with_separate_source_code">Macros
      for libraries with separate source code</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="boost_config/guidelines_for_boost_authors.html">Guidelines for
    Boost Authors</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_config/guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.warnings">Disabling
      Compiler Warnings</a></span></dt>
 <dt><span class="section"><a href="boost_config/guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.adding_new_defect_macros">Adding
      New Defect Macros</a></span></dt>
 <dt><span class="section"><a href="boost_config/guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.adding_new_feature_test_macros">Adding
      New Feature Test Macros</a></span></dt>
 <dt><span class="section"><a href="boost_config/guidelines_for_boost_authors.html#boost_config.guidelines_for_boost_authors.modifying_the_boost_configuration_headers">Modifying
      the Boost Configuration Headers</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="boost_config/rationale.html">Rationale</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_config/rationale.html#boost_config.rationale.the_problem">The problem</a></span></dt>
 <dt><span class="section"><a href="boost_config/rationale.html#boost_config.rationale.the_solution">The solution</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="boost_config/acknowledgements.html">Acknowledgements</a></span></dt>
 </dl>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_config.configuring_boost_for_your_platform"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform" title="Configuring Boost for Your Platform">Configuring
    Boost for Your Platform</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.using_the_default_boost_configuration">Using
      the default boost configuration</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.the__boost_config_hpp__header">The
      &lt;boost/config.hpp&gt; header</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.using_the_configure_script">Using
      the configure script</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.user_settable_options">User
      settable options</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage">Advanced
      configuration usage</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.testing_the_boost_configuration">Testing
      the boost configuration</a></span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.using_the_default_boost_configuration"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.using_the_default_boost_configuration" title="Using the default boost configuration">Using
      the default boost configuration</a>
 </h3></div></div></div>
 <p>
        Boost comes already configured for most common compilers and platforms; you
        should be able to use boost "as is". Since the compiler is configured
        separately from the standard library, the default configuration should work
        even if you replace the compiler's standard library with a third-party standard
        library (like <a href="http://stlport.sourceforge.net" target="_top">STLport</a>).
      </p>
 <p>
        Using boost "as is" without trying to reconfigure is the recommended
        method for using boost. You can, however, run the configure script if you
        want to, and there are regression tests provided that allow you to test the
        current boost configuration with your particular compiler setup.
      </p>
 <p>
        Boost library users can request support for additional compilers or platforms
        by visiting our <a href="https://svn.boost.org/trac/boost/newticket" target="_top">Trac</a>
        and submitting a support request.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.the__boost_config_hpp__header"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.the__boost_config_hpp__header" title="The &lt;boost/config.hpp&gt; header">The
      &lt;boost/config.hpp&gt; header</a>
 </h3></div></div></div>
 <p>
        Boost library implementations access configuration macros via
      </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <a href="../../../../boost/config.hpp" target="_top">&lt;boost/config.hpp&gt;</a>
 </pre>
 <p>
        While Boost library users are not required to include that file directly,
        or use those configuration macros, such use is acceptable. The configuration
        macros are documented as to their purpose, usage, and limitations which makes
        them usable by both Boost library and user code.
      </p>
 <p>
        Boost <a class="link" href="boost_config/boost_macro_reference.html#config_info_macros">informational</a> or <a class="link" href="boost_config/boost_macro_reference.html#config_helpers">helper</a>
        macros are designed for use by Boost users as well as for our own internal
        use. Note however, that the <a class="link" href="boost_config/boost_macro_reference.html#config_features">feature test</a>
        and <a class="link" href="boost_config/boost_macro_reference.html#config_defects">defect test</a> macros were designed
        for internal use by Boost libraries, not user code, so they can change at
        any time (though no gratuitous changes are made to them). Boost library problems
        resulting from changes to the configuration macros are caught by the Boost
        regression tests, so the Boost libraries are updated to account for those
        changes. By contrast, Boost library user code can be adversely affected by
        changes to the macros without warning. The best way to keep abreast of changes
        to the macros used in user code is to monitor the discussions on the Boost
        developers list.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.using_the_configure_script"></a><a name="config_config_script"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.using_the_configure_script" title="Using the configure script">Using
      the configure script</a>
 </h3></div></div></div>
 <div class="important"><table border="0" summary="Important">
 <tr>
 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../doc/src/images/important.png"></td>
 <th align="left">Important</th>
 </tr>
 <tr><td align="left" valign="top"><p>
          This configure script only sets up the Boost headers for use with a particular
          compiler. It has no effect on Boost.Build, or how the libraries are built.
        </p></td></tr>
 </table></div>
 <p>
        If you know that boost is incorrectly configured for your particular setup,
        and you are on a UNIX like platform, then you may want to try and improve
        things by running the boost configure script. From a shell command prompt
        you will need to cd into <span class="emphasis"><em>&lt;boost-root&gt;</em></span><code class="computeroutput"><span class="special">/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span></code>
        and type:
      </p>
 <div class="blockquote"><blockquote class="blockquote"><p>
          <code class="computeroutput"><span class="identifier">sh</span> <span class="special">./</span><span class="identifier">configure</span></code>
        </p></blockquote></div>
 <p>
        you will see a list of the items being checked as the script works its way
        through the regression tests. Note that the configure script only really
        auto-detects your compiler if it's called g++, c++ or CC. If you are using
        some other compiler you will need to set one or more of the following environment
        variables:
      </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  Variable
                </p>
              </th>
 <th>
                <p>
                  Description
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  CXX
                </p>
              </td>
 <td>
                <p>
                  The name of the compiler, for example <code class="computeroutput"><span class="identifier">c</span><span class="special">++</span></code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  CXXFLAGS
                </p>
              </td>
 <td>
                <p>
                  The compiler flags to use, for example <code class="computeroutput"><span class="special">-</span><span class="identifier">O2</span></code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  LDFLAGS
                </p>
              </td>
 <td>
                <p>
                  The linker flags to use, for example <code class="computeroutput"><span class="special">-</span><span class="identifier">L</span><span class="special">/</span><span class="identifier">mypath</span></code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  LIBS
                </p>
              </td>
 <td>
                <p>
                  Any libraries to link in, for example <code class="computeroutput"><span class="special">-</span><span class="identifier">lpthread</span></code>.
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 <p>
        For example to run the configure script with HP aCC, you might use something
        like:
      </p>
 <pre class="programlisting"><span class="keyword">export</span> <span class="identifier">CXX</span><span class="special">=</span><span class="string">"aCC"</span>
 <span class="keyword">export</span> <span class="identifier">CXXFLAGS</span><span class="special">=</span><span class="string">"-Aa -DAportable -D__HPACC_THREAD_SAFE_RB_TREE \
   -DRWSTD_MULTI_THREAD -DRW_MULTI_THREAD -D_REENTRANT -D_THREAD_SAFE"</span>
 <span class="keyword">export</span> <span class="identifier">LDFLAGS</span><span class="special">=</span><span class="string">"-DAportable"</span>
 <span class="keyword">export</span> <span class="identifier">LIBS</span><span class="special">=</span><span class="string">"-lpthread"</span> 
 <span class="identifier">sh</span> <span class="special">./</span><span class="identifier">configure</span>
 </pre>
 <p>
        However you run the configure script, when it finishes you will find a new
        header -<code class="computeroutput"><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span></code>- located in the <span class="emphasis"><em>&lt;boost-root&gt;</em></span><code class="computeroutput"><span class="special">/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span></code>
        directory. <span class="bold"><strong>Note that configure does not install this
        header into your boost include path by default</strong></span>. This header contains
        all the options generated by the configure script, plus a header-section
        that contains the user settable options from the default version of <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>
        (located under <span class="emphasis"><em>&lt;boost-root&gt;</em></span><code class="computeroutput"><span class="special">/</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span></code>).
        There are two ways you can use this header:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            <span class="bold"><strong>Option 1:</strong></span> copy the header into <span class="emphasis"><em>&lt;boost-root&gt;</em></span><code class="computeroutput"><span class="special">/</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span></code> so that it replaces the default user.hpp
            provided by boost. This option allows only one configure-generated setup;
            boost developers should avoid this option, as it incurs the danger of
            accidentally committing a configure-modified <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>
            to the cvs repository (something you will not be thanked for!).
          </li>
 <li class="listitem">
            <span class="bold"><strong>Option 2:</strong></span> give the header a more memorable
            name, and place it somewhere convenient; then, define the macro <code class="computeroutput"><span class="identifier">BOOST_USER_CONFIG</span></code> to point to it. For
            example create a new sub-directory <span class="emphasis"><em>&lt;boost-root&gt;</em></span><code class="computeroutput"><span class="special">/</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span></code> <code class="computeroutput"><span class="identifier">user</span><span class="special">/</span></code>, and copy the header there; for example
            as <code class="computeroutput"><span class="identifier">multithread</span><span class="special">-</span><span class="identifier">gcc</span><span class="special">-</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span></code>. Then, when compiling add the command
            line option: <code class="computeroutput"><span class="special">-</span><span class="identifier">DBOOST_USER_CONFIG</span><span class="special">=</span><span class="string">"&lt;boost/config/user/multithread-gcc-config.hpp&gt;"</span></code>,
            and boost will use the new configuration header. This option allows you
            to generate more than one configuration header, and to keep them separate
            from the boost source - so that updates to the source do not interfere
            with your configuration.
          </li>
 </ul></div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.user_settable_options"></a><a name="config_user_settable"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.user_settable_options" title="User settable options">User
      settable options</a>
 </h3></div></div></div>
 <p>
        There are some configuration-options that represent user choices, rather
        than compiler defects or platform specific options. These are listed in
        <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        and at the start of a configure-generated <code class="computeroutput"><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span></code> header.
        You can define these on the command line, or by editing <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>, they are listed in the following table:
      </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  Macro
                </p>
              </th>
 <th>
                <p>
                  Description
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_USER_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, it should point to the name of the user configuration
                  file to include prior to any boost configuration files. When not
                  defined, defaults to <a href="../../../../boost/config/user.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_COMPILER_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, it should point to the name of the compiler configuration
                  file to use. Defining this cuts out the compiler selection logic,
                  and eliminates the dependency on the header containing that logic.
                  For example if you are using gcc, then you could define BOOST_COMPILER_CONFIG
                  to <a href="../../../../boost/config/compiler/gcc.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">compiler</span><span class="special">/</span><span class="identifier">gcc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_STDLIB_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, it should point to the name of the standard library
                  configuration file to use. Defining this cuts out the standard
                  library selection logic, and eliminates the dependency on the header
                  containing that logic. For example if you are using STLport, then
                  you could define <code class="computeroutput"><span class="identifier">BOOST_STDLIB_CONFIG</span></code>
                  to <a href="../../../../boost/config/stdlib/stlport.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">stdlib</span><span class="special">/</span><span class="identifier">stlport</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_PLATFORM_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, it should point to the name of the platform configuration
                  file to use. Defining this cuts out the platform selection logic,
                  and eliminates the dependency on the header containing that logic.
                  For example if you are compiling on linux, then you could define
                  <code class="computeroutput"><span class="identifier">BOOST_PLATFORM_CONFIG</span></code>
                  to <a href="../../../../boost/config/platform/linux.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">platform</span><span class="special">/</span><span class="identifier">linux</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_NO_COMPILER_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, no compiler configuration file is selected or included,
                  define when the compiler is fully conformant with the standard,
                  or where the user header (see <code class="computeroutput"><span class="identifier">BOOST_USER_CONFIG</span></code>),
                  has had any options necessary added to it, for example by an autoconf
                  generated configure script.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_NO_STDLIB_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, no standard library configuration file is selected
                  or included, define when the standard library is fully conformant
                  with the standard, or where the user header (see <code class="computeroutput"><span class="identifier">BOOST_USER_CONFIG</span></code>), has had any
                  options necessary added to it, for example by an autoconf generated
                  configure script.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_NO_PLATFORM_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, no platform configuration file is selected or included,
                  define when the platform is fully conformant with the standard
                  (and has no useful extra features), or where the user header (see
                  <code class="computeroutput"><span class="identifier">BOOST_USER_CONFIG</span></code>),
                  has had any options necessary added to it, for example by an autoconf
                  generated configure script.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_NO_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  Equivalent to defining all of <code class="computeroutput"><span class="identifier">BOOST_NO_COMPILER_CONFIG</span></code>,
                  <code class="computeroutput"><span class="identifier">BOOST_NO_STDLIB_CONFIG</span></code>
                  and <code class="computeroutput"><span class="identifier">BOOST_NO_PLATFORM_CONFIG</span></code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_STRICT_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  The normal behavior for compiler versions that are newer than the
                  last known version, is to assume that they have all the same defects
                  as the last known version. By setting this define, then compiler
                  versions that are newer than the last known version are assumed
                  to be fully conforming with the standard. This is probably most
                  useful for boost developers or testers, and for those who want
                  to use boost to test beta compiler versions.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_ASSERT_CONFIG</span></code>
                </p>
              </td>
 <td>
                <p>
                  When this flag is set, if the config finds anything unknown, then
                  it will stop with a #error rather than continue. Boost regression
                  testers should set this define, as should anyone who wants to quickly
                  check whether boost is supported on their platform.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_DISABLE_THREADS</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, disables threading support, even if the compiler
                  in its current translation mode supports multiple threads.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_DISABLE_WIN32</span></code>
                </p>
              </td>
 <td>
                <p>
                  When defined, disables the use of Win32 specific API's, even when
                  these are available. Also has the effect of setting <code class="computeroutput"><span class="identifier">BOOST_DISABLE_THREADS</span></code> unless
                  <code class="computeroutput"><span class="identifier">BOOST_HAS_PTHREADS</span></code>
                  is set. This option may be set automatically by the config system
                  when it detects that the compiler is in "strict mode".
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_DISABLE_ABI_HEADERS</span></code>
                </p>
              </td>
 <td>
                <p>
                  Stops boost headers from including any prefix/suffix headers that
                  normally control things like struct packing and alignment.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_ABI_PREFIX</span></code>
                </p>
              </td>
 <td>
                <p>
                  A prefix header to include in place of whatever boost.config would
                  normally select, any replacement should set up struct packing and
                  alignment options as required.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_ABI_SUFFIX</span></code>
                </p>
              </td>
 <td>
                <p>
                  A suffix header to include in place of whatever boost.config would
                  normally select, any replacement should undo the effects of the
                  prefix header.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_ALL_DYN_LINK</span></code>
                </p>
              </td>
 <td>
                <p>
                  Forces all libraries that have separate source, to be linked as
                  dll's rather than static libraries on Microsoft Windows (this macro
                  is used to turn on <code class="computeroutput"><span class="identifier">__declspec</span><span class="special">(</span><span class="identifier">dllimport</span><span class="special">)</span></code> modifiers, so that the compiler
                  knows which symbols to look for in a dll rather than in a static
                  library). Note that there may be some libraries that can only be
                  statically linked (Boost.Test for example) and others which may
                  only be dynamically linked (Boost.Threads for example), in these
                  cases this macro has no effect.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_</span></code><span class="emphasis"><em>WHATEVER</em></span><code class="computeroutput"><span class="identifier">_DYN_LINK</span></code>
                </p>
              </td>
 <td>
                <p>
                  Forces library "whatever" to be linked as a dll rather
                  than a static library on Microsoft Windows: replace the <span class="emphasis"><em>WHATEVER</em></span>
                  part of the macro name with the name of the library that you want
                  to dynamically link to, for example use <code class="computeroutput"><span class="identifier">BOOST_DATE_TIME_DYN_LINK</span></code>
                  or <code class="computeroutput"><span class="identifier">BOOST_REGEX_DYN_LINK</span></code>
                  etc (this macro is used to turn on <code class="computeroutput"><span class="identifier">__declspec</span><span class="special">(</span><span class="identifier">dllimport</span><span class="special">)</span></code> modifiers, so that the compiler
                  knows which symbols to look for in a dll rather than in a static
                  library). Note that there may be some libraries that can only be
                  statically linked (Boost.Test for example) and others which may
                  only be dynamically linked (Boost.Threads for example), in these
                  cases this macro is unsupported.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_ALL_NO_LIB</span></code>
                </p>
              </td>
 <td>
                <p>
                  Tells the config system not to automatically select which libraries
                  to link against. Normally if a compiler supports #pragma lib, then
                  the correct library build variant will be automatically selected
                  and linked against, simply by the act of including one of that
                  library's headers. This macro turns that feature off.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_</span></code><span class="emphasis"><em>WHATEVER</em></span><code class="computeroutput"><span class="identifier">_NO_LIB</span></code>
                </p>
              </td>
 <td>
                <p>
                  Tells the config system not to automatically select which library
                  to link against for library "whatever", replace <span class="emphasis"><em>WHATEVER</em></span>
                  in the macro name with the name of the library; for example <code class="computeroutput"><span class="identifier">BOOST_DATE_TIME_NO_LIB</span></code> or <code class="computeroutput"><span class="identifier">BOOST_REGEX_NO_LIB</span></code>. Normally
                  if a compiler supports <code class="computeroutput"><span class="preprocessor">#pragma</span>
                  <span class="identifier">lib</span></code>, then the correct
                  library build variant will be automatically selected and linked
                  against, simply by the act of including one of that library's headers.
                  This macro turns that feature off.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_LIB_DIAGNOSTIC</span></code>
                </p>
              </td>
 <td>
                <p>
                  Causes the auto-linking code to output diagnostic messages indicating
                  the name of the library that is selected for linking.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">BOOST_LIB_TOOLSET</span></code>
                </p>
              </td>
 <td>
                <p>
                  Overrides the name of the toolset part of the name of library being
                  linked to; note if defined this must be defined to a quoted string
                  literal, for example "abc".
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.advanced_configuration_usage"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage" title="Advanced configuration usage">Advanced
      configuration usage</a>
 </h3></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_1__creating_our_own_frozen_configuration">Example
        1, creating our own frozen configuration</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_2__skipping_files_that_you_don_t_need">Example
        2: skipping files that you don't need</a></span></dt>
 <dt><span class="section"><a href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_3__using_configure_script_to_freeze_the_boost_configuration">Example
        3: using configure script to freeze the boost configuration</a></span></dt>
 </dl></div>
 <p>
        By setting various macros on the compiler command line or by editing <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>,
        the boost configuration setup can be optimised in a variety of ways.
      </p>
 <p>
        Boost's configuration is structured so that the user-configuration is included
        first (defaulting to <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>
        if <code class="computeroutput"><span class="identifier">BOOST_USER_CONFIG</span></code> is not
        defined). This sets up any user-defined policies, and gives the user-configuration
        a chance to influence what happens next.
      </p>
 <p>
        Next the compiler, standard library, and platform configuration files are
        included. These are included via macros (<code class="computeroutput"><span class="identifier">BOOST_COMPILER_CONFIG</span></code>
        etc, <a class="link" href="index.html#config_user_settable">see user settable macros</a>),
        and if the corresponding macro is undefined then a separate header that detects
        which compiler/standard library/platform is in use is included in order to
        set these. The config can be told to ignore these headers altogether if the
        corresponding <code class="computeroutput"><span class="identifier">BOOST_NO_XXX</span></code>
        macro is set (for example <code class="computeroutput"><span class="identifier">BOOST_NO_COMPILER_CONFIG</span></code>
        to disable including any compiler configuration file - <a class="link" href="index.html#config_user_settable">see
        user settable macros</a>).
      </p>
 <p>
        Finally the boost configuration header, includes <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/suffix.hpp&gt;</a>;
        this header contains any boiler plate configuration code - for example where
        one boost macro being set implies that another must be set also.
      </p>
 <p>
        The following usage examples represent just a few of the possibilities:
      </p>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_1__creating_our_own_frozen_configuration"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_1__creating_our_own_frozen_configuration" title="Example 1, creating our own frozen configuration">Example
        1, creating our own frozen configuration</a>
 </h4></div></div></div>
 <p>
          Lets suppose that we're building boost with Visual C++ 6, and STLport 4.0.
          Lets suppose also that we don't intend to update our compiler or standard
          library any time soon. In order to avoid breaking dependencies when we
          update boost, we may want to "freeze" our configuration headers,
          so that we only have to rebuild our project if the boost code itself has
          changed, and not because the boost config has been updated for more recent
          versions of Visual C++ or STLport. We'll start by realising that the configuration
          files in use are: <a href="../../../../boost/config/compiler/visualc.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">compiler</span><span class="special">/</span><span class="identifier">visualc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a> for the compiler, <a href="../../../../boost/config/stdlib/stlport.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">stdlib</span><span class="special">/</span><span class="identifier">stlport</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a> for the standard library, and
          <a href="../../../../boost/config/platform/win32.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">platform</span><span class="special">/</span><span class="identifier">win32</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a> for the platform. Next we'll
          create our own private configuration directory: <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span><span class="identifier">mysetup</span><span class="special">/</span></code>, and copy the configuration files into
          there. Finally, open up <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>
          and edit the following defines:
        </p>
 <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_COMPILER_CONFIG</span> <span class="string">"boost/config/mysetup/visualc.hpp"</span>
 <span class="preprocessor">#define</span> <span class="identifier">BOOST_STDLIB_CONFIG</span> <span class="string">"boost/config/mysetup/stlport.hpp"</span>
 <span class="preprocessor">#define</span> <span class="identifier">BOOST_USER_CONFIG</span> <span class="string">"boost/config/mysetup/win32.hpp"</span>
 </pre>
 <p>
          Now when you use boost, its configuration header will go straight to our
          "frozen" versions, and ignore the default versions, you will
          now be insulated from any configuration changes when you update boost.
          This technique is also useful if you want to modify some of the boost configuration
          files; for example if you are working with a beta compiler release not
          yet supported by boost.
        </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_2__skipping_files_that_you_don_t_need"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_2__skipping_files_that_you_don_t_need" title="Example 2: skipping files that you don't need">Example
        2: skipping files that you don't need</a>
 </h4></div></div></div>
 <p>
          Lets suppose that you're using boost with a compiler that is fully conformant
          with the standard; you're not interested in the fact that older versions
          of your compiler may have had bugs, because you know that your current
          version does not need any configuration macros setting. In a case like
          this, you can define <code class="computeroutput"><span class="identifier">BOOST_NO_COMPILER_CONFIG</span></code>
          either on the command line, or in <a href="../../../../boost/config/user.hpp" target="_top">&lt;boost/config/user.hpp&gt;</a>,
          and miss out the compiler configuration header altogether (actually you
          miss out two headers, one which works out what the compiler is, and one
          that configures boost for it). This has two consequences: the first is
          that less code has to be c ompiled, and the second that you have removed
          a dependency on two boost headers.
        </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_3__using_configure_script_to_freeze_the_boost_configuration"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.advanced_configuration_usage.example_3__using_configure_script_to_freeze_the_boost_configuration" title="Example 3: using configure script to freeze the boost configuration">Example
        3: using configure script to freeze the boost configuration</a>
 </h4></div></div></div>
 <p>
          If you are working on a unix-like platform then you can use the configure
          script to generate a "frozen" configuration based on your current
          compiler setup - <a class="link" href="index.html#config_config_script">see using the configure
          script for more details</a>.
        </p>
 </div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_config.configuring_boost_for_your_platform.testing_the_boost_configuration"></a><a class="link" href="index.html#boost_config.configuring_boost_for_your_platform.testing_the_boost_configuration" title="Testing the boost configuration">Testing
      the boost configuration</a>
 </h3></div></div></div>
 <p>
        The boost configuration library provides a full set of regression test programs
        under the <span class="emphasis"><em>&lt;boost-root&gt;</em></span><code class="computeroutput"><span class="special">/</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">/</span></code>
        <code class="computeroutput"><span class="identifier">test</span><span class="special">/</span></code>
        sub-directory:
      </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  File
                </p>
              </th>
 <th>
                <p>
                  Description
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">config_info</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  Prints out a detailed description of your compiler/standard library/platform
                  setup, plus your current boost configuration. The information provided
                  by this program useful in setting up the boost configuration files.
                  If you report that boost is incorrectly configured for your compiler/library/platform
                  then please include the output from this program when reporting
                  the changes required.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">config_test</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  A monolithic test program that includes most of the individual
                  test cases. This provides a quick check to see if boost is correctly
                  configured for your compiler/library/platform.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">limits_test</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  Tests your standard library's <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
                  implementation (or its boost provided replacement if <code class="computeroutput"><span class="identifier">BOOST_NO_LIMITS</span></code> is defined).
                  This test file fails with most versions of numeric_limits, mainly
                  due to the way that some compilers treat NAN's and infinity.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">no_</span><span class="special">*</span><span class="identifier">pass</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  Individual compiler defect test files. Each of these should compile,
                  if one does not then the corresponding <code class="computeroutput"><span class="identifier">BOOST_NO_XXX</span></code>
                  macro needs to be defined - see each test file for specific details.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">no_</span><span class="special">*</span><span class="identifier">fail</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  Individual compiler defect test files. Each of these should not
                  compile, if one does then the corresponding <code class="computeroutput"><span class="identifier">BOOST_NO_XXX</span></code>
                  macro is defined when it need not be - see each test file for specific
                  details.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">has_</span><span class="special">*</span><span class="identifier">pass</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  Individual feature test files. If one of these does not compile
                  then the corresponding <code class="computeroutput"><span class="identifier">BOOST_HAS_XXX</span></code>
                  macro is defined when it should not be - see each test file for
                  specific details.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="computeroutput"><span class="identifier">has_</span><span class="special">*</span><span class="identifier">fail</span><span class="special">.</span><span class="identifier">cpp</span></code>
                </p>
              </td>
 <td>
                <p>
                  Individual feature test files. If one of these does compile then
                  the corresponding <code class="computeroutput"><span class="identifier">BOOST_HAS_XXX</span></code>
                  macro can be safely defined - see each test file for specific details.
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 <p>
        Although you can run the configuration regression tests as individual test
        files, there are rather a lot of them, so there are a couple of shortcuts
        to help you out:
      </p>
 <p>
        If you have built the <a href="../../../../tools/regression/doc/index.html" target="_top">boost
        regression test driver</a>, then you can use this to produce a nice html
        formatted report of the results using the supplied test file.
      </p>
 <p>
        Alternatively you can run the configure script like this:
      </p>
 <div class="blockquote"><blockquote class="blockquote"><p>
          <code class="computeroutput"><span class="special">./</span><span class="identifier">configure</span>
          <span class="special">--</span><span class="identifier">enable</span><span class="special">-</span><span class="identifier">test</span></code>
        </p></blockquote></div>
 <p>
        in which case the script will test the current configuration rather than
        creating a new one from scratch.
      </p>
 <p>
        If you are reporting the results of these tests for a new platform/library/compiler
        then please include a log of the full compiler output, the output from <code class="computeroutput"><span class="identifier">config_info</span><span class="special">.</span><span class="identifier">cpp</span></code>, and the pass/fail test results.
      </p>
 </div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"><p><small>Last revised: July 13, 2011 at 18:00:55 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="boost_config/boost_macro_reference.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
 </body>
 </html>
@@ -0,0 +1,80 @@
 [/
    Boost.Config
    Copyright (c) 2001 Beman Dawes
    Copyright (c) 2001 Vesa Karvonen
    Copyright (c) 2001 John Maddock
    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)
 ]
 [section Rationale]
 The problem with many traditional "textbook" implementations of configuration
 headers (where all the configuration options are in a single "monolithic"
 header) is that they violate certain fundamental software engineering
 principles which would have the effect of making boost more fragile, more
 difficult to maintain and more difficult to use safely. You can find a
 description of the principles from the __PRINCIPLES_AND_PATTERNS_ARTICLE__.
 [section The problem]
 Consider a situation in which you are concurrently developing on multiple
 platforms. Then consider adding a new platform or changing the platform
 definitions of an existing platform. What happens? Everything, and this does
 literally mean everything, recompiles. Isn't it quite absurd that adding a
 new platform, which has absolutely nothing to do with previously existing
 platforms, means that all code on all existing platforms needs to be
 recompiled?
 Effectively, there is an imposed physical dependency between platforms that
 have nothing to do with each other. Essentially, the traditional solution
 employed by configuration headers does not conform to the Open-Closed
 Principle:
 [: [*"A module should be open for extension but closed for modification."]]
 Extending a traditional configuration header implies modifying existing code.
 Furthermore, consider the complexity and fragility of the platform detection
 code. What if a simple change breaks the detection on some minor platform?
 What if someone accidentally or on purpose (as a workaround for some other
 problem) defines some platform dependent macros that are used by the
 detection code? A traditional configuration header is one of the most
 volatile headers of the entire library, and more stable elements of
 Boost would depend on it. This violates the Stable Dependencies Principle:
 [: [*"Depend in the direction of stability."]]
 After even a minor change to a traditional configuration header on one minor
 platform, almost everything on every platform should be tested if we follow
 sound software engineering practice.
 Another important issue is that it is not always possible to submit changes
 to `<boost/config.hpp>`. Some boost users are currently working on platforms
 using tools and libraries that are under strict Non-Disclosure Agreements.
 In this situation it is impossible to submit changes to a traditional
 monolithic configuration header, instead some method by which the user
 can insert their own configuration code must be provided.
 [endsect]
 [section The solution]
 The approach taken by boost's configuration headers is to separate
 configuration into three orthogonal parts: the compiler, the standard
 library and the platform. Each compiler/standard library/platform gets
 its own mini-configuration header, so that changes to one compiler's
 configuration (for example) does not affect other compilers. In addition
 there are measures that can be taken both to omit the compiler/standard
 library/platform detection code (so that adding support to a new platform
 does not break dependencies), or to freeze the configuration completely;
 providing almost complete protection against dependency changes.
 [endsect]
 [endsect]
@@ -1,346 +1,70 @@
 //  Boost config.hpp configuration header file  ------------------------------//
-//  (C) Copyright Boost.org 1999. Permission to copy, use, modify, sell and
+//  (C) Copyright John Maddock 2002. 
-//  distribute this software is granted provided this copyright notice appears
+//  Use, modification and distribution are subject to the 
-//  in all copies. This software is provided "as is" without express or implied
+//  Boost Software License, Version 1.0. (See accompanying file 
-//  warranty, and with no claim as to its suitability for any purpose.
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//  See http://www.boost.org for most recent version.
+//  See http://www.boost.org/libs/config for most recent version.
 //  Boost config.hpp policy and rationale documentation has been moved to
 //  http://www.boost.org/libs/config
-
+//
-//  Revision History (excluding minor changes for specific compilers)
+//  CAUTION: This file is intended to be completely stable -
-//   25 Sep 00  BOOST_NO_STD_ALLOCATOR (Jeremy Siek)
+//           DO NOT MODIFY THIS FILE!
-//   18 SEP 00  BOOST_NO_SLIST, BOOST_NO_HASH, 
+//
 //              BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 //              BOOST_NO_LIMITS (Jeremy Siek)
 //    1 Sep 00  BOOST_NO_PRIVATE_IN_AGGREGATE added. (Mark Rodgers)
 //   23 Jul 00  Fixed spelling of BOOST_NO_INCLASS_MEMBER_INITIALIZATION in
 //              comment (Dave Abrahams). 
 //   10 Jul 00  BOOST_NO_POINTER_TO_MEMBER_CONST added (Mark Rodgers)
 //   26 Jun 00  BOOST_NO_STD_ITERATOR, BOOST_MSVC_STD_ITERATOR,
 //              BOOST_NO_STD_ITERATOR_TRAITS, BOOST_NO_USING_TEMPLATE,
 //              added (Jeremy Siek)
 //   20 Jun 00  BOOST_MSVC added (Aleksey Gurtovoy)
 //   14 Jun 00  BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS (Jens M.)
 //   22 Mar 00  BOOST_MSVC6_MEMBER_TEMPLATES added (Dave Abrahams)
 //   18 Feb 00  BOOST_NO_INCLASS_MEMBER_INITIALIZATION added (Jens Maurer)
 //   26 Jan 00  Borland compiler support added (John Maddock)
 //   26 Jan 00  Sun compiler support added (Jörg Schaible)
 //   30 Dec 99  BOOST_NMEMBER_TEMPLATES compatibility moved here from
 //              smart_ptr.hpp. (Dave Abrahams)
 //   15 Nov 99  BOOST_NO_OPERATORS_IN_NAMESPACE,
 //              BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION added (Beman Dawes)
 //   11 Oct 99  BOOST_NO_STDC_NAMESPACE refined; <cstddef> supplied
 //   29 Sep 99  BOOST_NO_STDC_NAMESPACE added (Ed Brey)
 //   24 Sep 99  BOOST_DECL added (Ed Brey)
 //   10 Aug 99  Endedness flags added, GNU CC support added
 //   22 Jul 99  Initial version
 #ifndef BOOST_CONFIG_HPP
 #define BOOST_CONFIG_HPP
-//  Conformance Flag Macros  -------------------------------------------------//
+// if we don't have a user config, then use the default location:
-//
+#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG)
-//  Conformance flag macros should identify the absence of C++ Standard 
+#  define BOOST_USER_CONFIG <boost/config/user.hpp>
-//  conformance rather than its presence.  This ensures that standard conforming
+#endif
-//  compilers do not require a lot of configuration flag macros.  It places the
+// include it first:
-//  burden where it should be, on non-conforming compilers.  In the future,
+#ifdef BOOST_USER_CONFIG
-//  hopefully, less rather than more conformance flags will have to be defined.
+#  include BOOST_USER_CONFIG
 //  BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS: Template value
 //  parameters cannot have a dependent type, for example
 //  "template<class T, typename T::type value> class X { ... };"
 //  BOOST_NO_INCLASS_MEMBER_INITIALIZATION: Compiler violates std::9.4.2/4. 
 //  BOOST_NO_MEMBER_TEMPLATES: Member template functions not fully supported.
 //  Also see BOOST_MSVC6_MEMBER_TEMPLATES in the Compiler Control section below.
 //  BOOST_NO_MEMBER_TEMPLATE_FRIENDS: Member template friend syntax
 //  ("template<class P> friend class frd;") described in the C++ Standard,
 //  14.5.3, not supported.
 //  BOOST_NO_OPERATORS_IN_NAMESPACE: Compiler requires inherited operator
 //  friend functions to be defined at namespace scope, then using'ed to boost.
 //  Probably GCC specific.  See boost/operators.hpp for example.
 //  BOOST_NO_POINTER_TO_MEMBER_CONST: The compiler does not correctly handle
 //  pointers to const member functions, preventing use of these in overloaded 
 //  function templates.  See boost/functional.hpp for example.
 //  BOOST_NO_PRIVATE_IN_AGGREGATE: The compiler misreads 8.5.1, treating classes
 //  as non-aggregate if they contain private or protected member functions. 
 //  BOOST_NO_STD_ITERATOR: The C++ implementation fails to provide the
 //  std::iterator class.
 //  BOOST_NO_STD_ITERATOR_TRAITS: The compiler does not provide a standard
 //  compliant implementation of std::iterator_traits. Note that
 //  the compiler may still have a non-standard implementation.
 //  BOOST_NO_STDC_NAMESPACE: The contents of C++ standard headers for C library
 //  functions (the <c...> headers) have not been placed in namespace std.
 //  Because the use of std::size_t is so common, a specific workaround for
 //  <cstddef> (and thus std::size_t) is provided in this header (see below).
 //  For other <c...> headers, a workaround must be provided in the boost header:
 //
 //    #include <cstdlib>  // for abs
 //    #ifdef BOOST_NO_STDC_NAMESPACE
 //      namespace std { using ::abs; }
 //    #endif
 //  BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION. Class template partial
 //  specialization (14.5.4 [temp.class.spec]) not supported.
 //  BOOST_NO_USING_TEMPLATE: The compiler will not accept a using declaration
 //  that imports a template from the global namespace into a named namespace.
 //  Probably Borland specific.
 //  Compiler Control or Information Macros  ----------------------------------//
 //
 //  Compilers often supply features outside of the C++ Standard which need to be
 //  controlled or detected. As usual, reasonable default behavior should occur
 //  if any of these macros are not defined.
 //  BOOST_DECL:  Certain compilers for Microsoft operating systems require
 //  non-standard class and function decoration if dynamic load library linking
 //  is desired.  BOOST_DECL supplies that decoration, defaulting to a nul string
 //  so that it is harmless when not required.  Boost does not encourage the use
 //  of BOOST_DECL - it is non-standard and to be avoided if practical to do so.
 //  BOOST_DECL_EXPORTS:  User defined, BOOST_DECL_EXPORTS causes BOOST_DECL to
 //  be defined as __declspec(dllexport) rather than __declspec(dllimport).
 //  BOOST_MSVC6_MEMBER_TEMPLATES:  Microsoft Visual C++ 6.0 has enough member
 //  template idiosyncrasies (being polite) that BOOST_NO_MEMBER_TEMPLATES is
 //  defined for this compiler. BOOST_MSVC6_MEMBER_TEMPLATES is defined to allow
 //  compiler specific workarounds.
 //  BOOST_MSVC: defined as _MSC_VER for the Microsoft compiler only. In general,
 //  boost headers should test for a specific conformance flag macro (for
 //  example, BOOST_NO_MEMBER_TEMPLATE_FRIENDS) rather than a specific compiler.
 //  VC++ is a special case, however, since many libraries try to support it yet
 //  it has so many conformance issues that sometimes it is just easier to test
 //  for it directly. On the other hand, the obvious way to do this doesn't work,
 //  as many non-Microsoft compilers define _MSC_VER.  Thus BOOST_MSVC.
 //  BOOST_MSVC_STD_ITERATOR: Microsoft's broken version of std::iterator
 //  is being used. 
 //  BOOST_SYSTEM_HAS_STDINT_H: There are no 1998 C++ Standard headers <stdint.h> 
 //  or <cstdint>, although the 1999 C Standard does include <stdint.h>. 
 //  If <stdint.h> is present, <boost/stdint.h> can make good use of it,
 //  so a flag is supplied (signalling presence; thus the default is not
 //  present, conforming to the current C++ standard).
 //  BOOST_NO_SLIST: The C++ implementation does not provide the slist class.
 //  BOOST_NO_HASH: The C++ implementation does not provide the hash_set
 //  or hash_map classes.
 //  BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS: The standard library does not provide
 //  templated iterator constructors for its containers.
 //  BOOST_NO_LIMITS: The C++ implementation does not provide the <limits> header.
 //  BOOST_NO_INTRINSIC_WCHAR_T: The C++ implementation does not provide wchar_t,
 //  or it is really a synonym for another integral type. Use this symbol to
 //  decide whether it is appropriate to explicitly specialize a template on
 //  wchar_t if there is already a specialization for other integer types.
 //  BOOST_NO_STD_ALLOCATOR: The C++ standard library does not provide
 //  a standards conforming std::allocator.
 //  Compilers are listed in alphabetic order (except VC++ last - see below)---//
 //  GNU CC (also known as GCC and G++)  --------------------------------------//
 # if defined __GNUC__
 #   if __GNUC__ == 2 && __GNUC_MINOR__ <= 95
 #     include <iterator>  // not sure this is the right way to do this -JGS
 #     if !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS
 #       define BOOST_NO_STD_ITERATOR
 #       define BOOST_NO_LIMITS
 #     endif
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_OPERATORS_IN_NAMESPACE
 #   endif
 #   if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
 #     define BOOST_NO_MEMBER_TEMPLATES
 #   endif
 //  Kai C++ ------------------------------------------------------------------//
 #elif defined __KCC
 #   define BOOST_NO_SLIST
 #   define BOOST_NO_HASH
 //  Greenhills C++ -----------------------------------------------------------//
 #elif defined __ghs
 #   define BOOST_NO_SLIST
 #   define BOOST_NO_HASH
 //  Borland ------------------------------------------------------------------//
 #elif defined __BORLANDC__
 #   if __BORLANDC__ <= 0x0551
 #     define BOOST_NO_PRIVATE_IN_AGGREGATE
 #   endif
 #   if __BORLANDC__ <= 0x0550
 // Borland C++ Builder 4 and 5:
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_USING_TEMPLATE
 #     if __BORLANDC__ == 0x0550
 // Borland C++ Builder 5, command-line compiler 5.5:
 #       define BOOST_NO_OPERATORS_IN_NAMESPACE
 #     endif
 #   endif
 #   if defined BOOST_DECL_EXPORTS
 #     define BOOST_DECL __declspec(dllexport)
 #   else
 #     define BOOST_DECL __declspec(dllimport)
 #   endif
 //  Intel  -------------------------------------------------------------------//
 # elif defined __ICL
 #   include <iterator>  // not sure this is the right way to do this -JGS
 #   if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
        // a perfectly good implementation of std::iterator is supplied
 #   elif defined(__SGI_STL_ITERATOR)
 #     define BOOST_NO_STD_ITERATOR // No std::iterator in this case
 #   else // assume using dinkumware's STL that comes with VC++ 6.0
 #     define BOOST_MSVC_STD_ITERATOR
 #     define BOOST_NO_STD_ITERATOR_TRAITS
 #     define BOOST_NO_STDC_NAMESPACE
 #     define BOOST_NO_SLIST
 #     define BOOST_NO_HASH
 #     define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #     define BOOST_NO_STD_ALLOCATOR
 #   endif
 //  Metrowerks CodeWarrior  --------------------------------------------------//
 # elif defined  __MWERKS__
 #   if __MWERKS__ <= 0x4000
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #   endif
 #   if __MWERKS__ <= 0x2301
 #     define BOOST_NO_POINTER_TO_MEMBER_CONST
 #   endif
 #   if __MWERKS__ >= 0x2300
 #     define BOOST_SYSTEM_HAS_STDINT_H
 #   endif
 #   if defined BOOST_DECL_EXPORTS
 #     define BOOST_DECL __declspec(dllexport)
 #   else
 #     define BOOST_DECL __declspec(dllimport)
 #   endif
 //  Sun Workshop Compiler C++ ------------------------------------------------//
 # elif defined  __SUNPRO_CC
 #    if __SUNPRO_CC <= 0x500
 #      define BOOST_NO_MEMBER_TEMPLATES
 #      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #    endif
 //  Microsoft Visual C++ (excluding Intel/EDG front end)  --------------------//
 //
 //  Must remain the last #elif since some other vendors (Metrowerks, for
 //  example) also #define _MSC_VER
 # elif defined _MSC_VER
 #   define BOOST_MSVC _MSC_VER
    // turn off the warnings before we #include anything
 #   pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info
 #   pragma warning( disable : 4503 ) // warning: decorated name length exceeded
 #   if _MSC_VER <= 1200  // 1200 == VC++ 6.0
 #     define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #     define BOOST_NO_PRIVATE_IN_AGGREGATE
 #     define BOOST_NO_INTRINSIC_WCHAR_T
 //    VC++ 6.0 has member templates but they have numerous problems including
 //    cases of silent failure, so for safety we define:
 #     define BOOST_NO_MEMBER_TEMPLATES
 //    For VC++ experts wishing to attempt workarounds, we define:
 #     define BOOST_MSVC6_MEMBER_TEMPLATES
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #     include <iterator>  // not sure this is the right way to do this -JGS
 #     if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
        // a perfectly good implementation of std::iterator is supplied
 #     elif defined(__SGI_STL_ITERATOR)
 #       define BOOST_NO_STD_ITERATOR // No std::iterator in this case
 #     else
 #       define BOOST_MSVC_STD_ITERATOR 1
 #       define BOOST_NO_SLIST
 #       define BOOST_NO_HASH
 #       define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #       define BOOST_NO_STD_ALLOCATOR
 #     endif
 #     define BOOST_NO_STD_ITERATOR_TRAITS
 // Make sure at least one standard library header is included so that library
 // implementation detection will work, even if no standard headers have been
 // included in front of a boost header. (Ed Brey 5 Jun 00)
 #     include <cstddef>
 // Determine if the standard library implementation is already pulling names
 // into std.  STLport defines the following if so. (Ed Brey 5 Jun 00)
 #     ifndef __STL_IMPORT_VENDOR_CSTD
 #       define BOOST_NO_STDC_NAMESPACE
 #     endif
 #   endif
 #   if defined BOOST_DECL_EXPORTS
 #     define BOOST_DECL __declspec(dllexport)
 #   else
 #     define BOOST_DECL __declspec(dllimport)
 #   endif
 # endif // Microsoft (excluding Intel/EDG frontend) 
 # ifndef BOOST_DECL
 #   define BOOST_DECL  // default for compilers not needing this decoration.
 # endif
 //  end of compiler specific portion  ----------------------------------------//
 // Check for old name "BOOST_NMEMBER_TEMPLATES" for compatibility  -----------//
 // Don't use BOOST_NMEMBER_TEMPLATES. It is deprecated and will be removed soon.
 #if defined( BOOST_NMEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATES )
  #define BOOST_NO_MEMBER_TEMPLATES
 #endif
-//  BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
+// if we don't have a compiler config set, try and find one:
-//
+#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG)
-//  Because std::size_t usage is so common, even in boost headers which do not
+#  include <boost/config/select_compiler_config.hpp>
-//  otherwise use the C library, the <cstddef> workaround is included here so
+#endif
-//  that ugly workaround code need not appear in many other boost headers.
+// if we have a compiler config, include it now:
-//  NOTE WELL: This is a workaround for non-conforming compilers; <cstddef> 
+#ifdef BOOST_COMPILER_CONFIG
-//  must still be #included in the usual places so that <cstddef> inclusion
+#  include BOOST_COMPILER_CONFIG
-//  works as expected with standard conforming compilers.  The resulting
+#endif
 //  double inclusion of <cstddef> is harmless.
-# ifdef BOOST_NO_STDC_NAMESPACE
+// if we don't have a std library config set, try and find one:
-#   include <cstddef>
+#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus)
-    namespace std { using ::ptrdiff_t; using ::size_t; }
+#  include <boost/config/select_stdlib_config.hpp>
-    // using ::wchar_t; removed since wchar_t is a C++ built-in type (Ed Brey)
+#endif
-# endif
+// if we have a std library config, include it now:
 #ifdef BOOST_STDLIB_CONFIG
 #  include BOOST_STDLIB_CONFIG
 #endif
 // if we don't have a platform config set, try and find one:
 #if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG)
 #  include <boost/config/select_platform_config.hpp>
 #endif
 // if we have a platform config, include it now:
 #ifdef BOOST_PLATFORM_CONFIG
 #  include BOOST_PLATFORM_CONFIG
 #endif
 // get config suffix code:
 #include <boost/config/suffix.hpp>
 #endif  // BOOST_CONFIG_HPP
@@ -0,0 +1,27 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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)
 //  for C++ Builder the following options effect the ABI:
 //
 //  -b (on or off - effect emum sizes)
 //  -Vx  (on or off - empty members)
 //  -Ve (on or off - empty base classes)
 //  -aX (alignment - 5 options).
 //  -pX (Calling convention - 4 options)
 //  -VmX (member pointer size and layout - 5 options)
 //  -VC (on or off, changes name mangling)
 //  -Vl (on or off, changes struct layout).
 //  In addition the following warnings are sufficiently annoying (and
 //  unfixable) to have them turned off by default:
 //
 //  8027 - functions containing [for|while] loops are not expanded inline
 //  8026 - functions taking class by value arguments are not expanded inline
 #pragma nopushoptwarn
 #  pragma option push -a8 -Vx- -Ve- -b- -pc -Vmv -VC- -Vl- -w-8027 -w-8026
@@ -0,0 +1,12 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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)
 #  pragma option pop
 #pragma nopushoptwarn
@@ -0,0 +1,22 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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)
 //
 // Boost binaries are built with the compiler's default ABI settings,
 // if the user changes their default alignment in the VS IDE then their
 // code will no longer be binary compatible with the bjam built binaries
 // unless this header is included to force Boost code into a consistent ABI.
 //
 // Note that inclusion of this header is only necessary for libraries with 
 // separate source, header only libraries DO NOT need this as long as all
 // translation units are built with the same options.
 //
 #if defined(_M_X64)
 #  pragma pack(push,16)
 #else
 #  pragma pack(push,8)
 #endif
@@ -0,0 +1,8 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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)
 #pragma pack(pop)
@@ -0,0 +1,25 @@
 //  abi_prefix header  -------------------------------------------------------//
 // (c) Copyright John Maddock 2003
 // Use, modification and distribution are subject to 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).
 #ifndef BOOST_CONFIG_ABI_PREFIX_HPP
 # define BOOST_CONFIG_ABI_PREFIX_HPP
 #else
 # error double inclusion of header boost/config/abi_prefix.hpp is an error
 #endif
 #include <boost/config.hpp>
 // this must occur after all other includes and before any code appears:
 #ifdef BOOST_HAS_ABI_HEADERS
 #  include BOOST_ABI_PREFIX
 #endif
 #if defined( __BORLANDC__ )
 #pragma nopushoptwarn
 #endif
@@ -0,0 +1,27 @@
 //  abi_sufffix header  -------------------------------------------------------//
 // (c) Copyright John Maddock 2003
 // Use, modification and distribution are subject to 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).
 // This header should be #included AFTER code that was preceded by a #include
 // <boost/config/abi_prefix.hpp>.
 #ifndef BOOST_CONFIG_ABI_PREFIX_HPP
 # error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp
 #else
 # undef BOOST_CONFIG_ABI_PREFIX_HPP
 #endif
 // the suffix header occurs after all of our code:
 #ifdef BOOST_HAS_ABI_HEADERS
 #  include BOOST_ABI_SUFFIX
 #endif
 #if defined( __BORLANDC__ )
 #pragma nopushoptwarn
 #endif
@@ -0,0 +1,417 @@
 //  (C) Copyright John Maddock 2003.
 //  Use, modification and distribution are subject to 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)
 /*
  *   LOCATION:    see http://www.boost.org for most recent version.
  *   FILE         auto_link.hpp
  *   VERSION      see <boost/version.hpp>
  *   DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers.
  */
 /*************************************************************************
 USAGE:
 ~~~~~~
 Before including this header you must define one or more of define the following macros:
 BOOST_LIB_NAME:           Required: A string containing the basename of the library,
                          for example boost_regex.
 BOOST_LIB_TOOLSET:        Optional: the base name of the toolset.
 BOOST_DYN_LINK:           Optional: when set link to dll rather than static library.
 BOOST_LIB_DIAGNOSTIC:     Optional: when set the header will print out the name
                          of the library selected (useful for debugging).
 BOOST_AUTO_LINK_NOMANGLE: Specifies that we should link to BOOST_LIB_NAME.lib,
                          rather than a mangled-name version.
 BOOST_AUTO_LINK_TAGGED:   Specifies that we link to libraries built with the --layout=tagged option.
                          This is essentially the same as the default name-mangled version, but without
                          the compiler name and version, or the Boost version.  Just the build options.
 These macros will be undef'ed at the end of the header, further this header
 has no include guards - so be sure to include it only once from your library!
 Algorithm:
 ~~~~~~~~~~
 Libraries for Borland and Microsoft compilers are automatically
 selected here, the name of the lib is selected according to the following
 formula:
 BOOST_LIB_PREFIX
   + BOOST_LIB_NAME
   + "_"
   + BOOST_LIB_TOOLSET
   + BOOST_LIB_THREAD_OPT
   + BOOST_LIB_RT_OPT
   "-"
   + BOOST_LIB_VERSION
 These are defined as:
 BOOST_LIB_PREFIX:     "lib" for static libraries otherwise "".
 BOOST_LIB_NAME:       The base name of the lib ( for example boost_regex).
 BOOST_LIB_TOOLSET:    The compiler toolset name (vc6, vc7, bcb5 etc).
 BOOST_LIB_THREAD_OPT: "-mt" for multithread builds, otherwise nothing.
 BOOST_LIB_RT_OPT:     A suffix that indicates the runtime library used,
                      contains one or more of the following letters after
                      a hiphen:
                      s      static runtime (dynamic if not present).
                      g      debug/diagnostic runtime (release if not present).
                      y      Python debug/diagnostic runtime (release if not present).
                      d      debug build (release if not present).
                      g      debug/diagnostic runtime (release if not present).
                      p      STLPort Build.
 BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 ***************************************************************************/
 #ifdef __cplusplus
 #  ifndef BOOST_CONFIG_HPP
 #     include <boost/config.hpp>
 #  endif
 #elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__)
 //
 // C language compatability (no, honestly)
 //
 #  define BOOST_MSVC _MSC_VER
 #  define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
 #  define BOOST_DO_STRINGIZE(X) #X
 #endif
 //
 // Only include what follows for known and supported compilers:
 //
 #if defined(BOOST_MSVC) \
    || defined(__BORLANDC__) \
    || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
    || (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200))
 #ifndef BOOST_VERSION_HPP
 #  include <boost/version.hpp>
 #endif
 #ifndef BOOST_LIB_NAME
 #  error "Macro BOOST_LIB_NAME not set (internal error)"
 #endif
 //
 // error check:
 //
 #if defined(__MSVC_RUNTIME_CHECKS) && !defined(_DEBUG)
 #  pragma message("Using the /RTC option without specifying a debug runtime will lead to linker errors")
 #  pragma message("Hint: go to the code generation options and switch to one of the debugging runtimes")
 #  error "Incompatible build options"
 #endif
 //
 // select toolset if not defined already:
 //
 #ifndef BOOST_LIB_TOOLSET
 // Note: no compilers before 1200 are supported
 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
 #  ifdef UNDER_CE
     // vc6:
 #    define BOOST_LIB_TOOLSET "evc4"
 #  else
     // vc6:
 #    define BOOST_LIB_TOOLSET "vc6"
 #  endif
 #elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
   // vc7:
 #  define BOOST_LIB_TOOLSET "vc7"
 #elif defined(BOOST_MSVC) && (BOOST_MSVC == 1310)
   // vc71:
 #  define BOOST_LIB_TOOLSET "vc71"
 #elif defined(BOOST_MSVC) && (BOOST_MSVC == 1400)
   // vc80:
 #  define BOOST_LIB_TOOLSET "vc80"
 #elif defined(BOOST_MSVC) && (BOOST_MSVC == 1500)
   // vc90:
 #  define BOOST_LIB_TOOLSET "vc90"
 #elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)
   // vc10:
 #  define BOOST_LIB_TOOLSET "vc100"
 #elif defined(__BORLANDC__)
   // CBuilder 6:
 #  define BOOST_LIB_TOOLSET "bcb"
 #elif defined(__ICL)
   // Intel C++, no version number:
 #  define BOOST_LIB_TOOLSET "iw"
 #elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF )
   // Metrowerks CodeWarrior 8.x
 #  define BOOST_LIB_TOOLSET "cw8"
 #elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF )
   // Metrowerks CodeWarrior 9.x
 #  define BOOST_LIB_TOOLSET "cw9"
 #endif
 #endif // BOOST_LIB_TOOLSET
 //
 // select thread opt:
 //
 #if defined(_MT) || defined(__MT__)
 #  define BOOST_LIB_THREAD_OPT "-mt"
 #else
 #  define BOOST_LIB_THREAD_OPT
 #endif
 #if defined(_MSC_VER) || defined(__MWERKS__)
 #  ifdef _DLL
 #     if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS))
 #        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gydp"
 #        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
 #            define BOOST_LIB_RT_OPT "-gdp"
 #        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gydp"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #            define BOOST_LIB_RT_OPT "-gdp"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-p"
 #        endif
 #     elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
 #        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gydpn"
 #        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
 #            define BOOST_LIB_RT_OPT "-gdpn"
 #        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gydpn"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #            define BOOST_LIB_RT_OPT "-gdpn"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-pn"
 #        endif
 #     else
 #        if defined(_DEBUG) && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-gyd"
 #        elif defined(_DEBUG)
 #            define BOOST_LIB_RT_OPT "-gd"
 #        else
 #            define BOOST_LIB_RT_OPT
 #        endif
 #     endif
 #  else
 #     if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS))
 #        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-sgydp"
 #        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
 #            define BOOST_LIB_RT_OPT "-sgdp"
 #        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #             define BOOST_LIB_RT_OPT "-sgydp"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #             define BOOST_LIB_RT_OPT "-sgdp"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-sp"
 #        endif
 #     elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
 #        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #            define BOOST_LIB_RT_OPT "-sgydpn"
 #        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
 #            define BOOST_LIB_RT_OPT "-sgdpn"
 #        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #             define BOOST_LIB_RT_OPT "-sgydpn"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        elif defined(_DEBUG)
 #             define BOOST_LIB_RT_OPT "-sgdpn"
 #            pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1")
 #            error "Build options aren't compatible with pre-built libraries"
 #        else
 #            define BOOST_LIB_RT_OPT "-spn"
 #        endif
 #     else
 #        if defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #             define BOOST_LIB_RT_OPT "-sgyd"
 #        elif defined(_DEBUG)
 #             define BOOST_LIB_RT_OPT "-sgd"
 #        else
 #            define BOOST_LIB_RT_OPT "-s"
 #        endif
 #     endif
 #  endif
 #elif defined(__BORLANDC__)
 //
 // figure out whether we want the debug builds or not:
 //
 #if __BORLANDC__ > 0x561
 #pragma defineonoption BOOST_BORLAND_DEBUG -v
 #endif
 //
 // sanity check:
 //
 #if defined(__STL_DEBUG) || defined(_STLP_DEBUG)
 #error "Pre-built versions of the Boost libraries are not provided in STLPort-debug form"
 #endif
 #  ifdef _RTLDLL
 #     if defined(BOOST_BORLAND_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #         define BOOST_LIB_RT_OPT "-yd"
 #     elif defined(BOOST_BORLAND_DEBUG)
 #         define BOOST_LIB_RT_OPT "-d"
 #     elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #         define BOOST_LIB_RT_OPT -y
 #     else
 #         define BOOST_LIB_RT_OPT
 #     endif
 #  else
 #     if defined(BOOST_BORLAND_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #         define BOOST_LIB_RT_OPT "-syd"
 #     elif defined(BOOST_BORLAND_DEBUG)
 #         define BOOST_LIB_RT_OPT "-sd"
 #     elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
 #         define BOOST_LIB_RT_OPT "-sy"
 #     else
 #         define BOOST_LIB_RT_OPT "-s"
 #     endif
 #  endif
 #endif
 //
 // select linkage opt:
 //
 #if (defined(_DLL) || defined(_RTLDLL)) && defined(BOOST_DYN_LINK)
 #  define BOOST_LIB_PREFIX
 #elif defined(BOOST_DYN_LINK)
 #  error "Mixing a dll boost library with a static runtime is a really bad idea..."
 #else
 #  define BOOST_LIB_PREFIX "lib"
 #endif
 //
 // now include the lib:
 //
 #if defined(BOOST_LIB_NAME) \
      && defined(BOOST_LIB_PREFIX) \
      && defined(BOOST_LIB_TOOLSET) \
      && defined(BOOST_LIB_THREAD_OPT) \
      && defined(BOOST_LIB_RT_OPT) \
      && defined(BOOST_LIB_VERSION)
 #ifdef BOOST_AUTO_LINK_TAGGED
 #  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
 #     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
 #  endif
 #elif defined(BOOST_AUTO_LINK_NOMANGLE)
 #  pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
 #     pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
 #  endif
 #else
 #  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
 #     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
 #  endif
 #endif
 #else
 #  error "some required macros where not defined (internal logic error)."
 #endif
 #endif // _MSC_VER || __BORLANDC__
 //
 // finally undef any macros we may have set:
 //
 #ifdef BOOST_LIB_PREFIX
 #  undef BOOST_LIB_PREFIX
 #endif
 #if defined(BOOST_LIB_NAME)
 #  undef BOOST_LIB_NAME
 #endif
 // Don't undef this one: it can be set by the user and should be the 
 // same for all libraries:
 //#if defined(BOOST_LIB_TOOLSET)
 //#  undef BOOST_LIB_TOOLSET
 //#endif
 #if defined(BOOST_LIB_THREAD_OPT)
 #  undef BOOST_LIB_THREAD_OPT
 #endif
 #if defined(BOOST_LIB_RT_OPT)
 #  undef BOOST_LIB_RT_OPT
 #endif
 #if defined(BOOST_LIB_LINK_OPT)
 #  undef BOOST_LIB_LINK_OPT
 #endif
 #if defined(BOOST_LIB_DEBUG_OPT)
 #  undef BOOST_LIB_DEBUG_OPT
 #endif
 #if defined(BOOST_DYN_LINK)
 #  undef BOOST_DYN_LINK
 #endif
@@ -0,0 +1,285 @@
 //  (C) Copyright John Maddock 2001 - 2003.
 //  (C) Copyright David Abrahams 2002 - 2003.
 //  (C) Copyright Aleksey Gurtovoy 2002.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Borland C++ compiler setup:
 //
 // versions check:
 // we don't support Borland prior to version 5.4:
 #if __BORLANDC__ < 0x540
 #  error "Compiler not supported or configured - please reconfigure"
 #endif
 // last known compiler version:
 #if (__BORLANDC__ > 0x613)
 //#  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 //#  else
 //#     pragma message( "Unknown compiler version - please run the configure tests and report the results")
 //#  endif
 #elif (__BORLANDC__ == 0x600)
 #  error "CBuilderX preview compiler is no longer supported"
 #endif
 //
 // Support macros to help with standard library detection
 #if (__BORLANDC__ < 0x560) || defined(_USE_OLD_RW_STL)
 #  define BOOST_BCB_WITH_ROGUE_WAVE
 #elif __BORLANDC__ < 0x570
 #  define BOOST_BCB_WITH_STLPORT
 #else
 #  define BOOST_BCB_WITH_DINKUMWARE
 #endif
 //
 // Version 5.0 and below:
 #   if __BORLANDC__ <= 0x0550
 // Borland C++Builder 4 and 5:
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     if __BORLANDC__ == 0x0550
 // Borland C++Builder 5, command-line compiler 5.5:
 #       define BOOST_NO_OPERATORS_IN_NAMESPACE
 #     endif
 // Variadic macros do not exist for C++ Builder versions 5 and below
 #define BOOST_NO_VARIADIC_MACROS
 #   endif
 // Version 5.51 and below:
 #if (__BORLANDC__ <= 0x551)
 #  define BOOST_NO_CV_SPECIALIZATIONS
 #  define BOOST_NO_CV_VOID_SPECIALIZATIONS
 #  define BOOST_NO_DEDUCED_TYPENAME
 // workaround for missing WCHAR_MAX/WCHAR_MIN:
 #ifdef __cplusplus
 #include <climits>
 #include <cwchar>
 #else
 #include <limits.h>
 #include <wchar.h>
 #endif // __cplusplus
 #ifndef WCHAR_MAX
 #  define WCHAR_MAX 0xffff
 #endif
 #ifndef WCHAR_MIN
 #  define WCHAR_MIN 0
 #endif
 #endif
 // Borland C++ Builder 6 and below:
 #if (__BORLANDC__ <= 0x564)
 #  if defined(NDEBUG) && defined(__cplusplus)
      // fix broken <cstring> so that Boost.test works:
 #     include <cstring>
 #     undef strcmp
 #  endif
   // fix broken errno declaration:
 #  include <errno.h>
 #  ifndef errno
 #     define errno errno
 #  endif
 #endif
 //
 // new bug in 5.61:
 #if (__BORLANDC__ >= 0x561) && (__BORLANDC__ <= 0x580)
   // this seems to be needed by the command line compiler, but not the IDE:
 #  define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
 #endif
 // Borland C++ Builder 2006 Update 2 and below:
 #if (__BORLANDC__ <= 0x582)
 #  define BOOST_NO_SFINAE
 #  define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
 #  define BOOST_NO_TEMPLATE_TEMPLATES
 #  define BOOST_NO_PRIVATE_IN_AGGREGATE
 #  ifdef _WIN32
 #     define BOOST_NO_SWPRINTF
 #  elif defined(linux) || defined(__linux__) || defined(__linux)
      // we should really be able to do without this
      // but the wcs* functions aren't imported into std::
 #     define BOOST_NO_STDC_NAMESPACE
      // _CPPUNWIND doesn't get automatically set for some reason:
 #     pragma defineonoption BOOST_CPPUNWIND -x
 #  endif
 #endif
 #if (__BORLANDC__ <= 0x613)  // Beman has asked Alisdair for more info
   // we shouldn't really need this - but too many things choke
   // without it, this needs more investigation:
 #  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #  define BOOST_NO_IS_ABSTRACT
 #  define BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
 #  define BOOST_NO_USING_TEMPLATE
 #  define BOOST_SP_NO_SP_CONVERTIBLE
 // Temporary workaround
 #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
 #endif
 // Borland C++ Builder 2008 and below:
 #  define BOOST_NO_INTEGRAL_INT64_T
 #  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
 #  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
 #  define BOOST_NO_NESTED_FRIENDSHIP
 #  define BOOST_NO_TYPENAME_WITH_CTOR
 #if (__BORLANDC__ < 0x600)
 #  define BOOST_ILLEGAL_CV_REFERENCES
 #endif
 //
 //  Positive Feature detection
 //
 // Borland C++ Builder 2008 and below:
 #if (__BORLANDC__ >= 0x599)
 #  pragma defineonoption BOOST_CODEGEAR_0X_SUPPORT -Ax
 #endif
 //
 // C++0x Macros:
 //
 #if !defined( BOOST_CODEGEAR_0X_SUPPORT ) || (__BORLANDC__ < 0x610)
 #  define BOOST_NO_CHAR16_T
 #  define BOOST_NO_CHAR32_T
 #  define BOOST_NO_DECLTYPE
 #  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #  define BOOST_NO_EXTERN_TEMPLATE
 #  define BOOST_NO_RVALUE_REFERENCES 
 #  define BOOST_NO_SCOPED_ENUMS
 #  define BOOST_NO_STATIC_ASSERT
 #else
 #  define BOOST_HAS_ALIGNOF
 #  define BOOST_HAS_CHAR16_T
 #  define BOOST_HAS_CHAR32_T
 #  define BOOST_HAS_DECLTYPE
 #  define BOOST_HAS_EXPLICIT_CONVERSION_OPS
 #  define BOOST_HAS_REF_QUALIFIER
 #  define BOOST_HAS_RVALUE_REFS
 #  define BOOST_HAS_STATIC_ASSERT
 #endif
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS    // UTF-8 still not supported
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #if __BORLANDC__ >= 0x590
 #  define BOOST_HAS_TR1_HASH
 #  define BOOST_HAS_MACRO_USE_FACET
 #endif
 //
 // Post 0x561 we have long long and stdint.h:
 #if __BORLANDC__ >= 0x561
 #  ifndef __NO_LONG_LONG
 #     define BOOST_HAS_LONG_LONG
 #  else
 #     define BOOST_NO_LONG_LONG
 #  endif
   // On non-Win32 platforms let the platform config figure this out:
 #  ifdef _WIN32
 #      define BOOST_HAS_STDINT_H
 #  endif
 #endif
 // Borland C++Builder 6 defaults to using STLPort.  If _USE_OLD_RW_STL is
 // defined, then we have 0x560 or greater with the Rogue Wave implementation
 // which presumably has the std::DBL_MAX bug.
 #if defined( BOOST_BCB_WITH_ROGUE_WAVE )
 // <climits> is partly broken, some macros define symbols that are really in
 // namespace std, so you end up having to use illegal constructs like
 // std::DBL_MAX, as a fix we'll just include float.h and have done with:
 #include <float.h>
 #endif
 //
 // __int64:
 //
 #if (__BORLANDC__ >= 0x530) && !defined(__STRICT_ANSI__)
 #  define BOOST_HAS_MS_INT64
 #endif
 //
 // check for exception handling support:
 //
 #if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
 //
 // all versions have a <dirent.h>:
 //
 #ifndef __STRICT_ANSI__
 #  define BOOST_HAS_DIRENT_H
 #endif
 //
 // all versions support __declspec:
 //
 #if defined(__STRICT_ANSI__)
 // config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined  
 #  define BOOST_SYMBOL_EXPORT
 #endif
 //
 // ABI fixing headers:
 //
 #if __BORLANDC__ != 0x600 // not implemented for version 6 compiler yet
 #ifndef BOOST_ABI_PREFIX
 #  define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp"
 #endif
 #ifndef BOOST_ABI_SUFFIX
 #  define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp"
 #endif
 #endif
 //
 // Disable Win32 support in ANSI mode:
 //
 #if __BORLANDC__ < 0x600
 #  pragma defineonoption BOOST_DISABLE_WIN32 -A
 #elif defined(__STRICT_ANSI__)
 #  define BOOST_DISABLE_WIN32
 #endif
 //
 // MSVC compatibility mode does some nasty things:
 // TODO: look up if this doesn't apply to the whole 12xx range
 //
 #if defined(_MSC_VER) && (_MSC_VER <= 1200)
 #  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 #  define BOOST_NO_VOID_RETURNS
 #endif
 // Borland did not implement value-initialization completely, as I reported
 // in 2007, Borland Report 51854, "Value-initialization: POD struct should be
 // zero-initialized", http://qc.embarcadero.com/wc/qcmain.aspx?d=51854
 // See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
 // (Niels Dekker, LKEB, April 2010)
 #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)
@@ -0,0 +1,86 @@
 // (C) Copyright Douglas Gregor 2010
 //
 //  Use, modification and distribution are subject to 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 most recent version.
 // Clang compiler setup.
 #if __has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #else
 #  define BOOST_NO_EXCEPTIONS
 #endif
 #if !__has_feature(cxx_rtti)
 #  define BOOST_NO_RTTI
 #endif
 #if defined(__int64)
 #  define BOOST_HAS_MS_INT64
 #endif
 #define BOOST_HAS_NRVO
 // Clang supports "long long" in all compilation modes.
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #if !__has_feature(cxx_decltype)
 #  define BOOST_NO_DECLTYPE
 #endif
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #if !__has_feature(cxx_deleted_functions)
 #  define BOOST_NO_DELETED_FUNCTIONS
 #endif
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #if !__has_feature(cxx_default_function_template_args)
  #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #endif
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #if !__has_feature(cxx_rvalue_references)
 #  define BOOST_NO_RVALUE_REFERENCES
 #endif
 #if !__has_feature(cxx_strong_enums)
 #  define BOOST_NO_SCOPED_ENUMS
 #endif
 #if !__has_feature(cxx_static_assert)
 #  define BOOST_NO_STATIC_ASSERT
 #endif
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #if !__has_feature(cxx_variadic_templates)
 #  define BOOST_NO_VARIADIC_TEMPLATES
 #endif
 // Clang always supports variadic macros
 // Clang always supports extern templates
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "Clang version " __clang_version__
 #endif
 // Macro used to identify the Clang compiler.
 #define BOOST_CLANG 1
@@ -0,0 +1,178 @@
 //  (C) Copyright John Maddock 2001 - 2003.
 //  (C) Copyright David Abrahams 2002 - 2003.
 //  (C) Copyright Aleksey Gurtovoy 2002.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  CodeGear C++ compiler setup:
 #if !defined( BOOST_WITH_CODEGEAR_WARNINGS )
 // these warnings occur frequently in optimized template code
 # pragma warn -8004 // var assigned value, but never used
 # pragma warn -8008 // condition always true/false
 # pragma warn -8066 // dead code can never execute
 # pragma warn -8104 // static members with ctors not threadsafe
 # pragma warn -8105 // reference member in class without ctors
 #endif
 //
 // versions check:
 // last known and checked version is 0x621
 #if (__CODEGEARC__ > 0x621)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  else
 #     pragma message( "Unknown compiler version - please run the configure tests and report the results")
 #  endif
 #endif
 // CodeGear C++ Builder 2009
 #if (__CODEGEARC__ <= 0x613)
 #  define BOOST_NO_INTEGRAL_INT64_T
 #  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
 #  define BOOST_NO_PRIVATE_IN_AGGREGATE
 #  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
   // we shouldn't really need this - but too many things choke
   // without it, this needs more investigation:
 #  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #  define BOOST_SP_NO_SP_CONVERTIBLE
 #endif
 // CodeGear C++ Builder 2010
 #if (__CODEGEARC__ <= 0x621)
 #  define BOOST_NO_TYPENAME_WITH_CTOR    // Cannot use typename keyword when making temporaries of a dependant type
 #  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #  define BOOST_NO_NESTED_FRIENDSHIP     // TC1 gives nested classes access rights as any other member
 #  define BOOST_NO_USING_TEMPLATE
 #  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 // Temporary hack, until specific MPL preprocessed headers are generated
 #  define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
 // CodeGear has not yet completely implemented value-initialization, for
 // example for array types, as I reported in 2010: Embarcadero Report 83751,
 // "Value-initialization: arrays should have each element value-initialized",
 // http://qc.embarcadero.com/wc/qcmain.aspx?d=83751
 // Last checked version: Embarcadero C++ 6.21
 // See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
 // (Niels Dekker, LKEB, April 2010)
 #  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #  if defined(NDEBUG) && defined(__cplusplus)
      // fix broken <cstring> so that Boost.test works:
 #     include <cstring>
 #     undef strcmp
 #  endif
   // fix broken errno declaration:
 #  include <errno.h>
 #  ifndef errno
 #     define errno errno
 #  endif
 #endif
 //
 // C++0x macros:
 //
 #if (__CODEGEARC__ <= 0x620)
 #define BOOST_NO_STATIC_ASSERT
 #else
 #define BOOST_HAS_STATIC_ASSERT
 #endif
 #define BOOST_HAS_CHAR16_T
 #define BOOST_HAS_CHAR32_T
 #define BOOST_HAS_LONG_LONG
 // #define BOOST_HAS_ALIGNOF
 #define BOOST_HAS_DECLTYPE
 #define BOOST_HAS_EXPLICIT_CONVERSION_OPS
 // #define BOOST_HAS_RVALUE_REFS
 #define BOOST_HAS_SCOPED_ENUM
 // #define BOOST_HAS_STATIC_ASSERT
 #define BOOST_HAS_STD_TYPE_TRAITS
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 //
 // TR1 macros:
 //
 #define BOOST_HAS_TR1_HASH
 #define BOOST_HAS_TR1_TYPE_TRAITS
 #define BOOST_HAS_TR1_UNORDERED_MAP
 #define BOOST_HAS_TR1_UNORDERED_SET
 #define BOOST_HAS_MACRO_USE_FACET
 #define BOOST_NO_INITIALIZER_LISTS
 // On non-Win32 platforms let the platform config figure this out:
 #ifdef _WIN32
 #  define BOOST_HAS_STDINT_H
 #endif
 //
 // __int64:
 //
 #if !defined(__STRICT_ANSI__)
 #  define BOOST_HAS_MS_INT64
 #endif
 //
 // check for exception handling support:
 //
 #if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
 //
 // all versions have a <dirent.h>:
 //
 #if !defined(__STRICT_ANSI__)
 #  define BOOST_HAS_DIRENT_H
 #endif
 //
 // all versions support __declspec:
 //
 #if defined(__STRICT_ANSI__)
 // config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined  
 #  define BOOST_SYMBOL_EXPORT
 #endif
 //
 // ABI fixing headers:
 //
 #ifndef BOOST_ABI_PREFIX
 #  define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp"
 #endif
 #ifndef BOOST_ABI_SUFFIX
 #  define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp"
 #endif
 //
 // Disable Win32 support in ANSI mode:
 //
 #  pragma defineonoption BOOST_DISABLE_WIN32 -A
 //
 // MSVC compatibility mode does some nasty things:
 // TODO: look up if this doesn't apply to the whole 12xx range
 //
 #if defined(_MSC_VER) && (_MSC_VER <= 1200)
 #  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 #  define BOOST_NO_VOID_RETURNS
 #endif
 #define BOOST_COMPILER "CodeGear C++ version " BOOST_STRINGIZE(__CODEGEARC__)
@@ -0,0 +1,59 @@
 //  (C) Copyright John Maddock 2001. 
 //  (C) Copyright Douglas Gregor 2001. 
 //  (C) Copyright Peter Dimov 2001. 
 //  (C) Copyright Aleksey Gurtovoy 2003. 
 //  (C) Copyright Beman Dawes 2003. 
 //  (C) Copyright Jens Maurer 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Comeau C++ compiler setup:
 #include "boost/config/compiler/common_edg.hpp"
 #if (__COMO_VERSION__ <= 4245)
 #  if defined(_MSC_VER) && _MSC_VER <= 1300
 #     if _MSC_VER > 100
         // only set this in non-strict mode:
 #        define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 #     endif
 #  endif
 // Void returns don't work when emulating VC 6 (Peter Dimov)
 // TODO: look up if this doesn't apply to the whole 12xx range
 #  if defined(_MSC_VER) && (_MSC_VER < 1300)
 #     define BOOST_NO_VOID_RETURNS
 #  endif
 #endif  // version 4245
 //
 // enable __int64 support in VC emulation mode
 //
 #  if defined(_MSC_VER) && (_MSC_VER >= 1200)
 #     define BOOST_HAS_MS_INT64
 #  endif
 #define BOOST_COMPILER "Comeau compiler version " BOOST_STRINGIZE(__COMO_VERSION__)
 //
 // versions check:
 // we don't know Comeau prior to version 4245:
 #if __COMO_VERSION__ < 4245
 #  error "Compiler not configured - please reconfigure"
 #endif
 //
 // last known and checked version is 4245:
 #if (__COMO_VERSION__ > 4245)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,101 @@
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  (C) Copyright Jens Maurer 2001. 
 //  (C) Copyright David Abrahams 2002. 
 //  (C) Copyright Aleksey Gurtovoy 2002. 
 //  (C) Copyright Markus Schoepflin 2005.
 //  Use, modification and distribution are subject to 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 most recent version.
 //
 // Options common to all edg based compilers.
 //
 // This is included from within the individual compiler mini-configs.
 #ifndef  __EDG_VERSION__
 #  error This file requires that __EDG_VERSION__ be defined.
 #endif
 #if (__EDG_VERSION__ <= 238)
 #   define BOOST_NO_INTEGRAL_INT64_T
 #   define BOOST_NO_SFINAE
 #endif
 #if (__EDG_VERSION__ <= 240)
 #   define BOOST_NO_VOID_RETURNS
 #endif
 #if (__EDG_VERSION__ <= 241) && !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 #   define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 #endif
 #if (__EDG_VERSION__ <= 244) && !defined(BOOST_NO_TEMPLATE_TEMPLATES)
 #   define BOOST_NO_TEMPLATE_TEMPLATES
 #endif 
 #if (__EDG_VERSION__ < 300) && !defined(BOOST_NO_IS_ABSTRACT)
 #   define BOOST_NO_IS_ABSTRACT
 #endif 
 #if (__EDG_VERSION__ <= 303) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
 #   define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #endif 
 // See also kai.hpp which checks a Kai-specific symbol for EH
 # if !defined(__KCC) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
 #     define BOOST_NO_EXCEPTIONS
 # endif
 # if !defined(__NO_LONG_LONG)
 #     define BOOST_HAS_LONG_LONG
 # else
 #     define BOOST_NO_LONG_LONG
 # endif
 //
 // C++0x features
 //
 //   See above for BOOST_NO_LONG_LONG
 //
 #if (__EDG_VERSION__ < 310)
 #  define BOOST_NO_EXTERN_TEMPLATE
 #endif
 #if (__EDG_VERSION__ <= 310)
 // No support for initializer lists
 #  define BOOST_NO_INITIALIZER_LISTS
 #endif
 #if (__EDG_VERSION__ < 400)
 #  define BOOST_NO_VARIADIC_MACROS
 #endif
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #ifdef c_plusplus
 // EDG has "long long" in non-strict mode
 // However, some libraries have insufficient "long long" support
 // #define BOOST_HAS_LONG_LONG
 #endif
@@ -0,0 +1,19 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Tru64 C++ compiler setup (now HP):
 #define BOOST_COMPILER "HP Tru64 C++ " BOOST_STRINGIZE(__DECCXX_VER)
 #include "boost/config/compiler/common_edg.hpp"
 //
 // versions check:
 // Nothing to do here?
@@ -0,0 +1,61 @@
 //  (C) Copyright John Maddock 2011.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Greenhills C compiler setup:
 #define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE)
 #if _RELEASE < 7
 #  error "Boost is not configured for Cray compilers prior to version 7, please try the configure script."
 #endif
 //
 // Check this is a recent EDG based compiler, otherwise we don't support it here:
 //
 #ifndef __EDG_VERSION__
 #  error "Unsupported Cray compiler, please try running the configure script."
 #endif
 #include "boost/config/compiler/common_edg.hpp"
 //
 // Cray peculiarities, probably version 7 specific:
 //
 #undef BOOST_NO_AUTO_DECLARATIONS
 #undef BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_HAS_NRVO
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #define BOOST_HAS_NRVO
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CHAR16_T
 //#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
 #define BOOST_MATH_DISABLE_STD_FPCLASSIFY
 //#define BOOST_HAS_FPCLASSIFY
 #define BOOST_SP_USE_PTHREADS 
 #define BOOST_AC_USE_PTHREADS 
@@ -0,0 +1,101 @@
 //  Copyright (C) Christof Meerwald 2003
 //  Copyright (C) Dan Watkins 2003
 //
 //  Use, modification and distribution are subject to 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)
 //  Digital Mars C++ compiler setup:
 #define BOOST_COMPILER __DMC_VERSION_STRING__
 #define BOOST_HAS_LONG_LONG
 #define BOOST_HAS_PRAGMA_ONCE
 #if (__DMC__ <= 0x833)
 #define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #define BOOST_NO_TEMPLATE_TEMPLATES
 #define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING
 #define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
 #define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 #endif
 #if (__DMC__ <= 0x840) || !defined(BOOST_STRICT_CONFIG)
 #define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 #define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #define BOOST_NO_OPERATORS_IN_NAMESPACE
 #define BOOST_NO_UNREACHABLE_RETURN_DETECTION
 #define BOOST_NO_SFINAE
 #define BOOST_NO_USING_TEMPLATE
 #define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #endif
 //
 // has macros:
 #if (__DMC__ >= 0x840)
 #define BOOST_HAS_DIRENT_H
 #define BOOST_HAS_STDINT_H
 #define BOOST_HAS_WINTHREADS
 #endif
 #if (__DMC__ >= 0x847)
 #define BOOST_HAS_EXPM1
 #define BOOST_HAS_LOG1P
 #endif
 //
 // Is this really the best way to detect whether the std lib is in namespace std?
 //
 #ifdef __cplusplus
 #include <cstddef>
 #endif
 #if !defined(__STL_IMPORT_VENDOR_CSTD) && !defined(_STLP_IMPORT_VENDOR_CSTD)
 #  define BOOST_NO_STDC_NAMESPACE
 #endif
 // check for exception handling support:
 #if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
 //
 // C++0x features
 //
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #if (__DMC__ < 0x812)
 #define BOOST_NO_VARIADIC_MACROS
 #endif
 #if __DMC__ < 0x800
 #error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version is ...:
 #if (__DMC__ > 0x848)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,252 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Darin Adler 2001 - 2002. 
 //  (C) Copyright Jens Maurer 2001 - 2002. 
 //  (C) Copyright Beman Dawes 2001 - 2003. 
 //  (C) Copyright Douglas Gregor 2002. 
 //  (C) Copyright David Abrahams 2002 - 2003. 
 //  (C) Copyright Synge Todo 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  GNU C++ compiler setup:
 #if __GNUC__ < 3
 #   if __GNUC_MINOR__ == 91
       // egcs 1.1 won't parse shared_ptr.hpp without this:
 #      define BOOST_NO_AUTO_PTR
 #   endif
 #   if __GNUC_MINOR__ < 95
      //
      // Prior to gcc 2.95 member templates only partly
      // work - define BOOST_MSVC6_MEMBER_TEMPLATES
      // instead since inline member templates mostly work.
      //
 #     define BOOST_NO_MEMBER_TEMPLATES
 #     if __GNUC_MINOR__ >= 9
 #       define BOOST_MSVC6_MEMBER_TEMPLATES
 #     endif
 #   endif
 #   if __GNUC_MINOR__ < 96
 #     define BOOST_NO_SFINAE
 #   endif
 #   if __GNUC_MINOR__ <= 97
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_OPERATORS_IN_NAMESPACE
 #   endif
 #   define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
 #   define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #   define BOOST_NO_IS_ABSTRACT
 #   define BOOST_NO_EXTERN_TEMPLATE
 // Variadic macros do not exist for gcc versions before 3.0
 #   define BOOST_NO_VARIADIC_MACROS
 #elif __GNUC__ == 3
 #  if defined (__PATHSCALE__)
 #     define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #     define BOOST_NO_IS_ABSTRACT
 #  endif
   //
   // gcc-3.x problems:
   //
   // Bug specific to gcc 3.1 and 3.2:
   //
 #  if ((__GNUC_MINOR__ == 1) || (__GNUC_MINOR__ == 2))
 #     define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 #  endif
 #  if __GNUC_MINOR__ < 4
 #     define BOOST_NO_IS_ABSTRACT
 #  endif
 #  define BOOST_NO_EXTERN_TEMPLATE
 #endif
 #if __GNUC__ < 4
 //
 // All problems to gcc-3.x and earlier here:
 //
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #  ifdef __OPEN64__
 #     define BOOST_NO_IS_ABSTRACT
 #  endif
 #endif
 #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
 // Previous versions of GCC did not completely implement value-initialization:
 // GCC Bug 30111, "Value-initialization of POD base class doesn't initialize
 // members", reported by Jonathan Wakely in 2006,
 // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111 (fixed for GCC 4.4)
 // GCC Bug 33916, "Default constructor fails to initialize array members",
 // reported by Michael Elizabeth Chastain in 2007,
 // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916 (fixed for GCC 4.2.4)
 // See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
 #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #endif
 #if !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
 # define BOOST_NO_EXCEPTIONS
 #endif
 //
 // Threading support: Turn this on unconditionally here (except for
 // those platforms where we can know for sure). It will get turned off again
 // later if no threading API is detected.
 //
 #if !defined(__MINGW32__) && !defined(linux) && !defined(__linux) && !defined(__linux__)
 # define BOOST_HAS_THREADS
 #endif 
 //
 // gcc has "long long"
 //
 #define BOOST_HAS_LONG_LONG
 //
 // gcc implements the named return value optimization since version 3.1
 //
 #if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 )
 #define BOOST_HAS_NRVO
 #endif
 //
 // Dynamic shared object (DSO) and dynamic-link library (DLL) support
 //
 #if __GNUC__ >= 4
 #  if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(__CYGWIN__)
     // All Win32 development environments, including 64-bit Windows and MinGW, define 
     // _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
     // so does not define _WIN32 or its variants.
 #    define BOOST_HAS_DECLSPEC
 #    define BOOST_SYMBOL_EXPORT __attribute__((dllexport))
 #    define BOOST_SYMBOL_IMPORT __attribute__((dllimport))
 #  else
 #    define BOOST_SYMBOL_EXPORT __attribute__((visibility("default")))
 #    define BOOST_SYMBOL_IMPORT
 #  endif
 #  define BOOST_SYMBOL_VISIBLE __attribute__((visibility("default")))
 #else
 // config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined  
 #  define BOOST_SYMBOL_EXPORT
 #endif
 //
 // RTTI and typeinfo detection is possible post gcc-4.3:
 //
 #if __GNUC__ * 100 + __GNUC_MINOR__ >= 403
 #  ifndef __GXX_RTTI
 #     ifndef BOOST_NO_TYPEID
 #        define BOOST_NO_TYPEID
 #     endif
 #     ifndef BOOST_NO_RTTI
 #        define BOOST_NO_RTTI
 #     endif
 #  endif
 #endif
 // C++0x features not implemented in any GCC version
 //
 #define BOOST_NO_TEMPLATE_ALIASES
 // C++0x features in 4.3.n and later
 //
 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && defined(__GXX_EXPERIMENTAL_CXX0X__)
 // C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
 // passed on the command line, which in turn defines
 // __GXX_EXPERIMENTAL_CXX0X__.
 #  define BOOST_HAS_DECLTYPE
 #  define BOOST_HAS_RVALUE_REFS
 #  define BOOST_HAS_STATIC_ASSERT
 #  define BOOST_HAS_VARIADIC_TMPL
 #else
 #  define BOOST_NO_DECLTYPE
 #  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #  define BOOST_NO_RVALUE_REFERENCES
 #  define BOOST_NO_STATIC_ASSERT
 // Variadic templates compiler: 
 //   http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html
 #  if defined(__VARIADIC_TEMPLATES) || (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4) && defined(__GXX_EXPERIMENTAL_CXX0X__))
 #    define BOOST_HAS_VARIADIC_TMPL
 #  else
 #    define BOOST_NO_VARIADIC_TEMPLATES
 #  endif
 #endif
 // C++0x features in 4.4.n and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  define BOOST_NO_AUTO_DECLARATIONS
 #  define BOOST_NO_AUTO_MULTIDECLARATIONS
 #  define BOOST_NO_CHAR16_T
 #  define BOOST_NO_CHAR32_T
 #  define BOOST_NO_INITIALIZER_LISTS
 #  define BOOST_NO_DEFAULTED_FUNCTIONS
 #  define BOOST_NO_DELETED_FUNCTIONS
 #endif
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4)
 #  define BOOST_NO_SFINAE_EXPR
 #endif
 // C++0x features in 4.5.0 and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #  define BOOST_NO_LAMBDAS
 #  define BOOST_NO_RAW_LITERALS
 #  define BOOST_NO_UNICODE_LITERALS
 #endif
 // C++0x features in 4.5.1 and later
 //
 #if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40501) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 // scoped enums have a serious bug in 4.4.0, so define BOOST_NO_SCOPED_ENUMS before 4.5.1
 // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38064
 #  define BOOST_NO_SCOPED_ENUMS
 #endif
 // C++0x features in 4.6.n and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #endif
 // C++0x features not supported at all yet
 //
 #define BOOST_NO_DECLTYPE_N3276
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "GNU C++ version " __VERSION__
 #endif
 // ConceptGCC compiler:
 //   http://www.generic-programming.org/software/ConceptGCC/
 #ifdef __GXX_CONCEPTS__
 #  define BOOST_HAS_CONCEPTS
 #  define BOOST_COMPILER "ConceptGCC version " __VERSION__
 #endif
 // versions check:
 // we don't know gcc prior to version 2.90:
 #if (__GNUC__ == 2) && (__GNUC_MINOR__ < 90)
 #  error "Compiler not configured - please reconfigure"
 #endif
 //
 // last known and checked version is 4.6 (Pre-release):
 #if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  else
 // we don't emit warnings here anymore since there are no defect macros defined for
 // gcc post 3.4, so any failures are gcc regressions...
 //#     warning "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,59 @@
 //  (C) Copyright John Maddock 2006. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  GCC-XML C++ compiler setup:
 #  if !defined(__GCCXML_GNUC__) || ((__GCCXML_GNUC__ <= 3) && (__GCCXML_GNUC_MINOR__ <= 3))
 #     define BOOST_NO_IS_ABSTRACT
 #  endif
 //
 // Threading support: Turn this on unconditionally here (except for
 // those platforms where we can know for sure). It will get turned off again
 // later if no threading API is detected.
 //
 #if !defined(__MINGW32__) && !defined(_MSC_VER) && !defined(linux) && !defined(__linux) && !defined(__linux__)
 # define BOOST_HAS_THREADS
 #endif 
 //
 // gcc has "long long"
 //
 #define BOOST_HAS_LONG_LONG
 // C++0x features:
 //
 #  define BOOST_NO_CONSTEXPR
 #  define BOOST_NO_NULLPTR
 #  define BOOST_NO_TEMPLATE_ALIASES
 #  define BOOST_NO_DECLTYPE
 #  define BOOST_NO_DECLTYPE_N3276
 #  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #  define BOOST_NO_RVALUE_REFERENCES
 #  define BOOST_NO_STATIC_ASSERT
 #  define BOOST_NO_VARIADIC_TEMPLATES
 #  define BOOST_NO_VARIADIC_MACROS
 #  define BOOST_NO_AUTO_DECLARATIONS
 #  define BOOST_NO_AUTO_MULTIDECLARATIONS
 #  define BOOST_NO_CHAR16_T
 #  define BOOST_NO_CHAR32_T
 #  define BOOST_NO_DEFAULTED_FUNCTIONS
 #  define BOOST_NO_DELETED_FUNCTIONS
 #  define BOOST_NO_INITIALIZER_LISTS
 #  define BOOST_NO_SCOPED_ENUMS  
 #  define BOOST_NO_SFINAE_EXPR
 #  define BOOST_NO_SCOPED_ENUMS
 #  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #  define BOOST_NO_LAMBDAS
 #  define BOOST_NO_RAW_LITERALS
 #  define BOOST_NO_UNICODE_LITERALS
 #  define BOOST_NO_NOEXCEPT
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2001. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Greenhills C++ compiler setup:
 #define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs)
 #include "boost/config/compiler/common_edg.hpp"
 //
 // versions check:
 // we don't support Greenhills prior to version 0:
 #if __ghs < 0
 #  error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version is 0:
 #if (__ghs > 0)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,138 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2001 - 2003. 
 //  (C) Copyright Aleksey Gurtovoy 2002. 
 //  (C) Copyright David Abrahams 2002 - 2003. 
 //  (C) Copyright Toon Knapen 2003. 
 //  (C) Copyright Boris Gubenko 2006 - 2007.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  HP aCC C++ compiler setup:
 #if defined(__EDG__)
 #include "boost/config/compiler/common_edg.hpp"
 #endif
 #if (__HP_aCC <= 33100)
 #    define BOOST_NO_INTEGRAL_INT64_T
 #    define BOOST_NO_OPERATORS_IN_NAMESPACE
 #  if !defined(_NAMESPACE_STD)
 #     define BOOST_NO_STD_LOCALE
 #     define BOOST_NO_STRINGSTREAM
 #  endif
 #endif
 #if (__HP_aCC <= 33300)
 // member templates are sufficiently broken that we disable them for now
 #    define BOOST_NO_MEMBER_TEMPLATES
 #    define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
 #    define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
 #endif
 #if (__HP_aCC <= 38000)
 #  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #endif
 #if (__HP_aCC > 50000) && (__HP_aCC < 60000)
 #    define BOOST_NO_UNREACHABLE_RETURN_DETECTION
 #    define BOOST_NO_TEMPLATE_TEMPLATES
 #    define BOOST_NO_SWPRINTF
 #    define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #    define BOOST_NO_IS_ABSTRACT
 #    define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #endif 
 // optional features rather than defects:
 #if (__HP_aCC >= 33900)
 #    define BOOST_HAS_LONG_LONG
 #    define BOOST_HAS_PARTIAL_STD_ALLOCATOR
 #endif
 #if (__HP_aCC >= 50000 ) && (__HP_aCC <= 53800 ) || (__HP_aCC < 31300 )
 #    define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
 #endif
 // This macro should not be defined when compiling in strict ansi
 // mode, but, currently, we don't have the ability to determine
 // what standard mode we are compiling with. Some future version
 // of aCC6 compiler will provide predefined macros reflecting the
 // compilation options, including the standard mode.
 #if (__HP_aCC >= 60000) || ((__HP_aCC > 38000) && defined(__hpxstd98))
 #    define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #endif
 #define BOOST_COMPILER "HP aCC version " BOOST_STRINGIZE(__HP_aCC)
 //
 // versions check:
 // we don't support HP aCC prior to version 33000:
 #if __HP_aCC < 33000
 #  error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // Extended checks for supporting aCC on PA-RISC
 #if __HP_aCC > 30000 && __HP_aCC < 50000
 #  if __HP_aCC < 38000
      // versions prior to version A.03.80 not supported
 #     error "Compiler version not supported - version A.03.80 or higher is required"
 #  elif !defined(__hpxstd98)
      // must compile using the option +hpxstd98 with version A.03.80 and above
 #     error "Compiler option '+hpxstd98' is required for proper support"
 #  endif //PA-RISC
 #endif
 //
 // C++0x features
 //
 //   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
 //
 #if !defined(__EDG__)
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 /* 
  See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
      https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443436
 */
 #if (__HP_aCC < 62500) || !defined(HP_CXX0x_SOURCE)
  #define BOOST_NO_VARIADIC_MACROS
 #endif
 #endif
 //
 // last known and checked version for HP-UX/ia64 is 61300
 // last known and checked version for PA-RISC is 38000
 #if ((__HP_aCC > 61300) || ((__HP_aCC > 38000) && defined(__hpxstd98)))
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,244 @@
 //  (C) Copyright John Maddock 2001-8.
 //  (C) Copyright Peter Dimov 2001.
 //  (C) Copyright Jens Maurer 2001.
 //  (C) Copyright David Abrahams 2002 - 2003.
 //  (C) Copyright Aleksey Gurtovoy 2002 - 2003.
 //  (C) Copyright Guillaume Melquiond 2002 - 2003.
 //  (C) Copyright Beman Dawes 2003.
 //  (C) Copyright Martin Wille 2003.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Intel compiler setup:
 #include "boost/config/compiler/common_edg.hpp"
 #if defined(__INTEL_COMPILER)
 #  define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER
 #elif defined(__ICL)
 #  define BOOST_INTEL_CXX_VERSION __ICL
 #elif defined(__ICC)
 #  define BOOST_INTEL_CXX_VERSION __ICC
 #elif defined(__ECC)
 #  define BOOST_INTEL_CXX_VERSION __ECC
 #endif
 // Flags determined by comparing output of 'icpc -dM -E' with and without '-std=c++0x'
 #if (!(defined(_WIN32) || defined(_WIN64)) && defined(__STDC_HOSTED__) && (__STDC_HOSTED__ && (BOOST_INTEL_CXX_VERSION <= 1200))) || defined(__GXX_EXPERIMENTAL_CPP0X__)
 #  define BOOST_INTEL_STDCXX0X
 #endif
 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
 #  define BOOST_INTEL_STDCXX0X
 #endif
 #ifdef BOOST_INTEL_STDCXX0X
 #define BOOST_COMPILER "Intel C++ C++0x mode version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
 #else
 #define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
 #endif
 #define BOOST_INTEL BOOST_INTEL_CXX_VERSION
 #if defined(_WIN32) || defined(_WIN64)
 #  define BOOST_INTEL_WIN BOOST_INTEL
 #else
 #  define BOOST_INTEL_LINUX BOOST_INTEL
 #endif
 #if (BOOST_INTEL_CXX_VERSION <= 500) && defined(_MSC_VER)
 #  define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 #  define BOOST_NO_TEMPLATE_TEMPLATES
 #endif
 #if (BOOST_INTEL_CXX_VERSION <= 600)
 #  if defined(_MSC_VER) && (_MSC_VER <= 1300) // added check for <= VC 7 (Peter Dimov)
 // Boost libraries assume strong standard conformance unless otherwise
 // indicated by a config macro. As configured by Intel, the EDG front-end
 // requires certain compiler options be set to achieve that strong conformance.
 // Particularly /Qoption,c,--arg_dep_lookup (reported by Kirk Klobe & Thomas Witt)
 // and /Zc:wchar_t,forScope. See boost-root/tools/build/intel-win32-tools.jam for
 // details as they apply to particular versions of the compiler. When the
 // compiler does not predefine a macro indicating if an option has been set,
 // this config file simply assumes the option has been set.
 // Thus BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP will not be defined, even if
 // the compiler option is not enabled.
 #     define BOOST_NO_SWPRINTF
 #  endif
 // Void returns, 64 bit integrals don't work when emulating VC 6 (Peter Dimov)
 #  if defined(_MSC_VER) && (_MSC_VER <= 1200)
 #     define BOOST_NO_VOID_RETURNS
 #     define BOOST_NO_INTEGRAL_INT64_T
 #  endif
 #endif
 #if (BOOST_INTEL_CXX_VERSION <= 710) && defined(_WIN32)
 #  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
 #endif
 // See http://aspn.activestate.com/ASPN/Mail/Message/boost/1614864
 #if BOOST_INTEL_CXX_VERSION < 600
 #  define BOOST_NO_INTRINSIC_WCHAR_T
 #else
 // We should test the macro _WCHAR_T_DEFINED to check if the compiler
 // supports wchar_t natively. *BUT* there is a problem here: the standard
 // headers define this macro if they typedef wchar_t. Anyway, we're lucky
 // because they define it without a value, while Intel C++ defines it
 // to 1. So we can check its value to see if the macro was defined natively
 // or not.
 // Under UNIX, the situation is exactly the same, but the macro _WCHAR_T
 // is used instead.
 #  if ((_WCHAR_T_DEFINED + 0) == 0) && ((_WCHAR_T + 0) == 0)
 #    define BOOST_NO_INTRINSIC_WCHAR_T
 #  endif
 #endif
 #if defined(__GNUC__) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
 //
 // Figure out when Intel is emulating this gcc bug
 // (All Intel versions prior to 9.0.26, and versions
 // later than that if they are set up to emulate gcc 3.2
 // or earlier):
 //
 #  if ((__GNUC__ == 3) && (__GNUC_MINOR__ <= 2)) || (BOOST_INTEL < 900) || (__INTEL_COMPILER_BUILD_DATE < 20050912)
 #     define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #  endif
 #endif
 #if (defined(__GNUC__) && (__GNUC__ < 4)) || defined(_WIN32) || (BOOST_INTEL_CXX_VERSION <= 1200)
 // GCC or VC emulation:
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #endif
 //
 // Verify that we have actually got BOOST_NO_INTRINSIC_WCHAR_T
 // set correctly, if we don't do this now, we will get errors later
 // in type_traits code among other things, getting this correct
 // for the Intel compiler is actually remarkably fragile and tricky:
 //
 #ifdef __cplusplus
 #if defined(BOOST_NO_INTRINSIC_WCHAR_T)
 #include <cwchar>
 template< typename T > struct assert_no_intrinsic_wchar_t;
 template<> struct assert_no_intrinsic_wchar_t<wchar_t> { typedef void type; };
 // if you see an error here then you need to unset BOOST_NO_INTRINSIC_WCHAR_T
 // where it is defined above:
 typedef assert_no_intrinsic_wchar_t<unsigned short>::type assert_no_intrinsic_wchar_t_;
 #else
 template< typename T > struct assert_intrinsic_wchar_t;
 template<> struct assert_intrinsic_wchar_t<wchar_t> {};
 // if you see an error here then define BOOST_NO_INTRINSIC_WCHAR_T on the command line:
 template<> struct assert_intrinsic_wchar_t<unsigned short> {};
 #endif
 #endif
 #if defined(_MSC_VER) && (_MSC_VER+0 >= 1000)
 #  if _MSC_VER >= 1200
 #     define BOOST_HAS_MS_INT64
 #  endif
 #  define BOOST_NO_SWPRINTF
 #  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #elif defined(_WIN32)
 #  define BOOST_DISABLE_WIN32
 #endif
 // I checked version 6.0 build 020312Z, it implements the NRVO.
 // Correct this as you find out which version of the compiler
 // implemented the NRVO first.  (Daniel Frey)
 #if (BOOST_INTEL_CXX_VERSION >= 600)
 #  define BOOST_HAS_NRVO
 #endif
 //
 // versions check:
 // we don't support Intel prior to version 5.0:
 #if BOOST_INTEL_CXX_VERSION < 500
 #  error "Compiler not supported or configured - please reconfigure"
 #endif
 // Intel on MacOS requires
 #if defined(__APPLE__) && defined(__INTEL_COMPILER)
 #  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #endif
 // Intel on Altix Itanium
 #if defined(__itanium__) && defined(__INTEL_COMPILER)
 #  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #endif
 //
 // An attempt to value-initialize a pointer-to-member may trigger an
 // internal error on Intel <= 11.1 (last checked version), as was 
 // reported by John Maddock, Intel support issue 589832, May 2010.
 // Moreover, according to test results from Huang-Vista-x86_32_intel,
 // intel-vc9-win-11.1 may leave a non-POD array uninitialized, in some 
 // cases when it should be value-initialized.
 // (Niels Dekker, LKEB, May 2010)
 // Apparently Intel 12.1 (compiler version number 9999 !!) has the same issue (compiler regression).
 #if defined(__INTEL_COMPILER)
 #  if (__INTEL_COMPILER <= 1110) || (__INTEL_COMPILER == 9999)
 #    define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #  endif
 #endif
 //
 // Dynamic shared object (DSO) and dynamic-link library (DLL) support
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #  define BOOST_SYMBOL_EXPORT __attribute__((visibility("default")))
 #  define BOOST_SYMBOL_IMPORT
 #  define BOOST_SYMBOL_VISIBLE __attribute__((visibility("default")))
 #endif
 //
 // C++0x features
 //     - ICC added static_assert in 11.0 (first version with C++0x support)
 //
 #if defined(BOOST_INTEL_STDCXX0X)
 #  undef  BOOST_NO_STATIC_ASSERT
 //
 // These pass our test cases, but aren't officially supported according to:
 // http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
 //
 //#  undef  BOOST_NO_LAMBDAS
 //#  undef  BOOST_NO_DECLTYPE
 //#  undef  BOOST_NO_AUTO_DECLARATIONS
 //#  undef  BOOST_NO_AUTO_MULTIDECLARATIONS
 #endif
 #if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1200)
 //#  undef  BOOST_NO_RVALUE_REFERENCES // Enabling this breaks Filesystem and Exception libraries
 //#  undef  BOOST_NO_SCOPED_ENUMS  // doesn't really work!!
 #  undef  BOOST_NO_DELETED_FUNCTIONS
 #  undef  BOOST_NO_DEFAULTED_FUNCTIONS
 #  undef  BOOST_NO_LAMBDAS
 #  undef  BOOST_NO_DECLTYPE
 #  undef  BOOST_NO_AUTO_DECLARATIONS
 #  undef  BOOST_NO_AUTO_MULTIDECLARATIONS
 #endif
 #if (BOOST_INTEL_CXX_VERSION < 1200)
 //
 // fenv.h appears not to work with Intel prior to 12.0:
 //
 #  define BOOST_NO_FENV_H
 #endif
 //
 // last known and checked version:
 #if (BOOST_INTEL_CXX_VERSION > 1200)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  elif defined(_MSC_VER)
 //
 //      We don't emit this warning any more, since we have so few
 //      defect macros set anyway (just the one).
 //
 //#     pragma message("Unknown compiler version - please run the configure tests and report the results")
 #  endif
 #endif
@@ -0,0 +1,33 @@
 //  (C) Copyright John Maddock 2001. 
 //  (C) Copyright David Abrahams 2002. 
 //  (C) Copyright Aleksey Gurtovoy 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Kai C++ compiler setup:
 #include "boost/config/compiler/common_edg.hpp"
 #   if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG)
      // at least on Sun, the contents of <cwchar> is not in namespace std
 #     define BOOST_NO_STDC_NAMESPACE
 #   endif
 // see also common_edg.hpp which needs a special check for __KCC
 # if !defined(_EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
 #     define BOOST_NO_EXCEPTIONS
 # endif
 //
 // last known and checked version is 4001:
 #if (__KCC_VERSION > 4001)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,142 @@
 //  (C) Copyright John Maddock 2001. 
 //  (C) Copyright Darin Adler 2001. 
 //  (C) Copyright Peter Dimov 2001. 
 //  (C) Copyright David Abrahams 2001 - 2002. 
 //  (C) Copyright Beman Dawes 2001 - 2003. 
 //  (C) Copyright Stefan Slapeta 2004. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Metrowerks C++ compiler setup:
 // locale support is disabled when linking with the dynamic runtime
 #   ifdef _MSL_NO_LOCALE
 #     define BOOST_NO_STD_LOCALE
 #   endif 
 #   if __MWERKS__ <= 0x2301  // 5.3
 #     define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #     define BOOST_NO_POINTER_TO_MEMBER_CONST
 #     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #     define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
 #   endif
 #   if __MWERKS__ <= 0x2401  // 6.2
 //#     define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #   endif
 #   if(__MWERKS__ <= 0x2407)  // 7.x
 #     define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
 #     define BOOST_NO_UNREACHABLE_RETURN_DETECTION
 #   endif
 #   if(__MWERKS__ <= 0x3003)  // 8.x
 #     define BOOST_NO_SFINAE
 #    endif
 // the "|| !defined(BOOST_STRICT_CONFIG)" part should apply to the last
 // tested version *only*:
 #   if(__MWERKS__ <= 0x3207) || !defined(BOOST_STRICT_CONFIG) // 9.6
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_IS_ABSTRACT
 #    endif
 #if !__option(wchar_type)
 #   define BOOST_NO_INTRINSIC_WCHAR_T
 #endif
 #if !__option(exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #   define BOOST_NO_EXCEPTIONS
 #endif
 #if (__INTEL__ && _WIN32) || (__POWERPC__ && macintosh)
 #   if __MWERKS__ == 0x3000
 #     define BOOST_COMPILER_VERSION 8.0
 #   elif __MWERKS__ == 0x3001
 #     define BOOST_COMPILER_VERSION 8.1
 #   elif __MWERKS__ == 0x3002
 #     define BOOST_COMPILER_VERSION 8.2
 #   elif __MWERKS__ == 0x3003
 #     define BOOST_COMPILER_VERSION 8.3
 #   elif __MWERKS__ == 0x3200
 #     define BOOST_COMPILER_VERSION 9.0
 #   elif __MWERKS__ == 0x3201
 #     define BOOST_COMPILER_VERSION 9.1
 #   elif __MWERKS__ == 0x3202
 #     define BOOST_COMPILER_VERSION 9.2
 #   elif __MWERKS__ == 0x3204
 #     define BOOST_COMPILER_VERSION 9.3
 #   elif __MWERKS__ == 0x3205
 #     define BOOST_COMPILER_VERSION 9.4
 #   elif __MWERKS__ == 0x3206
 #     define BOOST_COMPILER_VERSION 9.5
 #   elif __MWERKS__ == 0x3207
 #     define BOOST_COMPILER_VERSION 9.6
 #   else
 #     define BOOST_COMPILER_VERSION __MWERKS__
 #   endif
 #else
 #  define BOOST_COMPILER_VERSION __MWERKS__
 #endif
 //
 // C++0x features
 //
 //   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
 //
 #if __MWERKS__ > 0x3206 && __option(rvalue_refs)
 #  define BOOST_HAS_RVALUE_REFS
 #else
 #  define BOOST_NO_RVALUE_REFERENCES              
 #endif
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_VARIADIC_MACROS
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
 //
 // versions check:
 // we don't support Metrowerks prior to version 5.3:
 #if __MWERKS__ < 0x2301
 #  error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version:
 #if (__MWERKS__ > 0x3205)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,84 @@
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  (C) Copyright Aleksey Gurtovoy 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  MPW C++ compilers setup:
 #   if    defined(__SC__)
 #     define BOOST_COMPILER "MPW SCpp version " BOOST_STRINGIZE(__SC__)
 #   elif defined(__MRC__)
 #     define BOOST_COMPILER "MPW MrCpp version " BOOST_STRINGIZE(__MRC__)
 #   else
 #     error "Using MPW compiler configuration by mistake.  Please update."
 #   endif
 //
 // MPW 8.90:
 //
 #if (MPW_CPLUS <= 0x890) || !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_NO_CV_SPECIALIZATIONS
 #  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
 #  define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #  define BOOST_NO_INTRINSIC_WCHAR_T
 #  define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #  define BOOST_NO_USING_TEMPLATE
 #  define BOOST_NO_CWCHAR
 #  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #  define BOOST_NO_STD_ALLOCATOR /* actually a bug with const reference overloading */
 #endif
 //
 // C++0x features
 //
 //   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
 //
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_VARIADIC_MACROS
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 //
 // versions check:
 // we don't support MPW prior to version 8.9:
 #if MPW_CPLUS < 0x890
 #  error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version is 0x890:
 #if (MPW_CPLUS > 0x890)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,28 @@
 //  (C) Copyright Eric Jourdanneau, Joel Falcou 2010
 //  Use, modification and distribution are subject to 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 most recent version.
 //  NVIDIA CUDA C++ compiler setup
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "NVIDIA CUDA C++ Compiler"
 #endif
 // NVIDIA Specific support
 // BOOST_GPU_ENABLED : Flag a function or a method as being enabled on the host and device
 #define BOOST_GPU_ENABLED __host__ __device__
 // Boost support macro for NVCC 
 // NVCC Basically behaves like some flavor of MSVC6 + some specific quirks
 #ifdef __GNUC__
 #include <boost/config/compiler/gcc.hpp>
 #elif defined(_MSC_VER)
 #include <boost/config/compiler/visualc.hpp>
 #endif
@@ -0,0 +1,80 @@
 //  (C) Copyright Bryce Lelbach 2011
 //  Use, modification and distribution are subject to 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 most recent version.
 // PathScale EKOPath C++ Compiler
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "PathScale EKOPath C++ Compiler version " __PATHSCALE__
 #endif
 #if __PATHCC__ >= 4
 #  define BOOST_MSVC6_MEMBER_TEMPLATES
 #  define BOOST_HAS_UNISTD_H
 #  define BOOST_HAS_STDINT_H
 #  define BOOST_HAS_SIGACTION
 #  define BOOST_HAS_SCHED_YIELD
 #  define BOOST_HAS_THREADS
 #  define BOOST_HAS_PTHREADS
 #  define BOOST_HAS_PTHREAD_YIELD
 #  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
 #  define BOOST_HAS_NRVO
 #  define BOOST_HAS_NL_TYPES_H
 #  define BOOST_HAS_NANOSLEEP
 #  define BOOST_HAS_LONG_LONG
 #  define BOOST_HAS_LOG1P
 #  define BOOST_HAS_GETTIMEOFDAY
 #  define BOOST_HAS_EXPM1
 #  define BOOST_HAS_DIRENT_H
 #  define BOOST_HAS_CLOCK_GETTIME
 #  define BOOST_NO_VARIADIC_TEMPLATES
 #  define BOOST_NO_UNICODE_LITERALS
 #  define BOOST_NO_TEMPLATE_ALIASES
 #  define BOOST_NO_STD_UNORDERED
 #  define BOOST_NO_STATIC_ASSERT
 #  define BOOST_NO_SFINAE_EXPR
 #  define BOOST_NO_SCOPED_ENUMS
 #  define BOOST_NO_RVALUE_REFERENCES
 #  define BOOST_NO_RAW_LITERALS
 #  define BOOST_NO_NULLPTR
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #  define BOOST_NO_NOEXCEPT
 #  define BOOST_NO_LAMBDAS
 #  define BOOST_NO_INITIALIZER_LISTS
 #  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
 #  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #  define BOOST_NO_DELETED_FUNCTIONS
 #  define BOOST_NO_DEFAULTED_FUNCTIONS
 #  define BOOST_NO_DECLTYPE
 #  define BOOST_NO_DECLTYPE_N3276
 #  define BOOST_NO_CONSTEXPR
 #  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #  define BOOST_NO_CHAR32_T
 #  define BOOST_NO_CHAR16_T
 #  define BOOST_NO_AUTO_MULTIDECLARATIONS
 #  define BOOST_NO_AUTO_DECLARATIONS
 #  define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CHRONO
 #endif
@@ -0,0 +1,80 @@
 //  (C) Copyright Noel Belcourt 2007.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  PGI C++ compiler setup:
 #define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__
 #define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(_COMPILER_VERSION)
 //
 // Threading support:
 // Turn this on unconditionally here, it will get turned off again later
 // if no threading API is detected.
 //
 // PGI 10.x doesn't seem to define __PGIC__
 // versions earlier than 10.x do define __PGIC__
 #if __PGIC__ >= 10
 // options requested by configure --enable-test
 #define BOOST_HAS_PTHREADS
 #define BOOST_HAS_NRVO
 #define BOOST_HAS_LONG_LONG
 // options --enable-test wants undefined
 #undef BOOST_NO_STDC_NAMESPACE
 #undef BOOST_NO_EXCEPTION_STD_NAMESPACE
 #undef BOOST_DEDUCED_TYPENAME
 #elif __PGIC__ >= 7
 #define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL 
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #define BOOST_NO_SWPRINTF
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_AUTO_DECLARATIONS
 #else
 #  error "Pgi compiler not configured - please reconfigure"
 #endif
 //
 // C++0x features
 //
 //   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
 //
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_VARIADIC_MACROS
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 //
 // version check:
 // probably nothing to do here?
@@ -0,0 +1,29 @@
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  SGI C++ compiler setup:
 #define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION)
 #include "boost/config/compiler/common_edg.hpp"
 //
 // Threading support:
 // Turn this on unconditionally here, it will get turned off again later
 // if no threading API is detected.
 //
 #define BOOST_HAS_THREADS
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #undef BOOST_NO_SWPRINTF
 #undef BOOST_DEDUCED_TYPENAME
 //
 // version check:
 // probably nothing to do here?
@@ -0,0 +1,147 @@
 //  (C) Copyright John Maddock 2001. 
 //  (C) Copyright Jens Maurer 2001 - 2003. 
 //  (C) Copyright Peter Dimov 2002. 
 //  (C) Copyright Aleksey Gurtovoy 2002 - 2003. 
 //  (C) Copyright David Abrahams 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Sun C++ compiler setup:
 #    if __SUNPRO_CC <= 0x500
 #      define BOOST_NO_MEMBER_TEMPLATES
 #      define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #    endif
 #    if (__SUNPRO_CC <= 0x520)
       //
       // Sunpro 5.2 and earler:
       //
       // although sunpro 5.2 supports the syntax for
       // inline initialization it often gets the value
       // wrong, especially where the value is computed
       // from other constants (J Maddock 6th May 2001)
 #      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
       // Although sunpro 5.2 supports the syntax for
       // partial specialization, it often seems to
       // bind to the wrong specialization.  Better
       // to disable it until suppport becomes more stable
       // (J Maddock 6th May 2001).
 #      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #    endif
 #    if (__SUNPRO_CC <= 0x530) 
       // Requesting debug info (-g) with Boost.Python results
       // in an internal compiler error for "static const"
       // initialized in-class.
       //    >> Assertion:   (../links/dbg_cstabs.cc, line 611)
       //         while processing ../test.cpp at line 0.
       // (Jens Maurer according to Gottfried Ganssauge 04 Mar 2002)
 #      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
       // SunPro 5.3 has better support for partial specialization,
       // but breaks when compiling std::less<shared_ptr<T> >
       // (Jens Maurer 4 Nov 2001).
       // std::less specialization fixed as reported by George
       // Heintzelman; partial specialization re-enabled
       // (Peter Dimov 17 Jan 2002)
 //#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
       // integral constant expressions with 64 bit numbers fail
 #      define BOOST_NO_INTEGRAL_INT64_T
 #    endif
 #    if (__SUNPRO_CC < 0x570) 
 #      define BOOST_NO_TEMPLATE_TEMPLATES
       // see http://lists.boost.org/MailArchives/boost/msg47184.php
       // and http://lists.boost.org/MailArchives/boost/msg47220.php
 #      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #      define BOOST_NO_SFINAE
 #      define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
 #    endif
 #    if (__SUNPRO_CC <= 0x580) 
 #      define BOOST_NO_IS_ABSTRACT
 #    endif
 #    if (__SUNPRO_CC <= 0x5100)
       // Sun 5.10 may not correctly value-initialize objects of
       // some user defined types, as was reported in April 2010
       // (CR 6947016), and confirmed by Steve Clamage.
       // (Niels Dekker, LKEB, May 2010).
 #      define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #    endif
 //
 // Dynamic shared object (DSO) and dynamic-link library (DLL) support
 //
 #if __SUNPRO_CC > 0x500
 #  define BOOST_SYMBOL_EXPORT __global
 #  define BOOST_SYMBOL_IMPORT __global
 #  define BOOST_SYMBOL_VISIBLE __global
 #endif
 //
 // Issues that effect all known versions:
 //
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #define BOOST_NO_ADL_BARRIER
 //
 // C++0x features
 //
 #  define BOOST_HAS_LONG_LONG
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_EXTERN_TEMPLATE
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_VARIADIC_MACROS
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 //
 // Version
 //
 #define BOOST_COMPILER "Sun compiler version " BOOST_STRINGIZE(__SUNPRO_CC)
 //
 // versions check:
 // we don't support sunpro prior to version 4:
 #if __SUNPRO_CC < 0x400
 #error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version is 0x590:
 #if (__SUNPRO_CC > 0x590)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
@@ -0,0 +1,120 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Toon Knapen 2001 - 2003. 
 //  (C) Copyright Lie-Quan Lee 2001. 
 //  (C) Copyright Markus Schoepflin 2002 - 2003. 
 //  (C) Copyright Beman Dawes 2002 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Visual Age (IBM) C++ compiler setup:
 #if __IBMCPP__ <= 501
 #  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #  define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
 #endif
 #if (__IBMCPP__ <= 502) 
 // Actually the compiler supports inclass member initialization but it
 // requires a definition for the class member and it doesn't recognize
 // it as an integral constant expression when used as a template argument.
 #  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #  define BOOST_NO_INTEGRAL_INT64_T
 #  define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
 #endif
 #if (__IBMCPP__ <= 600) || !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
 #endif
 #if (__IBMCPP__ <= 1110)
 // XL C++ V11.1 and earlier versions may not always value-initialize  
 // a temporary object T(), when T is a non-POD aggregate class type. 
 // Michael Wong (IBM Canada Ltd) has confirmed this issue and gave it 
 // high priority. -- Niels Dekker (LKEB), May 2010.
 #  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #endif
 //
 // On AIX thread support seems to be indicated by _THREAD_SAFE:
 //
 #ifdef _THREAD_SAFE
 #  define BOOST_HAS_THREADS
 #endif
 #define BOOST_COMPILER "IBM Visual Age version " BOOST_STRINGIZE(__IBMCPP__)
 //
 // versions check:
 // we don't support Visual age prior to version 5:
 #if __IBMCPP__ < 500
 #error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version is 1110:
 #if (__IBMCPP__ > 1110)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  endif
 #endif
 // Some versions of the compiler have issues with default arguments on partial specializations
 #if __IBMCPP__ <= 1010
 #define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
 #endif
 //
 // C++0x features
 //
 //   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
 //
 #if ! __IBMCPP_AUTO_TYPEDEDUCTION
 #  define BOOST_NO_AUTO_DECLARATIONS
 #  define BOOST_NO_AUTO_MULTIDECLARATIONS
 #endif
 #if ! __IBMCPP_UTF_LITERAL__
 #  define BOOST_NO_CHAR16_T
 #  define BOOST_NO_CHAR32_T
 #endif
 #define BOOST_NO_CONSTEXPR
 #if ! __IBMCPP_DECLTYPE
 #  define BOOST_NO_DECLTYPE
 #else
 #  define BOOST_HAS_DECLTYPE
 #endif
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #if ! __IBMCPP_EXTERN_TEMPLATE
 #  define BOOST_NO_EXTERN_TEMPLATE
 #endif
 #if ! __IBMCPP_VARIADIC_TEMPLATES
 // not enabled separately at this time
 #  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #endif
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 #if ! __IBMCPP_STATIC_ASSERT
 #  define BOOST_NO_STATIC_ASSERT
 #endif
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #if ! __IBMCPP_VARIADIC_TEMPLATES
 #  define BOOST_NO_VARIADIC_TEMPLATES
 #endif
 #if ! __C99_MACRO_WITH_VA_ARGS
 #  define BOOST_NO_VARIADIC_MACROS
 #endif
@@ -0,0 +1,283 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Darin Adler 2001 - 2002. 
 //  (C) Copyright Peter Dimov 2001. 
 //  (C) Copyright Aleksey Gurtovoy 2002. 
 //  (C) Copyright David Abrahams 2002 - 2003. 
 //  (C) Copyright Beman Dawes 2002 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Microsoft Visual C++ compiler setup:
 #define BOOST_MSVC _MSC_VER
 #if _MSC_FULL_VER > 100000000
 #  define BOOST_MSVC_FULL_VER _MSC_FULL_VER
 #else
 #  define BOOST_MSVC_FULL_VER (_MSC_FULL_VER * 10)
 #endif
 // turn off the warnings before we #include anything
 #pragma warning( disable : 4503 ) // warning: decorated name length exceeded
 #if _MSC_VER < 1300  // 1200 == VC++ 6.0, 1200-1202 == eVC++4
 #  pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info
 #  define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #  define BOOST_NO_VOID_RETURNS
 #  define BOOST_NO_EXCEPTION_STD_NAMESPACE
 #  if BOOST_MSVC == 1202
 #    define BOOST_NO_STD_TYPEINFO
 #  endif
   // disable min/max macro defines on vc6:
   //
 #endif
 /// Visual Studio has no fenv.h
 #define BOOST_NO_FENV_H
 #if (_MSC_VER <= 1300)  // 1300 == VC++ 7.0
 #  if !defined(_MSC_EXTENSIONS) && !defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS)      // VC7 bug with /Za
 #    define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #  endif
 #  define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 #  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #  define BOOST_NO_PRIVATE_IN_AGGREGATE
 #  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 #  define BOOST_NO_INTEGRAL_INT64_T
 #  define BOOST_NO_DEDUCED_TYPENAME
 #  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
 //    VC++ 6/7 has member templates but they have numerous problems including
 //    cases of silent failure, so for safety we define:
 #  define BOOST_NO_MEMBER_TEMPLATES
 //    For VC++ experts wishing to attempt workarounds, we define:
 #  define BOOST_MSVC6_MEMBER_TEMPLATES
 #  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #  define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #  define BOOST_NO_CV_VOID_SPECIALIZATIONS
 #  define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #  define BOOST_NO_USING_TEMPLATE
 #  define BOOST_NO_SWPRINTF
 #  define BOOST_NO_TEMPLATE_TEMPLATES
 #  define BOOST_NO_SFINAE
 #  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
 #  define BOOST_NO_IS_ABSTRACT
 #  define BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
 // TODO: what version is meant here? Have there really been any fixes in cl 12.01 (as e.g. shipped with eVC4)?
 #  if (_MSC_VER > 1200)
 #     define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
 #  endif
 #endif
 #if _MSC_VER < 1400 
 // although a conforming signature for swprint exists in VC7.1
 // it appears not to actually work:
 #  define BOOST_NO_SWPRINTF
 // Our extern template tests also fail for this compiler:
 #  define BOOST_NO_EXTERN_TEMPLATE
 // Variadic macros do not exist for VC7.1 and lower
 #  define BOOST_NO_VARIADIC_MACROS
 #endif
 #if defined(UNDER_CE)
 // Windows CE does not have a conforming signature for swprintf
 #  define BOOST_NO_SWPRINTF
 #endif
 #if _MSC_VER <= 1400  // 1400 == VC++ 8.0
 #  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #endif
 #if _MSC_VER == 1500  // 1500 == VC++ 9.0
   // A bug in VC9:
 #  define BOOST_NO_ADL_BARRIER
 #endif
 #if (_MSC_VER <= 1600)
 // MSVC (including the latest checked version) has not yet completely 
 // implemented value-initialization, as is reported:
 // "VC++ does not value-initialize members of derived classes without 
 // user-declared constructor", reported in 2009 by Sylvester Hesp:
 // https://connect.microsoft.com/VisualStudio/feedback/details/484295
 // "Presence of copy constructor breaks member class initialization",
 // reported in 2009 by Alex Vakulenko:
 // https://connect.microsoft.com/VisualStudio/feedback/details/499606
 // "Value-initialization in new-expression", reported in 2005 by
 // Pavel Kuznetsov (MetaCommunications Engineering):
 // https://connect.microsoft.com/VisualStudio/feedback/details/100744
 // See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
 // (Niels Dekker, LKEB, May 2010)
 #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
 #endif
 #if _MSC_VER <= 1500  || !defined(BOOST_STRICT_CONFIG) // 1500 == VC++ 9.0
 #  define BOOST_NO_INITIALIZER_LISTS
 #endif
 #ifndef _NATIVE_WCHAR_T_DEFINED
 #  define BOOST_NO_INTRINSIC_WCHAR_T
 #endif
 #if defined(_WIN32_WCE) || defined(UNDER_CE)
 #  define BOOST_NO_SWPRINTF
 #endif
 // we have ThreadEx or GetSystemTimeAsFileTime unless we're running WindowsCE
 #if !defined(_WIN32_WCE) && !defined(UNDER_CE)
 #  define BOOST_HAS_THREADEX
 #  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
 #endif
 //   
 // check for exception handling support:   
 #if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS   
 #endif 
 //
 // __int64 support:
 //
 #if (_MSC_VER >= 1200)
 #   define BOOST_HAS_MS_INT64
 #endif
 #if (_MSC_VER >= 1310) && (defined(_MSC_EXTENSIONS) || (_MSC_VER >= 1400))
 #   define BOOST_HAS_LONG_LONG
 #else
 #   define BOOST_NO_LONG_LONG
 #endif
 #if (_MSC_VER >= 1400) && !defined(_DEBUG)
 #   define BOOST_HAS_NRVO
 #endif
 //
 // disable Win32 API's if compiler extentions are
 // turned off:
 //
 #if !defined(_MSC_EXTENSIONS) && !defined(BOOST_DISABLE_WIN32)
 #  define BOOST_DISABLE_WIN32
 #endif
 #if !defined(_CPPRTTI) && !defined(BOOST_NO_RTTI)
 #  define BOOST_NO_RTTI
 #endif
 //
 // C++0x features
 //
 //   See above for BOOST_NO_LONG_LONG
 // C++ features supported by VC++ 10 (aka 2010)
 //
 #if _MSC_VER < 1600
 #define BOOST_NO_AUTO_DECLARATIONS
 #define BOOST_NO_AUTO_MULTIDECLARATIONS
 #define BOOST_NO_LAMBDAS
 #define BOOST_NO_RVALUE_REFERENCES
 #define BOOST_NO_STATIC_ASSERT
 #define BOOST_NO_NULLPTR
 #define BOOST_NO_DECLTYPE
 #endif // _MSC_VER < 1600
 #if _MSC_VER >= 1600
 #define BOOST_HAS_STDINT_H
 #endif
 // C++0x features not supported by any versions
 #define BOOST_NO_CHAR16_T
 #define BOOST_NO_CHAR32_T
 #define BOOST_NO_CONSTEXPR
 #define BOOST_NO_DECLTYPE_N3276
 #define BOOST_NO_DEFAULTED_FUNCTIONS
 #define BOOST_NO_DELETED_FUNCTIONS
 #define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
 #define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
 #define BOOST_NO_INITIALIZER_LISTS
 #define BOOST_NO_NOEXCEPT
 #define BOOST_NO_RAW_LITERALS
 #define BOOST_NO_SCOPED_ENUMS
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
 #define BOOST_NO_SFINAE_EXPR
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
 //
 // prefix and suffix headers:
 //
 #ifndef BOOST_ABI_PREFIX
 #  define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp"
 #endif
 #ifndef BOOST_ABI_SUFFIX
 #  define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp"
 #endif
 // TODO:
 // these things are mostly bogus. 1200 means version 12.0 of the compiler. The 
 // artificial versions assigned to them only refer to the versions of some IDE
 // these compilers have been shipped with, and even that is not all of it. Some
 // were shipped with freely downloadable SDKs, others as crosscompilers in eVC.
 // IOW, you can't use these 'versions' in any sensible way. Sorry.
 # if defined(UNDER_CE)
 #   if _MSC_VER < 1200
      // Note: these are so far off, they are not really supported
 #   elif _MSC_VER < 1300 // eVC++ 4 comes with 1200-1202
 #     define BOOST_COMPILER_VERSION evc4.0
 #   elif _MSC_VER == 1400
 #     define BOOST_COMPILER_VERSION evc8
 #   elif _MSC_VER == 1500
 #     define BOOST_COMPILER_VERSION evc9
 #   elif _MSC_VER == 1600
 #     define BOOST_COMPILER_VERSION evc10
 #   else
 #      if defined(BOOST_ASSERT_CONFIG)
 #         error "Unknown EVC++ compiler version - please run the configure tests and report the results"
 #      else
 #         pragma message("Unknown EVC++ compiler version - please run the configure tests and report the results")
 #      endif
 #   endif
 # else
 #   if _MSC_VER < 1200
      // Note: these are so far off, they are not really supported
 #     define BOOST_COMPILER_VERSION 5.0
 #   elif _MSC_VER < 1300
 #       define BOOST_COMPILER_VERSION 6.0
 #   elif _MSC_VER == 1300
 #     define BOOST_COMPILER_VERSION 7.0
 #   elif _MSC_VER == 1310
 #     define BOOST_COMPILER_VERSION 7.1
 #   elif _MSC_VER == 1400
 #     define BOOST_COMPILER_VERSION 8.0
 #   elif _MSC_VER == 1500
 #     define BOOST_COMPILER_VERSION 9.0
 #   elif _MSC_VER == 1600
 #     define BOOST_COMPILER_VERSION 10.0
 #   else
 #     define BOOST_COMPILER_VERSION _MSC_VER
 #   endif
 # endif
 #define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
 //
 // versions check:
 // we don't support Visual C++ prior to version 6:
 #if _MSC_VER < 1200
 #error "Compiler not supported or configured - please reconfigure"
 #endif
 //
 // last known and checked version is 1600 (VC10, aka 2010):
 #if (_MSC_VER > 1600)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  else
 #     pragma message("Unknown compiler version - please run the configure tests and report the results")
 #  endif
 #endif
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2008.
 //  Use, modification and distribution are subject to 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)
 //
 // The aim of this header is just to include <cmath> but to do
 // so in a way that does not result in recursive inclusion of
 // the Boost TR1 components if boost/tr1/tr1/cmath is in the
 // include search path.  We have to do this to avoid circular
 // dependencies:
 //
 #ifndef BOOST_CONFIG_CMATH
 #  define BOOST_CONFIG_CMATH
 #  ifndef BOOST_TR1_NO_RECURSION
 #     define BOOST_TR1_NO_RECURSION
 #     define BOOST_CONFIG_NO_CMATH_RECURSION
 #  endif
 #  include <cmath>
 #  ifdef BOOST_CONFIG_NO_CMATH_RECURSION
 #     undef BOOST_TR1_NO_RECURSION
 #     undef BOOST_CONFIG_NO_CMATH_RECURSION
 #  endif
 #endif
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2005.
 //  Use, modification and distribution are subject to 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)
 //
 // The aim of this header is just to include <complex> but to do
 // so in a way that does not result in recursive inclusion of
 // the Boost TR1 components if boost/tr1/tr1/complex is in the
 // include search path.  We have to do this to avoid circular
 // dependencies:
 //
 #ifndef BOOST_CONFIG_COMPLEX
 #  define BOOST_CONFIG_COMPLEX
 #  ifndef BOOST_TR1_NO_RECURSION
 #     define BOOST_TR1_NO_RECURSION
 #     define BOOST_CONFIG_NO_COMPLEX_RECURSION
 #  endif
 #  include <complex>
 #  ifdef BOOST_CONFIG_NO_COMPLEX_RECURSION
 #     undef BOOST_TR1_NO_RECURSION
 #     undef BOOST_CONFIG_NO_COMPLEX_RECURSION
 #  endif
 #endif
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2005.
 //  Use, modification and distribution are subject to 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)
 //
 // The aim of this header is just to include <functional> but to do
 // so in a way that does not result in recursive inclusion of
 // the Boost TR1 components if boost/tr1/tr1/functional is in the
 // include search path.  We have to do this to avoid circular
 // dependencies:
 //
 #ifndef BOOST_CONFIG_FUNCTIONAL
 #  define BOOST_CONFIG_FUNCTIONAL
 #  ifndef BOOST_TR1_NO_RECURSION
 #     define BOOST_TR1_NO_RECURSION
 #     define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
 #  endif
 #  include <functional>
 #  ifdef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
 #     undef BOOST_TR1_NO_RECURSION
 #     undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
 #  endif
 #endif
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2005.
 //  Use, modification and distribution are subject to 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)
 //
 // The aim of this header is just to include <memory> but to do
 // so in a way that does not result in recursive inclusion of
 // the Boost TR1 components if boost/tr1/tr1/memory is in the
 // include search path.  We have to do this to avoid circular
 // dependencies:
 //
 #ifndef BOOST_CONFIG_MEMORY
 #  define BOOST_CONFIG_MEMORY
 #  ifndef BOOST_TR1_NO_RECURSION
 #     define BOOST_TR1_NO_RECURSION
 #     define BOOST_CONFIG_NO_MEMORY_RECURSION
 #  endif
 #  include <memory>
 #  ifdef BOOST_CONFIG_NO_MEMORY_RECURSION
 #     undef BOOST_TR1_NO_RECURSION
 #     undef BOOST_CONFIG_NO_MEMORY_RECURSION
 #  endif
 #endif
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2005.
 //  Use, modification and distribution are subject to 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)
 //
 // The aim of this header is just to include <utility> but to do
 // so in a way that does not result in recursive inclusion of
 // the Boost TR1 components if boost/tr1/tr1/utility is in the
 // include search path.  We have to do this to avoid circular
 // dependencies:
 //
 #ifndef BOOST_CONFIG_UTILITY
 #  define BOOST_CONFIG_UTILITY
 #  ifndef BOOST_TR1_NO_RECURSION
 #     define BOOST_TR1_NO_RECURSION
 #     define BOOST_CONFIG_NO_UTILITY_RECURSION
 #  endif
 #  include <utility>
 #  ifdef BOOST_CONFIG_NO_UTILITY_RECURSION
 #     undef BOOST_TR1_NO_RECURSION
 #     undef BOOST_CONFIG_NO_UTILITY_RECURSION
 #  endif
 #endif
@@ -0,0 +1,33 @@
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  IBM/Aix specific config options:
 #define BOOST_PLATFORM "IBM Aix"
 #define BOOST_HAS_UNISTD_H
 #define BOOST_HAS_NL_TYPES_H
 #define BOOST_HAS_NANOSLEEP
 #define BOOST_HAS_CLOCK_GETTIME
 // This needs support in "boost/cstdint.hpp" exactly like FreeBSD.
 // This platform has header named <inttypes.h> which includes all
 // the things needed.
 #define BOOST_HAS_STDINT_H
 // Threading API's:
 #define BOOST_HAS_PTHREADS
 #define BOOST_HAS_PTHREAD_DELAY_NP
 #define BOOST_HAS_SCHED_YIELD
 //#define BOOST_HAS_PTHREAD_YIELD
 // boilerplate code:
 #include <boost/config/posix_features.hpp>
@@ -0,0 +1,15 @@
 //  (C) Copyright John Maddock 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 #define BOOST_PLATFORM "AmigaOS"
 #define BOOST_DISABLE_THREADS
 #define BOOST_NO_CWCHAR
 #define BOOST_NO_STD_WSTRING
 #define BOOST_NO_INTRINSIC_WCHAR_T
@@ -0,0 +1,26 @@
 //  (C) Copyright John Maddock 2001. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  BeOS specific config options:
 #define BOOST_PLATFORM "BeOS"
 #define BOOST_NO_CWCHAR
 #define BOOST_NO_CWCTYPE
 #define BOOST_HAS_UNISTD_H
 #define BOOST_HAS_BETHREADS
 #ifndef BOOST_DISABLE_THREADS
 #  define BOOST_HAS_THREADS
 #endif
 // boilerplate code:
 #include <boost/config/posix_features.hpp>
@@ -0,0 +1,86 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Darin Adler 2001. 
 //  (C) Copyright Douglas Gregor 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  generic BSD config options:
 #if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
 #error "This platform is not BSD"
 #endif
 #ifdef __FreeBSD__
 #define BOOST_PLATFORM "FreeBSD " BOOST_STRINGIZE(__FreeBSD__)
 #elif defined(__NetBSD__)
 #define BOOST_PLATFORM "NetBSD " BOOST_STRINGIZE(__NetBSD__)
 #elif defined(__OpenBSD__)
 #define BOOST_PLATFORM "OpenBSD " BOOST_STRINGIZE(__OpenBSD__)
 #elif defined(__DragonFly__)
 #define BOOST_PLATFORM "DragonFly " BOOST_STRINGIZE(__DragonFly__)
 #endif
 //
 // is this the correct version check?
 // FreeBSD has <nl_types.h> but does not
 // advertise the fact in <unistd.h>:
 //
 #if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) || defined(__DragonFly__)
 #  define BOOST_HAS_NL_TYPES_H
 #endif
 //
 // FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in <pthread.h>
 // and not in <unistd.h>
 //
 #if (defined(__FreeBSD__) && (__FreeBSD__ <= 3))\
   || defined(__OpenBSD__) || defined(__DragonFly__) 
 #  define BOOST_HAS_PTHREADS
 #endif
 //
 // No wide character support in the BSD header files:
 //
 #if defined(__NetBSD__)
 #define __NetBSD_GCC__ (__GNUC__         * 1000000 \
                       + __GNUC_MINOR__ *    1000 \
                       + __GNUC_PATCHLEVEL__)
 // XXX - the following is required until c++config.h
 //       defines _GLIBCXX_HAVE_SWPRINTF and friends
 //       or the preprocessor conditionals are removed
 //       from the cwchar header.
 #define _GLIBCXX_HAVE_SWPRINTF 1
 #endif
 #if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
      || (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) || defined(__DragonFly__))
 #  define BOOST_NO_CWCHAR
 #endif
 //
 // The BSD <ctype.h> has macros only, no functions:
 //
 #if !defined(__OpenBSD__) || defined(__DragonFly__)
 #  define BOOST_NO_CTYPE_FUNCTIONS
 #endif
 //
 // thread API's not auto detected:
 //
 #define BOOST_HAS_SCHED_YIELD
 #define BOOST_HAS_NANOSLEEP
 #define BOOST_HAS_GETTIMEOFDAY
 #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #define BOOST_HAS_SIGACTION
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
@@ -0,0 +1,18 @@
 //  (C) Copyright John Maddock 2011.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  SGI Irix specific config options:
 #define BOOST_PLATFORM "Cray"
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
@@ -0,0 +1,58 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  cygwin specific config options:
 #define BOOST_PLATFORM "Cygwin"
 #define BOOST_HAS_DIRENT_H
 #define BOOST_HAS_LOG1P
 #define BOOST_HAS_EXPM1
 //
 // Threading API:
 // See if we have POSIX threads, if we do use them, otherwise
 // revert to native Win threads.
 #define BOOST_HAS_UNISTD_H
 #include <unistd.h>
 #if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS)
 #  define BOOST_HAS_PTHREADS
 #  define BOOST_HAS_SCHED_YIELD
 #  define BOOST_HAS_GETTIMEOFDAY
 #  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #  define BOOST_HAS_SIGACTION
 #else
 #  if !defined(BOOST_HAS_WINTHREADS)
 #     define BOOST_HAS_WINTHREADS
 #  endif
 #  define BOOST_HAS_FTIME
 #endif
 //
 // find out if we have a stdint.h, there should be a better way to do this:
 //
 #include <sys/types.h>
 #ifdef _STDINT_H
 #define BOOST_HAS_STDINT_H
 #endif
 /// Cygwin has no fenv.h
 #define BOOST_NO_FENV_H
 // boilerplate code:
 #include <boost/config/posix_features.hpp>
 //
 // Cygwin lies about XSI conformance, there is no nl_types.h:
 //
 #ifdef BOOST_HAS_NL_TYPES_H
 #  undef BOOST_HAS_NL_TYPES_H
 #endif
@@ -0,0 +1,87 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2001 - 2003. 
 //  (C) Copyright David Abrahams 2002. 
 //  (C) Copyright Toon Knapen 2003. 
 //  (C) Copyright Boris Gubenko 2006 - 2007.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  hpux specific config options:
 #define BOOST_PLATFORM "HP-UX"
 // In principle, HP-UX has a nice <stdint.h> under the name <inttypes.h>
 // However, it has the following problem:
 // Use of UINT32_C(0) results in "0u l" for the preprocessed source
 // (verifyable with gcc 2.95.3)
 #if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__HP_aCC)
 #  define BOOST_HAS_STDINT_H
 #endif
 #if !(defined(__HP_aCC) || !defined(_INCLUDE__STDC_A1_SOURCE))
 #  define BOOST_NO_SWPRINTF
 #endif
 #if defined(__HP_aCC) && !defined(_INCLUDE__STDC_A1_SOURCE)
 #  define BOOST_NO_CWCTYPE
 #endif
 #if defined(__GNUC__)
 #  if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))
      // GNU C on HP-UX does not support threads (checked up to gcc 3.3)
 #     define BOOST_DISABLE_THREADS
 #  elif !defined(BOOST_DISABLE_THREADS)
      // threads supported from gcc-3.3 onwards:
 #     define BOOST_HAS_THREADS
 #     define BOOST_HAS_PTHREADS
 #  endif
 #elif defined(__HP_aCC) && !defined(BOOST_DISABLE_THREADS)
 #  define BOOST_HAS_PTHREADS
 #endif
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
 // the following are always available:
 #ifndef BOOST_HAS_GETTIMEOFDAY
 #  define BOOST_HAS_GETTIMEOFDAY
 #endif
 #ifndef BOOST_HAS_SCHED_YIELD
 #    define BOOST_HAS_SCHED_YIELD
 #endif
 #ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #endif
 #ifndef BOOST_HAS_NL_TYPES_H
 #    define BOOST_HAS_NL_TYPES_H
 #endif
 #ifndef BOOST_HAS_NANOSLEEP
 #    define BOOST_HAS_NANOSLEEP
 #endif
 #ifndef BOOST_HAS_GETTIMEOFDAY
 #    define BOOST_HAS_GETTIMEOFDAY
 #endif
 #ifndef BOOST_HAS_DIRENT_H
 #    define BOOST_HAS_DIRENT_H
 #endif
 #ifndef BOOST_HAS_CLOCK_GETTIME
 #    define BOOST_HAS_CLOCK_GETTIME
 #endif
 #ifndef BOOST_HAS_SIGACTION
 #  define BOOST_HAS_SIGACTION
 #endif
 #ifndef BOOST_HAS_NRVO 
 #  ifndef __parisc
 #    define BOOST_HAS_NRVO
 #  endif
 #endif
 #ifndef BOOST_HAS_LOG1P 
 #  define BOOST_HAS_LOG1P
 #endif
 #ifndef BOOST_HAS_EXPM1
 #  define BOOST_HAS_EXPM1
 #endif
@@ -0,0 +1,31 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  SGI Irix specific config options:
 #define BOOST_PLATFORM "SGI Irix"
 #define BOOST_NO_SWPRINTF 
 //
 // these are not auto detected by POSIX feature tests:
 //
 #define BOOST_HAS_GETTIMEOFDAY
 #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #ifdef __GNUC__
   // GNU C on IRIX does not support threads (checked up to gcc 3.3)
 #  define BOOST_DISABLE_THREADS
 #endif
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
@@ -0,0 +1,103 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2001 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  linux specific config options:
 #define BOOST_PLATFORM "linux"
 // make sure we have __GLIBC_PREREQ if available at all
 #ifdef __cplusplus
 #include <cstdlib>
 #else
 #include <stdlib.h>
 #endif
 //
 // <stdint.h> added to glibc 2.1.1
 // We can only test for 2.1 though:
 //
 #if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1)))
   // <stdint.h> defines int64_t unconditionally, but <sys/types.h> defines
   // int64_t only if __GNUC__.  Thus, assume a fully usable <stdint.h>
   // only when using GCC.
 #  if defined __GNUC__
 #    define BOOST_HAS_STDINT_H
 #  endif
 #endif
 #if defined(__LIBCOMO__)
   //
   // como on linux doesn't have std:: c functions:
   // NOTE: versions of libcomo prior to beta28 have octal version numbering,
   // e.g. version 25 is 21 (dec)
   //
 #  if __LIBCOMO_VERSION__ <= 20
 #    define BOOST_NO_STDC_NAMESPACE
 #  endif
 #  if __LIBCOMO_VERSION__ <= 21
 #    define BOOST_NO_SWPRINTF
 #  endif
 #endif
 //
 // If glibc is past version 2 then we definitely have
 // gettimeofday, earlier versions may or may not have it:
 //
 #if defined(__GLIBC__) && (__GLIBC__ >= 2)
 #  define BOOST_HAS_GETTIMEOFDAY
 #endif
 #ifdef __USE_POSIX199309
 #  define BOOST_HAS_NANOSLEEP
 #endif
 #if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
 // __GLIBC_PREREQ is available since 2.1.2
   // swprintf is available since glibc 2.2.0
 #  if !__GLIBC_PREREQ(2,2) || (!defined(__USE_ISOC99) && !defined(__USE_UNIX98))
 #    define BOOST_NO_SWPRINTF
 #  endif
 #else
 #  define BOOST_NO_SWPRINTF
 #endif
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
 #define BOOST_HAS_PTHREAD_YIELD
 #ifndef __GNUC__
 //
 // if the compiler is not gcc we still need to be able to parse
 // the GNU system headers, some of which (mainly <stdint.h>)
 // use GNU specific extensions:
 //
 #  ifndef __extension__
 #     define __extension__
 #  endif
 #  ifndef __const__
 #     define __const__ const
 #  endif
 #  ifndef __volatile__
 #     define __volatile__ volatile
 #  endif
 #  ifndef __signed__
 #     define __signed__ signed
 #  endif
 #  ifndef __typeof__
 #     define __typeof__ typeof
 #  endif
 #  ifndef __inline__
 #     define __inline__ inline
 #  endif
 #endif
@@ -0,0 +1,87 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Darin Adler 2001 - 2002. 
 //  (C) Copyright Bill Kempf 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Mac OS specific config options:
 #define BOOST_PLATFORM "Mac OS"
 #if __MACH__ && !defined(_MSL_USING_MSL_C)
 // Using the Mac OS X system BSD-style C library.
 #  ifndef BOOST_HAS_UNISTD_H
 #    define BOOST_HAS_UNISTD_H
 #  endif
 //
 // Begin by including our boilerplate code for POSIX
 // feature detection, this is safe even when using
 // the MSL as Metrowerks supply their own <unistd.h>
 // to replace the platform-native BSD one. G++ users
 // should also always be able to do this on MaxOS X.
 //
 #  include <boost/config/posix_features.hpp>
 #  ifndef BOOST_HAS_STDINT_H
 #     define BOOST_HAS_STDINT_H
 #  endif
 //
 // BSD runtime has pthreads, sigaction, sched_yield and gettimeofday,
 // of these only pthreads are advertised in <unistd.h>, so set the 
 // other options explicitly:
 //
 #  define BOOST_HAS_SCHED_YIELD
 #  define BOOST_HAS_GETTIMEOFDAY
 #  define BOOST_HAS_SIGACTION
 #  if (__GNUC__ < 3) && !defined( __APPLE_CC__)
 // GCC strange "ignore std" mode works better if you pretend everything
 // is in the std namespace, for the most part.
 #    define BOOST_NO_STDC_NAMESPACE
 #  endif
 #  if (__GNUC__ == 4)
 // Both gcc and intel require these.  
 #    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #    define BOOST_HAS_NANOSLEEP
 #  endif
 #else
 // Using the MSL C library.
 // We will eventually support threads in non-Carbon builds, but we do
 // not support this yet.
 #  if ( defined(TARGET_API_MAC_CARBON) && TARGET_API_MAC_CARBON ) || ( defined(TARGET_CARBON) && TARGET_CARBON )
 #  if !defined(BOOST_HAS_PTHREADS)
 // MPTasks support is deprecated/removed from Boost:
 //#    define BOOST_HAS_MPTASKS
 #  elif ( __dest_os == __mac_os_x )
 // We are doing a Carbon/Mach-O/MSL build which has pthreads, but only the
 // gettimeofday and no posix.
 #  define BOOST_HAS_GETTIMEOFDAY
 #  endif
 #ifdef BOOST_HAS_PTHREADS
 #  define BOOST_HAS_THREADS
 #endif
 // The remote call manager depends on this.
 #    define BOOST_BIND_ENABLE_PASCAL
 #  endif
 #endif
@@ -0,0 +1,31 @@
 //  (C) Copyright Jim Douglas 2005. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  QNX specific config options:
 #define BOOST_PLATFORM "QNX"
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
 // QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h
 // or log1p and expm1:
 #undef  BOOST_HAS_NL_TYPES_H
 #undef  BOOST_HAS_LOG1P
 #undef  BOOST_HAS_EXPM1
 #define BOOST_HAS_PTHREADS
 #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #define BOOST_HAS_GETTIMEOFDAY
 #define BOOST_HAS_CLOCK_GETTIME
 #define BOOST_HAS_NANOSLEEP
@@ -0,0 +1,28 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  sun specific config options:
 #define BOOST_PLATFORM "Sun Solaris"
 #define BOOST_HAS_GETTIMEOFDAY
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
 #include <boost/config/posix_features.hpp>
 //
 // pthreads don't actually work with gcc unless _PTHREADS is defined:
 //
 #if defined(__GNUC__) && defined(_POSIX_THREADS) && !defined(_PTHREADS)
 # undef BOOST_HAS_PTHREADS
 #endif
@@ -0,0 +1,97 @@
 //  (C) Copyright Yuriy Krasnoschek 2009. 
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2001 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  symbian specific config options:
 #define BOOST_PLATFORM "Symbian"
 #define BOOST_SYMBIAN 1
 #if defined(__S60_3X__)
 // Open C / C++ plugin was introdused in this SDK, earlier versions don't have CRT / STL
 #  define BOOST_S60_3rd_EDITION_FP2_OR_LATER_SDK
 // make sure we have __GLIBC_PREREQ if available at all
 #ifdef __cplusplus
 #include <cstdlib>
 #else
 #include <stdlib.h>
 #endif// boilerplate code:
 #  define BOOST_HAS_UNISTD_H
 #  include <boost/config/posix_features.hpp>
 // S60 SDK defines _POSIX_VERSION as POSIX.1
 #  ifndef BOOST_HAS_STDINT_H
 #    define BOOST_HAS_STDINT_H
 #  endif
 #  ifndef BOOST_HAS_GETTIMEOFDAY
 #    define BOOST_HAS_GETTIMEOFDAY
 #  endif
 #  ifndef BOOST_HAS_DIRENT_H
 #    define BOOST_HAS_DIRENT_H
 #  endif
 #  ifndef BOOST_HAS_SIGACTION
 #    define BOOST_HAS_SIGACTION
 #  endif
 #  ifndef BOOST_HAS_PTHREADS
 #    define BOOST_HAS_PTHREADS
 #  endif
 #  ifndef BOOST_HAS_NANOSLEEP
 #    define BOOST_HAS_NANOSLEEP
 #  endif
 #  ifndef BOOST_HAS_SCHED_YIELD
 #    define BOOST_HAS_SCHED_YIELD
 #  endif
 #  ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #  endif
 #  ifndef BOOST_HAS_LOG1P
 #    define BOOST_HAS_LOG1P
 #  endif
 #  ifndef BOOST_HAS_EXPM1
 #    define BOOST_HAS_EXPM1
 #  endif
 #  ifndef BOOST_POSIX_API
 #    define BOOST_POSIX_API
 #  endif
 // endianess support
 #  include <sys/endian.h>
 // Symbian SDK provides _BYTE_ORDER instead of __BYTE_ORDER
 #  ifndef __LITTLE_ENDIAN
 #    ifdef _LITTLE_ENDIAN
 #      define __LITTLE_ENDIAN _LITTLE_ENDIAN
 #    else
 #      define __LITTLE_ENDIAN 1234
 #    endif
 #  endif
 #  ifndef __BIG_ENDIAN
 #    ifdef _BIG_ENDIAN
 #      define __BIG_ENDIAN _BIG_ENDIAN
 #    else
 #      define __BIG_ENDIAN 4321
 #    endif
 #  endif
 #  ifndef __BYTE_ORDER
 #    define __BYTE_ORDER __LITTLE_ENDIAN // Symbian is LE
 #  endif
 // Known limitations
 #  define BOOST_ASIO_DISABLE_SERIAL_PORT
 #  define BOOST_DATE_TIME_NO_LOCALE
 #  define BOOST_NO_STD_WSTRING
 #  define BOOST_EXCEPTION_DISABLE
 #  define BOOST_NO_EXCEPTIONS
 #else // TODO: More platform support e.g. UIQ
 #  error "Unsuppoted Symbian SDK"
 #endif
 #if defined(__WINSCW__) && !defined(BOOST_DISABLE_WIN32)
 #  define BOOST_DISABLE_WIN32 // winscw defines WIN32 macro
 #endif
@@ -0,0 +1,25 @@
 //  (C) Copyright Artyom Beilis 2010.  
 //  Use, modification and distribution are subject to 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) 
 #ifndef BOOST_CONFIG_PLATFORM_VMS_HPP 
 #define BOOST_CONFIG_PLATFORM_VMS_HPP 
 #define BOOST_PLATFORM "OpenVMS" 
 #undef  BOOST_HAS_STDINT_H 
 #define BOOST_HAS_UNISTD_H 
 #define BOOST_HAS_NL_TYPES_H 
 #define BOOST_HAS_GETTIMEOFDAY 
 #define BOOST_HAS_DIRENT_H 
 #define BOOST_HAS_PTHREADS 
 #define BOOST_HAS_NANOSLEEP 
 #define BOOST_HAS_CLOCK_GETTIME 
 #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 
 #define BOOST_HAS_LOG1P 
 #define BOOST_HAS_EXPM1 
 #define BOOST_HAS_THREADS 
 #undef  BOOST_HAS_SCHED_YIELD 
 #endif 
@@ -0,0 +1,31 @@
 //  (C) Copyright Dustin Spicuzza 2009. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  vxWorks specific config options:
 #define BOOST_PLATFORM "vxWorks"
 #define BOOST_NO_CWCHAR
 #define BOOST_NO_INTRINSIC_WCHAR_T
 #if defined(__GNUC__) && defined(__STRICT_ANSI__)
 #define BOOST_NO_INT64_T
 #endif
 #define BOOST_HAS_UNISTD_H
 // these allow posix_features to work, since vxWorks doesn't
 // define them itself
 #define _POSIX_TIMERS 1
 #define _POSIX_THREADS 1
 // vxworks doesn't work with asio serial ports
 #define BOOST_ASIO_DISABLE_SERIAL_PORT
 // boilerplate code:
 #include <boost/config/posix_features.hpp>
@@ -0,0 +1,71 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Bill Kempf 2001. 
 //  (C) Copyright Aleksey Gurtovoy 2003. 
 //  (C) Copyright Rene Rivera 2005.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Win32 specific config options:
 #define BOOST_PLATFORM "Win32"
 //  Get the information about the MinGW runtime, i.e. __MINGW32_*VERSION.
 #if defined(__MINGW32__)
 #  include <_mingw.h>
 #endif
 #if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF)
 #  define BOOST_NO_SWPRINTF
 #endif
 //  Default defines for BOOST_SYMBOL_EXPORT and BOOST_SYMBOL_IMPORT
 //  If a compiler doesn't support __declspec(dllexport)/__declspec(dllimport),
 //  its boost/config/compiler/ file must define BOOST_SYMBOL_EXPORT and
 //  BOOST_SYMBOL_IMPORT
 #ifndef BOOST_SYMBOL_EXPORT
 #  define BOOST_HAS_DECLSPEC
 #  define BOOST_SYMBOL_EXPORT __declspec(dllexport)
 #  define BOOST_SYMBOL_IMPORT __declspec(dllimport)
 #endif
 #if defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 2) || ((__MINGW32_MAJOR_VERSION == 2) && (__MINGW32_MINOR_VERSION >= 0)))
 #  define BOOST_HAS_STDINT_H
 #  define __STDC_LIMIT_MACROS
 #  define BOOST_HAS_DIRENT_H
 #  define BOOST_HAS_UNISTD_H
 #endif
 #if defined(__MINGW32__) && (__GNUC__ >= 4)
 #  define BOOST_HAS_EXPM1
 #  define BOOST_HAS_LOG1P
 #  define BOOST_HAS_GETTIMEOFDAY
 #endif
 //
 // Win32 will normally be using native Win32 threads,
 // but there is a pthread library avaliable as an option,
 // we used to disable this when BOOST_DISABLE_WIN32 was 
 // defined but no longer - this should allow some
 // files to be compiled in strict mode - while maintaining
 // a consistent setting of BOOST_HAS_THREADS across
 // all translation units (needed for shared_ptr etc).
 //
 #ifdef _WIN32_WCE
 #  define BOOST_NO_ANSI_APIS
 #else
 #  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
 #endif
 #ifndef BOOST_HAS_PTHREADS
 #  define BOOST_HAS_WINTHREADS
 #endif
 #ifndef BOOST_DISABLE_WIN32
 // WEK: Added
 #define BOOST_HAS_FTIME
 #define BOOST_WINDOWS 1
 #endif
@@ -0,0 +1,95 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 // All POSIX feature tests go in this file,
 // Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well
 // _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's
 // may be present but none-functional unless _POSIX_C_SOURCE and
 // _XOPEN_SOURCE have been defined to the right value (it's up
 // to the user to do this *before* including any header, although
 // in most cases the compiler will do this for you).
 #  if defined(BOOST_HAS_UNISTD_H)
 #     include <unistd.h>
      // XOpen has <nl_types.h>, but is this the correct version check?
 #     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3)
 #        define BOOST_HAS_NL_TYPES_H
 #     endif
      // POSIX version 6 requires <stdint.h>
 #     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100)
 #        define BOOST_HAS_STDINT_H
 #     endif
      // POSIX version 2 requires <dirent.h>
 #     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L)
 #        define BOOST_HAS_DIRENT_H
 #     endif
      // POSIX version 3 requires <signal.h> to have sigaction:
 #     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L)
 #        define BOOST_HAS_SIGACTION
 #     endif
      // POSIX defines _POSIX_THREADS > 0 for pthread support,
      // however some platforms define _POSIX_THREADS without
      // a value, hence the (_POSIX_THREADS+0 >= 0) check.
      // Strictly speaking this may catch platforms with a
      // non-functioning stub <pthreads.h>, but such occurrences should
      // occur very rarely if at all.
 #     if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS)
 #        define BOOST_HAS_PTHREADS
 #     endif
      // BOOST_HAS_NANOSLEEP:
      // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME:
 #     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \
             || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
 #        define BOOST_HAS_NANOSLEEP
 #     endif
      // BOOST_HAS_CLOCK_GETTIME:
      // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME
      // but at least one platform - linux - defines that flag without
      // defining clock_gettime):
 #     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0))
 #        define BOOST_HAS_CLOCK_GETTIME
 #     endif
      // BOOST_HAS_SCHED_YIELD:
      // This is predicated on _POSIX_PRIORITY_SCHEDULING or
      // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME.
 #     if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\
            || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\
            || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
 #        define BOOST_HAS_SCHED_YIELD
 #     endif
      // BOOST_HAS_GETTIMEOFDAY:
      // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE:
      // These are predicated on _XOPEN_VERSION, and appears to be first released
      // in issue 4, version 2 (_XOPEN_VERSION > 500).
      // Likewise for the functions log1p and expm1.
 #     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500)
 #        define BOOST_HAS_GETTIMEOFDAY
 #        if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE+0 >= 500)
 #           define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #        endif
 #        ifndef BOOST_HAS_LOG1P
 #           define BOOST_HAS_LOG1P
 #        endif
 #        ifndef BOOST_HAS_EXPM1
 #           define BOOST_HAS_EXPM1
 #        endif
 #     endif
 #  endif
@@ -0,0 +1,92 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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)
 #ifndef BOOST_CONFIG_REQUIRES_THREADS_HPP
 #define BOOST_CONFIG_REQUIRES_THREADS_HPP
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
 #endif
 #if defined(BOOST_DISABLE_THREADS)
 //
 // special case to handle versions of gcc which don't currently support threads:
 //
 #if defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC_MINOR__ <= 3) || !defined(BOOST_STRICT_CONFIG))
 //
 // this is checked up to gcc 3.3:
 //
 #if defined(__sgi) || defined(__hpux)
 #  error "Multi-threaded programs are not supported by gcc on HPUX or Irix (last checked with gcc 3.3)"
 #endif
 #endif
 #  error "Threading support unavaliable: it has been explicitly disabled with BOOST_DISABLE_THREADS"
 #elif !defined(BOOST_HAS_THREADS)
 # if defined __COMO__
 //  Comeau C++
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_MT (Windows) or -D_REENTRANT (Unix)"
 #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
 //  Intel
 #ifdef _WIN32
 #  error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd"
 #else
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -openmp"
 #endif
 # elif defined __GNUC__
 //  GNU C++:
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)"
 #elif defined __sgi
 //  SGI MIPSpro C++
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_SGI_MP_SOURCE"
 #elif defined __DECCXX
 //  Compaq Tru64 Unix cxx
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread"
 #elif defined __BORLANDC__
 //  Borland
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -tWM"
 #elif defined  __MWERKS__
 //  Metrowerks CodeWarrior
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: either -runtime sm, -runtime smd, -runtime dm, or -runtime dmd"
 #elif defined  __SUNPRO_CC
 //  Sun Workshop Compiler C++
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt"
 #elif defined __HP_aCC
 //  HP aCC
 #   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt"
 #elif defined(__IBMCPP__)
 //  IBM Visual Age
 #   error "Compiler threading support is not turned on. Please compile the code with the xlC_r compiler"
 #elif defined _MSC_VER
 //  Microsoft Visual C++
 //
 //  Must remain the last #elif since some other vendors (Metrowerks, for
 //  example) also #define _MSC_VER
 #  error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd"
 #else
 #  error "Compiler threading support is not turned on.  Please consult your compiler's documentation for the appropriate options to use"
 #endif // compilers
 #endif // BOOST_HAS_THREADS
 #endif // BOOST_CONFIG_REQUIRES_THREADS_HPP
@@ -0,0 +1,112 @@
 //  Boost compiler configuration selection header file
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Martin Wille 2003.
 //  (C) Copyright Guillaume Melquiond 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 most recent version.
 // locate which compiler we are using and define
 // BOOST_COMPILER_CONFIG as needed: 
 #if defined(__GCCXML__)
 // GCC-XML emulates other compilers, it has to appear first here!
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc_xml.hpp"
 #elif defined(_CRAYC)
 // EDG based Cray compiler:
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/cray.hpp"
 #elif defined __CUDACC__
 //  NVIDIA CUDA C++ compiler for GPU
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/nvcc.hpp"
 #elif defined __COMO__
 //  Comeau C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp"
 #elif defined(__PATHSCALE__) && (__PATHCC__ >= 4)
 // PathScale EKOPath compiler (has to come before clang and gcc)
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/pathscale.hpp"
 #elif defined __clang__
 //  Clang C++ emulates GCC, so it has to appear early.
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp"
 #elif defined __DMC__
 //  Digital Mars C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp"
 #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
 //  Intel
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"
 # elif defined __GNUC__
 //  GNU C++:
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
 #elif defined __KCC
 //  Kai C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp"
 #elif defined __sgi
 //  SGI MIPSpro C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp"
 #elif defined __DECCXX
 //  Compaq Tru64 Unix cxx
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp"
 #elif defined __ghs
 //  Greenhills C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp"
 #elif defined __CODEGEARC__
 //  CodeGear - must be checked for before Borland
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/codegear.hpp"
 #elif defined __BORLANDC__
 //  Borland
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp"
 #elif defined  __MWERKS__
 //  Metrowerks CodeWarrior
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp"
 #elif defined  __SUNPRO_CC
 //  Sun Workshop Compiler C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp"
 #elif defined __HP_aCC
 //  HP aCC
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp"
 #elif defined(__MRC__) || defined(__SC__)
 //  MPW MrCpp or SCpp
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp"
 #elif defined(__IBMCPP__)
 //  IBM Visual Age
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp"
 #elif defined(__PGI)
 //  Portland Group Inc.
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp"
 #elif defined _MSC_VER
 //  Microsoft Visual C++
 //
 //  Must remain the last #elif since some other vendors (Metrowerks, for
 //  example) also #define _MSC_VER
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp"
 #elif defined (BOOST_ASSERT_CONFIG)
 // this must come last - generate an error if we don't
 // recognise the compiler:
 #  error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)"
 #endif
@@ -0,0 +1,105 @@
 //  Boost compiler configuration selection header file
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  (C) Copyright Jens Maurer 2001. 
 //  Use, modification and distribution are subject to 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 most recent version.
 // locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed.
 // Note that we define the headers to include using "header_name" not
 // <header_name> in order to prevent macro expansion within the header
 // name (for example "linux" is a macro on linux systems).
 #if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
 // linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though?
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
 #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
 // BSD:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp"
 #elif defined(sun) || defined(__sun)
 // solaris:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp"
 #elif defined(__sgi)
 // SGI Irix:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp"
 #elif defined(__hpux)
 // hp unix:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp"
 #elif defined(__CYGWIN__)
 // cygwin is not win32:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp"
 #elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
 // win32:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"
 #elif defined(__BEOS__)
 // BeOS
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"
 #elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
 // MacOS
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"
 #elif defined(__IBMCPP__) || defined(_AIX)
 // IBM
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"
 #elif defined(__amigaos__)
 // AmigaOS
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp"
 #elif defined(__QNXNTO__)
 // QNX:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp"
 #elif defined(__VXWORKS__)
 // vxWorks:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/vxworks.hpp"
 #elif defined(__SYMBIAN32__) 
 // Symbian: 
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" 
 #elif defined(_CRAYC)
 // Cray:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/cray.hpp" 
 #elif defined(__VMS) 
 // VMS:
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 
 #else
 #  if defined(unix) \
      || defined(__unix) \
      || defined(_XOPEN_SOURCE) \
      || defined(_POSIX_SOURCE)
   // generic unix platform:
 #  ifndef BOOST_HAS_UNISTD_H
 #     define BOOST_HAS_UNISTD_H
 #  endif
 #  include <boost/config/posix_features.hpp>
 #  endif
 #  if defined (BOOST_ASSERT_CONFIG)
      // this must come last - generate an error if we don't
      // recognise the platform:
 #     error "Unknown platform - please configure and report the results to boost.org"
 #  endif
 #endif
@@ -0,0 +1,85 @@
 //  Boost compiler configuration selection header file
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2001 - 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 // locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed:
 // First include <cstddef> to determine if some version of STLport is in use as the std lib
 // (do not rely on this header being included since users can short-circuit this header 
 //  if they know whose std lib they are using.)
 #ifdef __cplusplus
 #  include <cstddef>
 #else
 #  include <stddef.h>
 #endif
 #if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
 // STLPort library; this _must_ come first, otherwise since
 // STLport typically sits on top of some other library, we
 // can end up detecting that first rather than STLport:
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp"
 #else
 // If our std lib was not some version of STLport, then include <utility> as it is about 
 // the smallest of the std lib headers that includes real C++ stuff.  (Some std libs do not
 // include their C++-related macros in <cstddef> so this additional include makes sure
 // we get those definitions)
 // (again do not rely on this header being included since users can short-circuit this 
 //  header if they know whose std lib they are using.)
 #include <boost/config/no_tr1/utility.hpp>
 #if defined(__LIBCOMO__)
 // Comeau STL:
 #define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp"
 #elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
 // Rogue Wave library:
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp"
 #elif defined(_LIBCPP_VERSION)
 // libc++
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcpp.hpp"
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
 // GNU libstdc++ 3
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
 #elif defined(__STL_CONFIG_H)
 // generic SGI STL
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp"
 #elif defined(__MSL_CPP__)
 // MSL standard lib:
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp"
 #elif defined(__IBMCPP__)
 // take the default VACPP std lib
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp"
 #elif defined(MSIPL_COMPILE_H)
 // Modena C++ standard library
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp"
 #elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
 // Dinkumware Library (this has to appear after any possible replacement libraries):
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp"
 #elif defined (BOOST_ASSERT_CONFIG)
 // this must come last - generate an error if we don't
 // recognise the library:
 #  error "Unknown standard library - please configure and report the results to boost.org"
 #endif
 #endif
@@ -0,0 +1,145 @@
 //  (C) Copyright John Maddock 2001 - 2003.
 //  (C) Copyright Jens Maurer 2001.
 //  (C) Copyright Peter Dimov 2001.
 //  (C) Copyright David Abrahams 2002.
 //  (C) Copyright Guillaume Melquiond 2003.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Dinkumware standard library config:
 #if !defined(_YVALS) && !defined(_CPPLIB_VER)
 #include <boost/config/no_tr1/utility.hpp>
 #if !defined(_YVALS) && !defined(_CPPLIB_VER)
 #error This is not the Dinkumware lib!
 #endif
 #endif
 #if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
   // full dinkumware 3.06 and above
   // fully conforming provided the compiler supports it:
 #  if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700))   // can be defined in yvals.h
 #     define BOOST_NO_STDC_NAMESPACE
 #  endif
 #  if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC)
 #     define BOOST_NO_STD_ALLOCATOR
 #  endif
 #  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
 #  if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
      // if this lib version is set up for vc6 then there is no std::use_facet:
 #     define BOOST_NO_STD_USE_FACET
 #     define BOOST_HAS_TWO_ARG_USE_FACET
      // C lib functions aren't in namespace std either:
 #     define BOOST_NO_STDC_NAMESPACE
      // and nor is <exception>
 #     define BOOST_NO_EXCEPTION_STD_NAMESPACE
 #  endif
 // There's no numeric_limits<long long> support unless _LONGLONG is defined:
 #  if !defined(_LONGLONG) && (_CPPLIB_VER <= 310)
 #     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
 #  endif
 // 3.06 appears to have (non-sgi versions of) <hash_set> & <hash_map>,
 // and no <slist> at all
 #else
 #  define BOOST_MSVC_STD_ITERATOR 1
 #  define BOOST_NO_STD_ITERATOR
 #  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #  define BOOST_NO_STD_ALLOCATOR
 #  define BOOST_NO_STDC_NAMESPACE
 #  define BOOST_NO_STD_USE_FACET
 #  define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
 #  define BOOST_HAS_MACRO_USE_FACET
 #  ifndef _CPPLIB_VER
      // Updated Dinkum library defines this, and provides
      // its own min and max definitions, as does MTA version.
 #     ifndef __MTA__ 
 #        define BOOST_NO_STD_MIN_MAX
 #     endif
 #     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
 #  endif
 #endif
 //
 // std extension namespace is stdext for vc7.1 and later, 
 // the same applies to other compilers that sit on top
 // of vc7.1 (Intel and Comeau):
 //
 #if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__)
 #  define BOOST_STD_EXTENSION_NAMESPACE stdext
 #endif
 #if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306)
   // if we're using a dinkum lib that's
   // been configured for VC6/7 then there is
   // no iterator traits (true even for icl)
 #  define BOOST_NO_STD_ITERATOR_TRAITS
 #endif
 #if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310)
 // Intel C++ chokes over any non-trivial use of <locale>
 // this may be an overly restrictive define, but regex fails without it:
 #  define BOOST_NO_STD_LOCALE
 #endif
 #include <typeinfo>
 #if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) 
 #  define BOOST_NO_STD_TYPEINFO    
 #endif  
 //  C++0x headers implemented in 520 (as shipped by Microsoft)
 //
 #if !defined(_CPPLIB_VER) || _CPPLIB_VER < 520
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #endif
 #if !defined(_HAS_TR1_IMPORTS) && !defined(BOOST_NO_0X_HDR_TUPLE)
 #  define BOOST_NO_0X_HDR_TUPLE
 #endif
 //
 //  C++0x headers not yet (fully) implemented:
 //
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_THREAD
 #ifdef _CPPLIB_VER
 #  define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
 #else
 #  define BOOST_DINKUMWARE_STDLIB 1
 #endif
 #ifdef _CPPLIB_VER
 #  define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER)
 #else
 #  define BOOST_STDLIB "Dinkumware standard library version 1.x"
 #endif
@@ -0,0 +1,69 @@
 //  (C) Copyright John Maddock 2002 - 2003. 
 //  (C) Copyright Jens Maurer 2002 - 2003. 
 //  (C) Copyright Beman Dawes 2002 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Comeau STL:
 #if !defined(__LIBCOMO__)
 #  include <boost/config/no_tr1/utility.hpp>
 #  if !defined(__LIBCOMO__)
 #      error "This is not the Comeau STL!"
 #  endif
 #endif
 //
 // std::streambuf<wchar_t> is non-standard
 // NOTE: versions of libcomo prior to beta28 have octal version numbering,
 // e.g. version 25 is 21 (dec)
 #if __LIBCOMO_VERSION__ <= 22
 #  define BOOST_NO_STD_WSTREAMBUF
 #endif
 #if (__LIBCOMO_VERSION__ <= 31) && defined(_WIN32)
 #define BOOST_NO_SWPRINTF
 #endif
 #if __LIBCOMO_VERSION__ >= 31
 #  define BOOST_HAS_HASH
 #  define BOOST_HAS_SLIST
 #endif
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 //
 // Intrinsic type_traits support.
 // The SGI STL has it's own __type_traits class, which
 // has intrinsic compiler support with SGI's compilers.
 // Whatever map SGI style type traits to boost equivalents:
 //
 #define BOOST_HAS_SGI_TYPE_TRAITS
 #define BOOST_STDLIB "Comeau standard library " BOOST_STRINGIZE(__LIBCOMO_VERSION__)
@@ -0,0 +1,36 @@
 //  (C) Copyright Christopher Jefferson 2011.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  config for libc++
 //  Might need more in here later.
 #if !defined(_LIBCPP_VERSION)
 #  include <ciso646>
 #  if !defined(_LIBCPP_VERSION)
 #      error "This is not libc++!"
 #  endif
 #endif
 #define BOOST_STDLIB "libc++ version " BOOST_STRINGIZE(_LIBCPP_VERSION)
 #define BOOST_HAS_THREADS
 #ifdef _LIBCPP_HAS_NO_VARIADICS
 #    define BOOST_NO_0X_HDR_TUPLE
 #endif
 //
 // These appear to be unusable/incomplete so far:
 //
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 // libc++ uses a non-standard messages_base
 #define BOOST_NO_STD_MESSAGES
 //  --- end ---
@@ -0,0 +1,153 @@
 //  (C) Copyright John Maddock 2001.
 //  (C) Copyright Jens Maurer 2001.
 //  Use, modification and distribution are subject to 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 most recent version.
 //  config for libstdc++ v3
 //  not much to go in here:
 #define BOOST_GNU_STDLIB 1
 #ifdef __GLIBCXX__
 #define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
 #else
 #define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCPP__)
 #endif
 #if !defined(_GLIBCPP_USE_WCHAR_T) && !defined(_GLIBCXX_USE_WCHAR_T)
 #  define BOOST_NO_CWCHAR
 #  define BOOST_NO_CWCTYPE
 #  define BOOST_NO_STD_WSTRING
 #  define BOOST_NO_STD_WSTREAMBUF
 #endif
 #if defined(__osf__) && !defined(_REENTRANT) \
  && ( defined(_GLIBCXX_HAVE_GTHR_DEFAULT) || defined(_GLIBCPP_HAVE_GTHR_DEFAULT) )
 // GCC 3 on Tru64 forces the definition of _REENTRANT when any std lib header
 // file is included, therefore for consistency we define it here as well.
 #  define _REENTRANT
 #endif
 #ifdef __GLIBCXX__ // gcc 3.4 and greater:
 #  if defined(_GLIBCXX_HAVE_GTHR_DEFAULT) \
        || defined(_GLIBCXX__PTHREADS)
      //
      // If the std lib has thread support turned on, then turn it on in Boost
      // as well.  We do this because some gcc-3.4 std lib headers define _REENTANT
      // while others do not...
      //
 #     define BOOST_HAS_THREADS
 #  else
 #     define BOOST_DISABLE_THREADS
 #  endif
 #elif defined(__GLIBCPP__) \
        && !defined(_GLIBCPP_HAVE_GTHR_DEFAULT) \
        && !defined(_GLIBCPP__PTHREADS)
   // disable thread support if the std lib was built single threaded:
 #  define BOOST_DISABLE_THREADS
 #endif
 #if (defined(linux) || defined(__linux) || defined(__linux__)) && defined(__arm__) && defined(_GLIBCPP_HAVE_GTHR_DEFAULT)
 // linux on arm apparently doesn't define _REENTRANT
 // so just turn on threading support whenever the std lib is thread safe:
 #  define BOOST_HAS_THREADS
 #endif
 #if !defined(_GLIBCPP_USE_LONG_LONG) \
    && !defined(_GLIBCXX_USE_LONG_LONG)\
    && defined(BOOST_HAS_LONG_LONG)
 // May have been set by compiler/*.hpp, but "long long" without library
 // support is useless.
 #  undef BOOST_HAS_LONG_LONG
 #endif
 // Apple doesn't seem to reliably defined a *unix* macro
 #if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
 #  include <unistd.h>
 #endif
 #if defined(__GLIBCXX__) || (defined(__GLIBCPP__) && __GLIBCPP__>=20020514) // GCC >= 3.1.0
 #  define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
 #  define BOOST_HAS_SLIST
 #  define BOOST_HAS_HASH
 #  define BOOST_SLIST_HEADER <ext/slist>
 # if !defined(__GNUC__) || __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)
 #   define BOOST_HASH_SET_HEADER <ext/hash_set>
 #   define BOOST_HASH_MAP_HEADER <ext/hash_map>
 # else
 #   define BOOST_HASH_SET_HEADER <backward/hash_set>
 #   define BOOST_HASH_MAP_HEADER <backward/hash_map>
 # endif
 #endif
 //  stdlibc++ C++0x support is detected via __GNUC__, __GNUC_MINOR__, and possibly
 //  __GNUC_PATCHLEVEL__ at the suggestion of Jonathan Wakely, one of the stdlibc++
 //  developers. He also commented:
 //
 //       "I'm not sure how useful __GLIBCXX__ is for your purposes, for instance in
 //       GCC 4.2.4 it is set to 20080519 but in GCC 4.3.0 it is set to 20080305.
 //       Although 4.3.0 was released earlier than 4.2.4, it has better C++0x support
 //       than any release in the 4.2 series."
 //
 //  Another resource for understanding stdlibc++ features is:
 //  http://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#manual.intro.status.standard.200x
 //  C++0x headers in GCC 4.3.0 and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_STD_UNORDERED  // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #endif
 //  C++0x headers in GCC 4.4.0 and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #else
 #  define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG 
 #  define BOOST_HAS_TR1_COMPLEX_OVERLOADS 
 #endif
 #if (!defined(_GLIBCXX_HAS_GTHREADS) || !defined(_GLIBCXX_USE_C99_STDINT_TR1)) && (!defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE) || !defined(BOOST_NO_0X_HDR_MUTEX))
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_MUTEX
 #endif
 //  C++0x features in GCC 4.5.0 and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_RANDOM
 #endif
 //  C++0x features in GCC 4.5.0 and later
 //
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #endif
 //  C++0x headers not yet (fully!) implemented
 //
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_CODECVT
 //  --- end ---
@@ -0,0 +1,53 @@
 //  (C) Copyright Jens Maurer 2001. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Modena C++ standard library (comes with KAI C++)
 #if !defined(MSIPL_COMPILE_H)
 #  include <boost/config/no_tr1/utility.hpp>
 #  if !defined(__MSIPL_COMPILE_H)
 #      error "This is not the Modena C++ library!"
 #  endif
 #endif
 #ifndef MSIPL_NL_TYPES
 #define BOOST_NO_STD_MESSAGES
 #endif
 #ifndef MSIPL_WCHART
 #define BOOST_NO_STD_WSTRING
 #endif
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #define BOOST_STDLIB "Modena C++ standard library"
@@ -0,0 +1,81 @@
 //  (C) Copyright John Maddock 2001. 
 //  (C) Copyright Darin Adler 2001. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Metrowerks standard library:
 #ifndef __MSL_CPP__
 #  include <boost/config/no_tr1/utility.hpp>
 #  ifndef __MSL_CPP__
 #     error This is not the MSL standard library!
 #  endif
 #endif
 #if __MSL_CPP__ >= 0x6000  // Pro 6
 #  define BOOST_HAS_HASH
 #  define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
 #endif
 #define BOOST_HAS_SLIST
 #if __MSL_CPP__ < 0x6209
 #  define BOOST_NO_STD_MESSAGES
 #endif
 // check C lib version for <stdint.h>
 #include <cstddef>
 #if defined(__MSL__) && (__MSL__ >= 0x5000)
 #  define BOOST_HAS_STDINT_H
 #  if !defined(__PALMOS_TRAPS__)
 #    define BOOST_HAS_UNISTD_H
 #  endif
   // boilerplate code:
 #  include <boost/config/posix_features.hpp>
 #endif
 #if defined(_MWMT) || _MSL_THREADSAFE
 #  define BOOST_HAS_THREADS
 #endif
 #ifdef _MSL_NO_EXPLICIT_FUNC_TEMPLATE_ARG
 #  define BOOST_NO_STD_USE_FACET
 #  define BOOST_HAS_TWO_ARG_USE_FACET
 #endif
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
@@ -0,0 +1,183 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Jens Maurer 2001. 
 //  (C) Copyright David Abrahams 2003. 
 //  (C) Copyright Boris Gubenko 2007. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  Rogue Wave std lib:
 #define BOOST_RW_STDLIB 1 
 #if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)
 #  include <boost/config/no_tr1/utility.hpp>
 #  if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)
 #     error This is not the Rogue Wave standard library
 #  endif
 #endif
 //
 // figure out a consistent version number:
 //
 #ifndef _RWSTD_VER
 #  define BOOST_RWSTD_VER 0x010000
 #elif _RWSTD_VER < 0x010000
 #  define BOOST_RWSTD_VER (_RWSTD_VER << 8)
 #else
 #  define BOOST_RWSTD_VER _RWSTD_VER
 #endif
 #ifndef _RWSTD_VER
 #  define BOOST_STDLIB "Rogue Wave standard library version (Unknown version)"
 #elif _RWSTD_VER < 0x04010200
 #  define BOOST_STDLIB "Rogue Wave standard library version " BOOST_STRINGIZE(_RWSTD_VER)
 #else
 #  ifdef _RWSTD_VER_STR
 #    define BOOST_STDLIB "Apache STDCXX standard library version " _RWSTD_VER_STR
 #  else
 #    define BOOST_STDLIB "Apache STDCXX standard library version " BOOST_STRINGIZE(_RWSTD_VER)
 #  endif
 #endif
 //
 // Prior to version 2.2.0 the primary template for std::numeric_limits
 // does not have compile time constants, even though specializations of that
 // template do:
 //
 #if BOOST_RWSTD_VER < 0x020200
 #  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #endif
 // Sun CC 5.5 patch 113817-07 adds long long specialization, but does not change the
 // library version number (http://sunsolve6.sun.com/search/document.do?assetkey=1-21-113817):
 #if BOOST_RWSTD_VER <= 0x020101 && (!defined(__SUNPRO_CC) || (__SUNPRO_CC < 0x550))
 #  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
 # endif
 //
 // Borland version of numeric_limits lacks __int64 specialisation:
 //
 #ifdef __BORLANDC__
 #  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
 #endif
 //
 // No std::iterator if it can't figure out default template args:
 //
 #if defined(_RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || defined(RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || (BOOST_RWSTD_VER < 0x020000)
 #  define BOOST_NO_STD_ITERATOR
 #endif
 //
 // No iterator traits without partial specialization:
 //
 #if defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) || defined(RWSTD_NO_CLASS_PARTIAL_SPEC)
 #  define BOOST_NO_STD_ITERATOR_TRAITS
 #endif
 //
 // Prior to version 2.0, std::auto_ptr was buggy, and there were no
 // new-style iostreams, and no conformant std::allocator:
 //
 #if (BOOST_RWSTD_VER < 0x020000)
 #  define BOOST_NO_AUTO_PTR
 #  define BOOST_NO_STRINGSTREAM
 #  define BOOST_NO_STD_ALLOCATOR
 #  define BOOST_NO_STD_LOCALE
 #endif
 //
 // No template iterator constructors without member template support:
 //
 #if defined(RWSTD_NO_MEMBER_TEMPLATES) || defined(_RWSTD_NO_MEMBER_TEMPLATES)
 #  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #endif
 //
 // RW defines _RWSTD_ALLOCATOR if the allocator is conformant and in use
 // (the or _HPACC_ part is a hack - the library seems to define _RWSTD_ALLOCATOR
 // on HP aCC systems even though the allocator is in fact broken):
 //
 #if !defined(_RWSTD_ALLOCATOR) || (defined(__HP_aCC) && __HP_aCC <= 33100)
 #  define BOOST_NO_STD_ALLOCATOR
 #endif
 //
 // If we have a std::locale, we still may not have std::use_facet:
 //
 #if defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined(BOOST_NO_STD_LOCALE)
 #  define BOOST_NO_STD_USE_FACET
 #  define BOOST_HAS_TWO_ARG_USE_FACET
 #endif
 //
 // There's no std::distance prior to version 2, or without
 // partial specialization support:
 //
 #if (BOOST_RWSTD_VER < 0x020000) || defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
    #define BOOST_NO_STD_DISTANCE
 #endif
 //
 // Some versions of the rogue wave library don't have assignable
 // OutputIterators:
 //
 #if BOOST_RWSTD_VER < 0x020100
 #  define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
 #endif
 //
 // Disable BOOST_HAS_LONG_LONG when the library has no support for it.
 //
 #if !defined(_RWSTD_LONG_LONG) && defined(BOOST_HAS_LONG_LONG)
 #  undef BOOST_HAS_LONG_LONG
 #endif
 //
 // check that on HP-UX, the proper RW library is used
 //
 #if defined(__HP_aCC) && !defined(_HP_NAMESPACE_STD)
 #  error "Boost requires Standard RW library. Please compile and link with -AA"
 #endif
 //
 // Define macros specific to RW V2.2 on HP-UX
 //
 #if defined(__HP_aCC) && (BOOST_RWSTD_VER == 0x02020100)
 #  ifndef __HP_TC1_MAKE_PAIR
 #    define __HP_TC1_MAKE_PAIR
 #  endif
 #  ifndef _HP_INSTANTIATE_STD2_VL
 #    define _HP_INSTANTIATE_STD2_VL
 #  endif
 #endif
 #if _RWSTD_VER < 0x05000000
 #  define BOOST_NO_0X_HDR_ARRAY
 #endif
 // type_traits header is incomplete:
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 //
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
@@ -0,0 +1,145 @@
 //  (C) Copyright John Maddock 2001 - 2003. 
 //  (C) Copyright Darin Adler 2001. 
 //  (C) Copyright Jens Maurer 2001 - 2003. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  generic SGI STL:
 #if !defined(__STL_CONFIG_H)
 #  include <boost/config/no_tr1/utility.hpp>
 #  if !defined(__STL_CONFIG_H)
 #      error "This is not the SGI STL!"
 #  endif
 #endif
 //
 // No std::iterator traits without partial specialisation:
 //
 #if !defined(__STL_CLASS_PARTIAL_SPECIALIZATION)
 #  define BOOST_NO_STD_ITERATOR_TRAITS
 #endif
 //
 // No std::stringstream with gcc < 3
 //
 #if defined(__GNUC__) && (__GNUC__ < 3) && \
     ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)) && \
     !defined(__STL_USE_NEW_IOSTREAMS) || \
   defined(__APPLE_CC__)
   // Note that we only set this for GNU C++ prior to 2.95 since the
   // latest patches for that release do contain a minimal <sstream>
   // If you are running a 2.95 release prior to 2.95.3 then this will need
   // setting, but there is no way to detect that automatically (other
   // than by running the configure script).
   // Also, the unofficial GNU C++ 2.96 included in RedHat 7.1 doesn't
   // have <sstream>.
 #  define BOOST_NO_STRINGSTREAM
 #endif
 // Apple doesn't seem to reliably defined a *unix* macro
 #if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
 #  include <unistd.h>
 #endif
 //
 // Assume no std::locale without own iostreams (this may be an
 // incorrect assumption in some cases):
 //
 #if !defined(__SGI_STL_OWN_IOSTREAMS) && !defined(__STL_USE_NEW_IOSTREAMS)
 #  define BOOST_NO_STD_LOCALE
 #endif
 //
 // Original native SGI streams have non-standard std::messages facet:
 //
 #if defined(__sgi) && (_COMPILER_VERSION <= 650) && !defined(__SGI_STL_OWN_IOSTREAMS)
 #  define BOOST_NO_STD_LOCALE
 #endif
 //
 // SGI's new iostreams have missing "const" in messages<>::open
 //
 #if defined(__sgi) && (_COMPILER_VERSION <= 740) && defined(__STL_USE_NEW_IOSTREAMS)
 #  define BOOST_NO_STD_MESSAGES
 #endif
 //
 // No template iterator constructors, or std::allocator
 // without member templates:
 //
 #if !defined(__STL_MEMBER_TEMPLATES)
 #  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #  define BOOST_NO_STD_ALLOCATOR
 #endif
 //
 // We always have SGI style hash_set, hash_map, and slist:
 //
 #define BOOST_HAS_HASH
 #define BOOST_HAS_SLIST
 //
 // If this is GNU libstdc++2, then no <limits> and no std::wstring:
 //
 #if (defined(__GNUC__) && (__GNUC__ < 3))
 #  include <string>
 #  if defined(__BASTRING__)
 #     define BOOST_NO_LIMITS
 // Note: <boost/limits.hpp> will provide compile-time constants
 #     undef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #     define BOOST_NO_STD_WSTRING
 #  endif
 #endif
 //
 // There is no standard iterator unless we have namespace support:
 //
 #if !defined(__STL_USE_NAMESPACES)
 #  define BOOST_NO_STD_ITERATOR
 #endif
 //
 // Intrinsic type_traits support.
 // The SGI STL has it's own __type_traits class, which
 // has intrinsic compiler support with SGI's compilers.
 // Whatever map SGI style type traits to boost equivalents:
 //
 #define BOOST_HAS_SGI_TYPE_TRAITS
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #define BOOST_STDLIB "SGI standard library"
@@ -0,0 +1,244 @@
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  (C) Copyright Darin Adler 2001. 
 //  (C) Copyright Jens Maurer 2001. 
 //  Use, modification and distribution are subject to 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 most recent version.
 //  STLPort standard library config:
 #if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 #  include <cstddef>
 #  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 #      error "This is not STLPort!"
 #  endif
 #endif
 // Apple doesn't seem to reliably defined a *unix* macro
 #if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
 #  include <unistd.h>
 #endif
 //
 // __STL_STATIC_CONST_INIT_BUG implies BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 // for versions prior to 4.1(beta)
 //
 #if (defined(__STL_STATIC_CONST_INIT_BUG) || defined(_STLP_STATIC_CONST_INIT_BUG)) && (__SGI_STL_PORT <= 0x400)
 #  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #endif
 //
 // If STLport thinks that there is no partial specialisation, then there is no
 // std::iterator traits:
 //
 #if !(defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined(__STL_CLASS_PARTIAL_SPECIALIZATION))
 #  define BOOST_NO_STD_ITERATOR_TRAITS
 #endif
 //
 // No new style iostreams on GCC without STLport's iostreams enabled:
 //
 #if (defined(__GNUC__) && (__GNUC__ < 3)) && !(defined(__SGI_STL_OWN_IOSTREAMS) || defined(_STLP_OWN_IOSTREAMS))
 #  define BOOST_NO_STRINGSTREAM
 #endif
 //
 // No new iostreams implies no std::locale, and no std::stringstream:
 //
 #if defined(__STL_NO_IOSTREAMS) || defined(__STL_NO_NEW_IOSTREAMS) || defined(_STLP_NO_IOSTREAMS) || defined(_STLP_NO_NEW_IOSTREAMS)
 #  define BOOST_NO_STD_LOCALE
 #  define BOOST_NO_STRINGSTREAM
 #endif
 //
 // If the streams are not native, and we have a "using ::x" compiler bug
 // then the io stream facets are not available in namespace std::
 //
 #ifdef _STLPORT_VERSION
 #  if !(_STLPORT_VERSION >= 0x500) && !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__)
 #     define BOOST_NO_STD_LOCALE
 #  endif
 #else
 #  if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__)
 #     define BOOST_NO_STD_LOCALE
 #  endif
 #endif
 #if defined(_STLPORT_VERSION) && ((_STLPORT_VERSION < 0x500) || (_STLPORT_VERSION >= 0x520))
 #  define BOOST_NO_STD_UNORDERED
 #endif
 #if defined(_STLPORT_VERSION) && (_STLPORT_VERSION >= 0x520)
 #  define BOOST_HAS_TR1_UNORDERED_SET
 #  define BOOST_HAS_TR1_UNORDERED_MAP
 #endif
 //
 // Without member template support enabled, their are no template
 // iterate constructors, and no std::allocator:
 //
 #if !(defined(__STL_MEMBER_TEMPLATES) || defined(_STLP_MEMBER_TEMPLATES))
 #  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #  define BOOST_NO_STD_ALLOCATOR
 #endif
 //
 // however we always have at least a partial allocator:
 //
 #define BOOST_HAS_PARTIAL_STD_ALLOCATOR
 #if !defined(_STLP_MEMBER_TEMPLATE_CLASSES) || defined(_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
 #  define BOOST_NO_STD_ALLOCATOR
 #endif
 #if defined(_STLP_NO_MEMBER_TEMPLATE_KEYWORD) && defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 #  define BOOST_NO_STD_ALLOCATOR
 #endif
 //
 // If STLport thinks there is no wchar_t at all, then we have to disable
 // the support for the relevant specilazations of std:: templates.
 //
 #if !defined(_STLP_HAS_WCHAR_T) && !defined(_STLP_WCHAR_T_IS_USHORT)
 #  ifndef  BOOST_NO_STD_WSTRING
 #     define BOOST_NO_STD_WSTRING
 #  endif
 #  ifndef  BOOST_NO_STD_WSTREAMBUF
 #     define BOOST_NO_STD_WSTREAMBUF
 #  endif
 #endif
 //
 // We always have SGI style hash_set, hash_map, and slist:
 //
 #ifndef _STLP_NO_EXTENSIONS
 #define BOOST_HAS_HASH
 #define BOOST_HAS_SLIST
 #endif
 //
 // STLport does a good job of importing names into namespace std::,
 // but doesn't always get them all, define BOOST_NO_STDC_NAMESPACE, since our
 // workaround does not conflict with STLports:
 //
 //
 // Harold Howe says:
 // Borland switched to STLport in BCB6. Defining BOOST_NO_STDC_NAMESPACE with
 // BCB6 does cause problems. If we detect C++ Builder, then don't define 
 // BOOST_NO_STDC_NAMESPACE
 //
 #if !defined(__BORLANDC__) && !defined(__DMC__)
 //
 // If STLport is using it's own namespace, and the real names are in
 // the global namespace, then we duplicate STLport's using declarations
 // (by defining BOOST_NO_STDC_NAMESPACE), we do this because STLport doesn't
 // necessarily import all the names we need into namespace std::
 // 
 #  if (defined(__STL_IMPORT_VENDOR_CSTD) \
         || defined(__STL_USE_OWN_NAMESPACE) \
         || defined(_STLP_IMPORT_VENDOR_CSTD) \
         || defined(_STLP_USE_OWN_NAMESPACE)) \
      && (defined(__STL_VENDOR_GLOBAL_CSTD) || defined (_STLP_VENDOR_GLOBAL_CSTD))
 #     define BOOST_NO_STDC_NAMESPACE
 #     define BOOST_NO_EXCEPTION_STD_NAMESPACE
 #  endif
 #elif defined(__BORLANDC__) && __BORLANDC__ < 0x560
 // STLport doesn't import std::abs correctly:
 #include <stdlib.h>
 namespace std { using ::abs; }
 // and strcmp/strcpy don't get imported either ('cos they are macros)
 #include <string.h>
 #ifdef strcpy
 #  undef strcpy
 #endif
 #ifdef strcmp
 #  undef strcmp
 #endif
 #ifdef _STLP_VENDOR_CSTD
 namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD::strcpy; }
 #endif
 #endif
 //
 // std::use_facet may be non-standard, uses a class instead:
 //
 #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) || defined(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
 #  define BOOST_NO_STD_USE_FACET
 #  define BOOST_HAS_STLP_USE_FACET
 #endif
 //
 // If STLport thinks there are no wide functions, <cwchar> etc. is not working; but
 // only if BOOST_NO_STDC_NAMESPACE is not defined (if it is then we do the import 
 // into std:: ourselves).
 //
 #if defined(_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined(BOOST_NO_STDC_NAMESPACE)
 #  define BOOST_NO_CWCHAR
 #  define BOOST_NO_CWCTYPE
 #endif
 //
 // If STLport for some reason was configured so that it thinks that wchar_t
 // is not an intrinsic type, then we have to disable the support for it as
 // well (we would be missing required specializations otherwise).
 //
 #if !defined( _STLP_HAS_WCHAR_T) || defined(_STLP_WCHAR_T_IS_USHORT)
 #  undef  BOOST_NO_INTRINSIC_WCHAR_T
 #  define BOOST_NO_INTRINSIC_WCHAR_T
 #endif
 //
 // Borland ships a version of STLport with C++ Builder 6 that lacks
 // hashtables and the like:
 //
 #if defined(__BORLANDC__) && (__BORLANDC__ == 0x560)
 #  undef BOOST_HAS_HASH
 #endif
 //
 // gcc-2.95.3/STLPort does not like the using declarations we use to get ADL with std::min/max
 //
 #if defined(__GNUC__) && (__GNUC__ < 3)
 #  include <algorithm> // for std::min and std::max
 #  define BOOST_USING_STD_MIN() ((void)0)
 #  define BOOST_USING_STD_MAX() ((void)0)
 namespace boost { using std::min; using std::max; }
 #endif
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)
@@ -0,0 +1,51 @@
 //  (C) Copyright John Maddock 2001 - 2002. 
 //  Use, modification and distribution are subject to 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 most recent version.
 #if __IBMCPP__ <= 501
 #  define BOOST_NO_STD_ALLOCATOR
 #endif
 #define BOOST_HAS_MACRO_USE_FACET
 #define BOOST_NO_STD_MESSAGES
 // Apple doesn't seem to reliably defined a *unix* macro
 #if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
 #  include <unistd.h>
 #endif
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_ARRAY
 #  define BOOST_NO_0X_HDR_CHRONO
 #  define BOOST_NO_0X_HDR_CODECVT
 #  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
 #  define BOOST_NO_0X_HDR_FORWARD_LIST
 #  define BOOST_NO_0X_HDR_FUTURE
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RANDOM
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_REGEX
 #  define BOOST_NO_0X_HDR_SYSTEM_ERROR
 #  define BOOST_NO_0X_HDR_THREAD
 #  define BOOST_NO_0X_HDR_TUPLE
 #  define BOOST_NO_0X_HDR_TYPE_TRAITS
 #  define BOOST_NO_0X_HDR_TYPEINDEX
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
 #  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 #define BOOST_STDLIB "Visual Age default standard library"
@@ -0,0 +1,678 @@
 //  Boost config.hpp configuration header file  ------------------------------//
 //  Copyright (c) 2001-2003 John Maddock
 //  Copyright (c) 2001 Darin Adler
 //  Copyright (c) 2001 Peter Dimov
 //  Copyright (c) 2002 Bill Kempf 
 //  Copyright (c) 2002 Jens Maurer
 //  Copyright (c) 2002-2003 David Abrahams
 //  Copyright (c) 2003 Gennaro Prota
 //  Copyright (c) 2003 Eric Friedman
 //  Copyright (c) 2010 Eric Jourdanneau, Joel Falcou
 // 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 most recent version.
 //  Boost config.hpp policy and rationale documentation has been moved to
 //  http://www.boost.org/libs/config/
 //
 //  This file is intended to be stable, and relatively unchanging.
 //  It should contain boilerplate code only - no compiler specific
 //  code unless it is unavoidable - no changes unless unavoidable.
 #ifndef BOOST_CONFIG_SUFFIX_HPP
 #define BOOST_CONFIG_SUFFIX_HPP
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 //
 // Some GCC-4.x versions issue warnings even when __extension__ is used,
 // so use this as a workaround:
 //
 #pragma GCC system_header
 #endif
 //
 // ensure that visibility macros are always defined, thus symplifying use
 //
 #ifndef BOOST_SYMBOL_EXPORT
 # define BOOST_SYMBOL_EXPORT
 #endif
 #ifndef BOOST_SYMBOL_IMPORT
 # define BOOST_SYMBOL_IMPORT
 #endif
 #ifndef BOOST_SYMBOL_VISIBLE
 # define BOOST_SYMBOL_VISIBLE
 #endif
 //
 // look for long long by looking for the appropriate macros in <limits.h>.
 // Note that we use limits.h rather than climits for maximal portability,
 // remember that since these just declare a bunch of macros, there should be
 // no namespace issues from this.
 //
 #if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG)                                              \
   && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
 # include <limits.h>
 # if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
 #   define BOOST_HAS_LONG_LONG
 # else
 #   define BOOST_NO_LONG_LONG
 # endif
 #endif
 // GCC 3.x will clean up all of those nasty macro definitions that
 // BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
 // it under GCC 3.x.
 #if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS)
 #  undef BOOST_NO_CTYPE_FUNCTIONS
 #endif
 //
 // Assume any extensions are in namespace std:: unless stated otherwise:
 //
 #  ifndef BOOST_STD_EXTENSION_NAMESPACE
 #    define BOOST_STD_EXTENSION_NAMESPACE std
 #  endif
 //
 // If cv-qualified specializations are not allowed, then neither are cv-void ones:
 //
 #  if defined(BOOST_NO_CV_SPECIALIZATIONS) \
      && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
 #     define BOOST_NO_CV_VOID_SPECIALIZATIONS
 #  endif
 //
 // If there is no numeric_limits template, then it can't have any compile time
 // constants either!
 //
 #  if defined(BOOST_NO_LIMITS) \
      && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
 #     define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
 #     define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
 #  endif
 //
 // if there is no long long then there is no specialisation
 // for numeric_limits<long long> either:
 //
 #if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
 #  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
 #endif
 //
 // Normalize BOOST_NO_STATIC_ASSERT and (depricated) BOOST_HAS_STATIC_ASSERT:
 //
 #if !defined(BOOST_NO_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT)
 #  define BOOST_HAS_STATIC_ASSERT
 #endif
 //
 // if there is no __int64 then there is no specialisation
 // for numeric_limits<__int64> either:
 //
 #if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)
 #  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
 #endif
 //
 // if member templates are supported then so is the
 // VC6 subset of member templates:
 //
 #  if !defined(BOOST_NO_MEMBER_TEMPLATES) \
       && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 #     define BOOST_MSVC6_MEMBER_TEMPLATES
 #  endif
 //
 // Without partial specialization, can't test for partial specialisation bugs:
 //
 #  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
 #     define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
 #  endif
 //
 // Without partial specialization, we can't have array-type partial specialisations:
 //
 #  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 #     define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
 #  endif
 //
 // Without partial specialization, std::iterator_traits can't work:
 //
 #  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
 #     define BOOST_NO_STD_ITERATOR_TRAITS
 #  endif
 //
 // Without partial specialization, partial 
 // specialization with default args won't work either:
 //
 #  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
 #     define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
 #  endif
 //
 // Without member template support, we can't have template constructors
 // in the standard library either:
 //
 #  if defined(BOOST_NO_MEMBER_TEMPLATES) \
      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
      && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
 #     define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
 #  endif
 //
 // Without member template support, we can't have a conforming
 // std::allocator template either:
 //
 #  if defined(BOOST_NO_MEMBER_TEMPLATES) \
      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
      && !defined(BOOST_NO_STD_ALLOCATOR)
 #     define BOOST_NO_STD_ALLOCATOR
 #  endif
 //
 // without ADL support then using declarations will break ADL as well:
 //
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
 #  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #endif
 //
 // Without typeid support we have no dynamic RTTI either:
 //
 #if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
 #  define BOOST_NO_RTTI
 #endif
 //
 // If we have a standard allocator, then we have a partial one as well:
 //
 #if !defined(BOOST_NO_STD_ALLOCATOR)
 #  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
 #endif
 //
 // We can't have a working std::use_facet if there is no std::locale:
 //
 #  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET)
 #     define BOOST_NO_STD_USE_FACET
 #  endif
 //
 // We can't have a std::messages facet if there is no std::locale:
 //
 #  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES)
 #     define BOOST_NO_STD_MESSAGES
 #  endif
 //
 // We can't have a working std::wstreambuf if there is no std::locale:
 //
 #  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
 #     define BOOST_NO_STD_WSTREAMBUF
 #  endif
 //
 // We can't have a <cwctype> if there is no <cwchar>:
 //
 #  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE)
 #     define BOOST_NO_CWCTYPE
 #  endif
 //
 // We can't have a swprintf if there is no <cwchar>:
 //
 #  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
 #     define BOOST_NO_SWPRINTF
 #  endif
 //
 // If Win32 support is turned off, then we must turn off
 // threading support also, unless there is some other
 // thread API enabled:
 //
 #if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \
   && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS)
 #  define BOOST_DISABLE_THREADS
 #endif
 //
 // Turn on threading support if the compiler thinks that it's in
 // multithreaded mode.  We put this here because there are only a
 // limited number of macros that identify this (if there's any missing
 // from here then add to the appropriate compiler section):
 //
 #if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
    || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \
    && !defined(BOOST_HAS_THREADS)
 #  define BOOST_HAS_THREADS
 #endif
 //
 // Turn threading support off if BOOST_DISABLE_THREADS is defined:
 //
 #if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS)
 #  undef BOOST_HAS_THREADS
 #endif
 //
 // Turn threading support off if we don't recognise the threading API:
 //
 #if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\
      && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\
      && !defined(BOOST_HAS_MPTASKS)
 #  undef BOOST_HAS_THREADS
 #endif
 //
 // Turn threading detail macros off if we don't (want to) use threading
 //
 #ifndef BOOST_HAS_THREADS
 #  undef BOOST_HAS_PTHREADS
 #  undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #  undef BOOST_HAS_PTHREAD_YIELD
 #  undef BOOST_HAS_PTHREAD_DELAY_NP
 #  undef BOOST_HAS_WINTHREADS
 #  undef BOOST_HAS_BETHREADS
 #  undef BOOST_HAS_MPTASKS
 #endif
 //
 // If the compiler claims to be C99 conformant, then it had better
 // have a <stdint.h>:
 //
 #  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
 #     define BOOST_HAS_STDINT_H
 #     ifndef BOOST_HAS_LOG1P
 #        define BOOST_HAS_LOG1P
 #     endif
 #     ifndef BOOST_HAS_EXPM1
 #        define BOOST_HAS_EXPM1
 #     endif
 #  endif
 //
 // Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
 // Note that this is for backwards compatibility only.
 //
 #  if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST)
 #     define BOOST_NO_SLIST
 #  endif
 #  if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH)
 #     define BOOST_NO_HASH
 #  endif
 //
 // Set BOOST_SLIST_HEADER if not set already:
 //
 #if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER)
 #  define BOOST_SLIST_HEADER <slist>
 #endif
 //
 // Set BOOST_HASH_SET_HEADER if not set already:
 //
 #if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER)
 #  define BOOST_HASH_SET_HEADER <hash_set>
 #endif
 //
 // Set BOOST_HASH_MAP_HEADER if not set already:
 //
 #if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER)
 #  define BOOST_HASH_MAP_HEADER <hash_map>
 #endif
 //
 // Set BOOST_NO_INITIALIZER_LISTS if there is no library support.
 //
 #if defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS)
 #  define BOOST_NO_INITIALIZER_LISTS
 #endif
 #if defined(BOOST_NO_INITIALIZER_LISTS) && !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 #  define BOOST_NO_0X_HDR_INITIALIZER_LIST
 #endif
 //
 // Set BOOST_HAS_RVALUE_REFS when BOOST_NO_RVALUE_REFERENCES is not defined
 //
 #if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS)
 #define BOOST_HAS_RVALUE_REFS
 #endif
 //
 // Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_VARIADIC_TEMPLATES is not defined
 //
 #if !defined(BOOST_NO_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL)
 #define BOOST_HAS_VARIADIC_TMPL
 #endif
 //
 // Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined
 //
 #if !defined(BOOST_NO_DECLTYPE_N3276) && defined(BOOST_NO_DECLTYPE)
 #define BOOST_NO_DECLTYPE_N3276
 #endif
 //  BOOST_HAS_ABI_HEADERS
 //  This macro gets set if we have headers that fix the ABI,
 //  and prevent ODR violations when linking to external libraries:
 #if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS)
 #  define BOOST_HAS_ABI_HEADERS
 #endif
 #if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS)
 #  undef BOOST_HAS_ABI_HEADERS
 #endif
 //  BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
 //  Because std::size_t usage is so common, even in boost headers which do not
 //  otherwise use the C library, the <cstddef> workaround is included here so
 //  that ugly workaround code need not appear in many other boost headers.
 //  NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
 //  must still be #included in the usual places so that <cstddef> inclusion
 //  works as expected with standard conforming compilers.  The resulting
 //  double inclusion of <cstddef> is harmless.
 # if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus)
 #   include <cstddef>
    namespace std { using ::ptrdiff_t; using ::size_t; }
 # endif
 //  Workaround for the unfortunate min/max macros defined by some platform headers
 #define BOOST_PREVENT_MACRO_SUBSTITUTION
 #ifndef BOOST_USING_STD_MIN
 #  define BOOST_USING_STD_MIN() using std::min
 #endif
 #ifndef BOOST_USING_STD_MAX
 #  define BOOST_USING_STD_MAX() using std::max
 #endif
 //  BOOST_NO_STD_MIN_MAX workaround  -----------------------------------------//
 #  if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus)
 namespace std {
  template <class _Tp>
  inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
    return __b < __a ? __b : __a;
  }
  template <class _Tp>
  inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
    return  __a < __b ? __b : __a;
  }
 }
 #  endif
 // BOOST_STATIC_CONSTANT workaround --------------------------------------- //
 // On compilers which don't allow in-class initialization of static integral
 // constant members, we must use enums as a workaround if we want the constants
 // to be available at compile-time. This macro gives us a convenient way to
 // declare such constants.
 #  ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #       define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
 #  else
 #     define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
 #  endif
 // BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
 // When the standard library does not have a conforming std::use_facet there
 // are various workarounds available, but they differ from library to library.
 // The same problem occurs with has_facet.
 // These macros provide a consistent way to access a locale's facets.
 // Usage:
 //    replace
 //       std::use_facet<Type>(loc);
 //    with
 //       BOOST_USE_FACET(Type, loc);
 //    Note do not add a std:: prefix to the front of BOOST_USE_FACET!
 //  Use for BOOST_HAS_FACET is analogous.
 #if defined(BOOST_NO_STD_USE_FACET)
 #  ifdef BOOST_HAS_TWO_ARG_USE_FACET
 #     define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
 #     define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0))
 #  elif defined(BOOST_HAS_MACRO_USE_FACET)
 #     define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
 #     define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
 #  elif defined(BOOST_HAS_STLP_USE_FACET)
 #     define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc))
 #     define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
 #  endif
 #else
 #  define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
 #  define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
 #endif
 // BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
 // Member templates are supported by some compilers even though they can't use
 // the A::template member<U> syntax, as a workaround replace:
 //
 // typedef typename A::template rebind<U> binder;
 //
 // with:
 //
 // typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder;
 #ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
 #  define BOOST_NESTED_TEMPLATE template
 #else
 #  define BOOST_NESTED_TEMPLATE
 #endif
 // BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
 // Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION
 // is defined, in which case it evaluates to return x; Use when you have a return
 // statement that can never be reached.
 #ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
 #  define BOOST_UNREACHABLE_RETURN(x) return x;
 #else
 #  define BOOST_UNREACHABLE_RETURN(x)
 #endif
 // BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
 //
 // Some compilers don't support the use of `typename' for dependent
 // types in deduced contexts, e.g.
 //
 //     template <class T> void f(T, typename T::type);
 //                                  ^^^^^^^^
 // Replace these declarations with:
 //
 //     template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type);
 #ifndef BOOST_NO_DEDUCED_TYPENAME
 #  define BOOST_DEDUCED_TYPENAME typename
 #else
 #  define BOOST_DEDUCED_TYPENAME
 #endif
 #ifndef BOOST_NO_TYPENAME_WITH_CTOR
 #  define BOOST_CTOR_TYPENAME typename
 #else
 #  define BOOST_CTOR_TYPENAME
 #endif
 // long long workaround ------------------------------------------//
 // On gcc (and maybe other compilers?) long long is alway supported
 // but it's use may generate either warnings (with -ansi), or errors
 // (with -pedantic -ansi) unless it's use is prefixed by __extension__
 //
 #if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus)
 namespace boost{
 #  ifdef __GNUC__
   __extension__ typedef long long long_long_type;
   __extension__ typedef unsigned long long ulong_long_type;
 #  else
   typedef long long long_long_type;
   typedef unsigned long long ulong_long_type;
 #  endif
 }
 #endif
 // BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
 //
 // Some compilers have problems with function templates whose template
 // parameters don't appear in the function parameter list (basically
 // they just link one instantiation of the template in the final
 // executable). These macros provide a uniform way to cope with the
 // problem with no effects on the calling syntax.
 // Example:
 //
 //  #include <iostream>
 //  #include <ostream>
 //  #include <typeinfo>
 //
 //  template <int n>
 //  void f() { std::cout << n << ' '; }
 //
 //  template <typename T>
 //  void g() { std::cout << typeid(T).name() << ' '; }
 //
 //  int main() {
 //    f<1>();
 //    f<2>();
 //
 //    g<int>();
 //    g<double>();
 //  }
 //
 // With VC++ 6.0 the output is:
 //
 //   2 2 double double
 //
 // To fix it, write
 //
 //   template <int n>
 //   void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... }
 //
 //   template <typename T>
 //   void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... }
 //
 #if defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS) && defined(__cplusplus)
 #  include "boost/type.hpp"
 #  include "boost/non_type.hpp"
 #  define BOOST_EXPLICIT_TEMPLATE_TYPE(t)              boost::type<t>* = 0
 #  define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)         boost::type<t>*
 #  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)       boost::non_type<t, v>* = 0
 #  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)  boost::non_type<t, v>*
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)        \
             , BOOST_EXPLICIT_TEMPLATE_TYPE(t)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)   \
             , BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
             , BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)    \
             , BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
 #else
 // no workaround needed: expand to nothing
 #  define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
 #  define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
 #  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
 #  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
 #  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
 #endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 // When BOOST_NO_STD_TYPEINFO is defined, we can just import
 // the global definition into std namespace:
 #if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus)
 #include <typeinfo>
 namespace std{ using ::type_info; }
 #endif
 // ---------------------------------------------------------------------------//
 //
 // Helper macro BOOST_STRINGIZE:
 // Converts the parameter X to a string after macro replacement
 // on X has been performed.
 //
 #define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
 #define BOOST_DO_STRINGIZE(X) #X
 //
 // Helper macro BOOST_JOIN:
 // The following piece of macro magic joins the two
 // arguments together, even when one of the arguments is
 // itself a macro (see 16.3.1 in C++ standard).  The key
 // is that macro expansion of macro arguments does not
 // occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN.
 //
 #define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
 #define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
 #define BOOST_DO_JOIN2( X, Y ) X##Y
 //
 // Set some default values for compiler/library/platform names.
 // These are for debugging config setup only:
 //
 #  ifndef BOOST_COMPILER
 #     define BOOST_COMPILER "Unknown ISO C++ Compiler"
 #  endif
 #  ifndef BOOST_STDLIB
 #     define BOOST_STDLIB "Unknown ISO standard library"
 #  endif
 #  ifndef BOOST_PLATFORM
 #     if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
         || defined(_POSIX_SOURCE)
 #        define BOOST_PLATFORM "Generic Unix"
 #     else
 #        define BOOST_PLATFORM "Unknown"
 #     endif
 #  endif
 //
 // Set some default values GPU support
 //
 #  ifndef BOOST_GPU_ENABLED
 #  define BOOST_GPU_ENABLED 
 #  endif
 //
 // constexpr workarounds
 // 
 #if defined(BOOST_NO_CONSTEXPR)
 #define BOOST_CONSTEXPR
 #define BOOST_CONSTEXPR_OR_CONST const
 #else
 #define BOOST_CONSTEXPR constexpr
 #define BOOST_CONSTEXPR_OR_CONST constexpr
 #endif
 #define BOOST_STATIC_CONSTEXPR  static BOOST_CONSTEXPR_OR_CONST
 #endif
@@ -0,0 +1,124 @@
 //  boost/config/user.hpp  ---------------------------------------------------//
 //  (C) Copyright John Maddock 2001. 
 //  Use, modification and distribution are subject to 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)
 //  Do not check in modified versions of this file,
 //  This file may be customized by the end user, but not by boost.
 //
 //  Use this file to define a site and compiler specific
 //  configuration policy:
 //
 // define this to locate a compiler config file:
 // #define BOOST_COMPILER_CONFIG <myheader>
 // define this to locate a stdlib config file:
 // #define BOOST_STDLIB_CONFIG   <myheader>
 // define this to locate a platform config file:
 // #define BOOST_PLATFORM_CONFIG <myheader>
 // define this to disable compiler config,
 // use if your compiler config has nothing to set:
 // #define BOOST_NO_COMPILER_CONFIG
 // define this to disable stdlib config,
 // use if your stdlib config has nothing to set:
 // #define BOOST_NO_STDLIB_CONFIG
 // define this to disable platform config,
 // use if your platform config has nothing to set:
 // #define BOOST_NO_PLATFORM_CONFIG
 // define this to disable all config options,
 // excluding the user config.  Use if your
 // setup is fully ISO compliant, and has no
 // useful extensions, or for autoconf generated
 // setups:
 // #define BOOST_NO_CONFIG
 // define this to make the config "optimistic"
 // about unknown compiler versions.  Normally
 // unknown compiler versions are assumed to have
 // all the defects of the last known version, however
 // setting this flag, causes the config to assume
 // that unknown compiler versions are fully conformant
 // with the standard:
 // #define BOOST_STRICT_CONFIG
 // define this to cause the config to halt compilation
 // with an #error if it encounters anything unknown --
 // either an unknown compiler version or an unknown
 // compiler/platform/library:
 // #define BOOST_ASSERT_CONFIG
 // define if you want to disable threading support, even
 // when available:
 // #define BOOST_DISABLE_THREADS
 // define when you want to disable Win32 specific features
 // even when available:
 // #define BOOST_DISABLE_WIN32
 // BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any 
 // prefix/suffix headers that normally control things like struct 
 // packing and alignment. 
 // #define BOOST_DISABLE_ABI_HEADERS
 // BOOST_ABI_PREFIX: A prefix header to include in place of whatever
 // boost.config would normally select, any replacement should set up 
 // struct packing and alignment options as required. 
 // #define BOOST_ABI_PREFIX my-header-name
 // BOOST_ABI_SUFFIX: A suffix header to include in place of whatever 
 // boost.config would normally select, any replacement should undo 
 // the effects of the prefix header. 
 // #define BOOST_ABI_SUFFIX my-header-name
 // BOOST_ALL_DYN_LINK: Forces all libraries that have separate source, 
 // to be linked as dll's rather than static libraries on Microsoft Windows 
 // (this macro is used to turn on __declspec(dllimport) modifiers, so that 
 // the compiler knows which symbols to look for in a dll rather than in a 
 // static library).  Note that there may be some libraries that can only 
 // be statically linked (Boost.Test for example) and others which may only 
 // be dynamically linked (Boost.Threads for example), in these cases this 
 // macro has no effect.
 // #define BOOST_ALL_DYN_LINK
 // BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll 
 // rather than a static library on Microsoft Windows: replace the WHATEVER 
 // part of the macro name with the name of the library that you want to 
 // dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or 
 // BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) 
 // modifiers, so that the compiler knows which symbols to look for in a dll 
 // rather than in a static library).  
 // Note that there may be some libraries that can only be statically linked 
 // (Boost.Test for example) and others which may only be dynamically linked 
 // (Boost.Threads for example), in these cases this macro is unsupported.
 // #define BOOST_WHATEVER_DYN_LINK
 // BOOST_ALL_NO_LIB: Tells the config system not to automatically select 
 // which libraries to link against.  
 // Normally if a compiler supports #pragma lib, then the correct library 
 // build variant will be automatically selected and linked against, 
 // simply by the act of including one of that library's headers.  
 // This macro turns that feature off.
 // #define BOOST_ALL_NO_LIB
 // BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically 
 // select which library to link against for library "whatever", 
 // replace WHATEVER in the macro name with the name of the library; 
 // for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB.  
 // Normally if a compiler supports #pragma lib, then the correct library 
 // build variant will be automatically selected and linked against, simply 
 // by the act of including one of that library's headers.  This macro turns 
 // that feature off.
 // #define BOOST_WHATEVER_NO_LIB
@@ -0,0 +1,47 @@
 //  Copyright John Maddock 2008
 //  Use, modification, and distribution is subject to 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)
 //
 //  This file exists to turn off some overly-pedantic warning emitted
 //  by certain compilers.  You should include this header only in:
 //
 //  * A test case, before any other headers, or,
 //  * A library source file before any other headers.
 //
 //  IT SHOULD NOT BE INCLUDED BY ANY BOOST HEADER.
 //
 //  YOU SHOULD NOT INCLUDE IT IF YOU CAN REASONABLY FIX THE WARNING.
 //
 //  The only warnings disabled here are those that are:
 //
 //  * Quite unreasonably pedantic.
 //  * Generally only emitted by a single compiler.
 //  * Can't easily be fixed: for example if the vendors own std lib 
 //    code emits these warnings!
 //
 //  Note that THIS HEADER MUST NOT INCLUDE ANY OTHER HEADERS:
 //  not even std library ones!  Doing so may turn the warning
 //  off too late to be of any use.  For example the VC++ C4996
 //  warning can be emitted from <iosfwd> if that header is included
 //  before or by this one :-(
 //
 #ifndef BOOST_CONFIG_WARNING_DISABLE_HPP
 #define BOOST_CONFIG_WARNING_DISABLE_HPP
 #if defined(_MSC_VER) && (_MSC_VER >= 1400) 
   // Error 'function': was declared deprecated
   // http://msdn2.microsoft.com/en-us/library/ttcz0bys(VS.80).aspx
   // This error is emitted when you use some perfectly conforming
   // std lib functions in a perfectly correct way, and also by
   // some of Microsoft's own std lib code !
 #  pragma warning(disable:4996)
 #endif
 #if defined(__INTEL_COMPILER) || defined(__ICL)
   // As above: gives warning when a "deprecated"
   // std library function is encountered.
 #  pragma warning(disable:1786)
 #endif
 #endif // BOOST_CONFIG_WARNING_DISABLE_HPP
@@ -0,0 +1,449 @@
 // Copyright 2001 John Maddock
 // 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)
 /*
 * Copyright (c) 1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */
 /* NOTE: This is not portable code.  Parts of numeric_limits<> are
 * inherently machine-dependent, and this file is written for the MIPS
 * architecture and the SGI MIPSpro C++ compiler.  Parts of it (in
 * particular, some of the characteristics of floating-point types)
 * are almost certainly incorrect for any other platform.
 */
 /* The above comment is almost certainly out of date. This file works
 * on systems other than SGI MIPSpro C++ now.
 */
 /*
 * Revision history:
 * 21 Sep 2001:
 *    Only include <cwchar> if BOOST_NO_CWCHAR is defined. (Darin Adler)
 * 10 Aug 2001:
 *    Added MIPS (big endian) to the big endian family. (Jens Maurer)
 * 13 Apr 2001:
 *    Added powerpc to the big endian family. (Jeremy Siek)
 * 5 Apr 2001:
 *    Added sparc (big endian) processor support (John Maddock).
 * Initial sub:
 *      Modified by Jens Maurer for gcc 2.95 on x86.
 */
 #ifndef BOOST_SGI_CPP_LIMITS
 #define BOOST_SGI_CPP_LIMITS
 #include <climits>
 #include <cfloat>
 #include <boost/config.hpp>
 #include <boost/detail/endian.hpp>
 #ifndef BOOST_NO_CWCHAR
 #include <cwchar> // for WCHAR_MIN and WCHAR_MAX
 #endif
 namespace std {
 enum float_round_style {
  round_indeterminate       = -1,
  round_toward_zero         =  0,
  round_to_nearest          =  1,
  round_toward_infinity     =  2,
  round_toward_neg_infinity =  3
 };
 enum float_denorm_style {
  denorm_indeterminate = -1,
  denorm_absent        =  0,
  denorm_present       =  1
 };
 // The C++ standard (section 18.2.1) requires that some of the members of
 // numeric_limits be static const data members that are given constant-
 // initializers within the class declaration.  On compilers where the
 // BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro is defined, it is impossible to write
 // a standard-conforming numeric_limits class.
 //
 // There are two possible workarounds: either initialize the data
 // members outside the class, or change them from data members to
 // enums.  Neither workaround is satisfactory: the former makes it
 // impossible to use the data members in constant-expressions, and the
 // latter means they have the wrong type and that it is impossible to
 // take their addresses.  We choose the former workaround.
 #ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 # define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
  enum { __mem_name = __mem_value }
 #else /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */
 # define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
  static const __mem_type __mem_name = __mem_value
 #endif /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */
 // Base class for all specializations of numeric_limits.
 template <class __number>
 class _Numeric_limits_base {
 public:
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false);
  static __number min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); }
  static __number max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); }
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits,   0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, 0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed,  false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact,   false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 0);
  static __number epsilon() throw()     { return __number(); }
  static __number round_error() throw() { return __number(); }
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent,   0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent,   0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity,      false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN,     false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
                              has_denorm,
                              denorm_absent);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss,   false);
  static __number infinity() throw()      { return __number(); }
  static __number quiet_NaN() throw()     { return __number(); }
  static __number signaling_NaN() throw() { return __number(); }
  static __number denorm_min() throw()    { return __number(); }
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559,  false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo,  false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps,            false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before,  false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style,
                              round_style,
                              round_toward_zero);
 };
 // Base class for integers.
 template <class _Int,
          _Int __imin,
          _Int __imax,
          int __idigits = -1>
 class _Integer_limits : public _Numeric_limits_base<_Int> 
 {
 public:
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
  static _Int min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imin; }
  static _Int max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imax; }
  BOOST_STL_DECLARE_LIMITS_MEMBER(int,
                              digits,
                              (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)
                                                   - (__imin == 0 ? 0 : 1) 
                                              : __idigits);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000); 
                                // log 2 = 0.301029995664...
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed,  __imin != 0);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact,   true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int,  radix,      2);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true);
 };
 #if defined(BOOST_BIG_ENDIAN)
 template<class Number, unsigned int Word>
 struct float_helper{
  static Number get_word() throw() {
    // sizeof(long double) == 16
    const unsigned int _S_word[4] = { Word, 0, 0, 0 };
    return *reinterpret_cast<const Number*>(&_S_word);
  } 
 };
 #else
 template<class Number, unsigned int Word>
 struct float_helper{
  static Number get_word() throw() {
    // sizeof(long double) == 12, but only 10 bytes significant
    const unsigned int _S_word[4] = { 0, 0, 0, Word };
    return *reinterpret_cast<const Number*>(
        reinterpret_cast<const char *>(&_S_word)+16-
                (sizeof(Number) == 12 ? 10 : sizeof(Number)));
  } 
 };
 #endif
 // Base class for floating-point numbers.
 template <class __number,
         int __Digits, int __Digits10,
         int __MinExp, int __MaxExp,
         int __MinExp10, int __MaxExp10,
         unsigned int __InfinityWord,
         unsigned int __QNaNWord, unsigned int __SNaNWord,
         bool __IsIEC559,
         float_round_style __RoundStyle>
 class _Floating_limits : public _Numeric_limits_base<__number>
 {
 public:
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits,   __Digits);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent,   __MinExp);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent,   __MaxExp);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10);
  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity,      true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN,     true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
                              has_denorm,
                              denorm_indeterminate);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss,   false);
  static __number infinity() throw() {
    return float_helper<__number, __InfinityWord>::get_word();
  }
  static __number quiet_NaN() throw() {
    return float_helper<__number,__QNaNWord>::get_word();
  }
  static __number signaling_NaN() throw() {
    return float_helper<__number,__SNaNWord>::get_word();
  }
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559,       __IsIEC559);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded,      true);
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps,           false /* was: true */ );
  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);
  BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle);
 };
 // Class numeric_limits
 // The unspecialized class.
 template<class T> 
 class numeric_limits : public _Numeric_limits_base<T> {};
 // Specializations for all built-in integral types.
 template<>
 class numeric_limits<bool>
  : public _Integer_limits<bool, false, true, 0>
 {};
 template<>
 class numeric_limits<char>
  : public _Integer_limits<char, CHAR_MIN, CHAR_MAX>
 {};
 template<>
 class numeric_limits<signed char>
  : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>
 {};
 template<>
 class numeric_limits<unsigned char>
  : public _Integer_limits<unsigned char, 0, UCHAR_MAX>
 {};
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template<>
 class numeric_limits<wchar_t>
 #if !defined(WCHAR_MAX) || !defined(WCHAR_MIN)
 #if defined(_WIN32) || defined(__CYGWIN__)
  : public _Integer_limits<wchar_t, 0, USHRT_MAX>
 #elif defined(__hppa)
 // wchar_t has "unsigned int" as the underlying type
  : public _Integer_limits<wchar_t, 0, UINT_MAX>
 #else
 // assume that wchar_t has "int" as the underlying type
  : public _Integer_limits<wchar_t, INT_MIN, INT_MAX>
 #endif
 #else
 // we have WCHAR_MIN and WCHAR_MAX defined, so use it
  : public _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX>
 #endif
 {};
 #endif
 template<>
 class numeric_limits<short>
  : public _Integer_limits<short, SHRT_MIN, SHRT_MAX>
 {};
 template<>
 class numeric_limits<unsigned short>
  : public _Integer_limits<unsigned short, 0, USHRT_MAX>
 {};
 template<>
 class numeric_limits<int>
  : public _Integer_limits<int, INT_MIN, INT_MAX>
 {};
 template<>
 class numeric_limits<unsigned int>
  : public _Integer_limits<unsigned int, 0, UINT_MAX>
 {};
 template<>
 class numeric_limits<long>
  : public _Integer_limits<long, LONG_MIN, LONG_MAX>
 {};
 template<>
 class numeric_limits<unsigned long>
  : public _Integer_limits<unsigned long, 0, ULONG_MAX>
 {};
 #ifdef __GNUC__
 // Some compilers have long long, but don't define the
 // LONGLONG_MIN and LONGLONG_MAX macros in limits.h.  This
 // assumes that long long is 64 bits.
 #if !defined(LONGLONG_MAX) && !defined(ULONGLONG_MAX)
 # define ULONGLONG_MAX 0xffffffffffffffffLLU
 # define LONGLONG_MAX 0x7fffffffffffffffLL
 #endif
 #if !defined(LONGLONG_MIN)
 # define LONGLONG_MIN (-LONGLONG_MAX - 1)
 #endif 
 #if !defined(ULONGLONG_MIN)
 # define ULONGLONG_MIN 0
 #endif 
 #endif /* __GNUC__ */
 // Specializations for all built-in floating-point type.
 template<> class numeric_limits<float>
  : public _Floating_limits<float, 
                            FLT_MANT_DIG,   // Binary digits of precision
                            FLT_DIG,        // Decimal digits of precision
                            FLT_MIN_EXP,    // Minimum exponent
                            FLT_MAX_EXP,    // Maximum exponent
                            FLT_MIN_10_EXP, // Minimum base 10 exponent
                            FLT_MAX_10_EXP, // Maximum base 10 exponent
 #if defined(BOOST_BIG_ENDIAN)
                            0x7f80 << (sizeof(int)*CHAR_BIT-16),    // Last word of +infinity
                            0x7f81 << (sizeof(int)*CHAR_BIT-16),    // Last word of quiet NaN
                            0x7fc1 << (sizeof(int)*CHAR_BIT-16),    // Last word of signaling NaN
 #else
                            0x7f800000u,    // Last word of +infinity
                            0x7f810000u,    // Last word of quiet NaN
                            0x7fc10000u,    // Last word of signaling NaN
 #endif
                            true,           // conforms to iec559
                            round_to_nearest>
 {
 public:
  static float min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MIN; }
  static float denorm_min() throw() { return FLT_MIN; }
  static float max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MAX; }
  static float epsilon() throw() { return FLT_EPSILON; }
  static float round_error() throw() { return 0.5f; } // Units: ulps.
 };
 template<> class numeric_limits<double>
  : public _Floating_limits<double, 
                            DBL_MANT_DIG,   // Binary digits of precision
                            DBL_DIG,        // Decimal digits of precision
                            DBL_MIN_EXP,    // Minimum exponent
                            DBL_MAX_EXP,    // Maximum exponent
                            DBL_MIN_10_EXP, // Minimum base 10 exponent
                            DBL_MAX_10_EXP, // Maximum base 10 exponent
 #if defined(BOOST_BIG_ENDIAN)
                            0x7ff0 << (sizeof(int)*CHAR_BIT-16),    // Last word of +infinity
                            0x7ff1 << (sizeof(int)*CHAR_BIT-16),    // Last word of quiet NaN
                            0x7ff9 << (sizeof(int)*CHAR_BIT-16),    // Last word of signaling NaN
 #else
                            0x7ff00000u,    // Last word of +infinity
                            0x7ff10000u,    // Last word of quiet NaN
                            0x7ff90000u,    // Last word of signaling NaN
 #endif
                            true,           // conforms to iec559
                            round_to_nearest>
 {
 public:
  static double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MIN; }
  static double denorm_min() throw() { return DBL_MIN; }
  static double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MAX; }
  static double epsilon() throw() { return DBL_EPSILON; }
  static double round_error() throw() { return 0.5; } // Units: ulps.
 };
 template<> class numeric_limits<long double>
  : public _Floating_limits<long double, 
                            LDBL_MANT_DIG,  // Binary digits of precision
                            LDBL_DIG,       // Decimal digits of precision
                            LDBL_MIN_EXP,   // Minimum exponent
                            LDBL_MAX_EXP,   // Maximum exponent
                            LDBL_MIN_10_EXP,// Minimum base 10 exponent
                            LDBL_MAX_10_EXP,// Maximum base 10 exponent
 #if defined(BOOST_BIG_ENDIAN)
                            0x7ff0 << (sizeof(int)*CHAR_BIT-16),    // Last word of +infinity
                            0x7ff1 << (sizeof(int)*CHAR_BIT-16),    // Last word of quiet NaN
                            0x7ff9 << (sizeof(int)*CHAR_BIT-16),    // Last word of signaling NaN
 #else
                            0x7fff8000u,    // Last word of +infinity
                            0x7fffc000u,    // Last word of quiet NaN
                            0x7fff9000u,    // Last word of signaling NaN
 #endif
                            false,          // Doesn't conform to iec559
                            round_to_nearest>
 {
 public:
  static long double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MIN; }
  static long double denorm_min() throw() { return LDBL_MIN; }
  static long double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MAX; }
  static long double epsilon() throw() { return LDBL_EPSILON; }
  static long double round_error() throw() { return 4; } // Units: ulps.
 };
 } // namespace std
 #endif /* BOOST_SGI_CPP_LIMITS */
 // Local Variables:
 // mode:C++
 // End:
@@ -0,0 +1,267 @@
 // Copyright David Abrahams 2002.
 // 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)
 #ifndef WORKAROUND_DWA2002126_HPP
 # define WORKAROUND_DWA2002126_HPP
 // Compiler/library version workaround macro
 //
 // Usage:
 //
 //     #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 //        // workaround for eVC4 and VC6
 //        ... // workaround code here
 //     #endif
 //
 // When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
 // first argument must be undefined or expand to a numeric
 // value. The above expands to:
 //
 //     (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
 //
 // When used for workarounds that apply to the latest known version 
 // and all earlier versions of a compiler, the following convention 
 // should be observed:
 //
 //     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
 //
 // The version number in this case corresponds to the last version in
 // which the workaround was known to have been required. When
 // BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
 // BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
 // the workaround for any version of the compiler. When
 // BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
 // error will be issued if the compiler version exceeds the argument
 // to BOOST_TESTED_AT().  This can be used to locate workarounds which
 // may be obsoleted by newer versions.
 # ifndef BOOST_STRICT_CONFIG
 #include <boost/config.hpp>
 #ifndef __BORLANDC__
 #define __BORLANDC___WORKAROUND_GUARD 1
 #else
 #define __BORLANDC___WORKAROUND_GUARD 0
 #endif
 #ifndef __CODEGEARC__
 #define __CODEGEARC___WORKAROUND_GUARD 1
 #else
 #define __CODEGEARC___WORKAROUND_GUARD 0
 #endif
 #ifndef _MSC_VER
 #define _MSC_VER_WORKAROUND_GUARD 1
 #else
 #define _MSC_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef _MSC_FULL_VER
 #define _MSC_FULL_VER_WORKAROUND_GUARD 1
 #else
 #define _MSC_FULL_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_MSVC
 #define BOOST_MSVC_WORKAROUND_GUARD 1
 #else
 #define BOOST_MSVC_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_MSVC_FULL_VER
 #define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
 #else
 #define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef __GNUC__
 #define __GNUC___WORKAROUND_GUARD 1
 #else
 #define __GNUC___WORKAROUND_GUARD 0
 #endif
 #ifndef __GNUC_MINOR__
 #define __GNUC_MINOR___WORKAROUND_GUARD 1
 #else
 #define __GNUC_MINOR___WORKAROUND_GUARD 0
 #endif
 #ifndef __GNUC_PATCHLEVEL__
 #define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
 #else
 #define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
 #endif
 #ifndef __IBMCPP__
 #define __IBMCPP___WORKAROUND_GUARD 1
 #else
 #define __IBMCPP___WORKAROUND_GUARD 0
 #endif
 #ifndef __SUNPRO_CC
 #define __SUNPRO_CC_WORKAROUND_GUARD 1
 #else
 #define __SUNPRO_CC_WORKAROUND_GUARD 0
 #endif
 #ifndef __DECCXX_VER
 #define __DECCXX_VER_WORKAROUND_GUARD 1
 #else
 #define __DECCXX_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef __MWERKS__
 #define __MWERKS___WORKAROUND_GUARD 1
 #else
 #define __MWERKS___WORKAROUND_GUARD 0
 #endif
 #ifndef __EDG__
 #define __EDG___WORKAROUND_GUARD 1
 #else
 #define __EDG___WORKAROUND_GUARD 0
 #endif
 #ifndef __EDG_VERSION__
 #define __EDG_VERSION___WORKAROUND_GUARD 1
 #else
 #define __EDG_VERSION___WORKAROUND_GUARD 0
 #endif
 #ifndef __HP_aCC
 #define __HP_aCC_WORKAROUND_GUARD 1
 #else
 #define __HP_aCC_WORKAROUND_GUARD 0
 #endif
 #ifndef __hpxstd98
 #define __hpxstd98_WORKAROUND_GUARD 1
 #else
 #define __hpxstd98_WORKAROUND_GUARD 0
 #endif
 #ifndef _CRAYC
 #define _CRAYC_WORKAROUND_GUARD 1
 #else
 #define _CRAYC_WORKAROUND_GUARD 0
 #endif
 #ifndef __DMC__
 #define __DMC___WORKAROUND_GUARD 1
 #else
 #define __DMC___WORKAROUND_GUARD 0
 #endif
 #ifndef MPW_CPLUS
 #define MPW_CPLUS_WORKAROUND_GUARD 1
 #else
 #define MPW_CPLUS_WORKAROUND_GUARD 0
 #endif
 #ifndef __COMO__
 #define __COMO___WORKAROUND_GUARD 1
 #else
 #define __COMO___WORKAROUND_GUARD 0
 #endif
 #ifndef __COMO_VERSION__
 #define __COMO_VERSION___WORKAROUND_GUARD 1
 #else
 #define __COMO_VERSION___WORKAROUND_GUARD 0
 #endif
 #ifndef __INTEL_COMPILER
 #define __INTEL_COMPILER_WORKAROUND_GUARD 1
 #else
 #define __INTEL_COMPILER_WORKAROUND_GUARD 0
 #endif
 #ifndef __ICL
 #define __ICL_WORKAROUND_GUARD 1
 #else
 #define __ICL_WORKAROUND_GUARD 0
 #endif
 #ifndef _COMPILER_VERSION
 #define _COMPILER_VERSION_WORKAROUND_GUARD 1
 #else
 #define _COMPILER_VERSION_WORKAROUND_GUARD 0
 #endif
 #ifndef _RWSTD_VER
 #define _RWSTD_VER_WORKAROUND_GUARD 1
 #else
 #define _RWSTD_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_RWSTD_VER
 #define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
 #else
 #define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef __GLIBCPP__
 #define __GLIBCPP___WORKAROUND_GUARD 1
 #else
 #define __GLIBCPP___WORKAROUND_GUARD 0
 #endif
 #ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
 #define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
 #else
 #define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
 #endif
 #ifndef __SGI_STL_PORT
 #define __SGI_STL_PORT_WORKAROUND_GUARD 1
 #else
 #define __SGI_STL_PORT_WORKAROUND_GUARD 0
 #endif
 #ifndef _STLPORT_VERSION
 #define _STLPORT_VERSION_WORKAROUND_GUARD 1
 #else
 #define _STLPORT_VERSION_WORKAROUND_GUARD 0
 #endif
 #ifndef __LIBCOMO_VERSION__
 #define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
 #else
 #define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
 #endif
 #ifndef _CPPLIB_VER
 #define _CPPLIB_VER_WORKAROUND_GUARD 1
 #else
 #define _CPPLIB_VER_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_INTEL_CXX_VERSION
 #define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
 #else
 #define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_INTEL_WIN
 #define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
 #else
 #define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_DINKUMWARE_STDLIB
 #define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
 #else
 #define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
 #endif
 #ifndef BOOST_INTEL
 #define BOOST_INTEL_WORKAROUND_GUARD 1
 #else
 #define BOOST_INTEL_WORKAROUND_GUARD 0
 #endif
 // Always define to zero, if it's used it'll be defined my MPL:
 #define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
 #  define BOOST_WORKAROUND(symbol, test)                \
         ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
         (symbol != 0) && (1 % (( (symbol test) ) + 1)))
 //                              ^ ^           ^ ^
 // The extra level of parenthesis nesting above, along with the
 // BOOST_OPEN_PAREN indirection below, is required to satisfy the
 // broken preprocessor in MWCW 8.3 and earlier.
 //
 // The basic mechanism works as follows:
 //      (symbol test) + 1        =>   if (symbol test) then 2 else 1
 //      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
 //
 // The complication with % is for cooperation with BOOST_TESTED_AT().
 // When "test" is BOOST_TESTED_AT(x) and
 // BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
 //
 //      symbol test              =>   if (symbol <= x) then 1 else -1
 //      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
 //      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
 //
 #  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
 #   define BOOST_OPEN_PAREN (
 #   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
 #  else
 #   define BOOST_TESTED_AT(value) != ((value)-(value))
 #  endif
 # else
 #  define BOOST_WORKAROUND(symbol, test) 0
 # endif 
 #endif // WORKAROUND_DWA2002126_HPP
@@ -0,0 +1,146 @@
 //  (C) Copyright John maddock 1999. 
 //  (C) David Abrahams 2002.  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)
 //
 // use this header as a workaround for missing <limits>
 //  See http://www.boost.org/libs/compatibility/index.html for documentation.
 #ifndef BOOST_LIMITS
 #define BOOST_LIMITS
 #include <boost/config.hpp>
 #ifdef BOOST_NO_LIMITS
 # include <boost/detail/limits.hpp>
 #else
 # include <limits>
 #endif
 #if (defined(BOOST_HAS_LONG_LONG) && defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)) \
      || (defined(BOOST_HAS_MS_INT64) && defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS))
 // Add missing specializations for numeric_limits:
 #ifdef BOOST_HAS_MS_INT64
 #  define BOOST_LLT __int64
 #  define BOOST_ULLT unsigned __int64
 #else
 #  define BOOST_LLT  ::boost::long_long_type
 #  define BOOST_ULLT  ::boost::ulong_long_type
 #endif
 #include <climits>  // for CHAR_BIT
 namespace std
 {
  template<>
  class numeric_limits<BOOST_LLT> 
  {
   public:
      BOOST_STATIC_CONSTANT(bool, is_specialized = true);
 #ifdef BOOST_HAS_MS_INT64
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x8000000000000000i64; }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x7FFFFFFFFFFFFFFFi64; }
 #elif defined(LLONG_MAX)
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MIN; }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MAX; }
 #elif defined(LONGLONG_MAX)
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MIN; }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MAX; }
 #else
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 1LL << (sizeof(BOOST_LLT) * CHAR_BIT - 1); }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~(min)(); }
 #endif
      BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT -1);
      BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT) - 1) * 301L / 1000);
      BOOST_STATIC_CONSTANT(bool, is_signed = true);
      BOOST_STATIC_CONSTANT(bool, is_integer = true);
      BOOST_STATIC_CONSTANT(bool, is_exact = true);
      BOOST_STATIC_CONSTANT(int, radix = 2);
      static BOOST_LLT epsilon() throw() { return 0; };
      static BOOST_LLT round_error() throw() { return 0; };
      BOOST_STATIC_CONSTANT(int, min_exponent = 0);
      BOOST_STATIC_CONSTANT(int, min_exponent10 = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent10 = 0);
      BOOST_STATIC_CONSTANT(bool, has_infinity = false);
      BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false);
      static BOOST_LLT infinity() throw() { return 0; };
      static BOOST_LLT quiet_NaN() throw() { return 0; };
      static BOOST_LLT signaling_NaN() throw() { return 0; };
      static BOOST_LLT denorm_min() throw() { return 0; };
      BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
      BOOST_STATIC_CONSTANT(bool, is_bounded = true);
      BOOST_STATIC_CONSTANT(bool, is_modulo = true);
      BOOST_STATIC_CONSTANT(bool, traps = false);
      BOOST_STATIC_CONSTANT(bool, tinyness_before = false);
      BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
  };
  template<>
  class numeric_limits<BOOST_ULLT> 
  {
   public:
      BOOST_STATIC_CONSTANT(bool, is_specialized = true);
 #ifdef BOOST_HAS_MS_INT64
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0ui64; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0xFFFFFFFFFFFFFFFFui64; }
 #elif defined(ULLONG_MAX) && defined(ULLONG_MIN)
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MIN; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MAX; }
 #elif defined(ULONGLONG_MAX) && defined(ULONGLONG_MIN)
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MIN; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MAX; }
 #else
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0uLL; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~0uLL; }
 #endif
      BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT);
      BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT)) * 301L / 1000);
      BOOST_STATIC_CONSTANT(bool, is_signed = false);
      BOOST_STATIC_CONSTANT(bool, is_integer = true);
      BOOST_STATIC_CONSTANT(bool, is_exact = true);
      BOOST_STATIC_CONSTANT(int, radix = 2);
      static BOOST_ULLT epsilon() throw() { return 0; };
      static BOOST_ULLT round_error() throw() { return 0; };
      BOOST_STATIC_CONSTANT(int, min_exponent = 0);
      BOOST_STATIC_CONSTANT(int, min_exponent10 = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent10 = 0);
      BOOST_STATIC_CONSTANT(bool, has_infinity = false);
      BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false);
      static BOOST_ULLT infinity() throw() { return 0; };
      static BOOST_ULLT quiet_NaN() throw() { return 0; };
      static BOOST_ULLT signaling_NaN() throw() { return 0; };
      static BOOST_ULLT denorm_min() throw() { return 0; };
      BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
      BOOST_STATIC_CONSTANT(bool, is_bounded = true);
      BOOST_STATIC_CONSTANT(bool, is_modulo = true);
      BOOST_STATIC_CONSTANT(bool, traps = false);
      BOOST_STATIC_CONSTANT(bool, tinyness_before = false);
      BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
  };
 }
 #endif 
 #endif
@@ -1,407 +0,0 @@
 /** -*- C++ -*-
 **  KAI C++ Compiler
 **
 **  Copyright (C) 1996-1997, Kuck & Associates, Inc. All rights reserved.
 **  This is an almost complete rewrite of Modena version.
 **/
 /**
 ** Lib++     : The Modena C++ Standard Library,
 **             Version 2.4, August 27th 1997
 **
 ** Copyright (c) 1994-1997 Modena Software Inc.
 **/
 #ifndef BOOST_GRAPH_DETAIL_LIMITS_HPP
 #define BOOST_GRAPH_DETAIL_LIMITS_HPP
 #include <boost/config.hpp>
 #ifdef BOOST_NO_LIMITS
 #define MSIPL_THROW
 #include <float.h>
 #include <limits.h>
 namespace std {
 enum float_round_style {
     round_indeterminate       = -1,
     round_toward_zero         =  0,
     round_to_nearest          =  1,
     round_toward_infinity     =  2,
     round_toward_neg_infinity =  3
 };
 template <class T>
 class numeric_limits {
 public:
    static const bool is_specialized = false;
    static T min() throw() {return T();}
    static T max() throw() {return T();}
    static const int  digits = 0;
    static const int  digits10 = 0;
    static const bool is_signed = false;
    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int  radix = 0;
    static T epsilon() throw() {return T();}
    static T round_error() throw() {return T();}
    static const int  min_exponent = 0;
    static const int  min_exponent10 = 0;
    static const int  max_exponent = 0;
    static const int  max_exponent10 = 0;
    static const bool has_infinity = false;
    static const bool has_quiet_NaN = false;
    static const bool has_signaling_NaN = false;
    static const bool has_denorm = false;
    static const bool has_denorm_loss = false;
    // Sept. 1996 draft is vague on how these can be guaranteed to return
    // value without throwing an exception.  
    static T infinity() throw() {return T();};
    static T quiet_NaN() throw() {return T();}
    static T signaling_NaN() throw() {return T();}
    static T denorm_min() throw() {return T();}
    static const bool is_iec559 = false;
    static const bool is_bounded = false;
    static const bool is_modulo = false;
    static const bool traps = false;
    static const bool tinyness_before = false;
    static const float_round_style round_style = round_toward_zero;
 };
 template<class T> const bool numeric_limits<T>::is_specialized;
 template<class T> const int  numeric_limits<T>::digits;
 template<class T> const int  numeric_limits<T>::digits10;
 template<class T> const bool numeric_limits<T>::is_signed;
 template<class T> const bool numeric_limits<T>::is_integer;
 template<class T> const bool numeric_limits<T>::is_exact;
 template<class T> const int  numeric_limits<T>::radix;
 template<class T> const int  numeric_limits<T>::min_exponent;
 template<class T> const int  numeric_limits<T>::min_exponent10;
 template<class T> const int  numeric_limits<T>::max_exponent;
 template<class T> const int  numeric_limits<T>::max_exponent10;
 template<class T> const bool numeric_limits<T>::has_infinity;
 template<class T> const bool numeric_limits<T>::has_quiet_NaN;
 template<class T> const bool numeric_limits<T>::has_signaling_NaN;
 template<class T> const bool numeric_limits<T>::has_denorm;
 template<class T> const bool numeric_limits<T>::has_denorm_loss;
 template<class T> const bool numeric_limits<T>::is_iec559;
 template<class T> const bool numeric_limits<T>::is_bounded;
 template<class T> const bool numeric_limits<T>::is_modulo;
 template<class T> const bool numeric_limits<T>::traps;
 template<class T> const bool numeric_limits<T>::tinyness_before;
 template<class T> const float_round_style numeric_limits<T>::round_style;
 // The specializations for floating-point types use the following macro 
 // to factor out commonality.  They presume IEEE arithmetic.
 #define __KAI_NUMERIC_LIMITS_FLOAT(T)    \
    static const bool is_specialized = true;  \
    static const int  radix = 2;    \
                                    \
    static const bool is_signed = true;    \
    static const bool is_integer = false;  \
    static const bool is_exact = false;    \
                                    \
    static const bool has_infinity = true;  \
    static const bool has_quiet_NaN = true;  \
    static const bool has_signaling_NaN = true;  \
    static const bool has_denorm = false;  \
    static const bool has_denorm_loss = false;  \
                                    \
    static const bool is_iec559 = sizeof(T)<=8;  \
    static const bool is_bounded = true;  \
    static const bool is_modulo = false;  \
    static const bool traps = true;    \
    static const bool tinyness_before = true;  \
                                     \
    static T round_error ()   MSIPL_THROW    { return (T)0.5F; }      \
    static const float_round_style round_style = round_to_nearest;  \
    static T infinity ()      MSIPL_THROW {return *(T*)(void*)data.value[0];}\
    static T quiet_NaN ()     MSIPL_THROW {return *(T*)(void*)data.value[1];}\
    static T signaling_NaN () MSIPL_THROW {return *(T*)(void*)data.value[2];}\
 private:                            \
    static const struct data_t {    \
  T align;                          \
  int value[3][sizeof(T)/sizeof(int)];  \
    } data;                            \
 public:                                    \
 template<>
 class numeric_limits <float> {
 public:
    static const int  digits = FLT_MANT_DIG;
    static const int  digits10 = FLT_DIG;
    static const int  min_exponent = FLT_MIN_EXP;
    static const int  max_exponent = FLT_MAX_EXP;
    static const int  min_exponent10 = FLT_MIN_10_EXP;
    static const int  max_exponent10 = FLT_MAX_10_EXP;
    __KAI_NUMERIC_LIMITS_FLOAT(float)
    static float min ()          MSIPL_THROW    { return FLT_MIN; }
    static float max ()          MSIPL_THROW    { return FLT_MAX; }
    static float epsilon ()      MSIPL_THROW    { return FLT_EPSILON; }
    static float denorm_min ()   MSIPL_THROW    { return FLT_MIN; }
 };
 template<>
 class numeric_limits <double> {
 public:
    static const int  digits = DBL_MANT_DIG;
    static const int  digits10 = DBL_DIG;
    static const int  min_exponent = DBL_MIN_EXP;
    static const int  max_exponent = DBL_MAX_EXP;
    static const int  min_exponent10 = DBL_MIN_10_EXP;
    static const int  max_exponent10 = DBL_MAX_10_EXP;
    __KAI_NUMERIC_LIMITS_FLOAT(double)
    static double min ()          MSIPL_THROW    { return DBL_MIN; }
    static double max ()          MSIPL_THROW    { return DBL_MAX; }
    static double epsilon ()      MSIPL_THROW    { return DBL_EPSILON; }
    static double denorm_min ()   MSIPL_THROW    { return min (); }
 };
 template<>
 class numeric_limits <long double> {
 public:
    static const int  digits = LDBL_MANT_DIG;
    static const int  digits10 = LDBL_DIG;
    static const int  min_exponent = LDBL_MIN_EXP;
    static const int  max_exponent = LDBL_MAX_EXP;
    static const int  min_exponent10 = LDBL_MIN_10_EXP;
    static const int  max_exponent10 = LDBL_MAX_10_EXP;
    __KAI_NUMERIC_LIMITS_FLOAT(long double)
    static long double min ()          MSIPL_THROW    { return LDBL_MIN; }
    static long double max ()          MSIPL_THROW    { return LDBL_MAX; }
    static long double epsilon ()      MSIPL_THROW    { return LDBL_EPSILON; }
    static long double denorm_min ()   MSIPL_THROW    { return min (); }
 };
 // The specializations for integral types use three macros to factor out
 // commonality.
 //
 //   __KAI_NUMERIC_LIMITS_INTEGRAL declares members of numeric_limits<T>
 //   whose value does not depend on the signdness of T. 
 //
 //  __KAI_NUMERIC_LIMITS_SIGNED(T) declares members dependent on
 //  knowing that T is signed.
 //
 //  __KAI_NUMERIC_LIMITS_UNSIGNED(T) declares members dependent on
 //  knowing that T is unsigned.
 //
 // We could have been real cutesy and come up with definitions that would
 // work for both signed and unsigned types, but doing so does not seem
 // to be worth the additional obfuscation and overhead for constant folding.
 //
 // The definitions are not intended to be universally portable.
 // They are designed with KAI C++ targets in mind. -ADR
 #define __KAI_NUMERIC_LIMITS_INTEGRAL(T)            \
    static const bool is_specialized = true;            \
                                                    \
    static const int radix = 2;                            \
    static const int min_exponent = 0;                    \
    static const int max_exponent = 0;                    \
    static const int min_exponent10 = 0;            \
    static const int max_exponent10 = 0;            \
                                                    \
    static const bool is_integer = true;            \
    static const bool is_exact = true;                    \
                                                    \
    static const bool has_infinity = false;            \
    static const bool has_quiet_NaN = false;            \
    static const bool has_signaling_NaN = false;    \
    static const bool has_denorm = false;            \
    static const bool has_denorm_loss = false;            \
                                                    \
    static const bool is_iec559 = false;            \
    static const bool is_bounded = true;            \
    static const bool is_modulo = true;                    \
    static const bool traps = false;                    \
    static const bool tinyness_before = false;            \
                                                    \
    static T infinity ()       MSIPL_THROW { return 0; }  \
    static T quiet_NaN ()      MSIPL_THROW { return 0; }  \
    static T signaling_NaN () MSIPL_THROW { return 0; }    \
    static T epsilon ()     MSIPL_THROW { return 1; }    \
    static T denorm_min ()  MSIPL_THROW { return min (); }  \
    static T round_error () MSIPL_THROW { return 0; }    \
                                                    \
    static const float_round_style round_style = round_toward_zero;
 #define __KAI_NUMERIC_LIMITS_SIGNED(T)                     \
    static const int digits = 8*sizeof(T)-1;            \
    /* Following presumes 8, 16, 32, or 64-bit T. */    \
    static const int digits10 = 7*sizeof(T)/3;             \
    static const bool is_signed = true;                    
 #define __KAI_NUMERIC_LIMITS_UNSIGNED(T)             \
    static const int digits = 8*sizeof(T);            \
    /* Following presumes 8, 16, 32, or 64-bit T. */    \
    static const int digits10 = 12*sizeof(T)/5;      \
    static const bool is_signed = false;                    
 template<>
 class numeric_limits <int> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(int)
    __KAI_NUMERIC_LIMITS_SIGNED(int)
    static int min() MSIPL_THROW { return INT_MIN; }
    static int max() MSIPL_THROW { return INT_MAX; }
 };
 template<>
 class numeric_limits <unsigned int> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned int)
    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned int)
    static unsigned int min() MSIPL_THROW { return 0; }
    static unsigned int max() MSIPL_THROW { return UINT_MAX; }
 };
 template<>
 class numeric_limits <long> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(long)
    __KAI_NUMERIC_LIMITS_SIGNED(long)
    static long min() MSIPL_THROW { return LONG_MIN; }
    static long max() MSIPL_THROW { return LONG_MAX; }
 };
 template<>
 class numeric_limits <unsigned long> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned long)
    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned long)
    static unsigned long min() MSIPL_THROW { return 0; }
    static unsigned long max() MSIPL_THROW { return ULONG_MAX; }
 };
 template<>
 class numeric_limits <short> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(short)
    __KAI_NUMERIC_LIMITS_SIGNED(short)
    static short min () MSIPL_THROW { return SHRT_MIN; }
    static short max () MSIPL_THROW { return SHRT_MAX; }
 };
 template<>
 class numeric_limits <unsigned short> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned short)
    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned short)
    static unsigned short min () MSIPL_THROW { return 0; }
    static unsigned short max () MSIPL_THROW { return USHRT_MAX; }
 };
 template<>
 class numeric_limits <char> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(char)
    static const int digits = CHAR_MIN<0 ? 7 : 8;
    static const int digits10 = 2;
    static const bool is_signed = CHAR_MIN<0;                    
    static char min () MSIPL_THROW { return CHAR_MIN; }
    static char max () MSIPL_THROW { return CHAR_MAX; }
 };
 template<>
 class numeric_limits <signed char> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(signed char)
    __KAI_NUMERIC_LIMITS_SIGNED(signed char)
    static signed char min ()         MSIPL_THROW { return SCHAR_MIN; }
    static signed char max ()         MSIPL_THROW { return SCHAR_MAX; }
 };
 template<>
 class numeric_limits <unsigned char> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned char)
    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned char)
    static unsigned char min ()         MSIPL_THROW { return 0; }
    static unsigned char max ()         MSIPL_THROW { return UCHAR_MAX; }
 };
 #if 0
 #ifdef MSIPL_WCHART
 template<>
 class numeric_limits <wchar_t> {
 public:
    __KAI_NUMERIC_LIMITS_INTEGRAL(wchar_t)
    static const bool is_signed = (wchar_t)-1<0;
    static const int digits = 8*sizeof(wchar_t) - is_signed;
    // Following assumes that wchar_t is 8, 16, or 32-bit, 
    // either signed or unsigned.
    static const int digits10 = 7*sizeof(T)/3;
    static char min () MSIPL_THROW { return CHAR_MIN; }
    static char max () MSIPL_THROW { return CHAR_MAX; }
 };
 #endif /* MSIPL_WCHART */
 #ifdef _BOOL
 template<>
 class numeric_limits <bool> {
 public:
    static const bool is_specialized = true;
    static const int radix = 2;
    static const int min_exponent = 0;
    static const int max_exponent = 0;
    static const int min_exponent10 = 0;
    static const int max_exponent10 = 0;
    static const bool is_integer = false;
    static const bool is_exact = true;
    static const bool has_infinity = false;
    static const bool has_quiet_NaN = false;
    static const bool has_signaling_NaN = false;
    static const bool has_denorm = false;
    static const bool has_denorm_loss = false;
    static const bool is_iec559 = false;
    static const bool is_bounded = true;
    static const bool is_modulo = false;
    static const bool traps = false;
    static const bool tinyness_before = false;
    static bool infinity ()       MSIPL_THROW { return false; }
    static bool quiet_NaN ()      MSIPL_THROW { return false; }
    static bool signaling_NaN () MSIPL_THROW { return false; }
    static bool epsilon ()     MSIPL_THROW { return false; }
    static bool denorm_min ()  MSIPL_THROW { return min (); }
    static bool round_error () MSIPL_THROW { return false; }
    static const float_round_style round_style = round_toward_zero;
    static const int digits = 1;
    static const int digits10 = 0;
    static const bool is_signed = false;
    static bool min ()         MSIPL_THROW { return false; }
    static bool max ()         MSIPL_THROW { return true; }
 };
 #endif  /* _BOOL */
 #endif
 } /* namespace std */
 #else
 #include <limits>
 #endif /* BOOST_GRAPH_DETAIL_HAVE_LIMITS */
 #endif /* BOOST_GRAPH_DETAIL_LIMIT_H */
@@ -0,0 +1,35 @@
 //  Boost version.hpp configuration header file  ------------------------------//
 //  (C) Copyright John maddock 1999. 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/libs/config for documentation
 #ifndef BOOST_VERSION_HPP
 #define BOOST_VERSION_HPP
 //
 //  Caution, this is the only boost header that is guarenteed
 //  to change with every boost release, including this header
 //  will cause a recompile every time a new boost version is
 //  released.
 //
 //  BOOST_VERSION % 100 is the patch level
 //  BOOST_VERSION / 100 % 1000 is the minor version
 //  BOOST_VERSION / 100000 is the major version
 #define BOOST_VERSION 104800
 //
 //  BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
 //  but as a *string* in the form "x_y[_z]" where x is the major version
 //  number, y is the minor version number, and z is the patch level if not 0.
 //  This is used by <config/auto_link.hpp> to select which library version to link to.
 #define BOOST_LIB_VERSION "1_48"
 #endif
@@ -1,87 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Configuration Header</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <table border="1" bgcolor="#007F7F" cellpadding="2">
  <tr>
    <td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
    <td><a href="../../index.htm"><font face="Arial" color="#FFFFFF"><big>Home</big></font></a></td>
    <td><a href="../../libraries.htm"><font face="Arial" color="#FFFFFF"><big>Libraries</big></font></a></td>
    <td><a href="../../people.htm"><font face="Arial" color="#FFFFFF"><big>People</big></font></a></td>
    <td><a href="../../more/faq.htm"><font face="Arial" color="#FFFFFF"><big>FAQ</big></font></a></td>
    <td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More</big></font></a></td>
  </tr>
 </table>
 <h1>Configuration Header <a href="../../boost/config.hpp">boost/config.hpp</a></h1>
 <p>The <a href="../../boost/config.hpp">boost/config.hpp</a> header is used to
 pass configuration information to other boost files, allowing them to cope with
 platform dependencies such as arithmetic byte ordering, compiler pragmas, or
 compiler shortcomings. Without such configuration information, many current
 compilers would not work with the Boost libraries.</p>
 <p>Centralizing configuration information is this header reduces the number of
 files which must be modified when porting libraries to new platforms, or when
 compilers are updated. Ideally, no other files would have to be modified when
 porting to a new platform.</p>
 <p>Configuration headers are controversial because some view them as condoning
 broken compilers and encouraging non-standard subsets. Adding settings for
 additional platforms and maintaining existing settings can also be a problem. In
 other words, configuration headers are a necessary evil rather than a desirable
 feature. The boost config.hpp policy is designed to minimize the problems and
 maximize the benefits of a configuration header.</p>
 <h2>Boost config.hpp policy</h2>
 <p>For Library Users:</p>
 <ul>
  <li>Boost library users are never required to #include boost/config.hpp, and
    are discouraged from including it on their own.</li>
  <li>Boost library users can request support for additional platforms be added
    to config.hpp by emailing <a href="mailto:config@boost.org">config@boost.org</a>
    describing their request.</li>
 </ul>
 <p>For Library Implementors:</p>
 <ul>
  <li>Boost library implementors are not required to #include boost/config.hpp,
    and are not required in any way to support compilers which do not comply
    with the C++ Standard (ISO/IEC 14882).</li>
  <li>If a library implementor wishes to support some nonconforming compiler, or
    to support some platform specific feature, #include boost/config.hpp is the
    preferred way to obtain configuration information not available from the
    standard headers such as &lt;climits&gt;, etc.</li>
  <li>If configuration information can be deduced from standard headers such as
    &lt;climits&gt;, use those standard headers rather than boost/config.hpp.</li>
  <li>Boost files that use macros defined in boost/config.hpp should have
    sensible, standard conforming, default behavior if the macro is not defined.
    This means that the starting point for porting boost/config.hpp to a new
    platform is simply to define nothing at all specific to that platform. In
    the rare case where there is no sensible default behavior, an #error message
    should describe the problem.</li>
  <li>If a Boost library implementor wants something added to config.hpp, post a
    request on the Boost mailing list. There is no guarantee such a request will
    be honored; the intent is to limit the complexity of config.hpp.</li>
 </ul>
 <p>General:</p>
 <ul>
  <li>The intent is to support only compilers which appear on their way to
    becoming C++ Standard compliant, and only recent releases of those compilers
    at that.</li>
  <li>The intent is not to disable mainstream features now well-supported by the
    majority of compilers, such as namespaces, exceptions, RTTI, or templates.</li>
 </ul>
 <h2>Documentation</h2>
 <p>See <a href="../../boost/config.hpp">boost/config.hpp</a>; it is designed to
 be self documenting.</p>
 <h2>Test program</h2>
 <p>The <a href="config_test.cpp">config_test.cpp</a> program can be used to
 verify which #defines are in effect for your compiler.</p>
 <hr>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->23 Jun 2000<!--webbot bot="Timestamp" endspan i-checksum="15048" --></p>
 </body>
 </html>
@@ -0,0 +1,15 @@
 <html>
   <head>
      <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
   </head>
   <body>
      <P>
         Automatic redirection failed, please go to <a href="doc/html/index.html">doc/html/index.html</a>.
      </P>
      <P>Copyright&nbsp;John Maddock 2001</P>
      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
   </body>
 </html>
@@ -0,0 +1,62 @@
 #
 # Copyright John Maddock 2008.
 # Use, modification and distribution are subject to 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)
 #
 # If you need to alter build preferences then set them in
 # the template defined in options_v2.jam.
 #
 import modules ;
 local is_unix = [ modules.peek : UNIX ] ;
 if $(is_unix)
 {
 	local osname = [ SHELL uname ] ;
 	switch $(osname)
 	{
 		case "Sun*" : OTHERFLAGS = "-lpthread -lrt" ;
 		case "*BSD*" : OTHERFLAGS = "-lpthread" ;
 	}
 }
 test-suite config
  : 
    [ compile config_test_c.c ]
    [ run config_test.cpp 
          : #args
          : #input-files
          : #requirements
          <threading>multi
          : config_test_threaded
    ]
    [ run config_test.cpp 
          : #args
          : #input-files
          : #requirements
          <threading>single <toolset>msvc:<runtime-link>static <toolset>msvc:<link>static 
          <target-os>linux:<linkflags>-lpthread
          <target-os>linux:<linkflags>-lrt
          <toolset>gcc:<linkflags>$(OTHERFLAGS)
    ]
     [ run config_info.cpp : : : <test-info>always_show_run_output <threading>single <toolset>msvc:<runtime-link>static <toolset>msvc:<link>static ]
     [ run config_info.cpp : : : <test-info>always_show_run_output <threading>multi : config_info_threaded ]
     [ run math_info.cpp : : : <test-info>always_show_run_output <toolset>borland:<runtime-link>static <toolset>borland:<link>static ]
     [ run abi/abi_test.cpp abi/main.cpp ]
     [ run limits_test.cpp ../../test/build//boost_test_exec_monitor ]
     [ run link/main.cpp link//link_test
          : #args
          : #input-files
          : #requirements
          <runtime-link>shared
          <define>BOOST_DYN_LINK=1
          <define>BOOST_CONFIG_NO_LIB=1
          :
          config_link_test
    ]
    [ compile-fail threads/test_thread_fail1.cpp ]
    [ compile-fail threads/test_thread_fail2.cpp ]
  ;
@@ -0,0 +1,27 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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/libs/config for the most recent version.
 #include "abi_test.hpp"
 char abi_test::virtual_one()const
 { 
   return c; 
 }
 boost::int32_t abi_test::virtual_two()const
 { 
   return i; 
 }
 abi_test::abi_test()
 {
   c = 0x12;
   i = 0x5678;
 }
@@ -0,0 +1,54 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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/libs/config for the most recent version.
 #ifndef BOOST_ABI_TEST_HPP
 #define BOOST_ABI_TEST_HPP
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
 #ifdef BOOST_HAS_ABI_HEADERS
 #include BOOST_ABI_PREFIX
 #endif
 //
 // the following class is designed to break if the ABI
 // it's compiled with does not match that of the client
 // calling it....
 //
 struct empty{};
 class abi_test : protected empty
 {
 private:
   empty e;
   char c;
   boost::int32_t i;
 public:
   inline char inline_one()const
   { return c; }
   inline boost::int32_t inline_two()const
   { return i; }
   virtual char virtual_one()const;
   virtual boost::int32_t virtual_two()const;
   abi_test();
 };
 #ifdef BOOST_HAS_ABI_HEADERS
 #include BOOST_ABI_SUFFIX
 #endif
 #endif // BOOST_ABI_TEST_HPP
@@ -0,0 +1,31 @@
 //  (C) Copyright John Maddock 2003. 
 //  Use, modification and distribution are subject to 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/libs/config for the most recent version.
 //
 // before we do anything else, we need to mess with the compilers ABI:
 //
 #include <boost/config.hpp>
 #ifdef BOOST_MSVC
 #pragma pack(1)
 #elif defined(__BORLANDC__)
 #pragma option -Ve- -Vx- -a1 -b-
 #endif
 #include <stdio.h>
 #include "abi_test.hpp"
 int main()
 {
   abi_test t;
   if((t.inline_one() != t.virtual_one()) || (t.inline_two() != t.virtual_two()))
   {
      fwrite("Failed ABI test", 1, 15, stdout);
      return -1;
   }
   return 0;
 }
@@ -0,0 +1,526 @@
 #
 # Regression test Jamfile for boost configuration setup.
 # *** DO NOT EDIT THIS FILE BY HAND ***
 # This file was automatically generated on Wed Jul 13 18:50:14 2011
 #  by libs/config/tools/generate.cpp
 # Copyright John Maddock.
 # Use, modification and distribution are subject to 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)
 #
 # If you need to alter build preferences then set them in
 # the template defined in options_v2.jam.
 #
 path-constant DOT : . ;
 include $(DOT)/options_v2.jam ;
 run ../config_info.cpp  : : : <threading>single <toolset>msvc:<runtime-link>static <toolset>msvc:<link>static ;
 run ../config_info.cpp  : : : <threading>multi : config_info_threaded ;
 run ../math_info.cpp : : : <toolset>borland:<runtime-link>static <toolset>borland:<link>static ;
 run ../config_test.cpp : : : <threading>single <toolset>msvc:<runtime-link>static <toolset>msvc:<link>static ;
 run ../config_test.cpp : : : <threading>multi : config_test_threaded ;
 run ../limits_test.cpp ../../../test/build//boost_test_exec_monitor ;
 run ../abi/abi_test.cpp ../abi/main.cpp  ;
 test-suite "BOOST_HAS_TWO_ARG_USE_FACET" : 
 [ run ../has_2arg_use_facet_pass.cpp ]
 [ compile-fail ../has_2arg_use_facet_fail.cpp ] ;
 test-suite "BOOST_HAS_BETHREADS" : 
 [ run ../has_bethreads_pass.cpp ]
 [ compile-fail ../has_bethreads_fail.cpp ] ;
 test-suite "BOOST_HAS_CLOCK_GETTIME" : 
 [ run ../has_clock_gettime_pass.cpp ]
 [ compile-fail ../has_clock_gettime_fail.cpp ] ;
 test-suite "BOOST_HAS_DIRENT_H" : 
 [ run ../has_dirent_h_pass.cpp ]
 [ compile-fail ../has_dirent_h_fail.cpp ] ;
 test-suite "BOOST_HAS_EXPM1" : 
 [ run ../has_expm1_pass.cpp ]
 [ compile-fail ../has_expm1_fail.cpp ] ;
 test-suite "BOOST_HAS_FTIME" : 
 [ run ../has_ftime_pass.cpp ]
 [ compile-fail ../has_ftime_fail.cpp ] ;
 test-suite "BOOST_HAS_GETSYSTEMTIMEASFILETIME" : 
 [ run ../has_getsystemtimeasfiletime_pass.cpp ]
 [ compile-fail ../has_getsystemtimeasfiletime_fail.cpp ] ;
 test-suite "BOOST_HAS_GETTIMEOFDAY" : 
 [ run ../has_gettimeofday_pass.cpp ]
 [ compile-fail ../has_gettimeofday_fail.cpp ] ;
 test-suite "BOOST_HAS_HASH" : 
 [ run ../has_hash_pass.cpp ]
 [ compile-fail ../has_hash_fail.cpp ] ;
 test-suite "BOOST_HAS_LOG1P" : 
 [ run ../has_log1p_pass.cpp ]
 [ compile-fail ../has_log1p_fail.cpp ] ;
 test-suite "BOOST_HAS_LONG_LONG" : 
 [ run ../has_long_long_pass.cpp ]
 [ compile-fail ../has_long_long_fail.cpp ] ;
 test-suite "BOOST_HAS_MACRO_USE_FACET" : 
 [ run ../has_macro_use_facet_pass.cpp ]
 [ compile-fail ../has_macro_use_facet_fail.cpp ] ;
 test-suite "BOOST_HAS_MS_INT64" : 
 [ run ../has_ms_int64_pass.cpp ]
 [ compile-fail ../has_ms_int64_fail.cpp ] ;
 test-suite "BOOST_HAS_NANOSLEEP" : 
 [ run ../has_nanosleep_pass.cpp ]
 [ compile-fail ../has_nanosleep_fail.cpp ] ;
 test-suite "BOOST_HAS_NL_TYPES_H" : 
 [ run ../has_nl_types_h_pass.cpp ]
 [ compile-fail ../has_nl_types_h_fail.cpp ] ;
 test-suite "BOOST_HAS_NRVO" : 
 [ run ../has_nrvo_pass.cpp ]
 [ compile-fail ../has_nrvo_fail.cpp ] ;
 test-suite "BOOST_HAS_PARTIAL_STD_ALLOCATOR" : 
 [ run ../has_part_alloc_pass.cpp ]
 [ compile-fail ../has_part_alloc_fail.cpp ] ;
 test-suite "BOOST_HAS_PTHREADS" : 
 [ run ../has_pthreads_pass.cpp ]
 [ compile-fail ../has_pthreads_fail.cpp ] ;
 test-suite "BOOST_HAS_PTHREAD_DELAY_NP" : 
 [ run ../has_pthread_delay_np_pass.cpp ]
 [ compile-fail ../has_pthread_delay_np_fail.cpp ] ;
 test-suite "BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE" : 
 [ run ../has_pthread_ma_st_pass.cpp ]
 [ compile-fail ../has_pthread_ma_st_fail.cpp ] ;
 test-suite "BOOST_HAS_PTHREAD_YIELD" : 
 [ run ../has_pthread_yield_pass.cpp ]
 [ compile-fail ../has_pthread_yield_fail.cpp ] ;
 test-suite "BOOST_HAS_RVALUE_REFS" : 
 [ run ../has_rvalue_refs_pass.cpp ]
 [ compile-fail ../has_rvalue_refs_fail.cpp ] ;
 test-suite "BOOST_HAS_SCHED_YIELD" : 
 [ run ../has_sched_yield_pass.cpp ]
 [ compile-fail ../has_sched_yield_fail.cpp ] ;
 test-suite "BOOST_HAS_SGI_TYPE_TRAITS" : 
 [ run ../has_sgi_type_traits_pass.cpp ]
 [ compile-fail ../has_sgi_type_traits_fail.cpp ] ;
 test-suite "BOOST_HAS_SIGACTION" : 
 [ run ../has_sigaction_pass.cpp ]
 [ compile-fail ../has_sigaction_fail.cpp ] ;
 test-suite "BOOST_HAS_SLIST" : 
 [ run ../has_slist_pass.cpp ]
 [ compile-fail ../has_slist_fail.cpp ] ;
 test-suite "BOOST_HAS_STATIC_ASSERT" : 
 [ run ../has_static_assert_pass.cpp ]
 [ compile-fail ../has_static_assert_fail.cpp ] ;
 test-suite "BOOST_HAS_STDINT_H" : 
 [ run ../has_stdint_h_pass.cpp ]
 [ compile-fail ../has_stdint_h_fail.cpp ] ;
 test-suite "BOOST_HAS_STLP_USE_FACET" : 
 [ run ../has_stlp_use_facet_pass.cpp ]
 [ compile-fail ../has_stlp_use_facet_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_ARRAY" : 
 [ run ../has_tr1_array_pass.cpp ]
 [ compile-fail ../has_tr1_array_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_BIND" : 
 [ run ../has_tr1_bind_pass.cpp ]
 [ compile-fail ../has_tr1_bind_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_COMPLEX_OVERLOADS" : 
 [ run ../has_tr1_complex_over_pass.cpp ]
 [ compile-fail ../has_tr1_complex_over_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG" : 
 [ run ../has_tr1_complex_trig_pass.cpp ]
 [ compile-fail ../has_tr1_complex_trig_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_FUNCTION" : 
 [ run ../has_tr1_function_pass.cpp ]
 [ compile-fail ../has_tr1_function_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_HASH" : 
 [ run ../has_tr1_hash_pass.cpp ]
 [ compile-fail ../has_tr1_hash_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_MEM_FN" : 
 [ run ../has_tr1_mem_fn_pass.cpp ]
 [ compile-fail ../has_tr1_mem_fn_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_RANDOM" : 
 [ run ../has_tr1_random_pass.cpp ]
 [ compile-fail ../has_tr1_random_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_REFERENCE_WRAPPER" : 
 [ run ../has_tr1_ref_wrap_pass.cpp ]
 [ compile-fail ../has_tr1_ref_wrap_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_REGEX" : 
 [ run ../has_tr1_regex_pass.cpp ]
 [ compile-fail ../has_tr1_regex_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_RESULT_OF" : 
 [ run ../has_tr1_result_of_pass.cpp ]
 [ compile-fail ../has_tr1_result_of_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_SHARED_PTR" : 
 [ run ../has_tr1_shared_ptr_pass.cpp ]
 [ compile-fail ../has_tr1_shared_ptr_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_TUPLE" : 
 [ run ../has_tr1_tuple_pass.cpp ]
 [ compile-fail ../has_tr1_tuple_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_TYPE_TRAITS" : 
 [ run ../has_tr1_type_traits_pass.cpp ]
 [ compile-fail ../has_tr1_type_traits_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_UNORDERED_MAP" : 
 [ run ../has_tr1_unordered_map_pass.cpp ]
 [ compile-fail ../has_tr1_unordered_map_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_UNORDERED_SET" : 
 [ run ../has_tr1_unordered_set_pass.cpp ]
 [ compile-fail ../has_tr1_unordered_set_fail.cpp ] ;
 test-suite "BOOST_HAS_TR1_UTILITY" : 
 [ run ../has_tr1_utility_pass.cpp ]
 [ compile-fail ../has_tr1_utility_fail.cpp ] ;
 test-suite "BOOST_HAS_UNISTD_H" : 
 [ run ../has_unistd_h_pass.cpp ]
 [ compile-fail ../has_unistd_h_fail.cpp ] ;
 test-suite "BOOST_HAS_VARIADIC_TMPL" : 
 [ run ../has_variadic_tmpl_pass.cpp ]
 [ compile-fail ../has_variadic_tmpl_fail.cpp ] ;
 test-suite "BOOST_MSVC6_MEMBER_TEMPLATES" : 
 [ run ../has_vc6_mem_templ_pass.cpp ]
 [ compile-fail ../has_vc6_mem_templ_fail.cpp ] ;
 test-suite "BOOST_MSVC_STD_ITERATOR" : 
 [ run ../has_vc_iterator_pass.cpp ]
 [ compile-fail ../has_vc_iterator_fail.cpp ] ;
 test-suite "BOOST_HAS_WINTHREADS" : 
 [ run ../has_winthreads_pass.cpp ]
 [ compile-fail ../has_winthreads_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_ARRAY" : 
 [ run ../no_0x_hdr_array_pass.cpp ]
 [ compile-fail ../no_0x_hdr_array_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_CHRONO" : 
 [ run ../no_0x_hdr_chrono_pass.cpp ]
 [ compile-fail ../no_0x_hdr_chrono_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_CODECVT" : 
 [ run ../no_0x_hdr_codecvt_pass.cpp ]
 [ compile-fail ../no_0x_hdr_codecvt_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_CONDITION_VARIABLE" : 
 [ run ../no_0x_hdr_condition_variable_pass.cpp ]
 [ compile-fail ../no_0x_hdr_condition_variable_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_FORWARD_LIST" : 
 [ run ../no_0x_hdr_forward_list_pass.cpp ]
 [ compile-fail ../no_0x_hdr_forward_list_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_FUTURE" : 
 [ run ../no_0x_hdr_future_pass.cpp ]
 [ compile-fail ../no_0x_hdr_future_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_INITIALIZER_LIST" : 
 [ run ../no_0x_hdr_initializer_list_pass.cpp ]
 [ compile-fail ../no_0x_hdr_initializer_list_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_MUTEX" : 
 [ run ../no_0x_hdr_mutex_pass.cpp ]
 [ compile-fail ../no_0x_hdr_mutex_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_RANDOM" : 
 [ run ../no_0x_hdr_random_pass.cpp ]
 [ compile-fail ../no_0x_hdr_random_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_RATIO" : 
 [ run ../no_0x_hdr_ratio_pass.cpp ]
 [ compile-fail ../no_0x_hdr_ratio_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_REGEX" : 
 [ run ../no_0x_hdr_regex_pass.cpp ]
 [ compile-fail ../no_0x_hdr_regex_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_SYSTEM_ERROR" : 
 [ run ../no_0x_hdr_system_error_pass.cpp ]
 [ compile-fail ../no_0x_hdr_system_error_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_THREAD" : 
 [ run ../no_0x_hdr_thread_pass.cpp ]
 [ compile-fail ../no_0x_hdr_thread_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_TUPLE" : 
 [ run ../no_0x_hdr_tuple_pass.cpp ]
 [ compile-fail ../no_0x_hdr_tuple_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_TYPEINDEX" : 
 [ run ../no_0x_hdr_typeindex_pass.cpp ]
 [ compile-fail ../no_0x_hdr_typeindex_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_TYPE_TRAITS" : 
 [ run ../no_0x_hdr_type_traits_pass.cpp ]
 [ compile-fail ../no_0x_hdr_type_traits_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_UNORDERED_MAP" : 
 [ run ../no_0x_hdr_unordered_map_pass.cpp ]
 [ compile-fail ../no_0x_hdr_unordered_map_fail.cpp ] ;
 test-suite "BOOST_NO_0X_HDR_UNORDERED_SET" : 
 [ run ../no_0x_hdr_unordered_set_pass.cpp ]
 [ compile-fail ../no_0x_hdr_unordered_set_fail.cpp ] ;
 test-suite "BOOST_NO_ADL_BARRIER" : 
 [ run ../no_adl_barrier_pass.cpp ]
 [ compile-fail ../no_adl_barrier_fail.cpp ] ;
 test-suite "BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP" : 
 [ run ../no_arg_dep_lookup_pass.cpp ]
 [ compile-fail ../no_arg_dep_lookup_fail.cpp ] ;
 test-suite "BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS" : 
 [ run ../no_array_type_spec_pass.cpp ]
 [ compile-fail ../no_array_type_spec_fail.cpp ] ;
 test-suite "BOOST_NO_AUTO_DECLARATIONS" : 
 [ run ../no_auto_declarations_pass.cpp ]
 [ compile-fail ../no_auto_declarations_fail.cpp ] ;
 test-suite "BOOST_NO_AUTO_MULTIDECLARATIONS" : 
 [ run ../no_auto_multidecl_pass.cpp ]
 [ compile-fail ../no_auto_multidecl_fail.cpp ] ;
 test-suite "BOOST_NO_AUTO_PTR" : 
 [ run ../no_auto_ptr_pass.cpp ]
 [ compile-fail ../no_auto_ptr_fail.cpp ] ;
 test-suite "BOOST_BCB_PARTIAL_SPECIALIZATION_BUG" : 
 [ run ../no_bcb_partial_spec_pass.cpp ]
 [ compile-fail ../no_bcb_partial_spec_fail.cpp ] ;
 test-suite "BOOST_NO_CHAR16_T" : 
 [ run ../no_char16_t_pass.cpp ]
 [ compile-fail ../no_char16_t_fail.cpp ] ;
 test-suite "BOOST_NO_CHAR32_T" : 
 [ run ../no_char32_t_pass.cpp ]
 [ compile-fail ../no_char32_t_fail.cpp ] ;
 test-suite "BOOST_NO_COMPLETE_VALUE_INITIALIZATION" : 
 [ run ../no_com_value_init_pass.cpp ]
 [ compile-fail ../no_com_value_init_fail.cpp ] ;
 test-suite "BOOST_NO_CONSTEXPR" : 
 [ run ../no_constexpr_pass.cpp ]
 [ compile-fail ../no_constexpr_fail.cpp ] ;
 test-suite "BOOST_NO_CTYPE_FUNCTIONS" : 
 [ run ../no_ctype_functions_pass.cpp ]
 [ compile-fail ../no_ctype_functions_fail.cpp ] ;
 test-suite "BOOST_NO_CV_SPECIALIZATIONS" : 
 [ run ../no_cv_spec_pass.cpp ]
 [ compile-fail ../no_cv_spec_fail.cpp ] ;
 test-suite "BOOST_NO_CV_VOID_SPECIALIZATIONS" : 
 [ run ../no_cv_void_spec_pass.cpp ]
 [ compile-fail ../no_cv_void_spec_fail.cpp ] ;
 test-suite "BOOST_NO_CWCHAR" : 
 [ run ../no_cwchar_pass.cpp ]
 [ compile-fail ../no_cwchar_fail.cpp ] ;
 test-suite "BOOST_NO_CWCTYPE" : 
 [ run ../no_cwctype_pass.cpp ]
 [ compile-fail ../no_cwctype_fail.cpp ] ;
 test-suite "BOOST_NO_DECLTYPE" : 
 [ run ../no_decltype_pass.cpp ]
 [ compile-fail ../no_decltype_fail.cpp ] ;
 test-suite "BOOST_NO_DECLTYPE_N3276" : 
 [ run ../no_decltype_n3276_pass.cpp ]
 [ compile-fail ../no_decltype_n3276_fail.cpp ] ;
 test-suite "BOOST_DEDUCED_TYPENAME" : 
 [ run ../no_ded_typename_pass.cpp ]
 [ compile-fail ../no_ded_typename_fail.cpp ] ;
 test-suite "BOOST_NO_DEFAULTED_FUNCTIONS" : 
 [ run ../no_defaulted_functions_pass.cpp ]
 [ compile-fail ../no_defaulted_functions_fail.cpp ] ;
 test-suite "BOOST_NO_DELETED_FUNCTIONS" : 
 [ run ../no_deleted_functions_pass.cpp ]
 [ compile-fail ../no_deleted_functions_fail.cpp ] ;
 test-suite "BOOST_NO_DEPENDENT_NESTED_DERIVATIONS" : 
 [ run ../no_dep_nested_class_pass.cpp ]
 [ compile-fail ../no_dep_nested_class_fail.cpp ] ;
 test-suite "BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS" : 
 [ run ../no_dep_val_param_pass.cpp ]
 [ compile-fail ../no_dep_val_param_fail.cpp ] ;
 test-suite "BOOST_NO_EXCEPTIONS" : 
 [ run ../no_exceptions_pass.cpp ]
 [ compile-fail ../no_exceptions_fail.cpp ] ;
 test-suite "BOOST_NO_EXCEPTION_STD_NAMESPACE" : 
 [ run ../no_excep_std_pass.cpp ]
 [ compile-fail ../no_excep_std_fail.cpp ] ;
 test-suite "BOOST_NO_EXPLICIT_CONVERSION_OPERATORS" : 
 [ run ../no_explicit_cvt_ops_pass.cpp ]
 [ compile-fail ../no_explicit_cvt_ops_fail.cpp ] ;
 test-suite "BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS" : 
 [ run ../no_exp_func_tem_arg_pass.cpp ]
 [ compile-fail ../no_exp_func_tem_arg_fail.cpp ] ;
 test-suite "BOOST_NO_EXTERN_TEMPLATE" : 
 [ run ../no_extern_template_pass.cpp ]
 [ compile-fail ../no_extern_template_fail.cpp ] ;
 test-suite "BOOST_NO_FENV_H" : 
 [ run ../no_fenv_h_pass.cpp ]
 [ compile-fail ../no_fenv_h_fail.cpp ] ;
 test-suite "BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS" : 
 [ run ../no_function_template_default_args_pass.cpp ]
 [ compile-fail ../no_function_template_default_args_fail.cpp ] ;
 test-suite "BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS" : 
 [ run ../no_function_type_spec_pass.cpp ]
 [ compile-fail ../no_function_type_spec_fail.cpp ] ;
 test-suite "BOOST_NO_FUNCTION_TEMPLATE_ORDERING" : 
 [ run ../no_func_tmp_order_pass.cpp ]
 [ compile-fail ../no_func_tmp_order_fail.cpp ] ;
 test-suite "BOOST_NO_MS_INT64_NUMERIC_LIMITS" : 
 [ run ../no_i64_limits_pass.cpp ]
 [ compile-fail ../no_i64_limits_fail.cpp ] ;
 test-suite "BOOST_NO_INITIALIZER_LISTS" : 
 [ run ../no_initializer_lists_pass.cpp ]
 [ compile-fail ../no_initializer_lists_fail.cpp ] ;
 test-suite "BOOST_NO_INCLASS_MEMBER_INITIALIZATION" : 
 [ run ../no_inline_memb_init_pass.cpp ]
 [ compile-fail ../no_inline_memb_init_fail.cpp ] ;
 test-suite "BOOST_NO_INTEGRAL_INT64_T" : 
 [ run ../no_integral_int64_t_pass.cpp ]
 [ compile-fail ../no_integral_int64_t_fail.cpp ] ;
 test-suite "BOOST_NO_IOSFWD" : 
 [ run ../no_iosfwd_pass.cpp ]
 [ compile-fail ../no_iosfwd_fail.cpp ] ;
 test-suite "BOOST_NO_IOSTREAM" : 
 [ run ../no_iostream_pass.cpp ]
 [ compile-fail ../no_iostream_fail.cpp ] ;
 test-suite "BOOST_NO_IS_ABSTRACT" : 
 [ run ../no_is_abstract_pass.cpp ]
 [ compile-fail ../no_is_abstract_fail.cpp ] ;
 test-suite "BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS" : 
 [ run ../no_iter_construct_pass.cpp ]
 [ compile-fail ../no_iter_construct_fail.cpp ] ;
 test-suite "BOOST_NO_LAMBDAS" : 
 [ run ../no_lambdas_pass.cpp ]
 [ compile-fail ../no_lambdas_fail.cpp ] ;
 test-suite "BOOST_NO_LIMITS" : 
 [ run ../no_limits_pass.cpp ]
 [ compile-fail ../no_limits_fail.cpp ] ;
 test-suite "BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS" : 
 [ run ../no_limits_const_exp_pass.cpp ]
 [ compile-fail ../no_limits_const_exp_fail.cpp ] ;
 test-suite "BOOST_NO_NUMERIC_LIMITS_LOWEST" : 
 [ run ../no_limits_lowest_pass.cpp ]
 [ compile-fail ../no_limits_lowest_fail.cpp ] ;
 test-suite "BOOST_NO_LONG_LONG_NUMERIC_LIMITS" : 
 [ run ../no_ll_limits_pass.cpp ]
 [ compile-fail ../no_ll_limits_fail.cpp ] ;
 test-suite "BOOST_NO_LONG_LONG" : 
 [ run ../no_long_long_pass.cpp ]
 [ compile-fail ../no_long_long_fail.cpp ] ;
 test-suite "BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS" : 
 [ run ../no_mem_func_spec_pass.cpp ]
 [ compile-fail ../no_mem_func_spec_fail.cpp ] ;
 test-suite "BOOST_NO_MEMBER_TEMPLATES" : 
 [ run ../no_mem_templates_pass.cpp ]
 [ compile-fail ../no_mem_templates_fail.cpp ] ;
 test-suite "BOOST_NO_MEMBER_TEMPLATE_FRIENDS" : 
 [ run ../no_mem_templ_frnds_pass.cpp ]
 [ compile-fail ../no_mem_templ_frnds_fail.cpp ] ;
 test-suite "BOOST_NO_MEMBER_TEMPLATE_KEYWORD" : 
 [ run ../no_mem_tem_keyword_pass.cpp ]
 [ compile-fail ../no_mem_tem_keyword_fail.cpp ] ;
 test-suite "BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS" : 
 [ run ../no_mem_tem_pnts_pass.cpp ]
 [ compile-fail ../no_mem_tem_pnts_fail.cpp ] ;
 test-suite "BOOST_NO_NESTED_FRIENDSHIP" : 
 [ run ../no_nested_friendship_pass.cpp ]
 [ compile-fail ../no_nested_friendship_fail.cpp ] ;
 test-suite "BOOST_NO_NOEXCEPT" : 
 [ run ../no_noexcept_pass.cpp ]
 [ compile-fail ../no_noexcept_fail.cpp ] ;
 test-suite "BOOST_NO_NULLPTR" : 
 [ run ../no_nullptr_pass.cpp ]
 [ compile-fail ../no_nullptr_fail.cpp ] ;
 test-suite "BOOST_NO_OPERATORS_IN_NAMESPACE" : 
 [ run ../no_ops_in_namespace_pass.cpp ]
 [ compile-fail ../no_ops_in_namespace_fail.cpp ] ;
 test-suite "BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION" : 
 [ run ../no_partial_spec_pass.cpp ]
 [ compile-fail ../no_partial_spec_fail.cpp ] ;
 test-suite "BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS" : 
 [ run ../no_part_spec_def_args_pass.cpp ]
 [ compile-fail ../no_part_spec_def_args_fail.cpp ] ;
 test-suite "BOOST_NO_PRIVATE_IN_AGGREGATE" : 
 [ run ../no_priv_aggregate_pass.cpp ]
 [ compile-fail ../no_priv_aggregate_fail.cpp ] ;
 test-suite "BOOST_NO_POINTER_TO_MEMBER_CONST" : 
 [ run ../no_ptr_mem_const_pass.cpp ]
 [ compile-fail ../no_ptr_mem_const_fail.cpp ] ;
 test-suite "BOOST_NO_RAW_LITERALS" : 
 [ run ../no_raw_literals_pass.cpp ]
 [ compile-fail ../no_raw_literals_fail.cpp ] ;
 test-suite "BOOST_NO_UNREACHABLE_RETURN_DETECTION" : 
 [ run ../no_ret_det_pass.cpp ]
 [ compile-fail ../no_ret_det_fail.cpp ] ;
 test-suite "BOOST_NO_RTTI" : 
 [ run ../no_rtti_pass.cpp ]
 [ compile-fail ../no_rtti_fail.cpp ] ;
 test-suite "BOOST_NO_RVALUE_REFERENCES" : 
 [ run ../no_rvalue_references_pass.cpp ]
 [ compile-fail ../no_rvalue_references_fail.cpp ] ;
 test-suite "BOOST_NO_SCOPED_ENUMS" : 
 [ run ../no_scoped_enums_pass.cpp ]
 [ compile-fail ../no_scoped_enums_fail.cpp ] ;
 test-suite "BOOST_NO_SFINAE" : 
 [ run ../no_sfinae_pass.cpp ]
 [ compile-fail ../no_sfinae_fail.cpp ] ;
 test-suite "BOOST_NO_SFINAE_EXPR" : 
 [ run ../no_sfinae_expr_pass.cpp ]
 [ compile-fail ../no_sfinae_expr_fail.cpp ] ;
 test-suite "BOOST_NO_STRINGSTREAM" : 
 [ run ../no_sstream_pass.cpp ]
 [ compile-fail ../no_sstream_fail.cpp ] ;
 test-suite "BOOST_NO_STATIC_ASSERT" : 
 [ run ../no_static_assert_pass.cpp ]
 [ compile-fail ../no_static_assert_fail.cpp ] ;
 test-suite "BOOST_NO_STDC_NAMESPACE" : 
 [ run ../no_stdc_namespace_pass.cpp ]
 [ compile-fail ../no_stdc_namespace_fail.cpp ] ;
 test-suite "BOOST_NO_STD_ALLOCATOR" : 
 [ run ../no_std_allocator_pass.cpp ]
 [ compile-fail ../no_std_allocator_fail.cpp ] ;
 test-suite "BOOST_NO_STD_DISTANCE" : 
 [ run ../no_std_distance_pass.cpp ]
 [ compile-fail ../no_std_distance_fail.cpp ] ;
 test-suite "BOOST_NO_STD_ITERATOR" : 
 [ run ../no_std_iterator_pass.cpp ]
 [ compile-fail ../no_std_iterator_fail.cpp ] ;
 test-suite "BOOST_NO_STD_ITERATOR_TRAITS" : 
 [ run ../no_std_iter_traits_pass.cpp ]
 [ compile-fail ../no_std_iter_traits_fail.cpp ] ;
 test-suite "BOOST_NO_STD_LOCALE" : 
 [ run ../no_std_locale_pass.cpp ]
 [ compile-fail ../no_std_locale_fail.cpp ] ;
 test-suite "BOOST_NO_STD_MESSAGES" : 
 [ run ../no_std_messages_pass.cpp ]
 [ compile-fail ../no_std_messages_fail.cpp ] ;
 test-suite "BOOST_NO_STD_MIN_MAX" : 
 [ run ../no_std_min_max_pass.cpp ]
 [ compile-fail ../no_std_min_max_fail.cpp ] ;
 test-suite "BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN" : 
 [ run ../no_std_oi_assign_pass.cpp ]
 [ compile-fail ../no_std_oi_assign_fail.cpp ] ;
 test-suite "BOOST_NO_STD_TYPEINFO" : 
 [ run ../no_std_typeinfo_pass.cpp ]
 [ compile-fail ../no_std_typeinfo_fail.cpp ] ;
 test-suite "BOOST_NO_STD_UNORDERED" : 
 [ run ../no_std_unordered_pass.cpp ]
 [ compile-fail ../no_std_unordered_fail.cpp ] ;
 test-suite "BOOST_NO_STD_USE_FACET" : 
 [ run ../no_std_use_facet_pass.cpp ]
 [ compile-fail ../no_std_use_facet_fail.cpp ] ;
 test-suite "BOOST_NO_STD_WSTREAMBUF" : 
 [ run ../no_std_wstreambuf_pass.cpp ]
 [ compile-fail ../no_std_wstreambuf_fail.cpp ] ;
 test-suite "BOOST_NO_STD_WSTRING" : 
 [ run ../no_std_wstring_pass.cpp ]
 [ compile-fail ../no_std_wstring_fail.cpp ] ;
 test-suite "BOOST_NO_SWPRINTF" : 
 [ run ../no_swprintf_pass.cpp ]
 [ compile-fail ../no_swprintf_fail.cpp ] ;
 test-suite "BOOST_NO_TEMPLATE_ALIASES" : 
 [ run ../no_template_aliases_pass.cpp ]
 [ compile-fail ../no_template_aliases_fail.cpp ] ;
 test-suite "BOOST_NO_TEMPLATED_IOSTREAMS" : 
 [ run ../no_template_streams_pass.cpp ]
 [ compile-fail ../no_template_streams_fail.cpp ] ;
 test-suite "BOOST_NO_TEMPLATE_TEMPLATES" : 
 [ run ../no_template_template_pass.cpp ]
 [ compile-fail ../no_template_template_fail.cpp ] ;
 test-suite "BOOST_NO_TWO_PHASE_NAME_LOOKUP" : 
 [ run ../no_two_phase_lookup_pass.cpp ]
 [ compile-fail ../no_two_phase_lookup_fail.cpp ] ;
 test-suite "BOOST_NO_TYPEID" : 
 [ run ../no_typeid_pass.cpp ]
 [ compile-fail ../no_typeid_fail.cpp ] ;
 test-suite "BOOST_NO_TYPENAME_WITH_CTOR" : 
 [ run ../no_typename_with_ctor_pass.cpp ]
 [ compile-fail ../no_typename_with_ctor_fail.cpp ] ;
 test-suite "BOOST_NO_UNICODE_LITERALS" : 
 [ run ../no_unicode_literals_pass.cpp ]
 [ compile-fail ../no_unicode_literals_fail.cpp ] ;
 test-suite "BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX" : 
 [ run ../no_unified_init_pass.cpp ]
 [ compile-fail ../no_unified_init_fail.cpp ] ;
 test-suite "BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL" : 
 [ run ../no_using_breaks_adl_pass.cpp ]
 [ compile-fail ../no_using_breaks_adl_fail.cpp ] ;
 test-suite "BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE" : 
 [ run ../no_using_decl_overld_pass.cpp ]
 [ compile-fail ../no_using_decl_overld_fail.cpp ] ;
 test-suite "BOOST_NO_USING_TEMPLATE" : 
 [ run ../no_using_template_pass.cpp ]
 [ compile-fail ../no_using_template_fail.cpp ] ;
 test-suite "BOOST_NO_VARIADIC_MACROS" : 
 [ run ../no_variadic_macros_pass.cpp ]
 [ compile-fail ../no_variadic_macros_fail.cpp ] ;
 test-suite "BOOST_NO_VARIADIC_TEMPLATES" : 
 [ run ../no_variadic_templates_pass.cpp ]
 [ compile-fail ../no_variadic_templates_fail.cpp ] ;
 test-suite "BOOST_NO_VOID_RETURNS" : 
 [ run ../no_void_returns_pass.cpp ]
 [ compile-fail ../no_void_returns_fail.cpp ] ;
 test-suite "BOOST_NO_INTRINSIC_WCHAR_T" : 
 [ run ../no_wchar_t_pass.cpp ]
 [ compile-fail ../no_wchar_t_fail.cpp ] ;
@@ -0,0 +1,12 @@
 # copyright John Maddock 2003
 # Use, modification and distribution are subject to 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)
 project
    : requirements 
     # threading tests require thread support turned on:
     <threading>multi
   ;
 local test-requirements = <library>../../test/build//boost_test_exec_monitor  ;
@@ -0,0 +1,32 @@
 //  (C) Copyright John Maddock 2001. 
 //  Use, modification and distribution are subject to 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/libs/config for most recent version.
 //  MACRO:         BOOST_HAS_TWO_ARG_USE_FACET
 //  TITLE:         two argument version of use_facet
 //  DESCRIPTION:   The standard library lacks a conforming std::use_facet,
 //                 but has a two argument version that does the job.
 //                 This is primarily for the Rogue Wave std lib.
 #include <locale>
 namespace boost_has_two_arg_use_facet{
 int test()
 {
   std::locale l;
   const std::ctype<char>& ct = std::use_facet(l, (std::ctype<char>*)0);
   return 0;
 }
 }
--- a/Show More
+++ b/Show More