[19/N] [libcxx] Implement temp_directory_path using GetTempPath on windows

[mstorsjo]

Summary

This does roughly the same as the manual implementation, but checks a slightly different set of environment variables and has a more appropriate fallback if no environment variables are available (/tmp isn't a very useful fallback on windows).

[compnerd]

libcxx/src/filesystem/operations.cpp

1599

What do you think of using GetTempPath instead? That is more likely to be writable.

[mstorsjo]

libcxx/src/filesystem/operations.cpp

1599

That's also an option - or we could skip our own code and just use that one. That function does essentially the same, checks a few env vars (two of the ones checked here, plus USERPROFILE). But if none of the env vars are available, GetTempPath also falls back to c:\windows - that's where I got the idea.

[amccarth]

libcxx/src/filesystem/operations.cpp

1599

My first choice would be to use GetTempPathW directly, since that will match expectations for Windows programmers and be relatively future proff.

My second choice would be to keep the custom iteration through the well-known environment variables but to replace the hardcoded c:\windows with a call to GetWindowsDirectoryW.

[mstorsjo]

Using GetTempPathW instead of the manual code checking environment variables.

[amccarth]

LGTM.

libcxx/src/filesystem/operations.cpp

1702

My gut said >= rather than >, but the documentation for this API is a cagey about this boundary condition. I experimented and realized this does work with > because there is no case where it would return exactly the buffer size.

[mstorsjo]

libcxx/src/filesystem/operations.cpp

1702

Yeah, the return value handling there is pretty tricky - GetFinalPathNameByHandleW had the same pattern.

[mstorsjo]

Rebased, retriggering CI.

For this function, there's not much of a corresponding posix-like function to hide the functionality within.

libcxx/src/filesystem/operations.cpp

 
 file_status __symlink_status(const path& p, error_code* ec) {
   return detail::posix_lstat(p, ec);
 }
 
 path __temp_directory_path(error_code* ec) {
   ErrorHandler<path> err("temp_directory_path", ec);
 
+#if defined(_LIBCPP_WIN32API)
+  wchar_t buf[MAX_PATH];
+  DWORD retval = GetTempPathW(MAX_PATH, buf);
+  if (!retval)
+    return err.report(detail::make_windows_error(GetLastError()));
+  if (retval > MAX_PATH)
+    return err.report(errc::filename_too_long);
+  // GetTempPathW returns a path with a trailing slash, which we
+  // shouldn't include for consistency.
+  if (buf[retval-1] == L'\\')
+    buf[retval-1] = L'\0';
+  path p(buf);
+#else
   const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
   const char* ret = nullptr;
 
   for (auto& ep : env_paths)
     if ((ret = getenv(ep)))
       break;
   if (ret == nullptr)
     ret = "/tmp";
 
   path p(ret);
+#endif
   error_code m_ec;
   file_status st = detail::posix_stat(p, &m_ec);
   if (!status_known(st))
     return err.report(m_ec, "cannot access path \"" PS_FMT "\"", p);
 
   if (!exists(st) || !is_directory(st))
     return err.report(errc::not_a_directory, "path \"" PS_FMT "\" is not a directory",
                       p);
path path::lexically_normal() const {
   };
 
   bool MaybeNeedTrailingSep = false;
   // Build a stack containing the remaining elements of the path, popping off
   // elements which occur before a '..' entry.
   for (auto PP = PathParser::CreateBegin(__pn_); PP; ++PP) {
     auto Part = *PP;
     PathPartKind Kind = ClassifyPathPart(Part);
     switch (Kind) {
     case PK_Filename:
     case PK_RootSep: {
       // Add all non-dot and non-dot-dot elements to the stack of elements.
       AddPart(Kind, Part);
       MaybeNeedTrailingSep = false;
       break;
     }
     case PK_DotDot: {
path path::lexically_relative(const path& base) const {
   // dot-dot minus the number of dot-dot elements.
   int ElemCount = DetermineLexicalElementCount(PPBase);
   if (ElemCount < 0)
     return {};
 
   // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
   if (ElemCount == 0 && (PP.atEnd() || *PP == PS("")))
     return PS(".");
 
   // return a path constructed with 'n' dot-dot elements, followed by the the
   // elements of '*this' after the mismatch.
   path Result;
   // FIXME: Reserve enough room in Result that it won't have to re-allocate.
   while (ElemCount--)
     Result /= PS("..");
   for (; PP; ++PP)
     Result /= *PP;