Adapt find_executable() to use split_into_strings()

Make win32getshell() return std::string

Adapt args_init_from_string() to use split_into_strings()

Adapt add_prefix() to use split_into_strings()

Util: Add split_into_views/split_into_strings functions

Util: Don’t include path in error description from read_file/write_file

By only returning the error description the caller is more flexible when
composing their own error message.

Upgrade to fmt 6.2.0

Improve order of Travis CI jobs

Improve Travis CI job descriptions

Fix typos in 64-bit MinGW Travis CI job

Add test case for Args::from_gcc_atfile

Add an Args class with backward compatibility for the old args API (#575)

The idea of this is to make a proper C++ API while at the same time
implementing most of the old legacy args API. This makes it possible to
refactor call sites gradually instead of in a series of large
refactoring steps.

Given that “struct args* args” is replaced with “Args args”, the
following types of legacy API usage can be kept without source changes:

1. The args_* functions can be used as is.
2. args->argv[i] still works for read access.

Things that aren’t emulated:

1. args->argc (use args.size() instead).
2. args->argv to access the underlying char* array (use
   args.to_argv().data() instead).
3. Mutating the args->argv[i] string in place (don’t do that).

In other words, code that uses args_foo(args, ...) and args->argv[i] can
easily be converted to args.bar(...) and args[i] (with std::string
arguments instead of char*) at will and in arbitrarily small steps.

Make ccache build on Solaris 11.4 (#572)

These changes enable building on Oracle Solaris 11.4 for both i386 and sparc.

Enable check_format and clang-tidy checks in CI (#562)

Improve const-ness of parameters related to argv

Add .git-blame-ignore-revs

Prepare for v3.7.9

(cherry picked from commit f7f2333b46bcb2a0cbb323c144d59cc5abb267f6)

Remove obsolete src/lockfile.cpp

It should have been removed in c181fdd9.

Fixes #569.

Let run-clang-format always exit with success in non-check mode

I don’t consider explicit reformatting to be an error.

Make check_format exit with the appropriate status (#565)

Also print only diff to stdout and fix tabs.

Improve name of tmp file in x_unlink

There is no need to generate a unique temporary name in x_unlink since
we don’t care whether the temporary file is clobbered on NFS. The
previous usage of tmp_string() was not quite correct since the returned
string is supposed to be passed to mkstemp, not used as is.

(cherry picked from commit e7776305184c9338ee97334078153f298f6cfea7)

Disable hard link mode when the output object file is /dev/null

When hard link mode is enabled, ccache ≥3.6 unlinks the output file
before writing to it as a workaround for a bug in Clang (#331). This
unfortunately means that /dev/null will be removed when building as root
(don’t do that, BTW) with hard link mode enabled and /dev/null as the
the output file. A similar problem exists if the dependency file is
/dev/null, regardless of hard link mode.

Fix this by not unlinking the output file if it’s /dev/null and by not
copying files to /dev/null at all. (There is no need to handle other
non-regular output files since /dev/null is the only allowed non-regular
output file.)

Fixes #564.

(cherry picked from commit 9a794689a8ba47e79c96d6c370976448b756973c)

Remove superfluous unlink before rename

configure: Error out if failing to download libzstd or libb2

Align entries in dev.mk.in

Prepare for v3.7.8

(cherry picked from commit ec65f9f88cf75cbd9f04d88c4a3345fb60911975)

win32: Log epoch timestamp if localtime_r fails

(cherry picked from commit 21fc81c11966d674c3b3cfe30ccf3cdff7f6dfee)

doc: Clarify include_file_ctime sloppiness in the Performance section

(cherry picked from commit fc8182ae95af0f46fc8f71ab29e91534636325b7)

CacheEntryReader: Fix return type (#554)

Use tmp_unlink to remove temporary file in use_relative_paths_in_depfile

No need to remove via another temporary file.

(cherry picked from commit c74b625aaa46db85797a691c81f129834c7fd82e)

C++-ify lockfile routines

Simplify lock breaking

Acquiring a .lock.lock file does not make lock breaking significantly
safer; there is still a race condition. Simplify it by simply deleting
the lockfile when breaking and try to acquire it again.

Rewrite the Windows version of the lockfile routines

Instead of emulating the POSIX version, use the native Windows file API
to create a lockfile. This should mitigate several problems with the old
implementation.

Hopefully fixes #537.

(cherry picked from commit 53b9fdd6272896bb4a2dc42c9680d4030f86b33c)

Cap time to sleep to 10 ms when failing to acquire a lock

(cherry picked from commit 41ffc7ec009237da51040c6059b1bcd7903af30d)

Rewrite absolute input path to relative

This can now be done due to no longer using realpath in
make_relative_path (e8444a38).

Let development version be BRANCH.SHORTHASH

Previously the version of a master-based development build was something
like 3.7.1+NNN_gSHORTHASH which is a bit misleading.

Convert counters to a class (#548)

Also remove file writing logic from `stats_update_size()` and
delete unused declaration of `stats_timestamp()`.

Convert the single ofstream use to fwrite (#552)

Read/write optimizations (#551)

* Avoid one extra read call after the final bytes are read

If read returns less then the requested number of bytes, the file is at
EOF. This can be used in all places where a read is done, but it makes extra
impact in read_file where if the buffer is made one byte bigger than needed,
EOF can be detected before a unnecessary memory reallocation is done.

* Use write instead of fwrite to write the result file

This avoids the caching in stdio where a write is split into two (at least on
my system): first a small 4k one and then one with the remaining 60k.

Avoid duplicate stat calls (#550)

hash_source_code_string will, in read_file, stat the file to get the file
size. But when called from verify_result, the file size is already known so by
using this size the number of stat calls in a normal run can be cut in half.

Fix empty <obj>.ccache-log in debug mode without log_file set

Regression in dcf6ab3f349a33974b31ce2e7c06a2085149ab4a.

Add notes about intentional use of CCACHE_DEBUG in test cases

Restore test suite debug output where needed (#546)

Two fileclone tests rely on the output.

Low hanging fruits of some auto fixable improvements via clang-tidy (#545)

Merge pull request #544 from erijo/out-of-tree-commands

Fix four minor cppcheck warnings

- uninitvar:src/ccache.cpp:3422: Uninitialized variable: ctx
- redundantInitialization:src/legacy_util.cpp:1067: Redundant initialization
  for 'q'. The initialized value is overwritten before it is read.
- constVariable:src/stats.cpp:429: Variable 'ctx' can be declared with const
- variableScope:src/Util.cpp:404: The scope of the variable 'right' can be
  reduced.

Pass std::string instead of .c_str()

to function taking std::string.

Remove unused function stats_get_pending

Make cppcheck, format and check_format work in out-of-tree build

Remove leftover debug settings in test suites

Don’t use realpath(3) for normalization when computing relative paths

The current working directory (CWD) can come from two sources: Either
the return value of getcwd(3) (“actual CWD” below) or the environment
variable $PWD (“apparent CWD” below). The former is returned by e.g.
$(CURDIR) in Makefiles and by “pwd -P” and is always in normalized form
(no “.” or “..” parts or extra slashes). The latter is returned by “echo
$PWD” or “pwd” and can potentially be in unnormalized form on some
systems.

The actual CWD and apparent CWD may also differ if there are symlinks in
the path. Absolute paths to files given to ccache can therefore be based
on either of these CWD forms. When computing relative paths under the
base directory the CWD needs be in normalized form for the algorithm to
be reasonably simple.

2df269a3 solved a bug with an unnormalized apparent CWD by using
realpath(3) for normalization. Using realpath also makes the algorithm
correct in the presence of symlinks. It however also means that all
symlinks (both in CWD and in command line arguments) are dereferenced.
The downside of this is that if either of the symlink targets contain
specific names (such as build ID, date, username or similar) then the
relative paths will also contain those specific path names, leading to
cache misses.

Solve this by:

- Performing normalization without using realpath, i.e. without
  expanding symlinks.
- Computing a relative path based on normalized CWD and normalized path.
- Checking whether the relative path resolves to the same i-node as the
  original path. If it does, use it, otherwise just use the original
  path (and take a potential cache miss).
- Doing the above calculation both for the actual and the apparent CWD
  and choose the best one.

This solves the problem that PR #491 intended to address in a better
way.

Improve basedir calculation on Windows

Now basedir with backslashes or forward slashes should work.

Let Util::get_apparent_cwd return a normalized CWD

Add Stat::same_inode_as method

Add default Stat constructor

C++-ify make_relative_path

C++-ify get_relative_path

C++-ify common_dir_prefix_length

Implement Util::normalize_absolute_path

Normalization here means syntactically removing redundant slashes and
resolving "." and ".." parts. The algorithm does however *not* follow
symlinks, so the result may not actually resolve to `path`.

Make Util::is_absolute_path work with MSYS/Cygwin/POSIX win32 paths

C++-ify is_absolute_path

Sort test cases

Move basedir tests to the basedir test suite

Add pch test suite probe for seemingly broken compiler support

This fixes a problem mentioned by Orion Poplawski in a comment to PR #217.

Const-ify Context& parameters where possible

Simplify setting of ctx.args_info.profile_dir default value

Convert stats_update(x) + failed() to failed(x) in hash_*command*()

Use find_executable_in_path to find executable in hash_command_output

This makes the Windows version behave similar to the non-Windows
version: just search in $PATH, not potentially in the path specified by
the “path” configuration setting.

Make failure to run compiler_check command a soft error

No need to make a failure when running the compiler check fatal since
other misconfigured settings can have a similar effect without resulting
in fatal errors.

Rename cc_process_args to process_args

Convert stats_update(x) + failed() to failed(x) in cc_process_args

Convert most stats_update(x) + failed() to failed(x)

Don’t increment STATS_COMPILER on fatal error

Statistics counters are otherwise never incremented on fatal errors.

Make it possible to run failed() and not execute the real compiler

This removes one of the last x_exit calls deeper into the main ccache
code paths.

Remove leftover cc_reset declaration

Merge pull request #543 from totph/ctx5

Final Globals -> Context moves

Turn lock_staleness_limit into a constant

Remove now-empty legacy_globals.cpp/hpp.

Context: move counters

Context: move ignore_headers_len, remove cc_reset()

Context: move included_pch_file and convert to std::string

Context: move guessed_compiler

Convert guessed_compiler into an enum class

Context: move manifest_stats_file and convert to std::string

Context: move cpp_stderr and convert to std::string

Context: move i_tmpfile and converted to std::string

Context: move has_absolute_include_headers

Context: move g_included_files

Context: move time_of_compilation, adapt manifest

Context: move manifest_path and converted to std::string

Context: move (cached_)result_name/result_path

Also convert result_path to std::string.

Context: move arch_args

Context: move output_is_precompiled_header

Partially revert const-ification of context parameters

Improve functions related to CWD

The different functions related to current working directory (CWD) have
become messy during the years:

- gnu_getcwd is a simple wrapper around getcwd(3), thus returning the
  actual canonical path.
- get_cwd returns $PWD, falling back to getcwd(3) if $PWD is not sane.
- get_current_working_dir (local function in ccache.cpp) memoizes
  x_realpath(get_cwd()) (i.e., getcwd(3) in essence...) in the global
  current_working_dir variable. Unit tests may manipulate
  current_working_dir.

Improve this by:

- Replacing gnu_getcwd with Util::get_actual_cwd.
- Replacing get_cwd with Util::get_apparent_cwd.
- Removing get_current_working_dir and placing both actual and apparent
  CWD in the context object.

Simplify (non-)freeing of orig_args on failure

Simplify string creation from string_view

Remove now redundant resetting of config

Since the configuation no longer is global there is no need to reset the
unmodified Config object passed by cct_test_begin to cc_reset.

Const-ify context parameters where appropriate

Merge pull request #542 from totph/ctx4

Context: g_config, stats_file and orig_args moved

Context: move orig_args