/*

* Emscripten support for ccache.

*

* Emscripten is implemented as two compiler executables "emcc" and "em++", with accompanied .bat file launchers on Windows.

*

* The compiler is for the most parts a GCC/Clang compatible, with same compile time flags, that are passed directly to Clang, which Emscripten uses as a backend.

* The set of link time flags differs a lot though, but fortunately ccache does not need to care about those.

*

* Special Emscripten unique flags that need extra logic to handle:

*

* --default-obj-ext <.ext> (affects output artifact filename)

* --cache <path> (specifies cache directory, interacts with EM_CONFIG file, and EM_CONFIG env. var)

* --em-config <path> (specifies config file, interacts with EM_CONFIG env. var)

* -s STRICT[=0/1] (specifies compilation mode, interacts with EMCC_STRICT env. var)

*

* See also the set of environment variables that affect Emscripten compilation output below (emcc_env_vars array)

*

* Emscripten command line flags that affect preprocessor output:

*

* -pthread (injects -D__EMSCRIPTEN_PTHREADS__ to compiled code)

* -s USE_PTHREADS[=0/1] (injects -D__EMSCRIPTEN_PTHREADS__ to compiled code)

* -s EMSCRIPTEN_TRACING[=0/1] (injects -D__EMSCRIPTEN_TRACING__ to compiled code)

* -s STRICT[=0/1] (injects -DEMSCRIPTEN to compiled code)

* -s STB_IMAGE[=0/1] (injects -DSTB_IMAGE_IMPLEMENTATION to compiled code)

*

* Emscripten unique compile time flags that affect compilation output (but not preprocessor):

*

* -profiling and --profiling

* --minify <level>

* -s INLINING_LIMIT[=0/1]

* -gseparate-dwarf[=FILENAME]

* --llvm-opts <level>

* -s MEMORY64[=0/1]

* -s DISABLE_EXCEPTION_CATCHING[=0/1]

* -s EXCEPTION_CATCHING_ALLOWED[=0/1]

* -s RELOCATABLE[=0/1]

* -s MAIN_MODULE[=0/1]

* -s SIDE_MODULE[=0/1]

* -s DEFAULT_TO_CXX[=0/1]

*

* General (non compile time) flags that should just cause ccache to disable itself to avoid any complications:

*

* --check

* --clear-cache

* --clear-ports

* --show-ports

* --cflags

*

* Emscripten unique compile time flags that do not affect compilation output, but they do affect stdout results both when compiling and preprocessing (so ccache should also key on these):

*

* -v

* -Wwarn-absolute-paths

* --valid-abspath path

* -s VERBOSE[=0/1]

*

* Apart from the -s flags listed above, Emscripten has a lot of other -s FOO settings, but they are all link time only settings (so ccache can ignore those).

* The ccache support implementation here does not however treat those specially, but instead the cache *is* keyed on even the -s flags that

* do not affect compilation. The rationale for this is that:

* - developers do not generally pass any of the link time -s flags at compile time anyway,

* - if they do, the accident is benign (one gets a bit excess caching)

* - if a new -s flag is added that does affect compilation (or one was accidentally missed by a bug), it will not need to be added here, but will automatically be recognized

*/

#include "Context.hpp"

#include "Logging.hpp"

#include "assertions.hpp"

#include "emcc.hpp"

using nonstd::nullopt;

using nonstd::optional;

// The following Emscripten environment variables should be keyed into the common cache hash (can affect C++ preprocessing, compilation, and/or compilation stdout output message)

static const char* emcc_env_vars[] = {

"EMMAKEN_CFLAGS", // affects preprocessor, compilation, and stdout/stderr output

// "EMMAKEN_COMPILER", // affects preprocessor, compilation, and stdout/stderr output, but deprecated in Emscripten, so will disable ccache if enabled (see below).

// "EMMAKEN_JUST_CONFIGURE", // affects preprocessor, compilation, and stdout/stderr output. Handled specially below.

"EMMAKEN_NO_SDK", // affects preprocessor, compilation, and stdout/stderr output

// "EMCC_AUTODEBUG", // affects stdout/stderr, internal debugging tool. Will disable ccache if enabled (see below)

"EMCC_CFLAGS", // affects preprocessor, compilation, and stdout/stderr output

// "EMCC_CORES", // would affect stdout/stderr output if EMCC_DEBUG is also enabled, but since EMCC_DEBUG disables ccache, this can be ignored altogether.

// "EMCC_DEBUG", // affects stdout/stderr output. Will disable ccache

// "EMCC_DEBUG_SAVE", // affects stdout/stderr output. Will disable ccache

// "EMCC_FORCE_STDLIBS", // affects link stage behavior only, so can be ignored by ccache.

// "EMCC_ONLY_FORCED_STDLIBS" // affects link stage behavior only, so can be ignored by ccache.

"EM_LLVM_ROOT", // affects preprocessor, compilation, and stdout/stderr output

"EMCC_LOCAL_PORTS", // affects preprocessor, compilation, and stdout/stderr output

// "EMCC_STDERR_FILE" // affects link stage behavior only, so can be ignored by ccache.

// "EMCC_CLOSURE_ARGS" // affects link stage behavior only, so can be ignored by ccache.

// "EMCC_STRICT" // affects preprocessor, compilation, and stdout/stderr output. Handled specially, since it interacts with the -s STRICT=0/1 setting.

// "EMCC_SKIP_SANITY_CHECK", // can affect stdout/stderr output, but ignored since only happens if config is bad

// "EM_IGNORE_SANITY", // can affect stdout/stderr output, but ignored since only happens if config is bad

// "EM_CACHE" // affects preprocessor, compilation, and stdout/stderr output. Handled specially, since it interacts with the --cache=<path> setting.

// "EM_CONFIG" // affects preprocessor, compilation, and stdout/stderr output. Handled specially, since it interacts with the --em-config=<path> setting.

0

};

const char** get_emcc_preprocessor_affecting_env_vars()

{

return emcc_env_vars;

}

static const char* emcc_too_hard_env_vars[] = {

"EMMAKEN_COMPILER", // -> unsupported_compiler_option

"EMCC_AUTODEBUG", // -> unsupported_compiler_option

"EMCC_DEBUG", // -> unsupported_compiler_option

"EMCC_DEBUG_SAVE", // -> unsupported_compiler_option

// EMMAKEN_JUST_CONFIGURE // -> autoconf_test

0

};

static const char *read_param_from_cmdline(const Args& args, std::string param)

{

std::string paramEq = param + '=';

for (size_t i = 1; i < args.size(); i++) {

if (args[i] == param) {

if (i + 1 >= args.size()) {

return 0;

}

return args[i + 1].c_str();

}

#define starts_with(str, substr) (!strncmp((str), (substr), strlen((substr))))

if (starts_with(args[i].c_str(), paramEq.c_str())) {

return args[i].c_str() + paramEq.length();

}

}

return 0;

}

static const char *read_emcc_s_param_from_cmdline(const Args& args, std::string param)

{

std::string paramEq = param + '=';

std::string paramSEq = "-s" + param + '=';

for (size_t i = 1; i < args.size(); i++) {

if (args[i] == "-s") {

if (i + 1 >= args.size()) {

return 0;

}

// "-s FOO=<value>"

if (starts_with(args[i + 1].c_str(), paramEq.c_str())) {

return args[i + 1].c_str() + paramEq.length();

}

// "-s FOO" produces an implicit true.

if (args[i + 1] == param) {

return "1";

}

}

// "-sFOO=<value>"

if (starts_with(args[i].c_str(), paramSEq.c_str())) {

return args[i].c_str() + paramSEq.length();

}

}

return 0;

}

static std::string find_em_config_filename(const Args& args)

}

static bool find_emcc_strict_value(const Args& args)

}

static std::string

read_file_to_string(const char* filename)

}

#ifdef _WIN32

# define DIR_SEPARATOR '\\'

# define is_dir_separator(x) ((x) == '\\' || (x) == '/')

#else

# define DIR_SEPARATOR '/'

# define is_dir_separator(x) ((x) == '/')

#endif

#if 0

static std::string find_em_cache_directory(const Context &ctx)

}

#endif

std::string trim_string(const char *start, const char *end)

}

#ifndef _WIN32

static std::string

join_path(const std::string& lhs, const std::string& rhs)

}

#endif

std::string

git_read_repository_hash(const std::string& repository_path)

}

std::string

get_directory_part(const std::string& absolute_path)

}

bool string_starts_with_any_of(const char *str, const char **prefixes) {

}

bool

string_is_any_of(const char* str, const char** candidates)

}

optional<Statistic>

process_emcc_arg(Context& /*ctx*/,

}

nonstd::optional<Statistic>

read_emcc_context(Context& ctx)

}

void

hash_emcc_common_state(const Context& ctx,

}