#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;

}

const char* inspector_option_name() const {

if (break_node_first_line) return "--inspect-brk-node";

if (break_first_line) return "--inspect-brk";

if (inspect_wait) return "--inspect-wait";

if (inspector_enabled) return "--inspect";

return nullptr;

}

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_