diff --git a/include/boost/property_tree/detail/info_parser_read.hpp b/include/boost/property_tree/detail/info_parser_read.hpp
index 4e7d42406a..b87c2cbc65 100644
--- a/include/boost/property_tree/detail/info_parser_read.hpp
+++ b/include/boost/property_tree/detail/info_parser_read.hpp
@@ -60,24 +60,13 @@ namespace boost { namespace property_tree { namespace info_parser
         }
         return result;
     }
-    
-    // Detect whitespace in a not very smart way.
-    template <class Ch>
-    bool is_ascii_space(Ch c)
-    {
-        // Everything outside ASCII is not space.
-        unsigned n = c;
-        if (n > 127)
-            return false;
-        return isspace(c);
-    }
 
     // Advance pointer past whitespace
     template<class Ch>
     void skip_whitespace(const Ch *&text)
     {
         using namespace std;
-        while (is_ascii_space(*text))
+        while (isspace(*text))
             ++text;
     }
 
@@ -88,7 +77,7 @@ namespace boost { namespace property_tree { namespace info_parser
         using namespace std;
         skip_whitespace(text);
         const Ch *start = text;
-        while (!is_ascii_space(*text) && *text != Ch(';') && *text != Ch('\0'))
+        while (!isspace(*text) && *text != Ch(';') && *text != Ch('\0'))
             ++text;
         return expand_escapes(start, text);
     }
@@ -102,7 +91,7 @@ namespace boost { namespace property_tree { namespace info_parser
         const Ch *start = text;
         while (*text != Ch('\0') && *text != Ch(';'))
             ++text;
-        while (text > start && is_ascii_space(*(text - 1)))
+        while (text > start && isspace(*(text - 1)))
             --text;
         return expand_escapes(start, text);
     }
diff --git a/include/boost/property_tree/detail/json_parser_read.hpp b/include/boost/property_tree/detail/json_parser_read.hpp
index f8a374c44d..798552f6f1 100644
--- a/include/boost/property_tree/detail/json_parser_read.hpp
+++ b/include/boost/property_tree/detail/json_parser_read.hpp
@@ -32,9 +32,8 @@ namespace boost { namespace property_tree { namespace json_parser
     template<class Ptree>
     struct context
     {
-
-        typedef typename Ptree::key_type::value_type Ch;
-        typedef std::basic_string<Ch> Str;
+	typedef typename Ptree::key_type Str;
+        typedef typename Str::value_type Ch;
         typedef typename std::vector<Ch>::iterator It;
 
         Str string;
@@ -162,7 +161,8 @@ namespace boost { namespace property_tree { namespace json_parser
     {
 
         typedef context<Ptree> Context;
-        typedef typename Ptree::key_type::value_type Ch;
+        typedef typename Ptree::key_type Str;
+        typedef typename Str::value_type Ch;
 
         mutable Context c;
 
@@ -239,8 +239,8 @@ namespace boost { namespace property_tree { namespace json_parser
                     =   !ch_p("-") >>
                         (ch_p("0") | (range_p(Ch('1'), Ch('9')) >> *digit_p)) >>
                         !(ch_p(".") >> +digit_p) >>
-                        !(chset_p(detail::widen<Ch>("eE").c_str()) >>
-                          !chset_p(detail::widen<Ch>("-+").c_str()) >>
+                        !(chset_p(detail::widen<Str>("eE").c_str()) >>
+                          !chset_p(detail::widen<Str>("-+").c_str()) >>
                           +digit_p)
                         ;
 
@@ -255,7 +255,7 @@ namespace boost { namespace property_tree { namespace json_parser
                     ;
 
                 escape
-                    =   chset_p(detail::widen<Ch>("\"\\/bfnrt").c_str())
+                    =   chset_p(detail::widen<Str>("\"\\/bfnrt").c_str())
                             [typename Context::a_escape(self.c)]
                     |   'u' >> uint_parser<unsigned long, 16, 4, 4>()
                             [typename Context::a_unicode(self.c)]
diff --git a/include/boost/property_tree/detail/ptree_utils.hpp b/include/boost/property_tree/detail/ptree_utils.hpp
index 7e56c8f4bb..72aed4614c 100644
--- a/include/boost/property_tree/detail/ptree_utils.hpp
+++ b/include/boost/property_tree/detail/ptree_utils.hpp
@@ -54,49 +54,48 @@ namespace boost { namespace property_tree { namespace detail
 
 
     // Naively convert narrow string to another character type
-    template<class Ch>
-    std::basic_string<Ch> widen(const char *text)
+    template<typename Str>
+    Str widen(const char *text)
     {
-        std::basic_string<Ch> result;
+	Str result;
         while (*text)
         {
-            result += Ch(*text);
+            result += typename Str::value_type(*text);
             ++text;
         }
         return result;
     }
 
     // Naively convert string to narrow character type
-    template<class Ch>
-    std::string narrow(const Ch *text)
+    template<typename Str, typename char_type>
+    Str narrow(const char_type *text)
     {
-        std::string result;
+	Str result;
         while (*text)
         {
             if (*text < 0 || *text > (std::numeric_limits<char>::max)())
                 result += '*';
             else
-                result += char(*text);
+                result += typename Str::value_type(*text);
             ++text;
         }
         return result;
     }
 
     // Remove trailing and leading spaces
-    template<class Ch>
-    std::basic_string<Ch> trim(const std::basic_string<Ch> &s,
-                               const std::locale &loc = std::locale())
+    template<class Str>
+    Str trim(const Str &s, const std::locale &loc = std::locale())
     {
-        typename std::basic_string<Ch>::const_iterator first = s.begin();
-        typename std::basic_string<Ch>::const_iterator end = s.end();
+        typename Str::const_iterator first = s.begin();
+        typename Str::const_iterator end = s.end();
         while (first != end && std::isspace(*first, loc))
             ++first;
         if (first == end)
-            return std::basic_string<Ch>();
-        typename std::basic_string<Ch>::const_iterator last = end;
+            return Str();
+        typename Str::const_iterator last = end;
         do --last; while (std::isspace(*last, loc));
         if (first != s.begin() || last + 1 != end)
-            return std::basic_string<Ch>(first, last + 1);
+            return Str(first, last + 1);
         else
             return s;
     }
diff --git a/include/boost/property_tree/detail/xml_parser_read_rapidxml.hpp b/include/boost/property_tree/detail/xml_parser_read_rapidxml.hpp
index fc994b162e..9c04219189 100644
--- a/include/boost/property_tree/detail/xml_parser_read_rapidxml.hpp
+++ b/include/boost/property_tree/detail/xml_parser_read_rapidxml.hpp
@@ -38,14 +38,13 @@ namespace boost { namespace property_tree { namespace xml_parser
                 if (node->first_attribute())
                 {
                     Ptree &pt_attr_root = pt_node.push_back(
-                        std::make_pair(xmlattr<Ch>(), Ptree()))->second;
+                        std::make_pair(xmlattr<typename Ptree::key_type>(), Ptree()))->second;
                     for (xml_attribute<Ch> *attr = node->first_attribute();
                          attr; attr = attr->next_attribute())
                     {
                         Ptree &pt_attr = pt_attr_root.push_back(
                             std::make_pair(attr->name(), Ptree()))->second;
-                        pt_attr.data() = std::basic_string<Ch>(attr->value(),
-                                                            attr->value_size());
+                        pt_attr.data() = typename Ptree::key_type(attr->value(), attr->value_size());
                     }
                 }
 
@@ -61,11 +60,10 @@ namespace boost { namespace property_tree { namespace xml_parser
             case node_cdata:
             {
                 if (flags & no_concat_text)
-                    pt.push_back(std::make_pair(xmltext<Ch>(),
+                    pt.push_back(std::make_pair(xmltext<typename Ptree::key_type>(),
                                                 Ptree(node->value())));
                 else
-                    pt.data() += std::basic_string<Ch>(node->value(),
-                                                       node->value_size());
+                    pt.data() += typename Ptree::key_type(node->value(), node->value_size());
             }
             break;
 
@@ -73,9 +71,8 @@ namespace boost { namespace property_tree { namespace xml_parser
             case node_comment:
             {
                 if (!(flags & no_comments))
-                    pt.push_back(std::make_pair(xmlcomment<Ch>(),
-                                    Ptree(std::basic_string<Ch>(node->value(),
-                                                         node->value_size()))));
+                    pt.push_back(std::make_pair(xmlcomment<typename Ptree::key_type>(),
+                                    Ptree(typename Ptree::key_type(node->value(), node->value_size()))));
             }
             break;
 
diff --git a/include/boost/property_tree/detail/xml_parser_utils.hpp b/include/boost/property_tree/detail/xml_parser_utils.hpp
index 02e0936826..b4c502b5eb 100644
--- a/include/boost/property_tree/detail/xml_parser_utils.hpp
+++ b/include/boost/property_tree/detail/xml_parser_utils.hpp
@@ -20,14 +20,15 @@
 namespace boost { namespace property_tree { namespace xml_parser
 {
 
-    template<class Ch>
-    std::basic_string<Ch> condense(const std::basic_string<Ch> &s)
+    template<class Str>
+    Str condense(const Str &s)
     {
-        std::basic_string<Ch> r;
+	typedef typename Str::value_type Ch;
+	Str r;
         std::locale loc;
         bool space = false;
-        typename std::basic_string<Ch>::const_iterator end = s.end();
-        for (typename std::basic_string<Ch>::const_iterator it = s.begin();
+        typename Str::const_iterator end = s.end();
+        for (typename Str::const_iterator it = s.begin();
              it != end; ++it)
         {
             if (isspace(*it, loc) || *it == Ch('\n'))
@@ -41,20 +42,22 @@ namespace boost { namespace property_tree { namespace xml_parser
         return r;
     }
 
-    template<class Ch>
-    std::basic_string<Ch> encode_char_entities(const std::basic_string<Ch> &s)
+
+    template<class Str>
+    Str encode_char_entities(const Str &s)
     {
         // Don't do anything for empty strings.
         if(s.empty()) return s;
 
-        typedef typename std::basic_string<Ch> Str;
+        typedef typename Str::value_type Ch;
+
         Str r;
         // To properly round-trip spaces and not uglify the XML beyond
         // recognition, we have to encode them IF the text contains only spaces.
         Str sp(1, Ch(' '));
         if(s.find_first_not_of(sp) == Str::npos) {
             // The first will suffice.
-            r = detail::widen<Ch>("&#32;");
+            r = detail::widen<Str>("&#32;");
             r += Str(s.size() - 1, Ch(' '));
         } else {
             typename Str::const_iterator end = s.end();
@@ -62,13 +65,13 @@ namespace boost { namespace property_tree { namespace xml_parser
             {
                 switch (*it)
                 {
-                    case Ch('<'): r += detail::widen<Ch>("&lt;"); break;
-                    case Ch('>'): r += detail::widen<Ch>("&gt;"); break;
-                    case Ch('&'): r += detail::widen<Ch>("&amp;"); break;
-                    case Ch('"'): r += detail::widen<Ch>("&quot;"); break;
-                    case Ch('\''): r += detail::widen<Ch>("&apos;"); break;
-                    case Ch('\t'): r += detail::widen<Ch>("&#9;"); break;
-                    case Ch('\n'): r += detail::widen<Ch>("&#10;"); break;
+                    case Ch('<'): r += detail::widen<Str>("&lt;"); break;
+                    case Ch('>'): r += detail::widen<Str>("&gt;"); break;
+                    case Ch('&'): r += detail::widen<Str>("&amp;"); break;
+                    case Ch('"'): r += detail::widen<Str>("&quot;"); break;
+                    case Ch('\''): r += detail::widen<Str>("&apos;"); break;
+                    case Ch('\t'): r += detail::widen<Str>("&#9;"); break;
+                    case Ch('\n'): r += detail::widen<Str>("&#10;"); break;
                     default: r += *it; break;
                 }
             }
@@ -76,10 +79,10 @@ namespace boost { namespace property_tree { namespace xml_parser
         return r;
     }
     
-    template<class Ch>
-    std::basic_string<Ch> decode_char_entities(const std::basic_string<Ch> &s)
+    template<class Str>
+    Str decode_char_entities(const Str &s)
     {
-        typedef typename std::basic_string<Ch> Str;
+	typedef typename Str::value_type Ch;
         Str r;
         typename Str::const_iterator end = s.end();
         for (typename Str::const_iterator it = s.begin(); it != end; ++it)
@@ -90,11 +93,11 @@ namespace boost { namespace property_tree { namespace xml_parser
                 if (semicolon == end)
                     BOOST_PROPERTY_TREE_THROW(xml_parser_error("invalid character entity", "", 0));
                 Str ent(it + 1, semicolon);
-                if (ent == detail::widen<Ch>("lt")) r += Ch('<');
-                else if (ent == detail::widen<Ch>("gt")) r += Ch('>');
-                else if (ent == detail::widen<Ch>("amp")) r += Ch('&');
-                else if (ent == detail::widen<Ch>("quot")) r += Ch('"');
-                else if (ent == detail::widen<Ch>("apos")) r += Ch('\'');
+                if (ent == detail::widen<Str>("lt")) r += Ch('<');
+                else if (ent == detail::widen<Str>("gt")) r += Ch('>');
+                else if (ent == detail::widen<Str>("amp")) r += Ch('&');
+                else if (ent == detail::widen<Str>("quot")) r += Ch('"');
+                else if (ent == detail::widen<Str>("apos")) r += Ch('\'');
                 else
                     BOOST_PROPERTY_TREE_THROW(xml_parser_error("invalid character entity", "", 0));
                 it = semicolon;
@@ -105,31 +108,31 @@ namespace boost { namespace property_tree { namespace xml_parser
         return r;
     }
     
-    template<class Ch>
-    const std::basic_string<Ch> &xmldecl()
+    template<class Str>
+    const Str &xmldecl()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<?xml>");
+        static Str s = detail::widen<Str>("<?xml>");
         return s;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmlattr()
+    template<class Str>
+    const Str &xmlattr()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<xmlattr>");
+        static Str s = detail::widen<Str>("<xmlattr>");
         return s;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmlcomment()
+    template<class Str>
+    const Str &xmlcomment()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<xmlcomment>");
+        static Str s = detail::widen<Str>("<xmlcomment>");
         return s;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmltext()
+    template<class Str>
+    const Str &xmltext()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<xmltext>");
+        static Str s = detail::widen<Str>("<xmltext>");
         return s;
     }
 
diff --git a/include/boost/property_tree/detail/xml_parser_write.hpp b/include/boost/property_tree/detail/xml_parser_write.hpp
index d4d709c881..f861eabf73 100644
--- a/include/boost/property_tree/detail/xml_parser_write.hpp
+++ b/include/boost/property_tree/detail/xml_parser_write.hpp
@@ -19,23 +19,24 @@
 
 namespace boost { namespace property_tree { namespace xml_parser
 {
-    template<class Ch>
-    void write_xml_indent(std::basic_ostream<Ch> &stream,
+    template<class Stream, class Settings>
+    void write_xml_indent(Stream &stream,
           int indent,
-          const xml_writer_settings<Ch> & settings
+          const Settings & settings
           )
     {
-        stream << std::basic_string<Ch>(indent * settings.indent_count, settings.indent_char);
+        stream << std::basic_string<typename Stream::char_type>(indent * settings.indent_count, settings.indent_char);
     }
 
-    template<class Ch>
-    void write_xml_comment(std::basic_ostream<Ch> &stream,
-                           const std::basic_string<Ch> &s, 
+    template<class Str, class Settings>
+    void write_xml_comment(std::basic_ostream<typename Str::value_type> &stream,
+                           const Str &s,
                            int indent,
                            bool separate_line,
-                           const xml_writer_settings<Ch> & settings
+                           const Settings& settings
                            )
     {
+	typedef typename Str::value_type Ch;
         if (separate_line)
             write_xml_indent(stream,indent,settings);
         stream << Ch('<') << Ch('!') << Ch('-') << Ch('-');
@@ -45,14 +46,15 @@ namespace boost { namespace property_tree { namespace xml_parser
             stream << Ch('\n');
     }
     
-    template<class Ch>
-    void write_xml_text(std::basic_ostream<Ch> &stream,
-                        const std::basic_string<Ch> &s, 
+    template<class Str, class Settings>
+    void write_xml_text(std::basic_ostream<typename Str::value_type> &stream,
+                        const Str &s,
                         int indent, 
                         bool separate_line,
-                        const xml_writer_settings<Ch> & settings
+                        const Settings& settings
                         )
     {
+	typedef typename Str::value_type Ch;
         if (separate_line)    
             write_xml_indent(stream,indent,settings);
         stream << encode_char_entities(s);
@@ -60,15 +62,15 @@ namespace boost { namespace property_tree { namespace xml_parser
             stream << Ch('\n');
     }
 
-    template<class Ptree>
+    template<class Ptree, class Settings>
     void write_xml_element(std::basic_ostream<typename Ptree::key_type::value_type> &stream, 
-                           const std::basic_string<typename Ptree::key_type::value_type> &key,
+                           const typename Ptree::key_type &key,
                            const Ptree &pt, 
                            int indent,
-                           const xml_writer_settings<typename Ptree::key_type::value_type> & settings)
+                           const Settings& settings)
     {
-
         typedef typename Ptree::key_type::value_type Ch;
+        typedef typename Ptree::key_type Str;
         typedef typename Ptree::const_iterator It;
 
         bool want_pretty = settings.indent_count > 0;
@@ -77,10 +79,10 @@ namespace boost { namespace property_tree { namespace xml_parser
         bool has_attrs_only = pt.data().empty();
         for (It it = pt.begin(), end = pt.end(); it != end; ++it)
         {
-            if (it->first != xmlattr<Ch>() )
+            if (it->first != xmlattr<Str>() )
             {
                 has_attrs_only = false;
-                if (it->first != xmltext<Ch>())
+                if (it->first != xmltext<Str>())
                 {
                     has_elements = true;
                     break;
@@ -112,12 +114,12 @@ namespace boost { namespace property_tree { namespace xml_parser
                 stream << Ch('<') << key;
 
                 // Write attributes
-                if (optional<const Ptree &> attribs = pt.get_child_optional(xmlattr<Ch>()))
+                if (optional<const Ptree &> attribs = pt.get_child_optional(xmlattr<Str>()))
                     for (It it = attribs.get().begin(); it != attribs.get().end(); ++it)
                         stream << Ch(' ') << it->first << Ch('=')
                                << Ch('"')
                                << encode_char_entities(
-                                    it->second.template get_value<std::basic_string<Ch> >())
+                                    it->second.template get_value<Str>())
                                << Ch('"');
 
                 if ( has_attrs_only )
@@ -141,21 +143,21 @@ namespace boost { namespace property_tree { namespace xml_parser
             // Write data text, if present
             if (!pt.data().empty())
                 write_xml_text(stream,
-                    pt.template get_value<std::basic_string<Ch> >(),
+                    pt.template get_value<Str>(),
                     indent + 1, has_elements && want_pretty, settings);
 
             // Write elements, comments and texts
             for (It it = pt.begin(); it != pt.end(); ++it)
             {
-                if (it->first == xmlattr<Ch>())
+                if (it->first == xmlattr<Str>())
                     continue;
-                else if (it->first == xmlcomment<Ch>())
+                else if (it->first == xmlcomment<Str>())
                     write_xml_comment(stream,
-                        it->second.template get_value<std::basic_string<Ch> >(),
+                        it->second.template get_value<Str>(),
                         indent + 1, want_pretty, settings);
-                else if (it->first == xmltext<Ch>())
+                else if (it->first == xmltext<Str>())
                     write_xml_text(stream,
-                        it->second.template get_value<std::basic_string<Ch> >(),
+                        it->second.template get_value<Str>(),
                         indent + 1, has_elements && want_pretty, settings);
                 else
                     write_xml_element(stream, it->first, it->second,
@@ -175,17 +177,16 @@ namespace boost { namespace property_tree { namespace xml_parser
         }
     }
 
-    template<class Ptree>
+    template<class Ptree, class Settings>
     void write_xml_internal(std::basic_ostream<typename Ptree::key_type::value_type> &stream, 
                             const Ptree &pt,
                             const std::string &filename,
-                            const xml_writer_settings<typename Ptree::key_type::value_type> & settings)
+                            const Settings & settings)
     {
-        typedef typename Ptree::key_type::value_type Ch;
-        typedef typename std::basic_string<Ch> Str;
-        stream  << detail::widen<Ch>("<?xml version=\"1.0\" encoding=\"")
+        typedef typename Ptree::key_type Str;
+        stream  << detail::widen<Str>("<?xml version=\"1.0\" encoding=\"")
                 << settings.encoding
-                << detail::widen<Ch>("\"?>\n");
+                << detail::widen<Str>("\"?>\n");
         write_xml_element(stream, Str(), pt, -1, settings);
         if (!stream)
             BOOST_PROPERTY_TREE_THROW(xml_parser_error("write error", filename, 0));
diff --git a/include/boost/property_tree/detail/xml_parser_writer_settings.hpp b/include/boost/property_tree/detail/xml_parser_writer_settings.hpp
index 0cc707a538..dfdb50affa 100644
--- a/include/boost/property_tree/detail/xml_parser_writer_settings.hpp
+++ b/include/boost/property_tree/detail/xml_parser_writer_settings.hpp
@@ -18,10 +18,11 @@ namespace boost { namespace property_tree { namespace xml_parser
 {
     
     // Naively convert narrow string to another character type
-    template<class Ch>
-    std::basic_string<Ch> widen(const char *text)
+    template<class Str>
+    Str widen(const char *text)
     {
-        std::basic_string<Ch> result;
+	typedef typename Str::value_type Ch;
+        Str result;
         while (*text)
         {
             result += Ch(*text);
@@ -31,30 +32,56 @@ namespace boost { namespace property_tree { namespace xml_parser
     }
 
     //! Xml writer settings. The default settings lead to no pretty printing.
-    template<class Ch>
+    template<class Str>
     class xml_writer_settings
     {
+	typedef typename Str::value_type Ch;
     public:
         xml_writer_settings(Ch inchar = Ch(' '),
-                typename std::basic_string<Ch>::size_type incount = 0,
-                const std::basic_string<Ch> &enc = widen<Ch>("utf-8"))
+                typename Str::size_type incount = 0,
+                const Str &enc = widen<Str>("utf-8"))
             : indent_char(inchar)
             , indent_count(incount)
             , encoding(enc)
         {
         }
 
-        const Ch indent_char;
-        const typename std::basic_string<Ch>::size_type indent_count;
-        const std::basic_string<Ch> encoding;
+        Ch indent_char;
+        typename Str::size_type indent_count;
+        Str encoding;
     };
 
-    template <class Ch>
-    xml_writer_settings<Ch> xml_writer_make_settings(Ch indent_char = Ch(' '),
-        typename std::basic_string<Ch>::size_type indent_count = 0,
-        const std::basic_string<Ch> &encoding = widen<Ch>("utf-8"))
+    template<>
+    class xml_writer_settings<char>
     {
-        return xml_writer_settings<Ch>(indent_char, indent_count, encoding);
+    public:
+        xml_writer_settings(char inchar = ' ',
+                std::string::size_type incount = 0,
+                const std::string &enc = widen<std::string>("utf-8"))
+            : indent_char(inchar)
+            , indent_count(incount)
+            , encoding(enc)
+        {
+        }
+
+        char indent_char;
+        std::string::size_type indent_count;
+        std::string encoding;
+    };
+
+    template <class Str>
+    xml_writer_settings<Str> xml_writer_make_settings(typename Str::value_type indent_char = (typename Str::value_type)(' '),
+        typename Str::size_type indent_count = 0,
+        const Str &encoding = widen<Str>("utf-8"))
+    {
+        return xml_writer_settings<Str>(indent_char, indent_count, encoding);
+    }
+
+    template <class size_type>
+    xml_writer_settings<std::string> xml_writer_make_settings(char indent_char,
+        size_type indent_count)
+    {
+        return xml_writer_settings<std::string>(indent_char, indent_count, widen<std::string>("utf-8"));
     }
 
 } } }
diff --git a/include/boost/property_tree/string_path.hpp b/include/boost/property_tree/string_path.hpp
index d4bc686dc6..3ddcfb2033 100644
--- a/include/boost/property_tree/string_path.hpp
+++ b/include/boost/property_tree/string_path.hpp
@@ -61,7 +61,7 @@ namespace boost { namespace property_tree
 #ifndef BOOST_NO_STD_WSTRING
         inline std::string dump_sequence(const std::wstring &s)
         {
-            return narrow(s.c_str());
+            return narrow<std::string>(s.c_str());
         }
 #endif
     }
diff --git a/include/boost/property_tree/xml_parser.hpp b/include/boost/property_tree/xml_parser.hpp
index 4f36e9a0be..739f622590 100644
--- a/include/boost/property_tree/xml_parser.hpp
+++ b/include/boost/property_tree/xml_parser.hpp
@@ -96,19 +96,37 @@ namespace boost { namespace property_tree { namespace xml_parser
      * @param settings The settings to use when writing out the property tree as
      *                 XML.
      */
-    template<class Ptree>
+    template<class Ptree, class Settings>
     void write_xml(std::basic_ostream<
                        typename Ptree::key_type::value_type
                    > &stream,
                    const Ptree &pt,
-                   const xml_writer_settings<
+                   const Settings & settings)
+    {
+        write_xml_internal(stream, pt, std::string(), settings);
+    }
+
+    /**
+     * Translates the property tree to XML and writes it the given output
+     * stream.
+     * @throw xml_parser_error In case of error translating the property tree to
+     *                         XML or writing to the output stream.
+     * @param stream The stream to which to write the XML representation of the
+     *               property tree.
+     * @param pt The property tree to tranlsate to XML and output.
+     */
+    template<class Ptree>
+    void write_xml(std::basic_ostream<
                        typename Ptree::key_type::value_type
-                   > & settings = xml_writer_settings<
-                                    typename Ptree::key_type::value_type>() )
+                   > &stream,
+                   const Ptree &pt )
     {
+	xml_writer_settings<typename Ptree::key_type> settings;
+
         write_xml_internal(stream, pt, std::string(), settings);
     }
 
+
     /**
      * Translates the property tree to XML and writes it the given file.
      * @throw xml_parser_error In case of error translating the property tree to
@@ -120,14 +138,11 @@ namespace boost { namespace property_tree { namespace xml_parser
      * @param settings The settings to use when writing out the property tree as
      *                 XML.
      */
-    template<class Ptree>
+    template<class Ptree, class Settings>
     void write_xml(const std::string &filename,
                    const Ptree &pt,
-                   const std::locale &loc = std::locale(),
-                   const xml_writer_settings<
-                       typename Ptree::key_type::value_type
-                   > & settings = xml_writer_settings<
-                                    typename Ptree::key_type::value_type>())
+                   const std::locale &loc,
+                   const Settings & settings)
     {
         std::basic_ofstream<typename Ptree::key_type::value_type>
             stream(filename.c_str());
@@ -138,6 +153,24 @@ namespace boost { namespace property_tree { namespace xml_parser
         write_xml_internal(stream, pt, filename, settings);
     }
 
+    /**
+     * Translates the property tree to XML and writes it the given file.
+     * @throw xml_parser_error In case of error translating the property tree to
+     *                         XML or writing to the output stream.
+     * @param filename The file to which to write the XML representation of the
+     *                 property tree.
+     * @param pt The property tree to tranlsate to XML and output.
+     * @param loc The locale to use when writing the output to file.
+     */
+    template<class Ptree>
+    void write_xml(const std::string &filename,
+                   const Ptree &pt,
+                   const std::locale &loc = std::locale())
+    {
+	xml_writer_settings<typename Ptree::key_type> settings;
+	write_xml(filename, pt, loc, settings);
+    }
+
 } } }
 
 namespace boost { namespace property_tree
diff --git a/test/test_property_tree.hpp b/test/test_property_tree.hpp
index f9ac6664fd..9a0b1272ff 100644
--- a/test/test_property_tree.hpp
+++ b/test/test_property_tree.hpp
@@ -797,9 +797,6 @@ void test_get_put(PTREE *)
                                     
 void test_get_child_put_child(PTREE *)
 {
-
-    typedef std::basic_string<CHTYPE> str_t;
-
     PTREE pt(T("ala ma kota"));
 
     // Do insertions via put_child
@@ -1076,7 +1073,6 @@ void test_custom_data_type(PTREE *)
 
     typedef std::basic_string<CHTYPE> Str;
     typedef PTREE::key_compare Comp;
-    typedef PTREE::path_type Path;
 
     // Property_tree with boost::any as data type
     typedef boost::property_tree::basic_ptree<Str, boost::any, Comp> my_ptree;
diff --git a/test/test_registry_parser.cpp b/test/test_registry_parser.cpp
deleted file mode 100644
index 2e7c348816..0000000000
--- a/test/test_registry_parser.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-// ----------------------------------------------------------------------------
-// Copyright (C) 2002-2006 Marcin Kalicinski
-//
-// 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
-// ----------------------------------------------------------------------------
-
-#include "test_utils.hpp"
-
-// Only test registry parser if we have windows platform
-#ifdef BOOST_WINDOWS
-
-#include <boost/property_tree/registry_parser.hpp>
-#include <boost/property_tree/info_parser.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-// Test data
-
-const char *data_1 = 
-    "root\n"
-    "{\n"
-    "  subkey1 \"default value 1\"\n"
-    "  subkey2 \"default value 2\"\n"
-    "  \\\\values\n"
-    "  {\n"
-    "    REG_NONE \"\"\n"
-    "    REG_BINARY \"de ad be ef\"\n"
-    "    REG_DWORD 1234567890\n"
-    "    REG_QWORD 12345678901234567890\n"
-    "    REG_SZ \"some text\"\n"
-    "    REG_EXPAND_SZ \"some other text\"\n"
-    "  }\n"
-    "  \\\\types\n"
-    "  {\n"
-    "    REG_NONE 0\n"
-    "    REG_BINARY 3\n"
-    "    REG_DWORD 4\n"
-    "    REG_QWORD 11\n"
-    "    REG_SZ 1\n"
-    "    REG_EXPAND_SZ 2\n"
-    "  }\n"
-    "}\n";
-
-template<class Ptree>
-void test_registry_parser()
-{
-
-    using namespace boost::property_tree;
-    typedef typename Ptree::key_type::value_type Ch;
-    typedef std::basic_string<Ch> Str;
-
-    // Delete test registry key
-    RegDeleteKeyA(HKEY_CURRENT_USER, "boost ptree test");
-    
-    // Get test ptree
-    Ptree pt;
-    std::basic_stringstream<Ch> stream(detail::widen<Ch>(data_1));
-    read_info(stream, pt);
-
-    try
-    {
-
-        // Write to registry, read back and compare contents
-        Ptree pt2;
-        write_registry(HKEY_CURRENT_USER, detail::widen<Ch>("boost ptree test"), pt);
-        read_registry(HKEY_CURRENT_USER, detail::widen<Ch>("boost ptree test"), pt2);
-        BOOST_CHECK(pt == pt2);
-
-        // Test binary translation
-        Str s = pt2.template get<Str>(detail::widen<Ch>("root.\\values.REG_BINARY"));
-        std::vector<BYTE> bin = registry_parser::translate(REG_BINARY, s);
-        BOOST_REQUIRE(bin.size() == 4);
-        BOOST_CHECK(*reinterpret_cast<DWORD *>(&bin.front()) == 0xEFBEADDE);
-        Str s2 = registry_parser::translate<Ch>(REG_BINARY, bin);
-        BOOST_CHECK(s == s2);
-
-    }
-    catch (std::exception &e)
-    {
-        BOOST_ERROR(e.what());
-    }
-    
-    // Delete test registry key
-    RegDeleteKeyA(HKEY_CURRENT_USER, "boost ptree test");
-
-}
-
-int test_main(int argc, char *argv[])
-{
-    using namespace boost::property_tree;
-    test_registry_parser<ptree>();
-    //test_registry_parser<iptree>();
-#ifndef BOOST_NO_CWCHAR
-    //test_registry_parser<wptree>();
-    //test_registry_parser<wiptree>();
-#endif
-    return 0;
-}
-
-#else
-
-int test_main(int argc, char *argv[])
-{
-    return 0;
-}
-
-#endif
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index 2a4a3bdae6..809f91f572 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -81,13 +81,13 @@ template<class Ptree>
 Ptree get_test_ptree()
 {
     using namespace boost::property_tree;
-    typedef typename Ptree::key_type::value_type Ch;
+    typedef typename Ptree::key_type Str;
     Ptree pt;
-    pt.put_value(detail::widen<Ch>("data0"));
-    pt.put(detail::widen<Ch>("key1"), detail::widen<Ch>("data1"));
-    pt.put(detail::widen<Ch>("key1.key"), detail::widen<Ch>("data2"));
-    pt.put(detail::widen<Ch>("key2"), detail::widen<Ch>("data3"));
-    pt.put(detail::widen<Ch>("key2.key"), detail::widen<Ch>("data4"));
+    pt.put_value(detail::widen<Str>("data0"));
+    pt.put(detail::widen<Str>("key1"), detail::widen<Str>("data1"));
+    pt.put(detail::widen<Str>("key1.key"), detail::widen<Str>("data2"));
+    pt.put(detail::widen<Str>("key2"), detail::widen<Str>("data3"));
+    pt.put(detail::widen<Str>("key2.key"), detail::widen<Str>("data4"));
     return pt;
 }
 
@@ -104,7 +104,6 @@ void generic_parser_test(Ptree &pt,
 {
 
     using namespace boost::property_tree;
-    typedef typename Ptree::key_type::value_type Ch;
 
     // Create test files
     test_file file_1(test_data_1, filename_1);
@@ -236,7 +235,8 @@ void check_exact_roundtrip(ReadFunc rf, WriteFunc wf, const char *test_data) {
               << test_data << "\n-----\n";
     using namespace boost::property_tree;
     typedef typename Ptree::key_type::value_type Ch;
-    std::basic_string<Ch> native_test_data = detail::widen<Ch>(test_data);
+    typedef typename Ptree::key_type Str;
+    Str native_test_data = detail::widen<Str>(test_data);
 
     std::basic_istringstream<Ch> in_stream(native_test_data);
     std::basic_ostringstream<Ch> out_stream;
diff --git a/test/test_xml_parser_common.hpp b/test/test_xml_parser_common.hpp
index 9679cb57ec..019773bb65 100644
--- a/test/test_xml_parser_common.hpp
+++ b/test/test_xml_parser_common.hpp
@@ -49,8 +49,7 @@ struct WriteFuncNS
     void operator()(const std::string &filename, const Ptree &pt) const
     {
         boost::property_tree::write_xml(filename, pt, std::locale(),
-            boost::property_tree::xml_writer_make_settings(
-                typename Ptree::key_type::value_type(' '), 4));
+            boost::property_tree::xml_writer_make_settings<typename Ptree::key_type>(' ', 4));
     }
 };