[14/N] [libcxx] Implement the current_path function for windows

[amccarth]

libcxx/src/filesystem/operations.cpp

1139

Is _wgetcwd the right choice here? Shouldn't this instead go straight to Windows with GetCurrentDirectoryW so it doesn't take a dependence on MSVC's CRT?

[mstorsjo]

libcxx/src/filesystem/operations.cpp

1139

I guess we could do that as well; we still have a few other calls that go through the CRT (in the FileDescriptor helper class further up in the file, used for file copying), and in this case, there's no other practical limitation in _wgetcwd that we'd get around, other than cleanliness. (Calling GetCurrentDirectoryW takes two calls and manual allocation inbetween, unless we want to hardcode a PATH_MAX allocation, but I'd rather move away from such specific limits.)

But yeah I can change it if you still prefer that.

[amccarth]

Your call on using the CRT. I was under the mistaken impression that libcxx would implement both the standard C++ library as well as the CRT.

[mstorsjo]

Moved to a getcwd helper in posix_compat.h, change existing code to use path::value_type instead of hardcoded char.

[mstorsjo]

Reworked this patch to allow two use patterns of the POSIX getcwd() function - in strict POSIX getcwd(), it has to be given a preallocated buffer of a fixed size - but at least glibc and Darwin libc's (and windows) allow passing nullptr, to let the function allocate a suitably large buffer. For now I only use that codepath for windows (to reduce the risk of anything breaking due to this patch), but we could enable it on POSIX systems where we know it's supported as a later feature.

libcxx/src/filesystem/operations.cpp

void __create_symlink(path const& from, path const& to, error_code* ec) {
   ErrorHandler<void> err("create_symlink", ec, &from, &to);
   if (detail::symlink_file(from.c_str(), to.c_str()) == -1)
     return err.report(capture_errno());
 }
 
 path __current_path(error_code* ec) {
   ErrorHandler<path> err("current_path", ec);
 
+#if defined(_LIBCPP_WIN32API)
+  // Common extension outside of POSIX getcwd() spec, without needing to
+  // preallocate a buffer. Also supported by a number of other POSIX libcs.
+  int size = 0;
+  path::value_type* ptr = nullptr;
+  typedef decltype(&::free) Deleter;
+  Deleter deleter = &::free;
+#else
   auto size = ::pathconf(".", _PC_PATH_MAX);
   _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
 
-  auto buff = unique_ptr<char[]>(new char[size + 1]);
-  char* ret;
-  if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr)
+  auto buff = unique_ptr<path::value_type[]>(new path::value_type[size + 1]);
+  path::value_type* ptr = buff.get();
+
+  // Preallocated buffer, don't free the buffer in the second unique_ptr
+  // below.
+  struct Deleter { void operator()(void*) const {} };
+  Deleter deleter;
+#endif
+
+  unique_ptr<path::value_type, Deleter> hold(detail::getcwd(ptr, size),
+                                             deleter);
+  if (hold.get() == nullptr)
     return err.report(capture_errno(), "call to getcwd failed");
 
-  return {buff.get()};
+  return {hold.get()};
 }
 
 void __current_path(const path& p, error_code* ec) {
   ErrorHandler<void> err("current_path", ec, &p);
   if (detail::chdir(p.c_str()) == -1)
     err.report(capture_errno());
 }
 
static file_time_type __extract_last_write_time(const path& p, const StatT& st,
 
   return fs_time::convert_from_timespec(ts);
 }
 
 file_time_type __last_write_time(const path& p, error_code* ec) {
   using namespace chrono;
   ErrorHandler<file_time_type> err("last_write_time", ec, &p);
 
   error_code m_ec;
   StatT st;
   detail::posix_stat(p, st, &m_ec);
   if (m_ec)
     return err.report(m_ec);
   return __extract_last_write_time(p, st, ec);
 }
 
 void __last_write_time(const path& p, file_time_type new_time, error_code* ec) {

libcxx/src/filesystem/posix_compat.h

if (!GetDiskFreeSpaceExW(dir.c_str(), &free_bytes_available_to_caller,
     return set_errno();
   buf->f_frsize = 1;
   buf->f_blocks = total_number_of_bytes.QuadPart;
   buf->f_bfree = total_number_of_free_bytes.QuadPart;
   buf->f_bavail = free_bytes_available_to_caller.QuadPart;
   return 0;
 }
 
+wchar_t *getcwd(wchar_t *buff, size_t size) { return _wgetcwd(buff, size); }
 #else
 int symlink_file(const char *oldname, const char *newname) {
   return ::symlink(oldname, newname);
 }
 int symlink_dir(const char *oldname, const char *newname) {
   return ::symlink(oldname, newname);
 }
 using ::chdir;
 using ::close;
 using ::fstat;
 using ::ftruncate;
+using ::getcwd;
 using ::link;
 using ::lstat;
 using ::mkdir;
 using ::open;
 using ::remove;
 using ::rename;
 using ::stat;
 using ::statvfs;