libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows.

[pcc]

Summary

This is an MSVC standard library extension. It seems like a reasonable
enough extension to me because wchar_t* is the native format for
filenames on that platform.

If others agree, I will write the remaining tests.

[compnerd]

Can we avoid the _WIN32 usage please? We spent some effort to avoid it, and have _LIBCPP_WIN32API to indicate that we want the Win32 API. I know that Marshall had some strong opinions on avoiding the _WIN32 usage, but, beyond that, I think that this is a completely reasonable thing to provide. I'm still torn if we should enable this on not _LIBCPP_ABI_MICROSOFT. One other option would be to have a _LIBCPP_MS_EXTENSIONS flag to control whether they are provided. But, all of that is merely details on how to control access to the interfaces, not the direction itself.

libcxx/include/fstream

560 ↗

(On Diff #130346)

Should this also be marked inline?

[mclow.lists]

In D42225#982057, @compnerd wrote:

Can we avoid the _WIN32 usage please? We spent some effort to avoid it, and have _LIBCPP_WIN32API to indicate that we want the Win32 API. I know that Marshall had some strong opinions on avoiding the _WIN32 usage, but, beyond that, I think that this is a completely reasonable thing to provide.

I agree. _WIN32 is really a big hammer. I'd much rather some more focused and descriptive guard macro. Maybe _LIBCPP_HAS_OPEN_WITH_WCHAR.

Also, if the tests are for a libc++ extension, then they belong in the test/libcxx hierarchy.

[pcc]

• Add tests, address review comments

[pcc]

In D42225#982057, @compnerd wrote:

I'm still torn if we should enable this on not _LIBCPP_ABI_MICROSOFT.

It looks like mingw32 provides a declaration of _wfopen, so at least from a technical perspective it seems fine.

In D42225#982275, @mclow.lists wrote:

In D42225#982057, @compnerd wrote:

Can we avoid the _WIN32 usage please? We spent some effort to avoid it, and have _LIBCPP_WIN32API to indicate that we want the Win32 API. I know that Marshall had some strong opinions on avoiding the _WIN32 usage, but, beyond that, I think that this is a completely reasonable thing to provide.

I agree. _WIN32 is really a big hammer. I'd much rather some more focused and descriptive guard macro. Maybe _LIBCPP_HAS_OPEN_WITH_WCHAR.

Also, if the tests are for a libc++ extension, then they belong in the test/libcxx hierarchy.

Done.

libcxx/include/fstream

560 ↗

(On Diff #130346)

No strong opinions, I was just being consistent with the const char* overload which isn't marked inline.

[compnerd]

LGTM

libcxx/include/__config

250 ↗

(On Diff #130747)

Thanks, this is great.

libcxx/include/fstream

614 ↗

(On Diff #130747)

It would be nice if we could do something like:

template <typename _CharT>
_CharT *ModeStringFromMode(const ios_base::openmode __mode);

[pcc]

libcxx/include/fstream

614 ↗

(On Diff #130747)

As discussed on IRC, I added a comment at the top of this function.

[ldionne]

@pcc @mstorsjo Are we aware of anyone using these extensions?

I would like to suggest that we either remove this extension if it's not useful, or make it unconditional (not only on Windows) if we really think it's that useful (but I'd like that to come with at least a paper proposing to add them to the standard). Carrying around an extension that's only enabled on one platform (and not the most widely used platform for libc++ at that) is kind of awkward.

WDYT?

[pcc]

I believe that Chromium uses it (or at least it did at the time that I added this, and Chromium has since switched to using libc++ on Windows).

I don't work on Chromium much anymore but perhaps @thakis or @thomasanderson can confirm.

[mstorsjo]

In D42225#2962348, @ldionne wrote:

@pcc @mstorsjo Are we aware of anyone using these extensions?

I would like to suggest that we either remove this extension if it's not useful, or make it unconditional (not only on Windows) if we really think it's that useful (but I'd like that to come with at least a paper proposing to add them to the standard). Carrying around an extension that's only enabled on one platform (and not the most widely used platform for libc++ at that) is kind of awkward.

This extension is fairly essential - without it, you can't interact with files that have names outside of the 8 bit charset on Windows (and exactly what the 8 bit charset is, can vary from system to system). I can't point to a specific user of it, but I'd expect there to be numerous out there.

Making it universally available sounds like a sensible strategy forward - although I don't think I have the bandwidth to take on making it a standards proposal. Maybe someone from Microsoft (who invented this extension) can collaborate on it?

[ldionne]

In D42225#2963190, @mstorsjo wrote:

In D42225#2962348, @ldionne wrote:

@pcc @mstorsjo Are we aware of anyone using these extensions?

I would like to suggest that we either remove this extension if it's not useful, or make it unconditional (not only on Windows) if we really think it's that useful (but I'd like that to come with at least a paper proposing to add them to the standard). Carrying around an extension that's only enabled on one platform (and not the most widely used platform for libc++ at that) is kind of awkward.

This extension is fairly essential - without it, you can't interact with files that have names outside of the 8 bit charset on Windows (and exactly what the 8 bit charset is, can vary from system to system). I can't point to a specific user of it, but I'd expect there to be numerous out there.

Making it universally available sounds like a sensible strategy forward - although I don't think I have the bandwidth to take on making it a standards proposal. Maybe someone from Microsoft (who invented this extension) can collaborate on it?

@CaseyCarter Any appetite for that?

[CaseyCarter]

In D42225#2963216, @ldionne wrote:

In D42225#2963190, @mstorsjo wrote:

In D42225#2962348, @ldionne wrote:

@pcc @mstorsjo Are we aware of anyone using these extensions?

I would like to suggest that we either remove this extension if it's not useful, or make it unconditional (not only on Windows) if we really think it's that useful (but I'd like that to come with at least a paper proposing to add them to the standard). Carrying around an extension that's only enabled on one platform (and not the most widely used platform for libc++ at that) is kind of awkward.

This extension is fairly essential - without it, you can't interact with files that have names outside of the 8 bit charset on Windows (and exactly what the 8 bit charset is, can vary from system to system). I can't point to a specific user of it, but I'd expect there to be numerous out there.

Making it universally available sounds like a sensible strategy forward - although I don't think I have the bandwidth to take on making it a standards proposal. Maybe someone from Microsoft (who invented this extension) can collaborate on it?

@CaseyCarter Any appetite for that?

This isn't an extension for us. The Standard mandates overloads of basic_filebuf::open, basic_ifstream::open, basic_ofstream::open, and basic_fstream::open, as well as constructors for basic_ifstream, basic_ofstream, and basic_fstream that take const filesystem::path::value_type* which are "only be [sic] provided on systems where filesystem::path::value_type is not char." ([fstream.syn]/3) Unsurprisingly, filesystem::path::value_type for us is wchar_t. If you're supporting our mess of narrow character encodings, you may want to consider wchar_t for filesystem::path on Win32 as well. If you are only supporting UTF-8, I suppose you could instead transcode filenames to UTF-16 and use _wfopen?

[mstorsjo]

In D42225#3020688, @CaseyCarter wrote:

In D42225#2963216, @ldionne wrote:

In D42225#2963190, @mstorsjo wrote:

In D42225#2962348, @ldionne wrote:

@pcc @mstorsjo Are we aware of anyone using these extensions?

I would like to suggest that we either remove this extension if it's not useful, or make it unconditional (not only on Windows) if we really think it's that useful (but I'd like that to come with at least a paper proposing to add them to the standard). Carrying around an extension that's only enabled on one platform (and not the most widely used platform for libc++ at that) is kind of awkward.

This extension is fairly essential - without it, you can't interact with files that have names outside of the 8 bit charset on Windows (and exactly what the 8 bit charset is, can vary from system to system). I can't point to a specific user of it, but I'd expect there to be numerous out there.

Making it universally available sounds like a sensible strategy forward - although I don't think I have the bandwidth to take on making it a standards proposal. Maybe someone from Microsoft (who invented this extension) can collaborate on it?

@CaseyCarter Any appetite for that?

This isn't an extension for us. The Standard mandates overloads of basic_filebuf::open, basic_ifstream::open, basic_ofstream::open, and basic_fstream::open, as well as constructors for basic_ifstream, basic_ofstream, and basic_fstream that take const filesystem::path::value_type* which are "only be [sic] provided on systems where filesystem::path::value_type is not char." ([fstream.syn]/3) Unsurprisingly, filesystem::path::value_type for us is wchar_t. If you're supporting our mess of narrow character encodings, you may want to consider wchar_t for filesystem::path on Win32 as well. If you are only supporting UTF-8, I suppose you could instead transcode filenames to UTF-16 and use _wfopen?

We also use wchar_t for filesystem::path::value_type on Windows, essentially following the MS STL when it comes to those details. I think also libstdc++ might have added these wchar_t overloads these days.

include/__config

 // If mingw not explicitly detected, assume using MS C runtime only if
 // a MS compatibility version is specified.
 #  if defined(_MSC_VER) && !defined(__MINGW32__)
 #    define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
 #  endif
 #  if (defined(_M_AMD64) || defined(__x86_64__)) || (defined(_M_ARM) || defined(__arm__))
 #    define _LIBCPP_HAS_BITSCAN64
 #  endif
+#  define _LIBCPP_HAS_OPEN_WITH_WCHAR
 # if defined(_LIBCPP_MSVCRT)
 #   define _LIBCPP_HAS_QUICK_EXIT
 # endif
 
 // Some CRT APIs are unavailable to store apps
 #if defined(WINAPI_FAMILY)
 #include <winapifamily.h>
 #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) &&                      \

include/fstream

 #endif
     void swap(basic_filebuf& __rhs);
 
     // 27.9.1.4 Members:
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     basic_filebuf* open(const char* __s, ios_base::openmode __mode);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
+#endif
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* open(const string& __s, ios_base::openmode __mode);
 #endif
     basic_filebuf* close();
 
 protected:
     // 27.9.1.5 Overridden virtual functions:
     virtual int_type underflow();
if (__file_ == 0)
             }
             else
                 __rt = 0;
         }
     }
     return __rt;
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+// This is basically the same as the char* overload except that it uses _wfopen
+// and long mode strings.
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>*
+basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+{
+    basic_filebuf<_CharT, _Traits>* __rt = 0;
+    if (__file_ == 0)
+    {
+        __rt = this;
+        const wchar_t* __mdstr;
+        switch (__mode & ~ios_base::ate)
+        {
+        case ios_base::out:
+        case ios_base::out | ios_base::trunc:
+            __mdstr = L"w";
+            break;
+        case ios_base::out | ios_base::app:
+        case ios_base::app:
+            __mdstr = L"a";
+            break;
+        case ios_base::in:
+            __mdstr = L"r";
+            break;
+        case ios_base::in | ios_base::out:
+            __mdstr = L"r+";
+            break;
+        case ios_base::in | ios_base::out | ios_base::trunc:
+            __mdstr = L"w+";
+            break;
+        case ios_base::in | ios_base::out | ios_base::app:
+        case ios_base::in | ios_base::app:
+            __mdstr = L"a+";
+            break;
+        case ios_base::out | ios_base::binary:
+        case ios_base::out | ios_base::trunc | ios_base::binary:
+            __mdstr = L"wb";
+            break;
+        case ios_base::out | ios_base::app | ios_base::binary:
+        case ios_base::app | ios_base::binary:
+            __mdstr = L"ab";
+            break;
+        case ios_base::in | ios_base::binary:
+            __mdstr = L"rb";
+            break;
+        case ios_base::in | ios_base::out | ios_base::binary:
+            __mdstr = L"r+b";
+            break;
+        case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
+            __mdstr = L"w+b";
+            break;
+        case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
+        case ios_base::in | ios_base::app | ios_base::binary:
+            __mdstr = L"a+b";
+            break;
+        default:
+            __rt = 0;
+            break;
+        }
+        if (__rt)
+        {
+            __file_ = _wfopen(__s, __mdstr);
+            if (__file_)
+            {
+                __om_ = __mode;
+                if (__mode & ios_base::ate)
+                {
+                    if (fseek(__file_, 0, SEEK_END))
+                    {
+                        fclose(__file_);
+                        __file_ = 0;
+                        __rt = 0;
+                    }
+                }
+            }
+            else
+                __rt = 0;
+        }
+    }
+    return __rt;
+}
+#endif
+
 template <class _CharT, class _Traits>
 inline
 basic_filebuf<_CharT, _Traits>*
 basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     return open(__s.c_str(), __mode);
 }
 #endif
public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream();
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
 #endif
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream(basic_ifstream&& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream& operator=(basic_ifstream&& __rhs);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ifstream& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::in);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
+#endif
     void open(const string& __s, ios_base::openmode __mode = ios_base::in);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void close();
 
 private:
     basic_filebuf<char_type, traits_type> __sb_;
 };

 inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
     : basic_istream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::in) == 0)
         this->setstate(ios_base::failbit);
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+inline
+basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
+    : basic_istream<char_type, traits_type>(&__sb_)
+{
+    if (__sb_.open(__s, __mode | ios_base::in) == 0)
+        this->setstate(ios_base::failbit);
+}
+#endif
+
 template <class _CharT, class _Traits>
 inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
     : basic_istream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::in) == 0)
         this->setstate(ios_base::failbit);
 }

 basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::in))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+void
+basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+{
+    if (__sb_.open(__s, __mode | ios_base::in))
+        this->clear();
+    else
+        this->setstate(ios_base::failbit);
+}
+#endif
+
 template <class _CharT, class _Traits>
 void
 basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::in))
         this->clear();
     else
         this->setstate(ios_base::failbit);
public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream();
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream(basic_ofstream&& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream& operator=(basic_ofstream&& __rhs);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ofstream& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::out);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
+#endif
     void open(const string& __s, ios_base::openmode __mode = ios_base::out);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void close();
 
 private:
     basic_filebuf<char_type, traits_type> __sb_;
 };

 inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::out) == 0)
         this->setstate(ios_base::failbit);
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+inline
+basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
+    : basic_ostream<char_type, traits_type>(&__sb_)
+{
+    if (__sb_.open(__s, __mode | ios_base::out) == 0)
+        this->setstate(ios_base::failbit);
+}
+#endif
+
 template <class _CharT, class _Traits>
 inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::out) == 0)
         this->setstate(ios_base::failbit);
 }

 basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::out))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+void
+basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+{
+    if (__sb_.open(__s, __mode | ios_base::out))
+        this->clear();
+    else
+        this->setstate(ios_base::failbit);
+}
+#endif
+
 template <class _CharT, class _Traits>
 void
 basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::out))
         this->clear();
     else
         this->setstate(ios_base::failbit);
public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream();
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #endif
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream(basic_fstream&& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream& operator=(basic_fstream&& __rhs);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_fstream& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+#endif
     void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void close();
 
 private:
     basic_filebuf<char_type, traits_type> __sb_;
 };

 inline
 basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode) == 0)
         this->setstate(ios_base::failbit);
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+inline
+basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
+    : basic_iostream<char_type, traits_type>(&__sb_)
+{
+    if (__sb_.open(__s, __mode) == 0)
+        this->setstate(ios_base::failbit);
+}
+#endif
+
 template <class _CharT, class _Traits>
 inline
 basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode) == 0)
         this->setstate(ios_base::failbit);
 }

 basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
 
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+void
+basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+{
+    if (__sb_.open(__s, __mode))
+        this->clear();
+    else
+        this->setstate(ios_base::failbit);
+}
+#endif
+
 template <class _CharT, class _Traits>
 void
 basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode))
         this->clear();
     else
         this->setstate(ios_base::failbit);

test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_fstream
+
+// explicit basic_fstream(const wchar_t* s, ios_base::openmode mode = ios_base::in | ios_base::out);
+
+#include <fstream>
+#include <cassert>
+#include "platform_support.h"
+
+int main()
+{
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    std::wstring temp = get_wide_temp_file_name();
+    {
+        std::fstream fs(temp.c_str(), std::ios_base::in | std::ios_base::out
+                                                | std::ios_base::trunc);
+        double x = 0;
+        fs << 3.25;
+        fs.seekg(0);
+        fs >> x;
+        assert(x == 3.25);
+    }
+    _wremove(temp.c_str());
+    {
+        std::wfstream fs(temp.c_str(), std::ios_base::in | std::ios_base::out
+                                                 | std::ios_base::trunc);
+        double x = 0;
+        fs << 3.25;
+        fs.seekg(0);
+        fs >> x;
+        assert(x == 3.25);
+    }
+    _wremove(temp.c_str());
+#endif
+}

test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_fstream
+
+// void open(const wchar_t* s, ios_base::openmode mode = ios_base::in|ios_base::out);
+
+#include <fstream>
+#include <cassert>
+#include "platform_support.h"
+
+int main()
+{
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    std::wstring temp = get_wide_temp_file_name();
+    {
+        std::fstream fs;
+        assert(!fs.is_open());
+        fs.open(temp.c_str(), std::ios_base::in | std::ios_base::out
+                                        | std::ios_base::trunc);
+        assert(fs.is_open());
+        double x = 0;
+        fs << 3.25;
+        fs.seekg(0);
+        fs >> x;
+        assert(x == 3.25);
+    }
+    _wremove(temp.c_str());
+    {
+        std::wfstream fs;
+        assert(!fs.is_open());
+        fs.open(temp.c_str(), std::ios_base::in | std::ios_base::out
+                                        | std::ios_base::trunc);
+        assert(fs.is_open());
+        double x = 0;
+        fs << 3.25;
+        fs.seekg(0);
+        fs >> x;
+        assert(x == 3.25);
+    }
+    _wremove(temp.c_str());
+#endif
+}

test/libcxx/input.output/file.streams/fstreams/ifstream.cons/test.dat

+3.25
 No newline at end of file

test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_ifstream
+
+// explicit basic_ifstream(const wchar_t* s, ios_base::openmode mode = ios_base::in);
+
+#include <fstream>
+#include <cassert>
+
+int main()
+{
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    {
+        std::ifstream fs(L"test.dat");
+        double x = 0;
+        fs >> x;
+        assert(x == 3.25);
+    }
+    // std::ifstream(const wchar_t*, std::ios_base::openmode) is tested in
+    // test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
+    // which creates writable files.
+    {
+        std::wifstream fs(L"test.dat");
+        double x = 0;
+        fs >> x;
+        assert(x == 3.25);
+    }
+    // std::wifstream(const wchar_t*, std::ios_base::openmode) is tested in
+    // test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
+    // which creates writable files.
+#endif
+}

test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_ifstream
+
+// void open(const wchar_t* s, ios_base::openmode mode = ios_base::in);
+
+#include <fstream>
+#include <cassert>
+
+int main()
+{
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    {
+        std::ifstream fs;
+        assert(!fs.is_open());
+        char c = 'a';
+        fs >> c;
+        assert(fs.fail());
+        assert(c == 'a');
+        fs.open(L"test.dat");
+        assert(fs.is_open());
+        fs >> c;
+        assert(c == 'r');
+    }
+    {
+        std::wifstream fs;
+        assert(!fs.is_open());
+        wchar_t c = L'a';
+        fs >> c;
+        assert(fs.fail());
+        assert(c == L'a');
+        fs.open(L"test.dat");
+        assert(fs.is_open());
+        fs >> c;
+        assert(c == L'r');
+    }
+#endif
+}

test/libcxx/input.output/file.streams/fstreams/ifstream.members/test.dat

+r
 No newline at end of file

test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_ofstream
+
+// explicit basic_ofstream(const wchar_t* s, ios_base::openmode mode = ios_base::out);
+
+#include <fstream>
+#include <cassert>
+#include "platform_support.h"
+
+int main()
+{
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    std::wstring temp = get_wide_temp_file_name();
+    {
+        std::ofstream fs(temp.c_str());
+        fs << 3.25;
+    }
+    {
+        std::ifstream fs(temp.c_str());
+        double x = 0;
+        fs >> x;
+        assert(x == 3.25);
+    }
+    {
+        std::ifstream fs(temp.c_str(), std::ios_base::out);
+        double x = 0;
+        fs >> x;
+        assert(x == 3.25);
+    }
+    _wremove(temp.c_str());
+    {
+        std::wofstream fs(temp.c_str());
+        fs << 3.25;
+    }
+    {
+        std::wifstream fs(temp.c_str());
+        double x = 0;
+        fs >> x;
+        assert(x == 3.25);
+    }
+    {
+        std::wifstream fs(temp.c_str(), std::ios_base::out);
+        double x = 0;
+        fs >> x;
+        assert(x == 3.25);
+    }
+    _wremove(temp.c_str());
+#endif
+}

test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_ofstream
+
+// void open(const wchar_t* s, ios_base::openmode mode = ios_base::out);
+
+#include <fstream>
+#include <cassert>
+#include "platform_support.h"
+
+int main()
+{
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+    std::wstring temp = get_wide_temp_file_name();
+    {
+        std::ofstream fs;
+        assert(!fs.is_open());
+        char c = 'a';
+        fs << c;
+        assert(fs.fail());
+        fs.open(temp.c_str());
+        assert(fs.is_open());
+        fs << c;
+    }
+    {
+        std::ifstream fs(temp.c_str());
+        char c = 0;
+        fs >> c;
+        assert(c == 'a');
+    }
+    _wremove(temp.c_str());
+    {
+        std::wofstream fs;
+        assert(!fs.is_open());
+        wchar_t c = L'a';
+        fs << c;
+        assert(fs.fail());
+        fs.open(temp.c_str());
+        assert(fs.is_open());
+        fs << c;
+    }
+    {
+        std::wifstream fs(temp.c_str());
+        wchar_t c = 0;
+        fs >> c;
+        assert(c == L'a');
+    }
+    _wremove(temp.c_str());
+#endif
+}

test/support/platform_support.h

 #define LOCALE_cs_CZ_ISO8859_2 "cs_CZ.ISO8859-2"
 #endif
 #define LOCALE_ru_RU_UTF_8     "ru_RU.UTF-8"
 #define LOCALE_zh_CN_UTF_8     "zh_CN.UTF-8"
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <codecvt>
+#include <locale>
 #include <string>
 #if defined(_WIN32) || defined(__MINGW32__)
 #include <io.h> // _mktemp_s
 #else
 #include <unistd.h> // close
 #endif
 
 #if defined(_NEWLIB_VERSION) && defined(__STRICT_ANSI__)
do {
             perror("mkstemp");
             abort();
         }
     } while (FD == -1);
     close(FD);
     return Name;
 #endif
 }
+
+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+inline
+std::wstring get_wide_temp_file_name()
+{
+    return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t> >().from_bytes(
+        get_temp_file_name());
+}
+#endif // _LIBCPP_HAS_OPEN_WITH_WCHAR
+
 #endif // __CloudABI__
 
 #endif // PLATFORM_SUPPORT_H