cmake/Source/kwsys/Directory.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
#include "kwsysPrivate.h"
#include KWSYS_HEADER(Directory.hxx)

#include KWSYS_HEADER(Configure.hxx)

#include KWSYS_HEADER(Encoding.hxx)

#include KWSYS_HEADER(SystemTools.hxx)

// Work-around CMake dependency scanning limitation.  This must
// duplicate the above list of headers.
#if 0
#  include "Configure.hxx.in"
#  include "Directory.hxx.in"
#  include "Encoding.hxx.in"
#endif

#include <string>
#include <utility>
#include <vector>

#if defined(_WIN32) && !defined(__CYGWIN__)
#  include <windows.h>

#  include <ctype.h>
#  include <fcntl.h>
#  include <io.h>
#  include <stdio.h>
#  include <stdlib.h>
#  include <string.h>
#  include <sys/stat.h>
#  include <sys/types.h>
#endif

namespace KWSYS_NAMESPACE {

class DirectoryInternals
{
public:
  struct FileData
  {
    std::string Name;
#if defined(_WIN32) && !defined(__CYGWIN__)
    WIN32_FIND_DATAW FindData;
#endif
    FileData(std::string name
#if defined(_WIN32) && !defined(__CYGWIN__)
             ,
             WIN32_FIND_DATAW data
#endif
             )
      : Name(std::move(name))
#if defined(_WIN32) && !defined(__CYGWIN__)
      , FindData(std::move(data))
#endif
    {
    }
  };
  // Array of Files
  std::vector<FileData> Files;

  // Path to Open'ed directory
  std::string Path;
};

Directory::Directory()
{
  this->Internal = new DirectoryInternals;
}

Directory::Directory(Directory&& other)
{
  this->Internal = other.Internal;
  other.Internal = nullptr;
}

Directory& Directory::operator=(Directory&& other)
{
  std::swap(this->Internal, other.Internal);
  return *this;
}

Directory::~Directory()
{
  delete this->Internal;
}

unsigned long Directory::GetNumberOfFiles() const
{
  return static_cast<unsigned long>(this->Internal->Files.size());
}

const char* Directory::GetFile(unsigned long dindex) const
{
  return this->Internal->Files[dindex].Name.c_str();
}

std::string const& Directory::GetFileName(std::size_t i) const
{
  return this->Internal->Files[i].Name;
}

std::string Directory::GetFilePath(std::size_t i) const
{
  std::string abs = this->Internal->Path;
  if (!abs.empty() && abs.back() != '/') {
    abs += '/';
  }
  abs += this->Internal->Files[i].Name;
  return abs;
}

bool Directory::FileIsDirectory(std::size_t i) const
{
#if defined(_WIN32) && !defined(__CYGWIN__)
  auto const& data = this->Internal->Files[i].FindData;
  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
#else
  std::string const& path = this->GetFilePath(i);
  return kwsys::SystemTools::FileIsDirectory(path);
#endif
}

bool Directory::FileIsSymlink(std::size_t i) const
{
  std::string const& path = this->GetFilePath(i);
#if defined(_WIN32) && !defined(__CYGWIN__)
  auto const& data = this->Internal->Files[i].FindData;
  return kwsys::SystemTools::FileIsSymlinkWithAttr(
    Encoding::ToWindowsExtendedPath(path), data.dwFileAttributes);
#else
  return kwsys::SystemTools::FileIsSymlink(path);
#endif
}

const char* Directory::GetPath() const
{
  return this->Internal->Path.c_str();
}

void Directory::Clear()
{
  this->Internal->Path.resize(0);
  this->Internal->Files.clear();
}

} // namespace KWSYS_NAMESPACE

// First Windows platforms

#if defined(_WIN32) && !defined(__CYGWIN__)

namespace KWSYS_NAMESPACE {

Status Directory::Load(std::string const& name, std::string* errorMessage)
{
  this->Clear();
  HANDLE srchHandle;
  char* buf;
  size_t bufLength;
  size_t n = name.size();
  if (name.back() == '/' || name.back() == '\\') {
    bufLength = n + 1 + 1;
    buf = new char[bufLength];
    snprintf(buf, bufLength, "%s*", name.c_str());
  } else {
    // Make sure the slashes in the wildcard suffix are consistent with the
    // rest of the path
    bufLength = n + 2 + 1;
    buf = new char[bufLength];
    if (name.find('\\') != std::string::npos) {
      snprintf(buf, bufLength, "%s\\*", name.c_str());
    } else {
      snprintf(buf, bufLength, "%s/*", name.c_str());
    }
  }
  WIN32_FIND_DATAW data; // data of current file

  // Now put them into the file array
  srchHandle =
    FindFirstFileW(Encoding::ToWindowsExtendedPath(buf).c_str(), &data);
  delete[] buf;

  if (srchHandle == INVALID_HANDLE_VALUE) {
    Status status = Status::POSIX_errno();
    if (errorMessage) {
      *errorMessage = status.GetString();
    }
    return status;
  }

  // Loop through names
  do {
    this->Internal->Files.emplace_back(Encoding::ToNarrow(data.cFileName),
                                       data);
  } while (FindNextFileW(srchHandle, &data));
  this->Internal->Path = name;
  if (!FindClose(srchHandle)) {
    Status status = Status::POSIX_errno();
    if (errorMessage) {
      *errorMessage = status.GetString();
    }
    return status;
  }
  return Status::Success();
}

unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
                                                     std::string* errorMessage)
{
  HANDLE srchHandle;
  char* buf;
  size_t bufLength;
  size_t n = name.size();
  if (name.back() == '/') {
    bufLength = n + 1 + 1;
    buf = new char[n + 1 + 1];
    snprintf(buf, bufLength, "%s*", name.c_str());
  } else {
    bufLength = n + 2 + 1;
    buf = new char[n + 2 + 1];
    snprintf(buf, bufLength, "%s/*", name.c_str());
  }
  WIN32_FIND_DATAW data; // data of current file

  // Now put them into the file array
  srchHandle = FindFirstFileW(Encoding::ToWide(buf).c_str(), &data);
  delete[] buf;

  if (srchHandle == INVALID_HANDLE_VALUE) {
    if (errorMessage) {
      if (unsigned int errorId = GetLastError()) {
        LPSTR message = nullptr;
        DWORD size = FormatMessageA(
          FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
          nullptr, errorId, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
          (LPSTR)&message, 0, nullptr);
        *errorMessage = std::string(message, size);
        LocalFree(message);
      } else {
        *errorMessage = "Unknown error.";
      }
    }
    return 0;
  }

  // Loop through names
  unsigned long count = 0;
  do {
    count++;
  } while (FindNextFileW(srchHandle, &data));
  FindClose(srchHandle);
  return count;
}

} // namespace KWSYS_NAMESPACE

#else

// Now the POSIX style directory access

#  include <sys/types.h>

#  include <dirent.h>
#  include <errno.h>
#  include <string.h>

// PGI with glibc has trouble with dirent and large file support:
//  https://www.pgroup.com/userforum/viewtopic.php?
//  p=1992&sid=f16167f51964f1a68fe5041b8eb213b6
// Work around the problem by mapping dirent the same way as readdir.
#  if defined(__PGI) && defined(__GLIBC__)
#    define kwsys_dirent_readdir dirent
#    define kwsys_dirent_readdir64 dirent64
#    define kwsys_dirent kwsys_dirent_lookup(readdir)
#    define kwsys_dirent_lookup(x) kwsys_dirent_lookup_delay(x)
#    define kwsys_dirent_lookup_delay(x) kwsys_dirent_##x
#  else
#    define kwsys_dirent dirent
#  endif

namespace KWSYS_NAMESPACE {

Status Directory::Load(std::string const& name, std::string* errorMessage)
{
  this->Clear();

  errno = 0;
  DIR* dir = opendir(name.c_str());

  if (!dir) {
    if (errorMessage != nullptr) {
      *errorMessage = std::string(strerror(errno));
    }
    return Status::POSIX_errno();
  }

  errno = 0;
  for (kwsys_dirent* d = readdir(dir); d; d = readdir(dir)) {
    this->Internal->Files.emplace_back(d->d_name);
  }
  if (errno != 0) {
    if (errorMessage != nullptr) {
      *errorMessage = std::string(strerror(errno));
    }
    return Status::POSIX_errno();
  }

  this->Internal->Path = name;
  closedir(dir);
  return Status::Success();
}

unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
                                                     std::string* errorMessage)
{
  errno = 0;
  DIR* dir = opendir(name.c_str());

  if (!dir) {
    if (errorMessage != nullptr) {
      *errorMessage = std::string(strerror(errno));
    }
    return 0;
  }

  unsigned long count = 0;
  for (kwsys_dirent* d = readdir(dir); d; d = readdir(dir)) {
    count++;
  }
  if (errno != 0) {
    if (errorMessage != nullptr) {
      *errorMessage = std::string(strerror(errno));
    }
    return false;
  }

  closedir(dir);
  return count;
}

} // namespace KWSYS_NAMESPACE

#endif