#include "node_options.h"  // NOLINT(build/include_inline)

#include "node_options-inl.h"

#include "env-inl.h"

#include "node_binding.h"

#include "node_internals.h"

#include <errno.h>

#include <sstream>

#include <limits>

#include <algorithm>

#include <cstdlib>  // strtoul, errno

using v8::Boolean;

using v8::Context;

using v8::FunctionCallbackInfo;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::Map;

using v8::Number;

using v8::Object;

using v8::Undefined;

using v8::Value;

namespace node {

namespace per_process {

}  // namespace per_process

#if !NODE_USE_V8_PLATFORM && !HAVE_INSPECTOR

  if (inspector_enabled) {

    errors->push_back("Inspector is not available when Node is compiled "

                      "--without-v8-platform and --without-inspector.");

  }

#endif

                      "are invalid. Please use `node --inspect` and "

  }

  std::vector<std::string> destinations =

    } else {

    }

  }

#if HAVE_OPENSSL

  }

  // Any value less than 2 disables use of the secure heap.

            static_cast<int64_t>(std::numeric_limits<int>::max())});

  }

#endif

  }

  }

  }

    }

  }

    }

  }

  }

  }

  }

  }

#if HAVE_INSPECTOR

    }

    }

    // We can't catch the case where the value passed is the default value,

    // then the option just becomes a noop which is fine.

    }

  }

    }

    }

    }

    // We can't catch the case where the value passed is the default value,

    // then the option just becomes a noop which is fine.

    }

  }

  }

#endif  // HAVE_INSPECTOR

namespace options_parser {

 public:

  DebugOptionsParser();

};

 public:

  EnvironmentOptionsParser();

};

 public:

  PerIsolateOptionsParser() = delete;

  explicit PerIsolateOptionsParser(const EnvironmentOptionsParser& eop);

};

 public:

  PerProcessOptionsParser() = delete;

  explicit PerProcessOptionsParser(const PerIsolateOptionsParser& iop);

};

#if HAVE_INSPECTOR

// This Parse is not dead code. It is used by embedders (e.g., Electron).

template <>

  StringVector* const args, StringVector* const exec_args,

  StringVector* const v8_args,

  DebugOptions* const options,

  OptionEnvvarSettings required_env_settings, StringVector* const errors) {

  _dop_instance.Parse(

}

#else

const EnvironmentOptionsParser _eop_instance{};

#endif  // HAVE_INSPECTOR

template <>

  StringVector* const args, StringVector* const exec_args,

  StringVector* const v8_args,

  PerIsolateOptions* const options,

  OptionEnvvarSettings required_env_settings, StringVector* const errors) {

  _piop_instance.Parse(

}

template <>

  StringVector* const args, StringVector* const exec_args,

  StringVector* const v8_args,

  PerProcessOptions* const options,

  OptionEnvvarSettings required_env_settings, StringVector* const errors) {

  _ppop_instance.Parse(

// XXX: If you add an option here, please also add it to doc/node.1 and

// doc/api/cli.md

// TODO(addaleax): Make that unnecessary.

            "set host:port for inspector",

            &DebugOptions::host_port,

            "activate inspector on host:port (default: 127.0.0.1:9229)",

            &DebugOptions::inspector_enabled,

            "activate inspector on host:port and break at start of user script",

            &DebugOptions::break_first_line,

            "comma separated list of destinations for inspector uid"

            "(default: stderr,http)",

            &DebugOptions::inspect_publish_uid_string,

            "additional user conditions for conditional exports and imports",

            &EnvironmentOptions::conditions,

            "set dir for all output files"

            " (default: current working directory)",

            &EnvironmentOptions::diagnostic_dir,

            "experimental Source Map V3 support",

            &EnvironmentOptions::enable_source_maps,

            "experimental JSON interop support for the ES Module loader",

            &EnvironmentOptions::experimental_json_modules,

            "use the specified module as a custom loader",

            &EnvironmentOptions::userland_loader,

            "",

            &EnvironmentOptions::experimental_modules,

            "experimental ES Module support for webassembly modules",

            &EnvironmentOptions::experimental_wasm_modules,

            "experimental ES Module import.meta.resolve() support",

            &EnvironmentOptions::experimental_import_meta_resolve,

            "use the specified file as a "

            "security policy",

            &EnvironmentOptions::experimental_policy,

            "",

            "ensure the security policy contents match "

            "the specified integrity",

            &EnvironmentOptions::experimental_policy_integrity,

            "experimental await keyword support in REPL",

            &EnvironmentOptions::experimental_repl_await,

            "experimental ES Module support in vm module",

            &EnvironmentOptions::experimental_vm_modules,

            "experimental WASI support",

            &EnvironmentOptions::experimental_wasi,

            "experimental frozen intrinsics support",

            &EnvironmentOptions::frozen_intrinsics,

            "Generate heap snapshot on specified signal",

            &EnvironmentOptions::heap_snapshot_signal,

            "Generate heap snapshots whenever V8 is approaching "

            "the heap limit. No more than the specified number of "

            "heap snapshots will be generated.",

            &EnvironmentOptions::heap_snapshot_near_heap_limit,

            "use an insecure HTTP parser that accepts invalid HTTP headers",

            &EnvironmentOptions::insecure_http_parser,

            "set module type for string input",

            &EnvironmentOptions::module_type,

            "Select extension resolution algorithm for es modules; "

            "either 'explicit' (default) or 'node'",

            &EnvironmentOptions::experimental_specifier_resolution,

            "silence deprecation warnings",

            &EnvironmentOptions::no_deprecation,

            "disable checks for async_hooks",

            &EnvironmentOptions::no_force_async_hooks_checks,

            "silence all process warnings",

            &EnvironmentOptions::no_warnings,

            "disable loading non-context-aware addons",

            &EnvironmentOptions::force_context_aware,

            "emit pending deprecation warnings",

            &EnvironmentOptions::pending_deprecation,

            "preserve symbolic links when resolving",

            &EnvironmentOptions::preserve_symlinks,

            "preserve symbolic links when resolving the main module",

            &EnvironmentOptions::preserve_symlinks_main,

            "Generate V8 profiler output.",

            "process V8 profiler output generated using --prof",

  // Options after --prof-process are passed through to the prof processor.

#if HAVE_INSPECTOR

            "Start the V8 CPU profiler on start up, and write the CPU profile "

            "to disk before exit. If --cpu-prof-dir is not specified, write "

            "the profile to the current working directory.",

            "specified file name of the V8 CPU profile generated with "

            "--cpu-prof",

            "specified sampling interval in microseconds for the V8 CPU "

            "profile generated with --cpu-prof. (default: 1000)",

            "Directory where the V8 profiles generated by --cpu-prof will be "

            "placed. Does not affect --prof.",

      "--heap-prof",

      "Start the V8 heap profiler on start up, and write the heap profile "

      "to disk before exit. If --heap-prof-dir is not specified, write "

      "the profile to the current working directory.",

            "specified file name of the V8 heap profile generated with "

            "--heap-prof",

            "Directory where the V8 heap profiles generated by --heap-prof "

            "will be placed.",

            "specified sampling interval in bytes for the V8 heap "

            "profile generated with --heap-prof. (default: 512 * 1024)",

#endif  // HAVE_INSPECTOR

            "set the maximum size of HTTP headers (default: 16384 (16KB))",

            &EnvironmentOptions::max_http_header_size,

            "write warnings to file instead of stderr",

            &EnvironmentOptions::redirect_warnings,

            "throw an exception on deprecations",

            &EnvironmentOptions::throw_deprecation,

            "trace Atomics.wait() operations",

            &EnvironmentOptions::trace_atomics_wait,

            "show stack traces on deprecations",

            &EnvironmentOptions::trace_deprecation,

            "show stack trace when an environment exits",

            &EnvironmentOptions::trace_exit,

            "show stack trace when use of sync IO is detected after the "

            "first tick",

            &EnvironmentOptions::trace_sync_io,

            "prints TLS packet trace information to stderr",

            &EnvironmentOptions::trace_tls,

            "show stack traces for the `throw` behind uncaught exceptions",

            &EnvironmentOptions::trace_uncaught,

            "show stack traces on process warnings",

            &EnvironmentOptions::trace_warnings,

            "define unhandled rejections behavior. Options are 'strict' (raise "

            "an error), 'warn' (enforce warnings) or 'none' (silence warnings)",

            &EnvironmentOptions::unhandled_rejections,

            "", /* undocumented, only for debugging */

            &EnvironmentOptions::verify_base_objects,

            "syntax check script without executing",

  // This option is only so that we can tell --eval with an empty string from

  // no eval at all. Having it not start with a dash makes it inaccessible

  // from the parser itself, but available for using Implies().

  // TODO(addaleax): When moving --help over to something generated from the

  // programmatic descriptions, this will need some special care.

  // (See also [ssl_openssl_cert_store] below.)

            "evaluate script and print result",

            "module to preload (option can be repeated)",

            &EnvironmentOptions::preload_modules,

            "always enter the REPL even if stdin does not appear "

            "to be a terminal",

            "log TLS decryption keys to named file for traffic analysis",

            "set default TLS minimum to TLSv1.0 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_0,

            "set default TLS minimum to TLSv1.1 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_1,

            "set default TLS minimum to TLSv1.2 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_2,

            "set default TLS minimum to TLSv1.3 (default: TLSv1.2)",

            &EnvironmentOptions::tls_min_v1_3,

            "set default TLS maximum to TLSv1.2 (default: TLSv1.3)",

            &EnvironmentOptions::tls_max_v1_2,

  // Current plan is:

  // - 11.x and below: TLS1.3 is opt-in with --tls-max-v1.3

  // - 12.x: TLS1.3 is opt-out with --tls-max-v1.2

  // In either case, support both options they are uniformly available.

            "set default TLS maximum to TLSv1.3 (default: TLSv1.3)",

            &EnvironmentOptions::tls_max_v1_3,

            "track heap object allocations for heap snapshots",

            &PerIsolateOptions::track_heap_objects,

            "",  // It's a debug-only option.

            &PerIsolateOptions::no_node_snapshot,

  // Explicitly add some V8 flags to mark them as allowed in NODE_OPTIONS.

            "aborting instead of exiting causes a core file to be generated "

            "for analysis",

            "help system profilers to translate JavaScript interpreted frames",

            "",

            "",

            "disallow eval and friends",

             "increase default maximum heap size on machines with 16GB memory "

             "or more",

             "disable runtime allocation of executable memory",

            "generate diagnostic report on uncaught exceptions",

            &PerIsolateOptions::report_uncaught_exception,

            "generate diagnostic report upon receiving signals",

            &PerIsolateOptions::report_on_signal,

            "causes diagnostic report to be produced on provided signal,"

            " unsupported in Windows. (default: SIGUSR2)",

            &PerIsolateOptions::report_signal,

            "",

            &PerIsolateOptions::experimental_top_level_await,

            "the process title to use on startup",

            &PerProcessOptions::title,

            "comma separated list of trace event categories to record",

            &PerProcessOptions::trace_event_categories,

            "Template string specifying the filepath for the trace-events "

            "data, it supports ${rotation} and ${pid}.",

            &PerProcessOptions::trace_event_file_pattern,

            "set V8's thread pool size",

            &PerProcessOptions::v8_thread_pool_size,

            "automatically zero-fill all newly allocated Buffer and "

            "SlowBuffer instances",

            &PerProcessOptions::zero_fill_all_buffers,

            "", /* undocumented, only for debugging */

            &PerProcessOptions::debug_arraybuffer_allocations,

            "disable Object.prototype.__proto__",

            &PerProcessOptions::disable_proto,

  // 12.x renamed this inadvertently, so alias it for consistency within the

  // release line, while using the original name for consistency with older

  // release lines.

            "print source-able bash completion script",

            "print node command line options",

            "print V8 command line options",

            "output compact single-line JSON",

            &PerProcessOptions::report_compact,

            "define custom report pathname."

            " (default: current working directory)",

            &PerProcessOptions::report_directory,

            "define custom report file name."

            " (default: YYYYMMDD.HHMMSS.PID.SEQUENCE#.txt)",

            &PerProcessOptions::report_filename,

              "generate diagnostic report on fatal (internal) errors",

              &PerProcessOptions::report_on_fatalerror,

#ifdef NODE_HAVE_I18N_SUPPORT

            "set ICU data load path to dir (overrides NODE_ICU_DATA)"

#ifndef NODE_HAVE_SMALL_ICU

            " (note: linked-in ICU data is present)\n"

#endif

            ,

            &PerProcessOptions::icu_data_dir,

#endif

#if HAVE_OPENSSL

            "load OpenSSL configuration from the specified file "

            "(overrides OPENSSL_CONF)",

            &PerProcessOptions::openssl_config,

            "use an alternative default TLS cipher list",

            &PerProcessOptions::tls_cipher_list,

            "use OpenSSL's default CA store"

#if defined(NODE_OPENSSL_CERT_STORE)

            " (default)"

#endif

            ,

            &PerProcessOptions::use_openssl_ca,

            "use bundled CA store"

#if !defined(NODE_OPENSSL_CERT_STORE)

            " (default)"

#endif

            ,

            &PerProcessOptions::use_bundled_ca,

  // Similar to [has_eval_string] above, except that the separation between

  // this and use_openssl_ca only exists for option validation after parsing.

  // This is not ideal.

            "",

#if NODE_FIPS_MODE

  AddOption("--enable-fips",

            "enable FIPS crypto at startup",

            &PerProcessOptions::enable_fips_crypto,

            kAllowedInEnvironment);

  AddOption("--force-fips",

            "force FIPS crypto (cannot be disabled)",

            &PerProcessOptions::force_fips_crypto,

            kAllowedInEnvironment);

#endif

            "total size of the OpenSSL secure heap",

            &PerProcessOptions::secure_heap,

            "minimum allocation size from the OpenSSL secure heap",

            &PerProcessOptions::secure_heap_min,

#endif

            "Map the Node.js static code to large pages. Options are "

            "'off' (the default value, meaning do not map), "

            "'on' (map and ignore failure, reporting it to stderr), "

            "or 'silent' (map and silently ignore failure)",

            &PerProcessOptions::use_largepages,

            "enable printing JavaScript stacktrace on SIGINT",

            &PerProcessOptions::trace_sigint,

            "Run with extra debug checks for memory leaks in Node.js itself",

  else

}

                                std::vector<std::string>* errors) {

  char* endptr;

  const unsigned long result =                 // NOLINT(runtime/int)

  }

}

                      std::vector<std::string>* errors) {

  // remove_brackets only works if no port is specified

  // so if it has an effect only an IPv6 address was specified.

    // Either a port number or a host name.  Assume that

    // if it's not all decimal digits, it's a host name.

      }

    }

  }

  // Host and port found:

}

  out << "_node_complete() {\n"

         "  local cur_word options\n"

         "  cur_word=\"${COMP_WORDS[COMP_CWORD]}\"\n"

         "  if [[ \"${cur_word}\" == -* ]] ; then\n"

    }

  }

    }

  }

  }

  out << "' -- \"${cur_word}\") )\n"

         "    return 0\n"

         "  else\n"

         "    COMPREPLY=( $(compgen -f \"${cur_word}\") )\n"

         "    return 0\n"

         "  fi\n"

         "}\n"

         "complete -o filenames -o nospace -o bashdefault "

}

// Return a map containing all the options and their metadata as well

// as the aliases

    // No code because this is an assertion.

    return env->ThrowError(

  }

  // Temporarily act as if the current Environment's/IsolateData's options were

  // the default options, i.e. like they are the ones we'd access for global

  // options parsing, so that all options are available from the main parser.

          .IsNothing()) {

  }

    Local<Value> value;

      case kNoOp:

      case kV8Option:

        // Special case for --abort-on-uncaught-exception which is also

        // respected by Node.js internals

        } else {

        }

      case kBoolean:

      case kInteger:

            isolate,

      case kUInteger:

            isolate,

      case kString:

        }

      case kStringList:

        }

      case kHostPort: {

        const HostPort& host_port =

        Local<Value> host;