static const char HASH_PREFIX[] = "3";
static void
-add_prefix(Context& ctx, struct args* args, const char* prefix_command)
+add_prefix(const Context& ctx, struct args* args, const char* prefix_command)
{
if (str_eq(prefix_command, "")) {
return;
}
static const char*
-temp_dir(Context& ctx)
+temp_dir(const Context& ctx)
{
static const char* path = NULL;
if (path) {
#endif // _WIN32
static void
-clean_up_internal_tempdir(Context& ctx)
+clean_up_internal_tempdir(const Context& ctx)
{
time_t now = time(NULL);
auto st = Stat::stat(ctx.config.cache_dir(), Stat::OnError::log);
}
static void
-init_hash_debug(Context& ctx,
+init_hash_debug(const Context& ctx,
struct hash* hash,
const char* obj_path,
char type,
}
static bool
-do_remember_include_file(Context& ctx,
+do_remember_include_file(const Context& ctx,
std::string path,
struct hash* cpp_hash,
bool system,
// Make a relative path from current working directory to path if path is under
// the base directory.
static std::string
-make_relative_path(Context& ctx, const char* path)
+make_relative_path(const Context& ctx, const char* path)
{
if (ctx.config.base_dir().empty()
|| !str_startswith(path, ctx.config.base_dir().c_str())) {
// Replace absolute paths with relative paths in the provided dependency file.
static void
-use_relative_paths_in_depfile(Context& ctx)
+use_relative_paths_in_depfile(const Context& ctx)
{
const char* depfile = ctx.args_info.output_dep.c_str();
// Create or update the manifest file.
static void
-update_manifest_file(Context& ctx)
+update_manifest_file(const Context& ctx)
{
if (!ctx.config.direct_mode() || ctx.config.read_only()
|| ctx.config.read_only_direct()) {
// Hash mtime or content of a file, or the output of a command, according to
// the CCACHE_COMPILERCHECK setting.
static void
-hash_compiler(Context& ctx,
+hash_compiler(const Context& ctx,
struct hash* hash,
const Stat& st,
const char* path,
// with -ccbin/--compiler-bindir. If they are NULL, the compilers are looked up
// in PATH instead.
static void
-hash_nvcc_host_compiler(Context& ctx,
+hash_nvcc_host_compiler(const Context& ctx,
struct hash* hash,
const Stat* ccbin_st,
const char* ccbin)
// Update a hash with information common for the direct and preprocessor modes.
static void
-hash_common_info(Context& ctx,
+hash_common_info(const Context& ctx,
struct args* args,
struct hash* hash,
const ArgsInfo& args_info)
// Try to return the compile result from cache. If we can return from cache
// then this function exits with the correct status code, otherwise it returns.
static void
-from_cache(Context& ctx,
+from_cache(const Context& ctx,
enum fromcache_call_mode mode,
bool put_result_in_manifest)
{
// Find the real compiler. We just search the PATH to find an executable of the
// same name that isn't a link to ourselves.
static void
-find_compiler(Context& ctx, char** argv)
+find_compiler(const Context& ctx, char** argv)
{
// We might be being invoked like "ccache gcc -c foo.c".
std::string base(Util::base_name(argv[0]));
struct args* orig_args_for_execv = ctx.orig_args;
exitfn_call();
execv(orig_args_for_execv->argv[0], orig_args_for_execv->argv);
- fatal("execv of %s failed: %s", orig_args_for_execv->argv[0], strerror(errno));
+ fatal(
+ "execv of %s failed: %s", orig_args_for_execv->argv[0], strerror(errno));
}
}
}
static void
-recompress_file(Context& ctx,
+recompress_file(const Context& ctx,
const std::string& stats_file,
const CacheFile& cache_file,
int8_t level)
}
void
-compress_recompress(Context& ctx,
+compress_recompress(const Context& ctx,
int8_t level,
const Util::ProgressReceiver& progress_receiver)
{
// - level: Target compression level (positive or negative value), or 0 for no
// compression.
// - progress_receiver: Function that will be called for progress updates.
-void compress_recompress(Context& ctx,
+void compress_recompress(const Context& ctx,
int8_t level,
const Util::ProgressReceiver& progress_receiver);
// Find an executable by name in $PATH. Exclude any that are links to
// exclude_name.
char*
-find_executable(Context& ctx, const char* name, const char* exclude_name)
+find_executable(const Context& ctx, const char* name, const char* exclude_name)
{
if (is_absolute_path(name)) {
return x_strdup(name);
struct Context;
int execute(char** argv, int fd_out, int fd_err, pid_t* pid);
-char* find_executable(Context& ctx, const char* name, const char* exclude_name);
+char*
+find_executable(const Context& ctx, const char* name, const char* exclude_name);
void print_command(FILE* fp, char** argv);
char* format_command(const char* const* argv);
}
bool
-hash_command_output(Context& ctx,
+hash_command_output(const Context& ctx,
struct hash* hash,
const char* command,
const char* compiler)
}
bool
-hash_multicommand_output(Context& ctx,
+hash_multicommand_output(const Context& ctx,
struct hash* hash,
const char* commands,
const char* compiler)
int hash_source_code_file(const Config& config,
struct hash* hash,
const char* path);
-bool hash_command_output(Context& ctx,
+bool hash_command_output(const Context& ctx,
struct hash* hash,
const char* command,
const char* compiler);
-bool hash_multicommand_output(Context& ctx,
+bool hash_multicommand_output(const Context& ctx,
struct hash* hash,
const char* command,
const char* compiler);
// File stored as-is in the file system.
const uint8_t k_raw_file_marker = 1;
-using ReadEntryFunction = void (*)(Context& ctx,
+using ReadEntryFunction = void (*)(const Context& ctx,
CacheEntryReader& reader,
const std::string& result_path_in_cache,
uint32_t entry_number,
FILE* dump_stream);
using WriteEntryFunction =
- void (*)(Context& ctx,
+ void (*)(const Context& ctx,
CacheEntryWriter& writer,
const std::string& result_path_in_cache,
uint32_t entry_number,
}
static void
-read_embedded_file_entry(Context&,
+read_embedded_file_entry(const Context&,
CacheEntryReader& reader,
const std::string& /*result_path_in_cache*/,
uint32_t entry_number,
}
static bool
-copy_raw_file(Context& ctx,
+copy_raw_file(const Context& ctx,
const std::string& source,
const std::string& dest,
bool to_cache)
}
static void
-read_raw_file_entry(Context& ctx,
+read_raw_file_entry(const Context& ctx,
CacheEntryReader& reader,
const std::string& result_path_in_cache,
uint32_t entry_number,
}
static bool
-read_result(Context& ctx,
+read_result(const Context& ctx,
const std::string& path,
const ResultFileMap* result_file_map,
FILE* dump_stream)
}
static void
-write_embedded_file_entry(Context&,
+write_embedded_file_entry(const Context&,
CacheEntryWriter& writer,
const std::string& /*result_path_in_cache*/,
uint32_t entry_number,
}
static void
-write_raw_file_entry(Context& ctx,
+write_raw_file_entry(const Context& ctx,
CacheEntryWriter& writer,
const std::string& result_path_in_cache,
uint32_t entry_number,
}
static void
-write_result(Context& ctx,
+write_result(const Context& ctx,
const std::string& path,
const ResultFileMap& result_file_map)
{
}
bool
-result_get(Context& ctx,
+result_get(const Context& ctx,
const std::string& path,
const ResultFileMap& result_file_map)
{
}
bool
-result_put(Context& ctx,
+result_put(const Context& ctx,
const std::string& path,
const ResultFileMap& result_file_map)
{
}
bool
-result_dump(Context& ctx, const std::string& path, FILE* stream)
+result_dump(const Context& ctx, const std::string& path, FILE* stream)
{
assert(stream);
using ResultFileMap = std::map<FileType, std::string /*path*/>;
-bool result_get(Context& ctx,
+bool result_get(const Context& ctx,
const std::string& path,
const ResultFileMap& result_file_map);
-bool result_put(Context& ctx,
+bool result_put(const Context& ctx,
const std::string& path,
const ResultFileMap& result_file_map);
-bool result_dump(Context& ctx, const std::string& path, FILE* stream);
+bool result_dump(const Context& ctx, const std::string& path, FILE* stream);
// Record that a number of bytes and files have been added to the cache. Size
// is in bytes.
void
-stats_update_size(Context& ctx,
+stats_update_size(const Context& ctx,
const std::string& sfile,
int64_t size,
int files)
void stats_zero(const Config& config);
void stats_summary(const Config& config);
void stats_print(const Config& config);
-void stats_update_size(Context& ctx,
+void stats_update_size(const Context& ctx,
const std::string& sfile,
int64_t size,
int files);