passenger 3.9.1.beta → 3.9.2.beta

data/ext/boost/lambda/detail/return_type_traits.hpp

@@ -0,0 +1,282 @@
+//  return_type_traits.hpp -- Boost Lambda Library ---------------------------
+
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+//
+// For more information, see www.boost.org
+
+
+#ifndef BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
+#define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
+
+#include "boost/mpl/has_xxx.hpp"
+
+#include <cstddef> // needed for the ptrdiff_t
+
+namespace boost { 
+namespace lambda {
+
+using ::boost::type_traits::ice_and;
+using ::boost::type_traits::ice_or;
+using ::boost::type_traits::ice_not;
+
+// Much of the type deduction code for standard arithmetic types 
+// from Gary Powell
+
+  // different arities:
+template <class Act, class A1> struct return_type_1; // 1-ary actions
+template <class Act, class A1, class A2> struct return_type_2; // 2-ary
+template <class Act, class Args> struct return_type_N; // >3- ary
+
+template <class Act, class A1> struct return_type_1_prot;
+template <class Act, class A1, class A2> struct return_type_2_prot; // 2-ary
+template <class Act, class A1> struct return_type_N_prot; // >3-ary
+
+
+namespace detail {
+
+template<class> class return_type_deduction_failure {};
+
+  // In some cases return type deduction should fail (an invalid lambda 
+  // expression). Sometimes the lambda expression can be ok, the return type
+  // just is not deducible (user defined operators). Then return type deduction
+  // should never be entered at all, and the use of ret<> does this.
+  // However, for nullary lambda functors, return type deduction is always
+  // entered, and there seems to be no way around this.
+
+  // (the return type is part of the prototype of the non-template
+  // operator()(). The prototype is instantiated, even though the body 
+  // is not.) 
+ 
+  // So, in the case the return type deduction should fail, it should not
+  // fail directly, but rather result in a valid but wrong return type,
+  // causing a compile time error only if the function is really called.
+
+
+
+} // end detail
+
+
+
+// return_type_X_prot classes --------------------------------------------
+// These classes are the first layer that gets instantiated from the 
+// lambda_functor_base sig templates. It will check whether 
+// the action is protectable and one of arguments is "protected" or its
+// evaluation will otherwise result in another lambda functor.
+// If this is a case, the result type will be another lambda functor.
+
+// The arguments are always non-reference types, except for comma action
+// where the right argument can be a reference too. This is because it 
+// matters (in the builtin case) whether the argument is an lvalue or 
+// rvalue: int i; i, 1 -> rvalue; 1, i -> lvalue
+
+template <class Act, class A> struct return_type_1_prot {
+public:
+  typedef typename 
+    detail::IF<
+  //      is_protectable<Act>::value && is_lambda_functor<A>::value,
+      ice_and<is_protectable<Act>::value, is_lambda_functor<A>::value>::value,
+      lambda_functor<
+        lambda_functor_base< 
+          Act, 
+          tuple<typename detail::remove_reference_and_cv<A>::type>
+        >
+      >,
+      typename return_type_1<Act, A>::type
+    >::RET type;  
+};
+
+  // take care of the unavoidable instantiation for nullary case
+template<class Act> struct return_type_1_prot<Act, null_type> {
+  typedef null_type type;
+};
+ 
+// Unary actions (result from unary operators)
+// do not have a default return type.
+template<class Act, class A> struct return_type_1 { 
+   typedef typename 
+     detail::return_type_deduction_failure<return_type_1> type;
+};
+
+
+namespace detail {
+
+  template <class T>
+  class protect_conversion {
+      typedef typename boost::remove_reference<T>::type non_ref_T;
+    public:
+
+  // add const to rvalues, so that all rvalues are stored as const in 
+  // the args tuple
+    typedef typename detail::IF_type<
+//      boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value,
+      ice_and<boost::is_reference<T>::value,
+              ice_not<boost::is_const<non_ref_T>::value>::value>::value,
+      detail::identity_mapping<T>,
+      const_copy_argument<non_ref_T> // handles funtion and array 
+    >::type type;                      // types correctly
+  };
+
+} // end detail
+
+template <class Act, class A, class B> struct return_type_2_prot {
+
+// experimental feature
+  // We may have a lambda functor as a result type of a subexpression 
+  // (if protect) has  been used.
+  // Thus, if one of the parameter types is a lambda functor, the result
+  // is a lambda functor as well. 
+  // We need to make a conservative choise here.
+  // The resulting lambda functor stores all const reference arguments as
+  // const copies. References to non-const are stored as such.
+  // So if the source of the argument is a const open argument, a bound
+  // argument stored as a const reference, or a function returning a 
+  // const reference, that information is lost. There is no way of 
+  // telling apart 'real const references' from just 'LL internal
+  // const references' (or it would be really hard)
+
+  // The return type is a subclass of lambda_functor, which has a converting 
+  // copy constructor. It can copy any lambda functor, that has the same 
+  // action type and code, and a copy compatible argument tuple.
+
+
+  typedef typename boost::remove_reference<A>::type non_ref_A;
+  typedef typename boost::remove_reference<B>::type non_ref_B;
+
+typedef typename 
+  detail::IF<
+//    is_protectable<Act>::value &&
+//      (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
+    ice_and<is_protectable<Act>::value,
+            ice_or<is_lambda_functor<A>::value, 
+                   is_lambda_functor<B>::value>::value>::value,
+    lambda_functor<
+      lambda_functor_base< 
+        Act, 
+        tuple<typename detail::protect_conversion<A>::type, 
+              typename detail::protect_conversion<B>::type>
+      >
+    >,
+    typename return_type_2<Act, non_ref_A, non_ref_B>::type
+  >::RET type;
+};
+
+  // take care of the unavoidable instantiation for nullary case
+template<class Act> struct return_type_2_prot<Act, null_type, null_type> {
+  typedef null_type type;
+};
+  // take care of the unavoidable instantiation for nullary case
+template<class Act, class Other> struct return_type_2_prot<Act, Other, null_type> {
+  typedef null_type type;
+};
+  // take care of the unavoidable instantiation for nullary case
+template<class Act, class Other> struct return_type_2_prot<Act, null_type, Other> {
+  typedef null_type type;
+};
+
+  // comma is a special case, as the user defined operator can return
+  // an lvalue (reference) too, hence it must be handled at this level.
+template<class A, class B> 
+struct return_type_2_comma
+{
+  typedef typename boost::remove_reference<A>::type non_ref_A;
+  typedef typename boost::remove_reference<B>::type non_ref_B;
+
+typedef typename 
+  detail::IF<
+//  is_protectable<other_action<comma_action> >::value && // it is protectable
+//  (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
+    ice_and<is_protectable<other_action<comma_action> >::value, // it is protectable
+            ice_or<is_lambda_functor<A>::value, 
+                   is_lambda_functor<B>::value>::value>::value,
+    lambda_functor<
+      lambda_functor_base< 
+        other_action<comma_action>, 
+        tuple<typename detail::protect_conversion<A>::type, 
+              typename detail::protect_conversion<B>::type>
+      >
+    >,
+    typename 
+      return_type_2<other_action<comma_action>, non_ref_A, non_ref_B>::type
+  >::RET type1;
+
+   // if no user defined return_type_2 (or plain_return_type_2) specialization
+  // matches, then return the righthand argument
+  typedef typename 
+    detail::IF<
+      boost::is_same<type1, detail::unspecified>::value, 
+      B,
+      type1
+    >::RET type;
+
+};
+
+
+  // currently there are no protectable actions with > 2 args
+
+template<class Act, class Args> struct return_type_N_prot {
+  typedef typename return_type_N<Act, Args>::type type;
+};
+
+  // take care of the unavoidable instantiation for nullary case
+template<class Act> struct return_type_N_prot<Act, null_type> {
+  typedef null_type type;
+};
+
+// handle different kind of actions ------------------------
+
+  // use the return type given in the bind invocation as bind<Ret>(...)
+template<int I, class Args, class Ret> 
+struct return_type_N<function_action<I, Ret>, Args> { 
+  typedef Ret type;
+};
+
+// ::result_type support
+
+namespace detail
+{
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
+
+template<class F> struct get_result_type
+{
+  typedef typename F::result_type type;
+};
+
+template<class F, class A> struct get_sig
+{
+  typedef typename function_adaptor<F>::template sig<A>::type type;
+};
+
+} // namespace detail
+
+  // Ret is detail::unspecified, so try to deduce return type
+template<int I, class Args> 
+struct return_type_N<function_action<I, detail::unspecified>, Args > { 
+
+  // in the case of function action, the first element in Args is 
+  // some type of function
+  typedef typename Args::head_type Func;
+  typedef typename detail::remove_reference_and_cv<Func>::type plain_Func;
+
+public: 
+  // pass the function to function_adaptor, and get the return type from 
+  // that
+  typedef typename detail::IF<
+    detail::has_result_type<plain_Func>::value,
+    detail::get_result_type<plain_Func>,
+    detail::get_sig<plain_Func, Args>
+  >::RET::type type;
+};
+
+
+} // namespace lambda
+} // namespace boost
+
+#endif
+
+
+

data/ext/boost/lambda/detail/select_functions.hpp

@@ -0,0 +1,74 @@
+// -- select_functions.hpp -- Boost Lambda Library --------------------------
+
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+//
+// For more information, see http://www.boost.org
+
+
+#ifndef BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
+#define BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
+
+namespace boost { 
+namespace lambda {
+namespace detail {
+
+
+// select functions -------------------------------
+template<class Any, CALL_TEMPLATE_ARGS>
+inline Any& select(Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
+
+
+template<class Arg, CALL_TEMPLATE_ARGS>
+inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
+select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { 
+  return op.template call<
+    typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
+  >(CALL_ACTUAL_ARGS); 
+}
+template<class Arg, CALL_TEMPLATE_ARGS>
+inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
+select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) { 
+  return op.template call<
+    typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
+  >(CALL_ACTUAL_ARGS); 
+}
+
+// ------------------------------------------------------------------------
+// select functions where the return type is explicitly given
+// Note: on many functions, this return type is just discarded.
+// The select functions are inside a class template, and the return type
+// is a class template argument.
+// The first implementation used function templates with an explicitly 
+// specified template parameter.
+// However, this resulted in ambiguous calls (at least with gcc 2.95.2 
+// and edg 2.44). Not sure whether the compilers were right or wrong. 
+  
+template<class RET> struct r_select {
+
+// Any == RET
+  template<class Any, CALL_TEMPLATE_ARGS>
+  static 
+  inline RET go (Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
+
+
+  template<class Arg, CALL_TEMPLATE_ARGS> 
+  static 
+  inline RET go (const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
+    return op.template call<RET>(CALL_ACTUAL_ARGS); 
+  }
+  template<class Arg, CALL_TEMPLATE_ARGS> 
+  static 
+  inline RET go (lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { 
+    return op.template call<RET>(CALL_ACTUAL_ARGS); 
+  }
+};
+   
+} // namespace detail
+} // namespace lambda
+} // namespace boost
+
+#endif

data/ext/boost/lambda/lambda.hpp

@@ -0,0 +1,34 @@
+// -- lambda.hpp -- Boost Lambda Library -----------------------------------
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+//
+// For more information, see http://lambda.cs.utu.fi 
+
+#ifndef BOOST_LAMBDA_LAMBDA_HPP
+#define BOOST_LAMBDA_LAMBDA_HPP
+
+
+#include "boost/lambda/core.hpp"
+
+#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
+#include <istream>
+#include <ostream>
+#endif
+
+#include "boost/lambda/detail/operator_actions.hpp"
+#include "boost/lambda/detail/operator_lambda_func_base.hpp"
+#include "boost/lambda/detail/operator_return_type_traits.hpp"
+
+
+#include "boost/lambda/detail/operators.hpp"
+
+#ifndef BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER
+// sorry, member ptr does not work with gcc2.95
+#include "boost/lambda/detail/member_ptr.hpp"
+#endif
+
+
+#endif

data/ext/boost/lexical_cast.hpp

@@ -18,7 +18,7 @@
 //        with additional fixes and suggestions from Gennaro Prota,
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
 //        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
-//        Cheng Yang, Matthew Bradbury, David W. Birdsall and other Boosters
+//        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
 // when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2012
 
 #include <boost/config.hpp>
@@ -26,65 +26,33 @@
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 
-#if (defined(__MINGW32__) || defined(__MINGW64__)) && (__GNUC__ == 4) \
- && ((__GNUC_MINOR__ == 4) || (__GNUC_MINOR__ == 5)) && defined(__STRICT_ANSI__) \
- && !defined(BOOST_LCAST_NO_WCHAR_T)
-
-// workaround for a mingw bug
-// http://sourceforge.net/tracker/index.php?func=detail&aid=2373234&group_id=2435&atid=102435
-#include <_mingw.h>
-#if (__GNUC_MINOR__ == 4)
-extern "C" {
-_CRTIMP int __cdecl swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...);
-_CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...);
-}
-#endif
-#if (__GNUC_MINOR__ == 5)
-extern "C" {
-_CRTIMP int __cdecl swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...);
-_CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , va_list);
-}
-#endif
-#endif
-
 #include <climits>
 #include <cstddef>
-#include <istream>
 #include <string>
 #include <cstring>
 #include <cstdio>
 #include <typeinfo>
 #include <exception>
-#include <cmath>
 #include <boost/limits.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/numeric/conversion/cast.hpp>
 #include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/math/special_functions/sign.hpp>
-#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/type_traits/is_pointer.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
-#if !defined(__SUNPRO_CC)
-#include <boost/container/container_fwd.hpp>
-#endif // !defined(__SUNPRO_CC)
-#ifndef BOOST_NO_CWCHAR
-#   include <cwchar>
-#endif
+
 
 #ifndef BOOST_NO_STD_LOCALE
 #   include <locale>
 #else
 #   ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-#       warning "Unable to use <locale> header. boost::lexical_cast will use the 'C' locale."
-#       define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+        // Getting error at this point means, that your STL library is old/lame/misconfigured.
+        // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
+        // but beware: lexical_cast will understand only 'C' locale delimeters and thousands
+        // separators.
+#       error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
+#       error "boost::lexical_cast to use only 'C' locale during conversions."
 #   endif
 #endif
 
@@ -104,7 +72,7 @@ _CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restric
 namespace boost
 {
     // exception used to indicate runtime lexical_cast failure
-    class bad_lexical_cast :
+    class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
     // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0 
 #if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS 
         public std::exception 
@@ -119,7 +87,7 @@ namespace boost
 
     {
     public:
-        bad_lexical_cast() :
+        bad_lexical_cast() BOOST_NOEXCEPT :
 #ifndef BOOST_NO_TYPEID
           source(&typeid(void)), target(&typeid(void))
 #else
@@ -130,7 +98,7 @@ namespace boost
 
         bad_lexical_cast(
             const std::type_info &source_type_arg,
-            const std::type_info &target_type_arg) :
+            const std::type_info &target_type_arg) BOOST_NOEXCEPT :
             source(&source_type_arg), target(&target_type_arg)
         {
         }
@@ -144,131 +112,222 @@ namespace boost
             return *target;
         }
 
+#ifndef BOOST_NO_NOEXCEPT
+        virtual const char *what() const noexcept
+#else
         virtual const char *what() const throw()
+#endif
         {
             return "bad lexical cast: "
                    "source type value could not be interpreted as target";
         }
+
+#ifndef BOOST_NO_NOEXCEPT
+        virtual ~bad_lexical_cast() BOOST_NOEXCEPT
+#else
         virtual ~bad_lexical_cast() throw()
-        {
-        }
+#endif
+        {}
     private:
         const std::type_info *source;
         const std::type_info *target;
     };
 
-    namespace detail // selectors for choosing stream character type
+    namespace detail // widest_char
     {
-    template<typename Type>
-    struct stream_char
-    {
-        typedef char type;
-    };
+        template <typename TargetChar, typename SourceChar>
+        struct widest_char
+        {
+            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+                (sizeof(TargetChar) > sizeof(SourceChar))
+                , TargetChar
+                , SourceChar >::type type;
+        };
+    }
+} // namespace boost
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template<class CharT, class Traits, class Alloc>
-    struct stream_char< std::basic_string<CharT,Traits,Alloc> >
-    {
-        typedef CharT type;
-    };
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC) && !defined(__PGIC__)
 
-#if !defined(__SUNPRO_CC)
-    template<class CharT, class Traits, class Alloc>
-    struct stream_char< ::boost::container::basic_string<CharT,Traits,Alloc> >
-    {
-        typedef CharT type;
-    };
-#endif // !defined(__SUNPRO_CC)
+#include <cmath>
+#include <istream>
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+#include <array>
 #endif
 
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    template<>
-    struct stream_char<wchar_t>
-    {
-        typedef wchar_t type;
-    };
+#include <boost/array.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/math/special_functions/sign.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/container/container_fwd.hpp>
+#ifndef BOOST_NO_CWCHAR
+#   include <cwchar>
 #endif
 
-    template<>
-    struct stream_char<wchar_t *>
+namespace boost {
+    namespace detail // widest_char<...> (continuation)
     {
-        typedef wchar_t type;
-    };
+        struct not_a_character_type{};
 
-    template<>
-    struct stream_char<const wchar_t *>
-    {
-        typedef wchar_t type;
-    };
+        template <typename CharT>
+        struct widest_char<not_a_character_type, CharT >
+        {
+            typedef CharT type;
+        };
+
+        template <typename CharT>
+        struct widest_char< CharT, not_a_character_type >
+        {
+            typedef CharT type;
+        };
+                
+        template <>
+        struct widest_char< not_a_character_type, not_a_character_type >
+        {
+            typedef char type;
+        };
+    } 
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template<>
-    struct stream_char<std::wstring>
+    namespace detail // is_char_or_wchar<...> and stream_char<...> templates
     {
-        typedef wchar_t type;
-    };
-#endif
-#endif
+        // returns true, if T is one of the character types
+        template <typename T>
+        struct is_char_or_wchar
+        {
+            typedef ::boost::type_traits::ice_or<
+                    ::boost::is_same< T, char >::value,
+                    #ifndef BOOST_LCAST_NO_WCHAR_T
+                        ::boost::is_same< T, wchar_t >::value,
+                    #endif
+                    #ifndef BOOST_NO_CHAR16_T
+                        ::boost::is_same< T, char16_t >::value,
+                    #endif
+                    #ifndef BOOST_NO_CHAR32_T
+                        ::boost::is_same< T, char32_t >::value,
+                    #endif
+                    ::boost::is_same< T, unsigned char >::value,
+                    ::boost::is_same< T, signed char >::value
+            > result_type;
+
+            BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
+        };
 
+        // selectors for choosing stream character type
+        // returns one of char, wchar_t, char16_t, char32_t or not_a_character_type types
+        template <typename Type>
+        struct stream_char
+        {
+            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+                is_char_or_wchar<Type >::value,
+                Type,
+                boost::detail::not_a_character_type
+            >::type type;
+        };
 
-#ifndef BOOST_NO_CHAR16_T
+        template <>
+        struct stream_char<unsigned char>
+        {
+            typedef char type;
+        };
 
-    template<>
-    struct stream_char<char16_t>
-    {
-        typedef char16_t type;
-    };
+        template <>
+        struct stream_char<signed char>
+        {
+            typedef char type;
+        };
 
-    template<>
-    struct stream_char<char16_t *>
-    {
-        typedef char16_t type;
-    };
+        template <typename CharT>
+        struct stream_char<CharT*>
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT>::type type;
+        };
 
-    template<>
-    struct stream_char<const char16_t *>
-    {
-        typedef char16_t type;
-    };
+        template <typename CharT>
+        struct stream_char<const CharT*>
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT>::type type;
+        };
 
-#endif
+        template <typename CharT>
+        struct stream_char<iterator_range<CharT*> >
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT*>::type type;
+        };
+    
+        template <typename CharT>
+        struct stream_char<iterator_range<const CharT*> >
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<const CharT*>::type type;
+        };
 
-#ifndef BOOST_NO_CHAR32_T
+        template <class CharT, class Traits, class Alloc>
+        struct stream_char< std::basic_string<CharT, Traits, Alloc> >
+        {
+            typedef CharT type;
+        };
 
-    template<>
-    struct stream_char<char32_t>
-    {
-        typedef char32_t type;
-    };
+        template <class CharT, class Traits, class Alloc>
+        struct stream_char< ::boost::container::basic_string<CharT, Traits, Alloc> >
+        {
+            typedef CharT type;
+        };
 
-    template<>
-    struct stream_char<char32_t *>
-    {
-        typedef char32_t type;
-    };
+        template<typename CharT, std::size_t N>
+        struct stream_char<boost::array<CharT, N> >
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT>::type type;
+        };
 
-    template<>
-    struct stream_char<const char32_t *>
-    {
-        typedef char32_t type;
-    };
+        template<typename CharT, std::size_t N>
+        struct stream_char<boost::array<const CharT, N> >
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT>::type type;
+        };
 
-#endif
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+        template <typename CharT, std::size_t N>
+        struct stream_char<std::array<CharT, N> >
+        {
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT>::type type;
+        };
 
-        template<typename TargetChar, typename SourceChar>
-        struct widest_char
+        template <typename CharT, std::size_t N>
+        struct stream_char<std::array<const CharT, N> >
         {
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                (sizeof(TargetChar) > sizeof(SourceChar))
-                , TargetChar
-                , SourceChar >::type type;
+            typedef BOOST_DEDUCED_TYPENAME stream_char<CharT>::type type;
         };
+#endif // !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
+        template<>
+        struct stream_char<wchar_t>
+        {
+            typedef boost::detail::not_a_character_type type;
+        };
+
+        template<>
+        struct stream_char<wchar_t*>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<const wchar_t*>
+        {
+            typedef wchar_t type;
+        };
+#endif
     }
 
     namespace detail // deduce_char_traits template
     {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
         template<class CharT, class Target, class Source>
         struct deduce_char_traits
         {
@@ -293,7 +352,6 @@ namespace boost
             typedef Traits type;
         };
 
-#if !defined(__SUNPRO_CC)
         template<class CharT, class Traits, class Alloc, class Source>
         struct deduce_char_traits< CharT
                                  , ::boost::container::basic_string<CharT,Traits,Alloc>
@@ -333,7 +391,7 @@ namespace boost
         template<class CharT, class Traits, class Alloc1, class Alloc2>
         struct deduce_char_traits< CharT
                                  , ::boost::container::basic_string<CharT,Traits,Alloc1>
-                                 , std::basic_string<CharT,Traits,Alloc2>
+                                 , ::std::basic_string<CharT,Traits,Alloc2>
                                  >
         {
             typedef Traits type;
@@ -341,14 +399,12 @@ namespace boost
 
         template<class CharT, class Traits, class Alloc1, class Alloc2>
         struct deduce_char_traits< CharT
-                                 , std::basic_string<CharT,Traits,Alloc1>
+                                 , ::std::basic_string<CharT,Traits,Alloc1>
                                  , ::boost::container::basic_string<CharT,Traits,Alloc2>
                                  >
         {
             typedef Traits type;
         };
-#endif // !defined(__SUNPRO_CC)
-#endif
     }
 
     namespace detail // lcast_src_length
@@ -391,7 +447,7 @@ namespace boost
             BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
 #endif
         };
-// TODO: FIX for char16_t, char32_t, we can ignore CharT
+
 #define BOOST_LCAST_DEF(T)               \
     template<> struct lcast_src_length<T> \
         : lcast_src_length_integral<T>           \
@@ -488,7 +544,7 @@ namespace boost
         };
 #endif
 
-#ifndef BOOST_NO_CHAR16_T
+#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
         template<>
         struct lcast_char_constants<char16_t>
         {
@@ -501,7 +557,7 @@ namespace boost
         };
 #endif
 
-#ifndef BOOST_NO_CHAR32_T
+#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
         template<>
         struct lcast_char_constants<char32_t>
         {
@@ -526,10 +582,10 @@ namespace boost
 #endif
         template<class T>
         inline
-        BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value)
+        BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value) BOOST_NOEXCEPT
         {
             typedef BOOST_DEDUCED_TYPENAME make_unsigned<T>::type result_type;
-            result_type uvalue = static_cast<result_type>(value);
+            const result_type uvalue = static_cast<result_type>(value);
             return value < 0 ? -uvalue : uvalue;
         }
 #if (defined _MSC_VER)
@@ -732,12 +788,21 @@ namespace boost
 
     namespace detail
     {
+        template <class CharT>
+        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
+            for( unsigned int i=0; i < len; ++i ) {
+                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
+            }
+
+            return true;
+        }
+
         /* Returns true and sets the correct value if found NaN or Inf. */
         template <class CharT, class T>
         inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
             , const CharT* lc_NAN, const CharT* lc_nan
             , const CharT* lc_INFINITY, const CharT* lc_infinity
-            , const CharT opening_brace, const CharT closing_brace)
+            , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
         {
             using namespace std;
             if (begin == end) return false;
@@ -755,7 +820,7 @@ namespace boost
             else if( *begin == plus ) ++begin;
 
             if( end-begin < 3 ) return false;
-            if( !memcmp(begin, lc_nan, 3*sizeof(CharT)) || !memcmp(begin, lc_NAN, 3*sizeof(CharT)) )
+            if( lc_iequal(begin, lc_nan, lc_NAN, 3) )
             {
                 begin += 3;
                 if (end != begin) /* It is 'nan(...)' or some bad input*/
@@ -772,13 +837,13 @@ namespace boost
             if (( /* 'INF' or 'inf' */
                   end-begin==3
                   &&
-                  (!memcmp(begin, lc_infinity, 3*sizeof(CharT)) || !memcmp(begin, lc_INFINITY, 3*sizeof(CharT)))
+                  lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
                 )
                 ||
                 ( /* 'INFINITY' or 'infinity' */
                   end-begin==inifinity_size
                   &&
-                  (!memcmp(begin, lc_infinity, inifinity_size)|| !memcmp(begin, lc_INFINITY, inifinity_size))
+                  lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
                 )
              )
             {
@@ -790,112 +855,105 @@ namespace boost
             return false;
         }
 
+        template <class CharT, class T>
+        bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
+                         , const CharT* lc_nan
+                         , const CharT* lc_infinity) BOOST_NOEXCEPT
+        {
+            using namespace std;
+            const CharT minus = lcast_char_constants<CharT>::minus;
+            if ( (boost::math::isnan)(value) )
+            {
+                if ( (boost::math::signbit)(value) )
+                {
+                    *begin = minus;
+                    ++ begin;
+                }
+
+                memcpy(begin, lc_nan, 3 * sizeof(CharT));
+                end = begin + 3;
+                return true;
+            } else if ( (boost::math::isinf)(value) )
+            {
+                if ( (boost::math::signbit)(value) )
+                {
+                    *begin = minus;
+                    ++ begin;
+                }
+
+                memcpy(begin, lc_infinity, 3 * sizeof(CharT));
+                end = begin + 3;
+                return true;
+            }
+
+            return false;
+        }
+
+
 #ifndef BOOST_LCAST_NO_WCHAR_T
         template <class T>
-        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value)
+        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT
         {
             return parse_inf_nan_impl(begin, end, value
                                , L"NAN", L"nan"
                                , L"INFINITY", L"infinity"
                                , L'(', L')');
         }
+
+        template <class T>
+        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT
+        {
+            return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
+        }
+
 #endif
-#ifndef BOOST_NO_CHAR16_T
+#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
         template <class T>
-        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value)
+        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT
         {
             return parse_inf_nan_impl(begin, end, value
                                , u"NAN", u"nan"
                                , u"INFINITY", u"infinity"
                                , u'(', u')');
         }
+
+        template <class T>
+        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT
+        {
+            return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
+        }
 #endif
-#ifndef BOOST_NO_CHAR32_T
+#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
         template <class T>
-        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value)
+        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT
         {
             return parse_inf_nan_impl(begin, end, value
                                , U"NAN", U"nan"
                                , U"INFINITY", U"infinity"
                                , U'(', U')');
         }
+
+        template <class T>
+        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT
+        {
+            return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
+        }
 #endif
 
         template <class CharT, class T>
-        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value)
+        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT
         {
             return parse_inf_nan_impl(begin, end, value
                                , "NAN", "nan"
                                , "INFINITY", "infinity"
                                , '(', ')');
         }
-#ifndef BOOST_LCAST_NO_WCHAR_T
-        template <class T>
-        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value)
-        {
-            using namespace std;
-            if ( (boost::math::isnan)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,L"-nan", sizeof(L"-nan"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,L"nan", sizeof(L"nan"));
-                    end = begin + 3;
-                }
-                return true;
-            } else if ( (boost::math::isinf)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,L"-inf", sizeof(L"-inf"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,L"inf", sizeof(L"inf"));
-                    end = begin + 3;
-                }
-                return true;
-            }
 
-            return false;
-        }
-#endif
         template <class CharT, class T>
-        bool put_inf_nan(CharT* begin, CharT*& end, const T& value)
+        bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT
         {
-            using namespace std;
-            if ( (boost::math::isnan)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,"-nan", sizeof("-nan"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,"nan", sizeof("nan"));
-                    end = begin + 3;
-                }
-                return true;
-            } else if ( (boost::math::isinf)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,"-inf", sizeof("-inf"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,"inf", sizeof("inf"));
-                    end = begin + 3;
-                }
-                return true;
-            }
-
-            return false;
+            return put_inf_nan_impl(begin, end, value, "nan", "infinity");
         }
-
     }
 
 
@@ -951,7 +1009,7 @@ namespace boost
             CharT const capital_e = lcast_char_constants<CharT>::capital_e;
             CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
 
-            value = 0.0;
+            value = static_cast<T>(0);
 
             if (parse_inf_nan(begin, end, value)) return true;
 
@@ -962,11 +1020,11 @@ namespace boost
 
             /* Getting the plus/minus sign */
             bool has_minus = false;
-            if ( *begin == minus ) {
+            if (Traits::eq(*begin, minus) ) {
                 ++ begin;
                 has_minus = true;
                 if (begin == end) return false;
-            } else if ( *begin == plus ) {
+            } else if (Traits::eq(*begin, plus) ) {
                 ++begin;
                 if (begin == end) return false;
             }
@@ -985,7 +1043,7 @@ namespace boost
                     /* We allow no thousand_separators after decimal point */
 
                     mantissa_type tmp_mantissa = mantissa * 10u;
-                    if ( *begin == lowercase_e || *begin == capital_e ) break;
+                    if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break;
                     if ( *begin < czero || *begin >= czero + 10 ) return false;
                     if (    is_mantissa_full
                             || tmp_mantissa / 10u != mantissa
@@ -1024,7 +1082,7 @@ namespace boost
 
                         found_number_before_exp = true;
                         ++ length_since_last_delim;
-                    } else if ( *begin == decimal_point || *begin == lowercase_e || *begin == capital_e) {
+                    } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) {
 #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
                         /* If ( we need to check grouping
                          *      and (   grouping missmatches
@@ -1042,9 +1100,10 @@ namespace boost
                            ) return false;
 #endif
 
-                        if(*begin == decimal_point){
+                        if(Traits::eq(*begin, decimal_point)) {
                             ++ begin;
                             found_decimal = true;
+                            if (!found_number_before_exp && begin==end) return false;
                             continue;
                         }else {
                             if (!found_number_before_exp) return false;
@@ -1052,7 +1111,7 @@ namespace boost
                         }
                     }
 #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-                    else if (grouping_size && *begin == thousands_sep){
+                    else if (grouping_size && Traits::eq(*begin, thousands_sep)){
                         if(found_grouping)
                         {
                             /* It is not he first time, when we find thousands separator,
@@ -1094,16 +1153,16 @@ namespace boost
             }
 
             // Exponent found
-            if ( begin != end && ( *begin == lowercase_e || *begin == capital_e ) ) {
+            if ( begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) ) {
                 ++ begin;
                 if ( begin == end ) return false;
 
                 bool exp_has_minus = false;
-                if( *begin == minus ) {
+                if(Traits::eq(*begin, minus)) {
                     exp_has_minus = true;
                     ++ begin;
                     if ( begin == end ) return false;
-                } else if (*begin == plus ) {
+                } else if (Traits::eq(*begin, plus)) {
                     ++ begin;
                     if ( begin == end ) return false;
                 }
@@ -1165,7 +1224,7 @@ namespace boost
 
     namespace detail
     {
-        struct do_not_construct_stringbuffer_t{};
+        struct do_not_construct_out_stream_t{};
     }
 
     namespace detail // optimized stream wrapper
@@ -1177,25 +1236,27 @@ namespace boost
                 >
         class lexical_stream_limited_src
         {
-            typedef stl_buf_unlocker<std::basic_streambuf<CharT, Traits>, CharT > local_streambuffer_t;
 
 #if defined(BOOST_NO_STRINGSTREAM)
-            typedef stl_buf_unlocker<std::strstream, CharT > local_stringbuffer_t;
+            typedef std::ostrstream                         out_stream_t;
+            typedef stl_buf_unlocker<std::strstreambuf, char>  unlocked_but_t;
 #elif defined(BOOST_NO_STD_LOCALE)
-            typedef stl_buf_unlocker<std::stringstream, CharT > local_stringbuffer_t;
+            typedef std::ostringstream                      out_stream_t;
+            typedef stl_buf_unlocker<std::stringbuf, char>  unlocked_but_t;
 #else
-            typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT > local_stringbuffer_t;
+            typedef std::basic_ostringstream<CharT, Traits>       out_stream_t;
+            typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT> unlocked_but_t;
 #endif
             typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c<
                 RequiresStringbuffer,
-                local_stringbuffer_t,
-                do_not_construct_stringbuffer_t
-            >::type deduced_stringbuffer_t;
+                out_stream_t,
+                do_not_construct_out_stream_t
+            >::type deduced_out_stream_t;
 
             // A string representation of Source is written to [start, finish).
             CharT* start;
             CharT* finish;
-            deduced_stringbuffer_t stringbuffer;
+            deduced_out_stream_t out_stream;
 
         public:
             lexical_stream_limited_src(CharT* sta, CharT* fin)
@@ -1209,7 +1270,7 @@ namespace boost
             void operator=(lexical_stream_limited_src const&);
 
 /************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
-            bool shl_char(CharT ch)
+            bool shl_char(CharT ch) BOOST_NOEXCEPT
             {
                 Traits::assign(*start, ch);
                 finish = start + 1;
@@ -1221,13 +1282,13 @@ namespace boost
             bool shl_char(T ch)
             {
                 BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
-                    "boost::lexical_cast does not support conversions from whar_t to char types."
+                    "boost::lexical_cast does not support narrowing of char types."
                     "Use boost::locale instead" );
 #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
                 std::locale loc;
-                wchar_t w = BOOST_USE_FACET(std::ctype<wchar_t>, loc).widen(ch);
+                CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
 #else
-                wchar_t w = ch;
+                CharT const w = ch;
 #endif
                 Traits::assign(*start, w);
                 finish = start + 1;
@@ -1235,31 +1296,42 @@ namespace boost
             }
 #endif
 
-            bool shl_char_array(CharT const* str)
+            bool shl_char_array(CharT const* str) BOOST_NOEXCEPT
             {
                 start = const_cast<CharT*>(str);
                 finish = start + Traits::length(str);
                 return true;
             }
 
-#ifndef BOOST_LCAST_NO_WCHAR_T
             template <class T>
             bool shl_char_array(T const* str)
             {
                 BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
-                    "boost::lexical_cast does not support conversions from wchar_t to char types."
+                    "boost::lexical_cast does not support narrowing of char types."
                     "Use boost::locale instead" );
                 return shl_input_streamable(str);
             }
-#endif
+            
+            bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT
+            {
+                start = const_cast<CharT*>(str);
+                finish = std::find(start, start + max_size, Traits::to_char_type(0));
+                return true;
+            }
 
             template<typename InputStreamable>
             bool shl_input_streamable(InputStreamable& input)
             {
-                std::basic_ostream<CharT> stream(&stringbuffer);
-                bool const result = !(stream << input).fail();
-                start = stringbuffer.pbase();
-                finish = stringbuffer.pptr();
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+                // If you have compilation error at this point, than your STL library
+                // does not support such conversions. Try updating it.
+                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
+#endif
+                bool const result = !(out_stream << input).fail();
+                const unlocked_but_t* const p
+                        = static_cast<unlocked_but_t*>(out_stream.rdbuf()) ;
+                start = p->pbase();
+                finish = p->pptr();
                 return result;
             }
 
@@ -1276,110 +1348,105 @@ namespace boost
                 return true;
             }
 
-#if (defined _MSC_VER)
-# pragma warning( push )
-// C4996: This function or variable may be unsafe. Consider using sprintf_s instead
-# pragma warning( disable : 4996 )
-#endif
+            template <class T, class SomeCharT>
+            bool shl_real_type(const T& val, SomeCharT* begin, SomeCharT*& end)
+            {
+                if (put_inf_nan(begin, end, val)) return true;
+                lcast_set_precision(out_stream, &val);
+                return shl_input_streamable(val);
+            }
 
-            template <class T>
-            bool shl_float(float val,T* out)
+            static bool shl_real_type(float val, char* begin, char*& end)
             {   using namespace std;
-                if (put_inf_nan(start,finish,val)) return true;
-                finish = start + sprintf(out,"%.*g", static_cast<int>(boost::detail::lcast_get_precision<float >()), val );
-                return finish > start;
+                if (put_inf_nan(begin, end, val)) return true;
+                const double val_as_double = val;
+                end = begin + 
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+                    sprintf_s(begin, end-begin,
+#else
+                    sprintf(begin, 
+#endif
+                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
+                return end > begin;
             }
 
-            template <class T>
-            bool shl_double(double val,T* out)
+            static bool shl_real_type(double val, char* begin, char*& end)
             {   using namespace std;
-                if (put_inf_nan(start,finish,val)) return true;
-                finish = start + sprintf(out,"%.*lg", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
-                return finish > start;
+                if (put_inf_nan(begin, end, val)) return true;
+                end = begin + 
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+                    sprintf_s(begin, end-begin,
+#else
+                    sprintf(begin, 
+#endif
+                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
+                return end > begin;
             }
+
 #ifndef __MINGW32__
-            template <class T>
-            bool shl_long_double(long double val,T* out)
+            static bool shl_real_type(long double val, char* begin, char*& end)
             {   using namespace std;
-                if (put_inf_nan(start,finish,val)) return true;
-                finish = start + sprintf(out,"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
-                return finish > start;
-            }
+                if (put_inf_nan(begin, end, val)) return true;
+                end = begin + 
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+                    sprintf_s(begin, end-begin,
+#else
+                    sprintf(begin, 
 #endif
-
-#if (defined _MSC_VER)
-# pragma warning( pop )
+                    "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
+                return end > begin;
+            }
 #endif
 
 
-#ifndef BOOST_LCAST_NO_WCHAR_T
-            bool shl_float(float val,wchar_t* out)
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+            static bool shl_real_type(float val, wchar_t* begin, wchar_t*& end)
             {   using namespace std;
-                if (put_inf_nan(start,finish,val)) return true;
-                finish = start + swprintf(out,
-#if !defined(__MINGW32__) && !defined(UNDER_CE)
-                                          finish-start,
-#endif
-                                          L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<float >()), val );
-
-                return finish > start;
+                if (put_inf_nan(begin, end, val)) return true;
+                const double val_as_double = val;
+                end = begin + swprintf(begin, end-begin,
+                                       L"%.*g",
+                                       static_cast<int>(boost::detail::lcast_get_precision<float >()),
+                                       val_as_double );
+                return end > begin;
             }
 
-
-            bool shl_double(double val,wchar_t* out)
+            static bool shl_real_type(double val, wchar_t* begin, wchar_t*& end)
             {   using namespace std;
-                if (put_inf_nan(start,finish,val)) return true;
-                /* __MINGW32__ is defined for both mingw.org and for mingw-w64.
-                 * For mingw-w64, __MINGW64__ is defined, too, when targetting
-                 * 64 bits.
-                 *
-                 * swprintf realization in MinGW and under WinCE does not conform
-                 * to the ISO C
-                 * Standard.
-                 */
-                finish = start + swprintf(out,
-#if !defined(__MINGW32__) && !defined(UNDER_CE)
-                                          finish-start,
-#endif
-                                          L"%.*lg", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
-                return finish > start;
+                if (put_inf_nan(begin, end, val)) return true;
+                end = begin + swprintf(begin, end-begin,
+                                          L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
+                return end > begin;
             }
 
-#ifndef __MINGW32__
-            bool shl_long_double(long double val,wchar_t* out)
+            static bool shl_real_type(long double val, wchar_t* begin, wchar_t*& end)
             {   using namespace std;
-                if (put_inf_nan(start,finish,val)) return true;
-                finish = start + swprintf(out,
-#if !defined(UNDER_CE)
-                                          finish-start,
-#endif
+                if (put_inf_nan(begin, end, val)) return true;
+                end = begin + swprintf(begin, end-begin,
                                           L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
-                return finish > start;
+                return end > begin;
             }
 #endif
 
-#endif
-
 /************************************ OPERATORS << ( ... ) ********************************/
         public:
             template<class Alloc>
-            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str)
+            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
             {
                 start = const_cast<CharT*>(str.data());
                 finish = start + str.length();
                 return true;
             }
 
-#if !defined(__SUNPRO_CC)
             template<class Alloc>
-            bool operator<<(::boost::container::basic_string<CharT,Traits,Alloc> const& str)
+            bool operator<<(::boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
             {
                 start = const_cast<CharT*>(str.data());
                 finish = start + str.length();
                 return true;
             }
-#endif // !defined(__SUNPRO_CC)
-            bool operator<<(bool value)
+
+            bool operator<<(bool value) BOOST_NOEXCEPT
             {
                 CharT const czero = lcast_char_constants<CharT>::zero;
                 Traits::assign(*start, Traits::to_char_type(czero + value));
@@ -1387,6 +1454,52 @@ namespace boost
                 return true;
             }
 
+            bool operator<<(const iterator_range<CharT*>& rng) BOOST_NOEXCEPT
+            {
+                start = rng.begin();
+                finish = rng.end();
+                return true; 
+            }
+            
+            bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT
+            {
+                start = const_cast<CharT*>(rng.begin());
+                finish = const_cast<CharT*>(rng.end());
+                return true; 
+            }
+
+            bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT
+            {
+                return (*this) << iterator_range<char*>(
+                    const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
+                    const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
+                );
+            }
+
+            bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT
+            {
+                return (*this) << iterator_range<char*>(
+                    const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
+                    const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
+                );
+            }
+
+            bool operator<<(const iterator_range<signed char*>& rng) BOOST_NOEXCEPT
+            {
+                return (*this) << iterator_range<char*>(
+                    reinterpret_cast<char*>(rng.begin()),
+                    reinterpret_cast<char*>(rng.end())
+                );
+            }
+
+            bool operator<<(const iterator_range<unsigned char*>& rng) BOOST_NOEXCEPT
+            {
+                return (*this) << iterator_range<char*>(
+                    reinterpret_cast<char*>(rng.begin()),
+                    reinterpret_cast<char*>(rng.end())
+                );
+            }
+
             bool operator<<(char ch)                    { return shl_char(ch); }
             bool operator<<(unsigned char ch)           { return ((*this) << static_cast<char>(ch)); }
             bool operator<<(signed char ch)             { return ((*this) << static_cast<char>(ch)); }
@@ -1396,6 +1509,16 @@ namespace boost
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
             bool operator<<(wchar_t ch)                 { return shl_char(ch); }
 #endif
+#endif
+#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+            bool operator<<(char16_t ch)                { return shl_char(ch); }
+            bool operator<<(char16_t * str)             { return shl_char_array(str); }
+            bool operator<<(char16_t const * str)       { return shl_char_array(str); }
+#endif
+#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+            bool operator<<(char32_t ch)                { return shl_char(ch); }
+            bool operator<<(char32_t * str)             { return shl_char_array(str); }
+            bool operator<<(char32_t const * str)       { return shl_char_array(str); }
 #endif
             bool operator<<(unsigned char const* ch)    { return ((*this) << reinterpret_cast<char const*>(ch)); }
             bool operator<<(unsigned char * ch)         { return ((*this) << reinterpret_cast<char *>(ch)); }
@@ -1417,17 +1540,67 @@ namespace boost
             bool operator<<(unsigned __int64 n)         { start = lcast_put_unsigned<Traits>(n, finish); return true; }
             bool operator<<(         __int64 n)         { return shl_signed(n); }
 #endif
-            bool operator<<(float val)                  { return shl_float(val,start); }
-            bool operator<<(double val)                 { return shl_double(val,start); }
+            bool operator<<(float val)                  { return shl_real_type(val, start, finish); }
+            bool operator<<(double val)                 { return shl_real_type(val, start, finish); }
             bool operator<<(long double val)            {
 #ifndef __MINGW32__
-                return shl_long_double(val,start);
+                return shl_real_type(val, start, finish);
 #else
-                return shl_double(val,start);
+                return shl_real_type(static_cast<double>(val), start, finish);
 #endif
             }
-
-            template<class InStreamable>
+            
+            template <std::size_t N>
+            bool operator<<(boost::array<CharT, N> const& input) BOOST_NOEXCEPT
+            { return shl_char_array_limited(input.begin(), N); }
+
+            template <std::size_t N>
+            bool operator<<(boost::array<unsigned char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
+
+            template <std::size_t N>
+            bool operator<<(boost::array<signed char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
+
+            template <std::size_t N>
+            bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT
+            { return shl_char_array_limited(input.begin(), N); }
+
+            template <std::size_t N>
+            bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
+
+            template <std::size_t N>
+            bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
+ 
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+            template <std::size_t N>
+            bool operator<<(std::array<CharT, N> const& input) BOOST_NOEXCEPT
+            { return shl_char_array_limited(input.begin(), N); }
+
+            template <std::size_t N>
+            bool operator<<(std::array<unsigned char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
+
+            template <std::size_t N>
+            bool operator<<(std::array<signed char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
+
+            template <std::size_t N>
+            bool operator<<(std::array<const CharT, N> const& input) BOOST_NOEXCEPT
+            { return shl_char_array_limited(input.begin(), N); }
+
+            template <std::size_t N>
+            bool operator<<(std::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
+
+            template <std::size_t N>
+            bool operator<<(std::array<const signed char, N> const& input) BOOST_NOEXCEPT
+            { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
+#endif // !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+            
+            template <class InStreamable>
             bool operator<<(const InStreamable& input)  { return shl_input_streamable(input); }
 
 /************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
@@ -1524,9 +1697,22 @@ namespace boost
                 if(is_pointer<InputStreamable>::value)
                     return false;
 
-                local_streambuffer_t bb;
-                bb.setg(start, start, finish);
-                std::basic_istream<CharT> stream(&bb);
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+                // If you have compilation error at this point, than your STL library
+                // unsupports such conversions. Try updating it.
+                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
+#endif
+
+#if defined(BOOST_NO_STRINGSTREAM)
+                std::istrstream stream(start, finish - start);
+#elif defined(BOOST_NO_STD_LOCALE)
+                std::istringstream stream;
+#else
+                std::basic_istringstream<CharT, Traits> stream;
+#endif
+                static_cast<unlocked_but_t*>(stream.rdbuf())
+                        ->setg(start, start, finish);
+
                 stream.unsetf(std::ios::skipws);
                 lcast_set_precision(stream, static_cast<InputStreamable*>(0));
 #if (defined _MSC_VER)
@@ -1549,10 +1735,10 @@ namespace boost
             inline bool shr_xchar(T& output)
             {
                 BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
-                    "boost::lexical_cast does not support conversions from whar_t to char types."
+                    "boost::lexical_cast does not support narrowing of character types."
                     "Use boost::locale instead" );
                 bool const ok = (finish - start == 1);
-                if(ok) {
+                if (ok) {
                     CharT out;
                     Traits::assign(out, *start);
                     output = static_cast<T>(out);
@@ -1581,31 +1767,81 @@ namespace boost
 #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
             bool operator>>(wchar_t& output)                    { return shr_xchar(output); }
 #endif
-#ifndef BOOST_NO_CHAR16_T
+#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
             bool operator>>(char16_t& output)                   { return shr_xchar(output); }
 #endif
-#ifndef BOOST_NO_CHAR32_T
+#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
             bool operator>>(char32_t& output)                   { return shr_xchar(output); }
 #endif
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            bool operator>>(std::string& str)                   { str.assign(start, finish); return true; }
-#   ifndef BOOST_LCAST_NO_WCHAR_T
-            bool operator>>(std::wstring& str)                  { str.assign(start, finish); return true; }
-#   endif
-#else
             template<class Alloc>
             bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
-#if !defined(__SUNPRO_CC)
+
             template<class Alloc>
             bool operator>>(::boost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
-#endif // !defined(__SUNPRO_CC)
-#endif
+
+            
+    private:
+            template <std::size_t N, class ArrayT>
+            bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT
+            {
+                using namespace std;
+                const std::size_t size = finish - start;
+                if (size > N - 1) { // `-1` because we need to store \0 at the end 
+                    return false;
+                }
+
+                memcpy(output.begin(), start, size * sizeof(CharT));
+                *(output.begin() + size) = Traits::to_char_type(0);
+                return true;
+            }
+
+    public:
+
+            template <std::size_t N>
+            bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT
+            { 
+                return shr_std_array<N>(output); 
+            }
+
+            template <std::size_t N>
+            bool operator>>(boost::array<unsigned char, N>& output)   
+            { 
+                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); 
+            }
+
+            template <std::size_t N>
+            bool operator>>(boost::array<signed char, N>& output)   
+            { 
+                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); 
+            }
+ 
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+            template <std::size_t N>
+            bool operator>>(std::array<CharT, N>& output) BOOST_NOEXCEPT
+            { 
+                return shr_std_array<N>(output); 
+            }
+
+            template <std::size_t N>
+            bool operator>>(std::array<unsigned char, N>& output)   
+            { 
+                return ((*this) >> reinterpret_cast<std::array<char, N>& >(output)); 
+            }
+
+            template <std::size_t N>
+            bool operator>>(std::array<signed char, N>& in)   
+            { 
+                return ((*this) >> reinterpret_cast<std::array<char, N>& >(output)); 
+            }
+#endif // !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+
+
             /*
              * case "-0" || "0" || "+0" :   output = false; return true;
              * case "1" || "+1":            output = true;  return true;
              * default:                     return false;
              */
-            bool operator>>(bool& output)
+            bool operator>>(bool& output) BOOST_NOEXCEPT
             {
                 CharT const zero = lcast_char_constants<CharT>::zero;
                 CharT const plus = lcast_char_constants<CharT>::plus;
@@ -1655,10 +1891,10 @@ namespace boost
                 CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
                 if ( return_value &&
                      (
-                        *(finish-1) == lowercase_e                   // 1.0e
-                        || *(finish-1) == capital_e                  // 1.0E
-                        || *(finish-1) == minus                      // 1.0e- or 1.0E-
-                        || *(finish-1) == plus                       // 1.0e+ or 1.0E+
+                        Traits::eq(*(finish-1), lowercase_e)                   // 1.0e
+                        || Traits::eq(*(finish-1), capital_e)                  // 1.0E
+                        || Traits::eq(*(finish-1), minus)                      // 1.0e- or 1.0E-
+                        || Traits::eq(*(finish-1), plus)                       // 1.0e+ or 1.0E+
                      )
                 ) return false;
 
@@ -1705,10 +1941,6 @@ namespace boost
         };
     }
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-    // call-by-const reference version
-
     namespace detail
     {
         template<class T>
@@ -1734,49 +1966,12 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-#if !defined(__SUNPRO_CC)
+
         template<typename CharT, typename Traits, typename Alloc>
         struct is_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc> >
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-#endif // !defined(__SUNPRO_CC)
-        template<typename T>
-        struct is_char_or_wchar
-        {
-        private:
-#ifndef BOOST_LCAST_NO_WCHAR_T
-            typedef wchar_t wchar_t_if_supported;
-#else
-            typedef char wchar_t_if_supported;
-#endif
-
-#ifndef BOOST_NO_CHAR16_T
-            typedef char16_t char16_t_if_supported;
-#else
-            typedef char char16_t_if_supported;
-#endif
-
-#ifndef BOOST_NO_CHAR32_T
-            typedef char32_t char32_t_if_supported;
-#else
-            typedef char char32_t_if_supported;
-#endif
-            public:
-
-            BOOST_STATIC_CONSTANT(bool, value =
-                    (
-                    ::boost::type_traits::ice_or<
-                         is_same< T, char >::value,
-                         is_same< T, wchar_t_if_supported >::value,
-                         is_same< T, char16_t_if_supported >::value,
-                         is_same< T, char32_t_if_supported >::value,
-                         is_same< T, unsigned char >::value,
-                         is_same< T, signed char >::value
-                    >::value
-                    )
-            );
-        };
 
         template<typename Target, typename Source>
         struct is_arithmetic_and_not_xchars
@@ -1784,8 +1979,8 @@ namespace boost
             BOOST_STATIC_CONSTANT(bool, value =
                (
                    ::boost::type_traits::ice_and<
-                           is_arithmetic<Source>::value,
-                           is_arithmetic<Target>::value,
+                           ::boost::is_arithmetic<Source>::value,
+                           ::boost::is_arithmetic<Target>::value,
                            ::boost::type_traits::ice_not<
                                 detail::is_char_or_wchar<Target>::value
                            >::value,
@@ -1823,6 +2018,28 @@ namespace boost
             );
         };
 
+
+        // this metafunction evaluates to true, if we have optimized comnversion 
+        // from Float type to Char array. 
+        // Must be in sync with lexical_stream_limited_src<Char, ...>::shl_real_type(...)
+        template <typename Float, typename Char>
+        struct is_this_float_conversion_optimized 
+        {
+            typedef ::boost::type_traits::ice_and<
+                ::boost::is_float<Float>::value,
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+                ::boost::type_traits::ice_or<
+                    ::boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value,
+                    ::boost::is_same<Char, wchar_t>::value
+                >::value
+#else
+                ::boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value
+#endif
+            > result_type;
+
+            BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
+        };
+
         template<typename Target, typename Source>
         struct is_char_array_to_stdstring
         {
@@ -1840,7 +2057,7 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-#if !defined(__SUNPRO_CC)
+
         template<typename CharT, typename Traits, typename Alloc>
         struct is_char_array_to_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
         {
@@ -1852,7 +2069,6 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-#endif // !defined(__SUNPRO_CC)
 
 #if (defined _MSC_VER)
 # pragma warning( push )
@@ -1866,59 +2082,64 @@ namespace boost
             static inline Target lexical_cast_impl(const Source& arg)
             {
                 typedef BOOST_DEDUCED_TYPENAME detail::array_to_pointer_decay<Source>::type src;
-
+                typedef BOOST_DEDUCED_TYPENAME ::boost::remove_cv<src>::type no_cv_src;
+                typedef BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type target_char_t;
+                typedef BOOST_DEDUCED_TYPENAME detail::stream_char<no_cv_src>::type src_char_type;
                 typedef BOOST_DEDUCED_TYPENAME detail::widest_char<
-                    BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type
-                    , BOOST_DEDUCED_TYPENAME detail::stream_char<src>::type
+                    target_char_t, src_char_type
                 >::type char_type;
 
-                typedef detail::lcast_src_length<src> lcast_src_length;
-                std::size_t const src_len = lcast_src_length::value;
-                char_type buf[src_len + 1];
-                lcast_src_length::check_coverage();
+#if !defined(BOOST_NO_CHAR16_T) && defined(BOOST_NO_UNICODE_LITERALS)
+                BOOST_STATIC_ASSERT_MSG(( !::boost::is_same<char16_t, src_char_type>::value
+                                          && !::boost::is_same<char16_t, target_char_t>::value),
+                    "Your compiler does not have full support for char16_t" );
+#endif
+#if !defined(BOOST_NO_CHAR32_T) && defined(BOOST_NO_UNICODE_LITERALS)
+                BOOST_STATIC_ASSERT_MSG(( !::boost::is_same<char32_t, src_char_type>::value
+                                          && !::boost::is_same<char32_t, target_char_t>::value),
+                    "Your compiler does not have full support for char32_t" );
+#endif
 
-                typedef BOOST_DEDUCED_TYPENAME
-                    deduce_char_traits<char_type,Target,Source>::type traits;
+                typedef BOOST_DEDUCED_TYPENAME ::boost::detail::deduce_char_traits<
+                    char_type, Target, no_cv_src
+                >::type traits;
 
-                typedef BOOST_DEDUCED_TYPENAME remove_pointer<src >::type removed_ptr_t;
+                typedef ::boost::type_traits::ice_and<
+                    ::boost::detail::is_char_or_wchar<src_char_type>::value,                    // source is lexical type
+                    ::boost::detail::is_char_or_wchar<target_char_t>::value,                    // target is a lexical type
+                    ::boost::is_same<char, src_char_type>::value,                               // source is not a wide character based type
+                    ::boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value   // target type is based on wide character
+                >   is_string_widening_required_t;
 
-                // is_char_types_match variable value can be computed via
-                // sizeof(char_type) == sizeof(removed_ptr_t). But when
-                // removed_ptr_t is an incomplete type or void*, compilers
-                // produce warnings or errors.
-                const bool is_char_types_match =
-                (::boost::type_traits::ice_or<
-                    ::boost::type_traits::ice_and<
-                        ::boost::type_traits::ice_eq<sizeof(char_type), sizeof(char) >::value,
-                        ::boost::type_traits::ice_or<
-                            ::boost::is_same<char, removed_ptr_t>::value,
-                            ::boost::is_same<unsigned char, removed_ptr_t>::value,
-                            ::boost::is_same<signed char, removed_ptr_t>::value
-                        >::value
-                    >::value,
-                    is_same<char_type, removed_ptr_t>::value
-                >::value);
-
-                const bool requires_stringbuf =
-                        !(
-                             ::boost::type_traits::ice_or<
-                                 is_stdstring<src >::value,
-                                 is_arithmetic<src >::value,
-                                 ::boost::type_traits::ice_and<
-                                     is_pointer<src >::value,
-                                     is_char_or_wchar<removed_ptr_t >::value,
-                                     is_char_types_match
-                                 >::value
-                             >::value
-                        );
-
-                detail::lexical_stream_limited_src<char_type,traits, requires_stringbuf >
-                        interpreter(buf, buf + src_len);
+                typedef ::boost::type_traits::ice_or<
+                    ::boost::is_integral<no_cv_src>::value,
+                    ::boost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value,
+                    ::boost::detail::is_char_or_wchar<src_char_type >::value
+                >   is_source_input_optimized_t;
 
+                // Target type must be default constructible
                 Target result;
+
+                // If we have an optimized conversion for
+                // Source, we do not need to construct stringbuf.
+                const bool requires_stringbuf = ::boost::type_traits::ice_or<
+                        is_string_widening_required_t::value,
+                        ::boost::type_traits::ice_not< is_source_input_optimized_t::value >::value
+                >::value;
+               
+                typedef detail::lexical_stream_limited_src<char_type, traits, requires_stringbuf > interpreter_type;
+
+                typedef detail::lcast_src_length<no_cv_src> lcast_src_length;
+                std::size_t const src_len = lcast_src_length::value;
+                char_type buf[src_len + 1];
+                lcast_src_length::check_coverage();
+
+                interpreter_type interpreter(buf, buf + src_len);
+
                 // Disabling ADL, by directly specifying operators.
                 if(!(interpreter.operator <<(arg) && interpreter.operator >>(result)))
                   BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+
                 return result;
             }
         };
@@ -1926,88 +2147,80 @@ namespace boost
 # pragma warning( pop )
 #endif
 
-        template<typename Source>
+        template <typename Source>
         struct lexical_cast_copy
         {
-            static inline Source lexical_cast_impl(const Source &arg)
+            static inline const Source& lexical_cast_impl(const Source &arg) BOOST_NOEXCEPT
             {
                 return arg;
             }
         };
 
-        class precision_loss_error : public boost::numeric::bad_numeric_cast
+        template <class Source, class Target >
+        struct detect_precision_loss
         {
-         public:
-            virtual const char * what() const throw()
-             {  return "bad numeric conversion: precision loss error"; }
-        };
-
-        template<class S >
-        struct throw_on_precision_loss
-        {
-         typedef boost::numeric::Trunc<S> Rounder;
-         typedef S source_type ;
+         typedef boost::numeric::Trunc<Source> Rounder;
+         typedef Source source_type ;
 
-         typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+         typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+            ::boost::is_arithmetic<Source>, Source, Source const&
+          >::type argument_type ;
 
          static source_type nearbyint ( argument_type s )
          {
-            source_type orig_div_round = s / Rounder::nearbyint(s);
+            const source_type orig_div_round = s / Rounder::nearbyint(s);
+            const source_type eps = std::numeric_limits<source_type>::epsilon();
+
+            if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps)
+                BOOST_LCAST_THROW_BAD_CAST(Source, Target);
 
-            if ( (orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > std::numeric_limits<source_type>::epsilon() )
-               BOOST_THROW_EXCEPTION( precision_loss_error() );
             return s ;
          }
 
          typedef typename Rounder::round_style round_style;
         } ;
 
-        template<typename Target, typename Source>
+        template <class Source, class Target >
+        struct nothrow_overflow_handler
+        {
+          void operator() ( boost::numeric::range_check_result r )
+          {
+            if (r != boost::numeric::cInRange)
+                BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+          }
+        } ;
+
+        template <typename Target, typename Source>
         struct lexical_cast_dynamic_num_not_ignoring_minus
         {
             static inline Target lexical_cast_impl(const Source &arg)
             {
-                try{
-                    typedef boost::numeric::converter<
-                            Target,
-                            Source,
-                            boost::numeric::conversion_traits<Target,Source>,
-                            boost::numeric::def_overflow_handler,
-                            throw_on_precision_loss<Source>
-                    > Converter ;
-
-                    return Converter::convert(arg);
-                } catch( ::boost::numeric::bad_numeric_cast const& ) {
-                    BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-                }
-                BOOST_UNREACHABLE_RETURN(static_cast<Target>(0));
+                return boost::numeric::converter<
+                        Target,
+                        Source,
+                        boost::numeric::conversion_traits<Target,Source>,
+                        nothrow_overflow_handler<Source, Target>,
+                        detect_precision_loss<Source, Target>
+                >::convert(arg);
             }
         };
 
-        template<typename Target, typename Source>
+        template <typename Target, typename Source>
         struct lexical_cast_dynamic_num_ignoring_minus
         {
             static inline Target lexical_cast_impl(const Source &arg)
             {
-                try{
-                    typedef boost::numeric::converter<
-                            Target,
-                            Source,
-                            boost::numeric::conversion_traits<Target,Source>,
-                            boost::numeric::def_overflow_handler,
-                            throw_on_precision_loss<Source>
-                    > Converter ;
-
-                    bool has_minus = ( arg < 0);
-                    if ( has_minus ) {
-                        return static_cast<Target>(-Converter::convert(-arg));
-                    } else {
-                        return Converter::convert(arg);
-                    }
-                } catch( ::boost::numeric::bad_numeric_cast const& ) {
-                    BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-                }
-                BOOST_UNREACHABLE_RETURN(static_cast<Target>(0));
+                typedef boost::numeric::converter<
+                        Target,
+                        Source,
+                        boost::numeric::conversion_traits<Target,Source>,
+                        nothrow_overflow_handler<Source, Target>,
+                        detect_precision_loss<Source, Target>
+                > converter_t;
+
+                return (
+                    arg < 0 ? -converter_t::convert(-arg) : converter_t::convert(arg)
+                );
             }
         };
 
@@ -2029,7 +2242,7 @@ namespace boost
          * optional, so if a negative number is read, no errors will arise
          * and the result will be the two's complement.
          */
-        template<typename Target, typename Source>
+        template <typename Target, typename Source>
         struct lexical_cast_dynamic_num
         {
             static inline Target lexical_cast_impl(const Source &arg)
@@ -2041,10 +2254,10 @@ namespace boost
                             ::boost::is_float<Source>::value
                         >::value,
                         ::boost::type_traits::ice_not<
-                            is_same<Source, bool>::value
+                            ::boost::is_same<Source, bool>::value
                         >::value,
                         ::boost::type_traits::ice_not<
-                            is_same<Target, bool>::value
+                            ::boost::is_same<Target, bool>::value
                         >::value,
                         ::boost::is_unsigned<Target>::value
                     >::value,
@@ -2057,40 +2270,133 @@ namespace boost
         };
     }
 
-    template<typename Target, typename Source>
+    template <typename Target, typename Source>
     inline Target lexical_cast(const Source &arg)
     {
-        typedef BOOST_DEDUCED_TYPENAME detail::array_to_pointer_decay<Source>::type src;
+        typedef BOOST_DEDUCED_TYPENAME ::boost::detail::array_to_pointer_decay<Source>::type src;
 
         typedef BOOST_DEDUCED_TYPENAME ::boost::type_traits::ice_or<
-                detail::is_xchar_to_xchar<Target, src>::value,
-                detail::is_char_array_to_stdstring<Target,src>::value,
+                ::boost::detail::is_xchar_to_xchar<Target, src >::value,
+                ::boost::detail::is_char_array_to_stdstring<Target, src >::value,
                 ::boost::type_traits::ice_and<
-                     is_same<Target, src>::value,
-                     detail::is_stdstring<Target>::value
+                     ::boost::is_same<Target, src >::value,
+                     ::boost::detail::is_stdstring<Target >::value
                 >::value
-        > do_copy_type;
+        > shall_we_copy_t;
 
         typedef BOOST_DEDUCED_TYPENAME
-                detail::is_arithmetic_and_not_xchars<Target, src> do_copy_with_dynamic_check_type;
+                ::boost::detail::is_arithmetic_and_not_xchars<Target, src > shall_we_copy_with_dynamic_check_t;
 
         typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c<
-            do_copy_type::value,
-            detail::lexical_cast_copy<src>,
+            shall_we_copy_t::value,
+            ::boost::detail::lexical_cast_copy<src >,
             BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c<
-                 do_copy_with_dynamic_check_type::value,
-                 detail::lexical_cast_dynamic_num<Target, src>,
-                 detail::lexical_cast_do_cast<Target, src>
+                 shall_we_copy_with_dynamic_check_t::value,
+                 ::boost::detail::lexical_cast_dynamic_num<Target, src >,
+                 ::boost::detail::lexical_cast_do_cast<Target, src >
             >::type
         >::type caster_type;
 
         return caster_type::lexical_cast_impl(arg);
     }
 
-    #else
+    template <typename Target>
+    inline Target lexical_cast(const char* chars, std::size_t count)
+    {
+        return ::boost::lexical_cast<Target>(
+            ::boost::iterator_range<const char*>(chars, chars + count)
+        );
+    }
+
+
+    template <typename Target>
+    inline Target lexical_cast(const unsigned char* chars, std::size_t count)
+    {
+        return ::boost::lexical_cast<Target>(
+            ::boost::iterator_range<const unsigned char*>(chars, chars + count)
+        );
+    }
+
+    template <typename Target>
+    inline Target lexical_cast(const signed char* chars, std::size_t count)
+    {
+        return ::boost::lexical_cast<Target>(
+            ::boost::iterator_range<const signed char*>(chars, chars + count)
+        );
+    }
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    template <typename Target>
+    inline Target lexical_cast(const wchar_t* chars, std::size_t count)
+    {
+        return ::boost::lexical_cast<Target>(
+            ::boost::iterator_range<const wchar_t*>(chars, chars + count)
+        );
+    }
+#endif
+#ifndef BOOST_NO_CHAR16_T
+    template <typename Target>
+    inline Target lexical_cast(const char16_t* chars, std::size_t count)
+    {
+        return ::boost::lexical_cast<Target>(
+            ::boost::iterator_range<const char16_t*>(chars, chars + count)
+        );
+    }
+#endif
+#ifndef BOOST_NO_CHAR32_T
+    template <typename Target>
+    inline Target lexical_cast(const char32_t* chars, std::size_t count)
+    {
+        return ::boost::lexical_cast<Target>(
+            ::boost::iterator_range<const char32_t*>(chars, chars + count)
+        );
+    }
+#endif
+
+} // namespace boost
 
-    namespace detail // stream wrapper for handling lexical conversions
+#else // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+namespace boost {
+    namespace detail
     {
+
+        // selectors for choosing stream character type
+        template<typename Type>
+        struct stream_char
+        {
+            typedef char type;
+        };
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+        template<>
+        struct stream_char<wchar_t>
+        {
+            typedef wchar_t type;
+        };
+#endif
+
+        template<>
+        struct stream_char<wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<const wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<std::wstring>
+        {
+            typedef wchar_t type;
+        };
+#endif
+
+        // stream wrapper for handling lexical conversions
         template<typename Target, typename Source, typename Traits>
         class lexical_stream
         {
@@ -2180,8 +2486,9 @@ namespace boost
         return result;
     }
 
-    #endif
-}
+} // namespace boost
+
+#endif
 
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
@@ -2191,5 +2498,8 @@ namespace boost
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#undef BOOST_LCAST_THROW_BAD_CAST
 #undef BOOST_LCAST_NO_WCHAR_T
-#endif
+
+#endif // BOOST_LEXICAL_CAST_INCLUDED
+