This makes FileExists consistent across Unix and Windows.

Avoid using our custom KWSys String type in interfaces.

Run the `clang-format.bash` script to update all our C and C++ code to a
new style defined by `.clang-format`.  Use `clang-format` version 6.0.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

LLVM libc++ as included with Mac OS X 10.7 suffers from an issue where
the trailing character is discarded when the delimiter (LF) is not found
within the given buffer size (1024).  The returned length is also 1024
rather than 1023.

This issue results in truncated reads as observed with CMake 3.11.0 on
Mac OS X 10.7 and `cmake -E cmake_link_script link.txt`.

Solve this by replacing `istream::getline` by `std::getline` which does
not trigger the buffering issue.  There is one edge case that I decided
to leave up to the callers though: a file containing `\0` previously
resulted in line truncation, but is now included in the result.

Tested with Mac OS X 10.7 and 10.11:

    -DCMAKE_OSX_DEPLOYMENT_TARGET=10.7 -DCMAKE_CXX_FLAGS=-stdlib=libc++

and `./kwsysTestsCxx testSystemTools`.

Issue: cmake/cmake#15039

Do not expose caching to `GetActualCaseForPath` callers.  Cache path
case conversion results internally for `CollapseFullPath` only.

This reverts commit e9d2b696 (SystemTools: Cache only existing path
names in GetActualCaseForPath", 2017-11-07).  The lack of caching
introduced a big performance regression in CMake.  Another solution
for the original problem will be needed.

The number of input components is a good hint for the number of output
components.

Instead of using two pointers to iterate through the string, iterate
using just one.

Checking the bool is faster than checking characters, so perform it
first.

The function only works on paths which are already properly escaped.

Non-Windows platforms don't have backslash as a separator, however some
projects may want to support Windows paths on non-Windows platforms
(e.g., paths from data files). For those which don't need this, this
allows the search to be faster since it's searching for a single
character.

This avoids a `strlen` call at least.

All callers of this function use temporary storage for the input.
Instead of copying strings, move them.

On Linux, getpwnam requires a dynamic glibc at runtime so it can't
really be used in a "fully static" build  and will cause an excessive
number of linker warnings pertaining to such.

+ fix documentation of method name
+ fix some source comment typos

When building with C++11 or greater, use the `nullptr` keyword.

Non-existent names may be created later with a different case.

Found using

    codespell -q 3 --skip="./Utilities" -I .cmake-whitelist.txt`

in CMake whereby the whitelist contained:

    ans
    dum
    helpfull
    emmited
    emmitted
    buil
    iff
    isnt
    nto
    ot
    pathes
    substract
    te
    todays
    upto
    whitespaces

MakeDirectory can create an entire directory structure
so it's convenient that we can set the default directory
permissions for directories that did not exist beforehand.

Only do one conversion attempt and write that directly to the target buffer. Do
the uppercasing of the drive letter only in the ASCII domain, not in wide chars.

This was used only by CMake's get_filename_components() command, which
has now been re-implemented independently.  The operation is not
well-defined (string parsing should not depend on filesystem content),
so remove it.

Teach `Load` to access the filesystem using extended paths to handle
long absolute paths.  Add a test case.

Previously trying to parse a windows-style (backslash separated) path on
Linux would fail.  Make this function handle either kind of separator on
both platforms.

This method was added recently but we've found another solution for its
intended use case.  Removing empty path elements can corrupt paths that
depend on a trailing empty component to preserve a trailing slash.

Since this method was meant to complement SplitPath and JoinPath, update
their documentation to explain how they treat empty components.