Guess the compiler type and variant by running it. If the pre argument is not empty, then only "confirm" the pre-guess. Return empty result if unable

Parse the regular expression representation (non-empty string value framed with introducer characters and optionally followed by flag characters from

Enumerations <summary> The state of an instance. </summary>

Auto-deleter.

If target/link path are syntactically to a directory, then the backlink is assumed to be to a directory, otherwise -- to a file.

Now find all the target-specific variables with this prefix. If this is the common .pc file, then we only look in the group. Otherwise, in the member

Call the cast thunk.

We have to parse names in chunks to detect invalid cases of the group{foo}<...> syntax. Consider (1): x = group{foo} $x<...>: And (2): x = group{f

Some of the script builtins (cp, mkdir, etc) extend libbutl builtins (via callbacks) registering/moving cleanups for the filesystem entries they creat

We more or less follow the logic in the Clang 'simplementation (see MSVC.cpp for details) but don't use the high level APIs (bstr_t, com_ptr_t, etc) a

GCC module mapper handler. Note that the input stream is non-blocking while output is blocking and this function should be prepared to handle closed

Note that we don't really need this for clean (where we only need unrefined unit type) so we could make this update-only. But let's keep it simple for

The (vague) idea is that in the future we may turn this into to some sort of key-value sequence (similar to the config initializer idea), for example:

Compile rule options specified on lib/exe{} to propagate to obj/bmi{} during dependency synthesis (see below).

Parse and evaluate the values we are matching. Similar to if-else, we expand patterns.

Similar to config.cxx.std, config.cxx.features.* overrides cxx.features.*.

Calculate (and cache) the global/local fragments split.

Deleters.

Deleters. Note that they are thread-safe.

Note: similar approach to forward() in configure.

Wrap the file_rule's recipe into a data-carrying recipe.

Common thunk for $x.lib_*(...) functions. The two supported function signatures are: $x.lib_*(<targets>, <otype> [, ...]]) $x.lib_*(<targets>) For

Wrap the in::rule's perform_update recipe into a data-carrying recipe. To optimize this a bit further (i.e., to avoid the dynamic memory allocation)

Return the latest MSVC and Platform SDK installation information if both are discovered on the system and nullopt otherwise. In particular, don't fail