#ifndef SRC_NODE_OPTIONS_H_
#define SRC_NODE_OPTIONS_H_
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "node_constants.h"
#include "node_mutex.h"
#include "util.h"
#if HAVE_OPENSSL
#include "openssl/opensslv.h"
#include "quic/guard.h"
#endif
namespace node {
// Helper macro for defining a 1-bit boolean field in a struct.
#define DEFINE_BOOL_FIELD(field) bool field : 1
class HostPort {
public:
HostPort(const std::string& host_name, int port)
: host_name_(host_name), port_(port) {}
HostPort(const HostPort&) = default;
HostPort& operator=(const HostPort&) = default;
HostPort(HostPort&&) = default;
HostPort& operator=(HostPort&&) = default;
void set_host(const std::string& host) { host_name_ = host; }
void set_port(uint16_t port) { port_ = port; }
const std::string& host() const { return host_name_; }
uint16_t port() const { return port_; }
void Update(const HostPort& other) {
if (!other.host_name_.empty()) host_name_ = other.host_name_;
port_ = other.port_;
}
private:
std::string host_name_;
uint16_t port_;
};
class Options {
public:
virtual void CheckOptions(std::vector<std::string>* errors,
std::vector<std::string>* argv) {}
virtual ~Options() = default;
};
struct InspectPublishUid {
DEFINE_BOOL_FIELD(console);
DEFINE_BOOL_FIELD(http);
};
// These options are currently essentially per-Environment, but it can be nice
// to keep them separate since they are a group of options applying to a very
// specific part of Node. It might also make more sense for them to be
// per-Isolate, rather than per-Environment.
class DebugOptions : public Options {
public:
DebugOptions() = default;
DebugOptions(const DebugOptions&) = default;
DebugOptions& operator=(const DebugOptions&) = default;
DebugOptions(DebugOptions&&) = default;
DebugOptions& operator=(DebugOptions&&) = default;
// --inspect-publish-uid
std::string inspect_publish_uid_string = "stderr,http";
DEFINE_BOOL_FIELD(allow_attaching_debugger) = true;
// --inspect
DEFINE_BOOL_FIELD(inspector_enabled) = false;
// --inspect-wait
DEFINE_BOOL_FIELD(inspect_wait) = false;
// --debug
DEFINE_BOOL_FIELD(deprecated_debug) = false;
// --inspect-brk
DEFINE_BOOL_FIELD(break_first_line) = false;
// --inspect-brk-node
DEFINE_BOOL_FIELD(break_node_first_line) = false;
InspectPublishUid inspect_publish_uid;
enum { kDefaultInspectorPort = 9229 };
HostPort host_port{"127.0.0.1", kDefaultInspectorPort};
// Used to patch the options as if --inspect-brk is passed.
void EnableBreakFirstLine() {
inspector_enabled = true;
break_first_line = true;
}
void DisableWaitOrBreakFirstLine() {
inspect_wait = false;
break_first_line = false;
}
bool wait_for_connect() const {
return break_first_line || break_node_first_line || inspect_wait;
}
bool should_break_first_line() const {
return break_first_line || break_node_first_line;
}
void CheckOptions(std::vector<std::string>* errors,
std::vector<std::string>* argv) override;
};
#ifndef EXPERIMENTALS_DEFAULT_VALUE
#define EXPERIMENTALS_DEFAULT_VALUE false
#endif
class EnvironmentOptions : public Options {
public:
#if HAVE_INSPECTOR
static constexpr uint64_t kDefaultCpuProfInterval = 1000;
static constexpr uint64_t kDefaultHeapProfInterval = 512 * 1024;
#endif
static constexpr bool IS_DEBUG =
#ifdef DEBUG
true;
#else
false;
#endif // DEBUG
std::string dns_result_order;
std::string localstorage_file;
std::string input_type; // Value of --input-type
std::string heap_snapshot_signal;
std::string redirect_warnings;
std::string diagnostic_dir;
std::string bench_isolation = "process";
std::string bench_name_pattern;
std::string test_rerun_failures_path;
std::string test_global_setup_path;
std::string test_isolation = "process";
std::string test_shard;
std::string trace_require_module;
std::string unhandled_rejections;
std::string watch_mode_kill_signal = "SIGTERM";
std::string eval_string;
std::string tls_keylog;
std::string config_file_path;
std::string experimental_package_map_path;
std::string vfs_load_source;
#if HAVE_INSPECTOR
std::string cpu_prof_dir;
std::string cpu_prof_name;
std::string heap_prof_dir;
std::string heap_prof_name;
#endif // HAVE_INSPECTOR
std::vector<std::string> conditions;
std::vector<std::string> allow_env;
std::vector<std::string> allow_fs_read;
std::vector<std::string> allow_fs_write;
std::vector<std::string> disable_warnings;
std::vector<std::string> bench_reporter;
std::vector<std::string> bench_reporter_destination;
std::vector<std::string> env_file;
std::vector<std::string> optional_env_file;
std::vector<std::string> test_name_pattern;
std::vector<std::string> test_reporter;
std::vector<std::string> test_reporter_destination;
std::vector<std::string> test_skip_pattern;
std::vector<std::string> experimental_test_tag_filter;
std::vector<std::string> coverage_include_pattern;
std::vector<std::string> coverage_exclude_pattern;
std::vector<std::string> userland_loaders;
std::vector<std::string> watch_mode_paths;
std::vector<std::string> preload_cjs_modules;
std::vector<std::string> preload_esm_modules;
std::vector<std::string> user_argv;
int64_t heap_snapshot_near_heap_limit = 0;
uint64_t network_family_autoselection_attempt_timeout = 500;
uint64_t max_http_header_size = 16 * 1024;
uint64_t bench_samples = 0;
uint64_t bench_warmup = 0;
uint64_t test_runner_concurrency = 0;
uint64_t test_runner_timeout = 0;
uint64_t test_coverage_branches = 0;
uint64_t test_coverage_functions = 0;
uint64_t test_coverage_lines = 0;
uint64_t test_random_seed = 0;
#if HAVE_INSPECTOR
uint64_t cpu_prof_interval = kDefaultCpuProfInterval;
uint64_t heap_prof_interval = kDefaultHeapProfInterval;
#endif // HAVE_INSPECTOR
// These are intentionally not bools. They are 1 bit packed flags in
// order to reduce the overall size of the struct.
DEFINE_BOOL_FIELD(abort_on_uncaught_exception) = false;
DEFINE_BOOL_FIELD(detect_module) = true;
DEFINE_BOOL_FIELD(disable_sigusr1) = false;
DEFINE_BOOL_FIELD(print_required_tla) = false;
DEFINE_BOOL_FIELD(require_module) = true;
DEFINE_BOOL_FIELD(enable_source_maps) = false;
DEFINE_BOOL_FIELD(experimental_addon_modules) = true;
DEFINE_BOOL_FIELD(experimental_bench) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_eventsource) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_ffi) = HAVE_FFI;
DEFINE_BOOL_FIELD(experimental_web_worker) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_websocket) = true;
DEFINE_BOOL_FIELD(experimental_sqlite) = HAVE_SQLITE;
DEFINE_BOOL_FIELD(experimental_stream_iter) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_vfs) = true;
DEFINE_BOOL_FIELD(vfs_load) = false;
DEFINE_BOOL_FIELD(sea_vfs_archive) = false;
DEFINE_BOOL_FIELD(webstorage) = HAVE_SQLITE;
DEFINE_BOOL_FIELD(experimental_dtls) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_quic) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_global_navigator) = true;
DEFINE_BOOL_FIELD(experimental_global_web_crypto) = true;
DEFINE_BOOL_FIELD(experimental_import_text) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_import_meta_resolve) =
EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(entry_is_url) = false;
DEFINE_BOOL_FIELD(permission) = false;
DEFINE_BOOL_FIELD(permission_audit) = false;
DEFINE_BOOL_FIELD(allow_addons) = false;
DEFINE_BOOL_FIELD(allow_fs_vfs) = false;
DEFINE_BOOL_FIELD(allow_inspector) = false;
DEFINE_BOOL_FIELD(allow_child_process) = false;
DEFINE_BOOL_FIELD(allow_net) = false;
DEFINE_BOOL_FIELD(allow_wasi) = false;
DEFINE_BOOL_FIELD(allow_ffi) = false;
DEFINE_BOOL_FIELD(allow_openssl_store) = false;
DEFINE_BOOL_FIELD(allow_worker_threads) = false;
DEFINE_BOOL_FIELD(experimental_vm_modules) = EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(expose_internals) = false;
DEFINE_BOOL_FIELD(force_node_api_uncaught_exceptions_policy) = false;
DEFINE_BOOL_FIELD(frozen_intrinsics) = false;
DEFINE_BOOL_FIELD(network_family_autoselection) = true;
DEFINE_BOOL_FIELD(deprecation) = true;
DEFINE_BOOL_FIELD(force_async_hooks_checks) = true;
DEFINE_BOOL_FIELD(allow_native_addons) = true;
DEFINE_BOOL_FIELD(global_search_paths) = true;
DEFINE_BOOL_FIELD(warnings) = true;
DEFINE_BOOL_FIELD(force_context_aware) = false;
DEFINE_BOOL_FIELD(pending_deprecation) = false;
DEFINE_BOOL_FIELD(preserve_symlinks) = false;
DEFINE_BOOL_FIELD(preserve_symlinks_main) = false;
DEFINE_BOOL_FIELD(prof_process) = false;
DEFINE_BOOL_FIELD(has_env_file_string) = false;
DEFINE_BOOL_FIELD(bench_runner) = false;
DEFINE_BOOL_FIELD(has_bench_options) = false;
DEFINE_BOOL_FIELD(has_bench_samples) = false;
DEFINE_BOOL_FIELD(has_bench_warmup) = false;
DEFINE_BOOL_FIELD(test_runner) = false;
DEFINE_BOOL_FIELD(test_runner_coverage) = false;
DEFINE_BOOL_FIELD(test_runner_force_exit) = false;
DEFINE_BOOL_FIELD(test_runner_module_mocks) = false;
DEFINE_BOOL_FIELD(test_runner_update_snapshots) = false;
DEFINE_BOOL_FIELD(test_randomize) = false;
DEFINE_BOOL_FIELD(has_test_random_seed) = false;
DEFINE_BOOL_FIELD(test_only) = false;
DEFINE_BOOL_FIELD(test_forbid_only) = false;
DEFINE_BOOL_FIELD(test_udp_no_try_send) = false;
DEFINE_BOOL_FIELD(coverage_include_all) = false;
DEFINE_BOOL_FIELD(throw_deprecation) = false;
DEFINE_BOOL_FIELD(trace_deprecation) = false;
DEFINE_BOOL_FIELD(trace_exit) = false;
DEFINE_BOOL_FIELD(trace_sync_io) = false;
DEFINE_BOOL_FIELD(trace_tls) = false;
DEFINE_BOOL_FIELD(trace_uncaught) = false;
DEFINE_BOOL_FIELD(trace_warnings) = false;
DEFINE_BOOL_FIELD(trace_promises) = false;
DEFINE_BOOL_FIELD(trace_env) = false;
DEFINE_BOOL_FIELD(trace_env_js_stack) = false;
DEFINE_BOOL_FIELD(trace_env_native_stack) = false;
DEFINE_BOOL_FIELD(use_system_ca) = false;
DEFINE_BOOL_FIELD(extra_info_on_fatal_exception) = true;
DEFINE_BOOL_FIELD(verify_base_objects) = IS_DEBUG;
DEFINE_BOOL_FIELD(watch_mode) = false;
DEFINE_BOOL_FIELD(watch_mode_report_to_parent) = false;
DEFINE_BOOL_FIELD(watch_mode_preserve_output) = false;
DEFINE_BOOL_FIELD(syntax_check_only) = false;
DEFINE_BOOL_FIELD(has_eval_string) = false;
DEFINE_BOOL_FIELD(print_eval) = false;
DEFINE_BOOL_FIELD(force_repl) = false;
DEFINE_BOOL_FIELD(insecure_http_parser) = false;
DEFINE_BOOL_FIELD(use_env_proxy) = false;
DEFINE_BOOL_FIELD(tls_min_v1_0) = false;
DEFINE_BOOL_FIELD(tls_min_v1_1) = false;
DEFINE_BOOL_FIELD(tls_min_v1_2) = false;
DEFINE_BOOL_FIELD(tls_min_v1_3) = false;
DEFINE_BOOL_FIELD(tls_max_v1_2) = false;
DEFINE_BOOL_FIELD(tls_max_v1_3) = false;
DEFINE_BOOL_FIELD(strip_types) = HAVE_AMARO;
DEFINE_BOOL_FIELD(experimental_strip_private_modules) =
EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(report_exclude_env) = false;
DEFINE_BOOL_FIELD(report_exclude_network) = false;
#if HAVE_INSPECTOR
DEFINE_BOOL_FIELD(cpu_prof) = false;
DEFINE_BOOL_FIELD(experimental_network_inspection) =
EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_worker_inspection) =
EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_storage_inspection) =
EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(experimental_inspector_network_resource) =
EXPERIMENTALS_DEFAULT_VALUE;
DEFINE_BOOL_FIELD(heap_prof) = false;
#endif // HAVE_INSPECTOR
inline DebugOptions* get_debug_options() { return &debug_options_; }
inline const DebugOptions& debug_options() const { return debug_options_; }
void CheckOptions(std::vector<std::string>* errors,
std::vector<std::string>* argv) override;
// `--bench` and the other benchmark runner options are gated behind
// `--experimental-bench`, but the gate and the options it guards can come
// from different option sources, each of which is parsed in its own
// options_parser::Parse() pass. CheckOptions() runs at the end of every
// pass, so this constraint cannot be validated there: the gate may still
// arrive in a later pass. Callers must invoke this once all of their option
// sources have been parsed.
void CheckBenchOptions(std::vector<std::string>* errors) const;
private:
DebugOptions debug_options_;
};
class PerIsolateOptions : public Options {
public:
bool worker_snapshot = true; // --[no-]worker-snapshot
PerIsolateOptions() = default;
PerIsolateOptions(PerIsolateOptions&&) = default;
std::shared_ptr<EnvironmentOptions> per_env{new EnvironmentOptions()};
std::string max_old_space_size_percentage;
std::string max_old_space_size;
std::string report_signal = "SIGUSR2";
std::string build_snapshot_config;
int64_t stack_trace_limit = 10;
DEFINE_BOOL_FIELD(track_heap_objects) = false;
DEFINE_BOOL_FIELD(report_uncaught_exception) = false;
DEFINE_BOOL_FIELD(report_on_signal) = false;
DEFINE_BOOL_FIELD(experimental_shadow_realm) = false;
DEFINE_BOOL_FIELD(build_snapshot) = false;
inline EnvironmentOptions* get_per_env_options();
void CheckOptions(std::vector<std::string>* errors,
std::vector<std::string>* argv) override;
void HandleMaxOldSpaceSizePercentage(std::vector<std::string>* errors,
std::string* max_old_space_size);
inline std::shared_ptr<PerIsolateOptions> Clone() const;
private:
PerIsolateOptions(const PerIsolateOptions&) = default;
};
class PerProcessOptions : public Options {
public:
// Options shouldn't be here unless they affect the entire process scope, and
// that should avoided when possible.
//
// When an option is used during process initialization, it does not need
// protection, but any use after that will likely require synchronization
// using the node::per_process::cli_options_mutex, typically:
//
// Mutex::ScopedLock lock(node::per_process::cli_options_mutex);
std::shared_ptr<PerIsolateOptions> per_isolate{new PerIsolateOptions()};
std::string title;
std::string trace_event_categories;
#if defined(V8_USE_PERFETTO)
std::string trace_event_file_pattern = "node_trace.${rotation}.pftrace";
#else
std::string trace_event_file_pattern = "node_trace.${rotation}.log";
#endif
std::string disable_proto;
std::string snapshot_blob;
std::string experimental_sea_config;
std::string run;
std::string build_sea;
#ifdef NODE_HAVE_I18N_SUPPORT
std::string icu_data_dir;
#endif
// Per-process because they affect singleton OpenSSL shared library state,
// or are used once during process initialization.
#if HAVE_OPENSSL
std::string openssl_config;
std::string tls_cipher_list = DEFAULT_CIPHER_LIST_CORE;
#endif // HAVE_OPENSSL
std::string report_directory;
std::string report_filename;
// TODO(addaleax): Some of these could probably be per-Environment.
std::string use_largepages = "off";
// --process-timeout, as passed on the command line (e.g. "30s").
std::string process_timeout;
// The parsed value of --process-timeout, or 0 if it was not passed.
uint64_t process_timeout_ms = 0;
std::vector<std::string> security_reverts;
std::vector<std::string> cmdline;
int64_t v8_thread_pool_size = 4;
#if HAVE_OPENSSL
int64_t secure_heap = 0;
int64_t secure_heap_min = 2;
#endif // HAVE_OPENSSL
DEFINE_BOOL_FIELD(zero_fill_all_buffers) = false;
DEFINE_BOOL_FIELD(debug_arraybuffer_allocations) = false;
// We enable the shared read-only heap which currently requires that the
// snapshot used in different isolates in the same process to be the same.
// Therefore --node-snapshot is a per-process option.
DEFINE_BOOL_FIELD(node_snapshot) = true;
DEFINE_BOOL_FIELD(print_bash_completion) = false;
DEFINE_BOOL_FIELD(print_help) = false;
DEFINE_BOOL_FIELD(print_v8_help) = false;
DEFINE_BOOL_FIELD(print_version) = false;
#if HAVE_OPENSSL
#ifdef NODE_OPENSSL_CERT_STORE
DEFINE_BOOL_FIELD(ssl_openssl_cert_store) = true;
#else
DEFINE_BOOL_FIELD(ssl_openssl_cert_store) = false;
#endif // NODE_OPENSSL_CERT_STORE
DEFINE_BOOL_FIELD(use_openssl_ca) = false;
DEFINE_BOOL_FIELD(use_bundled_ca) = false;
DEFINE_BOOL_FIELD(enable_fips_crypto) = false;
DEFINE_BOOL_FIELD(enable_fips_indicator_events) = false;
DEFINE_BOOL_FIELD(force_fips_crypto) = false;
std::string force_fips_crypto_policy = "provider";
#endif // HAVE_OPENSSL
#if HAVE_OPENSSL && !defined(OPENSSL_IS_BORINGSSL)
DEFINE_BOOL_FIELD(openssl_legacy_provider) = false;
DEFINE_BOOL_FIELD(openssl_shared_config) = false;
#endif
DEFINE_BOOL_FIELD(disable_wasm_trap_handler) = false;
DEFINE_BOOL_FIELD(report_on_fatalerror) = false;
DEFINE_BOOL_FIELD(report_on_process_timeout) = false;
DEFINE_BOOL_FIELD(report_compact) = false;
DEFINE_BOOL_FIELD(trace_sigint) = false;
// Tracks whether `--run` was passed, since an empty `run` is ambiguous
// between "not passed" and "passed without a script name" (lists scripts).
DEFINE_BOOL_FIELD(has_run) = false;
inline PerIsolateOptions* get_per_isolate_options();
void CheckOptions(std::vector<std::string>* errors,
std::vector<std::string>* argv) override;
// `--process-timeout` conflicts with options that can come from different
// option sources (e.g. `--inspect` from NODE_OPTIONS), each of which is
// parsed in its own options_parser::Parse() pass. Callers must invoke this
// once all of their option sources have been parsed. `argv` holds the
// remaining non-option arguments, starting with the program name.
void CheckProcessTimeoutOptions(std::vector<std::string>* errors,
const std::vector<std::string>& argv) const;
};
// The actual options parser, as opposed to the structs containing them:
namespace options_parser {
HostPort SplitHostPort(const std::string& arg,
std::vector<std::string>* errors);
void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
std::string GetBashCompletion();
enum OptionType {
kNoOp,
kV8Option,
kBoolean,
kInteger,
kUInteger,
kString,
kHostPort,
kStringList,
};
struct OptionMappingDetails {
OptionType type;
std::string help_text;
};
std::unordered_map<std::string, OptionMappingDetails>
MapEnvOptionsFlagInputType();
std::unordered_map<std::string, OptionMappingDetails> MapOptionsByNamespace(
std::string namespace_name);
std::unordered_map<
std::string,
std::unordered_map<std::string, options_parser::OptionMappingDetails>>
MapNamespaceOptionsAssociations();
std::vector<std::string> MapAvailableNamespaces();
// Define all namespace entries
#define OPTION_NAMESPACE_LIST(V) \
V(kNoNamespace, "") \
V(kBenchRunnerNamespace, "bench") \
V(kTestRunnerNamespace, "test") \
V(kWatchNamespace, "watch") \
V(kPermissionNamespace, "permission")
enum class OptionNamespaces {
#define V(name, _) name,
OPTION_NAMESPACE_LIST(V)
#undef V
};
inline const std::string NamespaceEnumToString(OptionNamespaces ns) {
switch (ns) {
#define V(name, string_value) \
case OptionNamespaces::name: \
return string_value;
OPTION_NAMESPACE_LIST(V)
#undef V
default:
return "";
}
}
inline constexpr auto AllNamespaces() {
return std::array{
#define V(name, _) OptionNamespaces::name,
OPTION_NAMESPACE_LIST(V)
#undef V
};
}
template <typename Options>
class OptionsParser {
public:
virtual ~OptionsParser() = default;
typedef Options TargetType;
struct NoOp {};
struct V8Option {};
// These methods add a single option to the parser. Optionally, it can be
// specified whether the option should be allowed from environment variable
// sources (i.e. NODE_OPTIONS).
// default_is_true is only a hint in printing help text, it does not
// affect the default value of the option. Set the default value in the
// Options struct instead.
void AddOption(
const char* name,
const char* help_text,
bool (*getter)(Options*),
void (*setter)(Options*, bool),
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
bool default_is_true = false,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
void AddOption(const char* name,
const char* help_text,
uint64_t Options::*field,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace,
bool strict = false);
void AddOption(
const char* name,
const char* help_text,
int64_t Options::*field,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
void AddOption(
const char* name,
const char* help_text,
std::string Options::*field,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
void AddOption(
const char* name,
const char* help_text,
std::vector<std::string> Options::*field,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
void AddOption(
const char* name,
const char* help_text,
HostPort Options::*field,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
void AddOption(
const char* name,
const char* help_text,
NoOp no_op_tag,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
void AddOption(
const char* name,
const char* help_text,
V8Option v8_option_tag,
OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
// Adds aliases. An alias can be of the form "--option-a" -> "--option-b",
// or have a more complex group expansion, like
// "--option-a" -> { "--option-b", "--harmony-foobar", "--eval", "42" }
// If `from` has the form "--option-a=", the alias will only be expanded if
// the option is presented in that form (i.e. with a '=').
// If `from` has the form "--option-a <arg>", the alias will only be expanded
// if the option has a non-option argument (not starting with -) following it.
void AddAlias(const char* from, const char* to);
void AddAlias(const char* from, const std::vector<std::string>& to);
void AddAlias(const char* from, const std::initializer_list<std::string>& to);
// Add implications from some arbitrary option to a boolean one, either
// in a way that makes `from` set `to` to true or to false.
void Implies(const char* from, const char* to);
void ImpliesNot(const char* from, const char* to);
// Insert options from another options parser into this one, along with
// a method that yields the target options type from this parser's options
// type.
template <typename ChildOptions>
void Insert(const OptionsParser<ChildOptions>& child_options_parser,
ChildOptions* (Options::*get_child)());
// Parse a sequence of options into an options struct, a list of
// arguments that were parsed as options, a list of unknown/JS engine options,
// and leave the remainder in the input `args` vector.
//
// For example, an `args` input of
//
// node --foo --harmony-bar --fizzle=42 -- /path/to/cow moo
//
// expands as
//
// - `args` -> { "node", "/path/to/cow", "moo" }
// - `exec_args` -> { "--foo", "--harmony-bar", "--fizzle=42" }
// - `v8_args` -> `{ "node", "--harmony-bar" }
// - `options->foo == true`, `options->fizzle == 42`.
//
// If `*error` is set, the result of the parsing should be discarded and the
// contents of any of the argument vectors should be considered undefined.
void Parse(std::vector<std::string>* const args,
std::vector<std::string>* const exec_args,
std::vector<std::string>* const v8_args,
Options* const options,
OptionEnvvarSettings required_env_settings,
std::vector<std::string>* const errors) const;
private:
// We support the wide variety of different option types by remembering
// how to access them, given a certain `Options` struct.
// Represents a field within `Options`.
class BaseOptionField {
public:
virtual ~BaseOptionField() = default;
virtual void* LookupImpl(Options* options) const = 0;
// For boolean bit-field options, we can't return a pointer so we
// use virtual getter/setter methods instead. The default
// implementations go through LookupImpl for non-bit-field types.
virtual bool GetBool(Options* options) const {
return *static_cast<bool*>(LookupImpl(options));
}
virtual void SetBool(Options* options, bool value) {
*static_cast<bool*>(LookupImpl(options)) = value;
}
template <typename T>
inline T* Lookup(Options* options) const {
return static_cast<T*>(LookupImpl(options));
}
};
// Represents a field of type T within `Options` that can be looked up
// as a C++ member field.
template <typename T>
class SimpleOptionField : public BaseOptionField {
public:
explicit SimpleOptionField(T Options::* field) : field_(field) {}
void* LookupImpl(Options* options) const override {
return static_cast<void*>(&(options->*field_));
}
private:
T Options::* field_;
};
// Represents a boolean bit-field within `Options`. Bit-fields cannot
// have their address taken, so we use getter/setter function pointers
// instead of a pointer-to-member.
class BitFieldOptionField : public BaseOptionField {
public:
using Getter = bool (*)(Options*);
using Setter = void (*)(Options*, bool);
BitFieldOptionField(Getter get, Setter set) : get_(get), set_(set) {}
void* LookupImpl(Options* options) const override { UNREACHABLE(); }
bool GetBool(Options* options) const override { return get_(options); }
void SetBool(Options* options, bool value) override {
set_(options, value);
}
private:
Getter get_;
Setter set_;
};
template <typename T>
inline T* Lookup(std::shared_ptr<BaseOptionField> field,
Options* options) const {
return field->template Lookup<T>(options);
}
// An option consists of:
// - A type.
// - A way to store/access the property value.
// - The information of whether it may occur in an env var or not.
// - A default value (if applicable).
// - A namespace ID (optional) to allow for namespacing of options.
struct OptionInfo {
OptionType type;
std::shared_ptr<BaseOptionField> field;
OptionEnvvarSettings env_setting;
std::string help_text;
bool default_is_true = false;
std::string namespace_id;
bool strict = false;
};
// An implied option is composed of the information on where to store a
// specific boolean value (if another specific option is encountered).
struct Implication {
OptionType type;
std::string name;
std::shared_ptr<BaseOptionField> target_field;
bool target_value;
};
// These are helpers that make `Insert()` support properties of other
// options structs, if we know how to access them.
template <typename OriginalField, typename ChildOptions>
static auto Convert(std::shared_ptr<OriginalField> original,
ChildOptions* (Options::*get_child)());
template <typename ChildOptions>
static auto Convert(typename OptionsParser<ChildOptions>::OptionInfo original,
ChildOptions* (Options::*get_child)());
template <typename ChildOptions>
static auto Convert(
typename OptionsParser<ChildOptions>::Implication original,
ChildOptions* (Options::*get_child)());
std::unordered_map<std::string, OptionInfo> options_;
std::unordered_map<std::string, std::vector<std::string>> aliases_;
std::unordered_multimap<std::string, Implication> implications_;
template <typename OtherOptions>
friend class OptionsParser;
friend void GetCLIOptionsValues(
const v8::FunctionCallbackInfo<v8::Value>& args);
friend void GetCLIOptionsInfo(
const v8::FunctionCallbackInfo<v8::Value>& args);
friend std::string GetBashCompletion();
friend std::unordered_map<std::string, OptionMappingDetails>
MapEnvOptionsFlagInputType();
friend std::unordered_map<std::string, OptionMappingDetails>
MapOptionsByNamespace(std::string namespace_name);
friend std::vector<std::string> MapAvailableNamespaces();
friend void GetEnvOptionsInputType(
const v8::FunctionCallbackInfo<v8::Value>& args);
friend void GetOptionsAsFlags(
const v8::FunctionCallbackInfo<v8::Value>& args);
};
using StringVector = std::vector<std::string>;
template <class OptionsType, class = Options>
void Parse(StringVector* const args,
StringVector* const exec_args,
StringVector* const v8_args,
OptionsType* const options,
OptionEnvvarSettings required_env_settings,
StringVector* const errors);
} // namespace options_parser
// Helper macro for passing bit-field members to AddOption(). Expands to a
// getter and setter function pointer pair that can read/write the named
// bit-field without requiring a pointer-to-member (which is illegal for
// bit-fields).
#define BOOL_FIELD(field) \
+[](TargetType* opts) -> bool { return opts->field; }, \
+[](TargetType* opts, bool v) { opts->field = v; }
namespace per_process {
extern Mutex cli_options_mutex;
extern NODE_EXTERN_PRIVATE std::shared_ptr<PerProcessOptions> cli_options;
} // namespace per_process
void HandleEnvOptions(std::shared_ptr<EnvironmentOptions> env_options);
void HandleEnvOptions(std::shared_ptr<EnvironmentOptions> env_options,
std::function<std::string(const char*)> opt_getter);
std::vector<std::string> ParseNodeOptionsEnvVar(
const std::string& node_options, std::vector<std::string>* errors);
#undef DEFINE_BOOL_FIELD
} // namespace node
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif // SRC_NODE_OPTIONS_H_