Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	node_options-inl.h	Lines:	200	206	97.1 %
Date:	2022-08-21 04:19:51	Branches:	126	141	89.4 %


#ifndef SRC_NODE_OPTIONS_INL_H_
#define SRC_NODE_OPTIONS_INL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include <cstdlib>
#include "node_options.h"
#include "util.h"

namespace node {

PerIsolateOptions* PerProcessOptions::get_per_isolate_options() {
  return per_isolate.get();
}

EnvironmentOptions* PerIsolateOptions::get_per_env_options() {
  return per_env.get();
}

namespace options_parser {

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       bool Options::* field,
                                       OptionEnvvarSettings env_setting,
                                       bool default_is_true) {
  options_.emplace(name,
                   OptionInfo{kBoolean,
                              std::make_shared<SimpleOptionField<bool>>(field),
                              env_setting,
                              help_text,
                              default_is_true});
}

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       uint64_t Options::* field,
                                       OptionEnvvarSettings env_setting) {
  options_.emplace(
      name,
      OptionInfo{kUInteger,
                 std::make_shared<SimpleOptionField<uint64_t>>(field),
                 env_setting,
                 help_text});
}

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       int64_t Options::* field,
                                       OptionEnvvarSettings env_setting) {
  options_.emplace(
      name,
      OptionInfo{kInteger,
                 std::make_shared<SimpleOptionField<int64_t>>(field),
                 env_setting,
                 help_text});
}

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       std::string Options::* field,
                                       OptionEnvvarSettings env_setting) {
  options_.emplace(
      name,
      OptionInfo{kString,
                 std::make_shared<SimpleOptionField<std::string>>(field),
                 env_setting,
                 help_text});
}

template <typename Options>
void OptionsParser<Options>::AddOption(
    const char* name,
    const char* help_text,
    std::vector<std::string> Options::* field,
    OptionEnvvarSettings env_setting) {
  options_.emplace(name, OptionInfo {
    kStringList,
    std::make_shared<SimpleOptionField<std::vector<std::string>>>(field),
    env_setting,
    help_text
  });
}

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       HostPort Options::* field,
                                       OptionEnvvarSettings env_setting) {
  options_.emplace(
      name,
      OptionInfo{kHostPort,
                 std::make_shared<SimpleOptionField<HostPort>>(field),
                 env_setting,
                 help_text});
}

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       NoOp no_op_tag,
                                       OptionEnvvarSettings env_setting) {
  options_.emplace(name, OptionInfo{kNoOp, nullptr, env_setting, help_text});
}

template <typename Options>
void OptionsParser<Options>::AddOption(const char* name,
                                       const char* help_text,
                                       V8Option v8_option_tag,
                                       OptionEnvvarSettings env_setting) {
  options_.emplace(name,
                   OptionInfo{kV8Option, nullptr, env_setting, help_text});
}

template <typename Options>
void OptionsParser<Options>::AddAlias(const char* from,
                                      const char* to) {
  aliases_[from] = { to };
}

template <typename Options>
void OptionsParser<Options>::AddAlias(const char* from,
                                      const std::vector<std::string>& to) {
  aliases_[from] = to;
}

template <typename Options>
void OptionsParser<Options>::AddAlias(
    const char* from,
    const std::initializer_list<std::string>& to) {
  AddAlias(from, std::vector<std::string>(to));
}

template <typename Options>
void OptionsParser<Options>::Implies(const char* from,
                                     const char* to) {
  auto it = options_.find(to);
  CHECK_NE(it, options_.end());
  CHECK(it->second.type == kBoolean || it->second.type == kV8Option);
  implications_.emplace(
      from, Implication{it->second.type, to, it->second.field, true});
}

template <typename Options>
void OptionsParser<Options>::ImpliesNot(const char* from,
                                        const char* to) {
  auto it = options_.find(to);
  CHECK_NE(it, options_.end());
  CHECK_EQ(it->second.type, kBoolean);
  implications_.emplace(
      from, Implication{it->second.type, to, it->second.field, false});
}

template <typename Options>
template <typename OriginalField, typename ChildOptions>
auto OptionsParser<Options>::Convert(
    std::shared_ptr<OriginalField> original,
    ChildOptions* (Options::* get_child)()) {
  // If we have a field on ChildOptions, and we want to access it from an
  // Options instance, we call get_child() on the original Options and then
  // access it, i.e. this class implements a kind of function chaining.
  struct AdaptedField : BaseOptionField {
    void* LookupImpl(Options* options) const override {
      return original->LookupImpl((options->*get_child)());
    }

    AdaptedField(
        std::shared_ptr<OriginalField> original,
        ChildOptions* (Options::* get_child)())
          : original(original), get_child(get_child) {}

    std::shared_ptr<OriginalField> original;
    ChildOptions* (Options::* get_child)();
  };

  return std::shared_ptr<BaseOptionField>(
      new AdaptedField(original, get_child));
}
template <typename Options>
template <typename ChildOptions>
auto OptionsParser<Options>::Convert(
    typename OptionsParser<ChildOptions>::OptionInfo original,
    ChildOptions* (Options::* get_child)()) {
  return OptionInfo{original.type,
                    Convert(original.field, get_child),
                    original.env_setting,
                    original.help_text,
                    original.default_is_true};
}

template <typename Options>
template <typename ChildOptions>
auto OptionsParser<Options>::Convert(
    typename OptionsParser<ChildOptions>::Implication original,
    ChildOptions* (Options::* get_child)()) {
  return Implication{
      original.type,
      original.name,
      Convert(original.target_field, get_child),
      original.target_value,
  };
}

template <typename Options>
template <typename ChildOptions>
void OptionsParser<Options>::Insert(
    const OptionsParser<ChildOptions>& child_options_parser,
    ChildOptions* (Options::* get_child)()) {
  aliases_.insert(std::begin(child_options_parser.aliases_),
                  std::end(child_options_parser.aliases_));

  for (const auto& pair : child_options_parser.options_)
    options_.emplace(pair.first, Convert(pair.second, get_child));

  for (const auto& pair : child_options_parser.implications_)
    implications_.emplace(pair.first, Convert(pair.second, get_child));
}

inline std::string NotAllowedInEnvErr(const std::string& arg) {
  return arg + " is not allowed in NODE_OPTIONS";
}

inline std::string RequiresArgumentErr(const std::string& arg) {
  return arg + " requires an argument";
}

inline std::string NegationImpliesBooleanError(const std::string& arg) {
  return arg + " is an invalid negation because it is not a boolean option";
}

// We store some of the basic information around a single Parse call inside
// this struct, to separate storage of command line arguments and their
// handling. In particular, this makes it easier to introduce 'synthetic'
// arguments that get inserted by expanding option aliases.
struct ArgsInfo {
  // Generally, the idea here is that the first entry in `*underlying` stores
  // the "0th" argument (the program name), then `synthetic_args` are inserted,
  // followed by the remainder of `*underlying`.
  std::vector<std::string>* underlying;
  std::vector<std::string> synthetic_args;

  std::vector<std::string>* exec_args;

  ArgsInfo(std::vector<std::string>* args,
           std::vector<std::string>* exec_args)
    : underlying(args), exec_args(exec_args) {}

  size_t remaining() const {
    // -1 to account for the program name.
    return underlying->size() - 1 + synthetic_args.size();
  }

  bool empty() const { return remaining() == 0; }
  const std::string& program_name() const { return underlying->at(0); }

  std::string& first() {
    return synthetic_args.empty() ? underlying->at(1) : synthetic_args.front();
  }

  std::string pop_first() {
    std::string ret = std::move(first());
    if (synthetic_args.empty()) {
      // Only push arguments to `exec_args` that were also originally passed
      // on the command line (i.e. not generated through alias expansion).
      // '--' is a special case here since its purpose is to end `exec_argv`,
      // which is why we do not include it.
      if (exec_args != nullptr && ret != "--")
        exec_args->push_back(ret);
      underlying->erase(underlying->begin() + 1);
    } else {
      synthetic_args.erase(synthetic_args.begin());
    }
    return ret;
  }
};

template <typename Options>
void OptionsParser<Options>::Parse(
    std::vector<std::string>* const orig_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 {
  ArgsInfo args(orig_args, exec_args);

  // The first entry is the process name. Make sure it ends up in the V8 argv,
  // since V8::SetFlagsFromCommandLine() expects that to hold true for that
  // array as well.
  if (v8_args->empty())
    v8_args->push_back(args.program_name());

  while (!args.empty() && errors->empty()) {
    if (args.first().size() <= 1 || args.first()[0] != '-') break;

    // We know that we're either going to consume this
    // argument or fail completely.
    const std::string arg = args.pop_first();

    if (arg == "--") {
      if (required_env_settings == kAllowedInEnvironment)
        errors->push_back(NotAllowedInEnvErr("--"));
      break;
    }

    // Only allow --foo=bar notation for options starting with double dashes.
    // (E.g. -e=a is not allowed as shorthand for --eval=a, which would
    // otherwise be the result of alias expansion.)
    const std::string::size_type equals_index =
        arg[0] == '-' && arg[1] == '-' ? arg.find('=') : std::string::npos;
    std::string name =
      equals_index == std::string::npos ? arg : arg.substr(0, equals_index);

    // Store the 'original name' of the argument. This name differs from
    // 'name' in that it contains a possible '=' sign and is not affected
    // by alias expansion.
    std::string original_name = name;
    if (equals_index != std::string::npos)
      original_name += '=';

    auto missing_argument = [&]() {
      errors->push_back(RequiresArgumentErr(original_name));
    };

    // Normalize by replacing `_` with `-` in options.
    for (std::string::size_type i = 2; i < name.size(); ++i) {
      if (name[i] == '_')
        name[i] = '-';
    }

    // Convert --no-foo to --foo and keep in mind that we're negating.
    bool is_negation = false;
    if (name.find("--no-") == 0) {
      name.erase(2, 3);  // remove no-
      is_negation = true;
    }

    {
      auto it = aliases_.end();
      // Expand aliases:
      // - If `name` can be found in `aliases_`.
      // - If `name` + '=' can be found in `aliases_`.
      // - If `name` + " <arg>" can be found in `aliases_`, and we have
      //   a subsequent argument that does not start with '-' itself.
      while ((it = aliases_.find(name)) != aliases_.end() ||
             (equals_index != std::string::npos &&
              (it = aliases_.find(name + '=')) != aliases_.end()) ||
             (!args.empty() &&
                 !args.first().empty() &&
                 args.first()[0] != '-' &&
              (it = aliases_.find(name + " <arg>")) != aliases_.end())) {
        const std::string prev_name = std::move(name);
        const std::vector<std::string>& expansion = it->second;

        // Use the first entry in the expansion as the new 'name'.
        name = expansion.front();

        if (expansion.size() > 1) {
          // The other arguments, if any, are going to be handled later.
          args.synthetic_args.insert(
              args.synthetic_args.begin(),
              expansion.begin() + 1,
              expansion.end());
        }

        if (name == prev_name) break;
      }
    }

    auto it = options_.find(name);

    if ((it == options_.end() ||
         it->second.env_setting == kDisallowedInEnvironment) &&
        required_env_settings == kAllowedInEnvironment) {
      errors->push_back(NotAllowedInEnvErr(original_name));
      break;
    }

    {
      std::string implied_name = name;
      if (is_negation) {
        // Implications for negated options are defined with "--no-".
        implied_name.insert(2, "no-");
      }
      auto implications = implications_.equal_range(implied_name);
      for (auto it = implications.first; it != implications.second; ++it) {
        if (it->second.type == kV8Option) {
          v8_args->push_back(it->second.name);
        } else {
          *it->second.target_field->template Lookup<bool>(options) =
              it->second.target_value;
        }
      }
    }

    if (it == options_.end()) {
      v8_args->push_back(arg);
      continue;
    }

    const OptionInfo& info = it->second;

    // Some V8 options can be negated and they are validated by V8 later.
    if (is_negation && info.type != kBoolean && info.type != kV8Option) {
      errors->push_back(NegationImpliesBooleanError(arg));
      break;
    }

    std::string value;
    if (info.type != kBoolean && info.type != kNoOp && info.type != kV8Option) {
      if (equals_index != std::string::npos) {
        value = arg.substr(equals_index + 1);
        if (value.empty()) {
          missing_argument();
          break;
        }
      } else {
        if (args.empty()) {
          missing_argument();
          break;
        }

        value = args.pop_first();

        if (!value.empty() && value[0] == '-') {
          missing_argument();
          break;
        } else {
          if (!value.empty() && value[0] == '\\' && value[1] == '-')
            value = value.substr(1);  // Treat \- as escaping an -.
        }
      }
    }

    switch (info.type) {
      case kBoolean:
        *Lookup<bool>(info.field, options) = !is_negation;
        break;
      case kInteger:
        *Lookup<int64_t>(info.field, options) = std::atoll(value.c_str());
        break;
      case kUInteger:
        *Lookup<uint64_t>(info.field, options) = std::stoull(value);
        break;
      case kString:
        *Lookup<std::string>(info.field, options) = value;
        break;
      case kStringList:
        Lookup<std::vector<std::string>>(info.field, options)
            ->emplace_back(std::move(value));
        break;
      case kHostPort:
        Lookup<HostPort>(info.field, options)
            ->Update(SplitHostPort(value, errors));
        break;
      case kNoOp:
        break;
      case kV8Option:
        v8_args->push_back(arg);
        break;
      default:
        UNREACHABLE();
    }
  }
  options->CheckOptions(errors);
}

}  // namespace options_parser
}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_NODE_OPTIONS_INL_H_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#ifndef SRC_NODE_OPTIONS_INL_H_
2			#define SRC_NODE_OPTIONS_INL_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include <cstdlib>
7			#include "node_options.h"
8			#include "util.h"
9
10			namespace node {
11
12		590390	PerIsolateOptions* PerProcessOptions::get_per_isolate_options() {
13		590390	return per_isolate.get();
14			}
15
16		550898	EnvironmentOptions* PerIsolateOptions::get_per_env_options() {
17		550898	return per_env.get();
18			}
19
20			namespace options_parser {
21
22			template <typename Options>
23		846924	void OptionsParser<Options>::AddOption(const char* name,
24			const char* help_text,
25			bool Options::* field,
26			OptionEnvvarSettings env_setting,
27			bool default_is_true) {
28		846924	options_.emplace(name,
29			OptionInfo{kBoolean,
30			std::make_shared<SimpleOptionField<bool>>(field),
31			env_setting,
32			help_text,
33			default_is_true});
34		846924	}
35
36			template <typename Options>
37		16287	void OptionsParser<Options>::AddOption(const char* name,
38			const char* help_text,
39			uint64_t Options::* field,
40			OptionEnvvarSettings env_setting) {
41		16287	options_.emplace(
42			name,
43			OptionInfo{kUInteger,
44			std::make_shared<SimpleOptionField<uint64_t>>(field),
45			env_setting,
46			help_text});
47		16287	}
48
49			template <typename Options>
50		43432	void OptionsParser<Options>::AddOption(const char* name,
51			const char* help_text,
52			int64_t Options::* field,
53			OptionEnvvarSettings env_setting) {
54		43432	options_.emplace(
55			name,
56			OptionInfo{kInteger,
57			std::make_shared<SimpleOptionField<int64_t>>(field),
58			env_setting,
59			help_text});
60		43432	}
61
62			template <typename Options>
63		304024	void OptionsParser<Options>::AddOption(const char* name,
64			const char* help_text,
65			std::string Options::* field,
66			OptionEnvvarSettings env_setting) {
67		304024	options_.emplace(
68			name,
69			OptionInfo{kString,
70			std::make_shared<SimpleOptionField<std::string>>(field),
71			env_setting,
72			help_text});
73		304024	}
74
75			template <typename Options>
76		54290	void OptionsParser<Options>::AddOption(
77			const char* name,
78			const char* help_text,
79			std::vector<std::string> Options::* field,
80			OptionEnvvarSettings env_setting) {
81		54290	options_.emplace(name, OptionInfo {
82			kStringList,
83			std::make_shared<SimpleOptionField<std::vector<std::string>>>(field),
84			env_setting,
85			help_text
86			});
87		54290	}
88
89			template <typename Options>
90		5429	void OptionsParser<Options>::AddOption(const char* name,
91			const char* help_text,
92			HostPort Options::* field,
93			OptionEnvvarSettings env_setting) {
94		5429	options_.emplace(
95			name,
96			OptionInfo{kHostPort,
97			std::make_shared<SimpleOptionField<HostPort>>(field),
98			env_setting,
99			help_text});
100		5429	}
101
102			template <typename Options>
103		97722	void OptionsParser<Options>::AddOption(const char* name,
104			const char* help_text,
105			NoOp no_op_tag,
106			OptionEnvvarSettings env_setting) {
107		97722	options_.emplace(name, OptionInfo{kNoOp, nullptr, env_setting, help_text});
108		97722	}
109
110			template <typename Options>
111		141154	void OptionsParser<Options>::AddOption(const char* name,
112			const char* help_text,
113			V8Option v8_option_tag,
114			OptionEnvvarSettings env_setting) {
115		141154	options_.emplace(name,
116			OptionInfo{kV8Option, nullptr, env_setting, help_text});
117		141154	}
118
119			template <typename Options>
120		173728	void OptionsParser<Options>::AddAlias(const char* from,
121			const char* to) {
122	✓✓	347456	aliases_[from] = { to };
123		173728	}
124
125			template <typename Options>
126		65148	void OptionsParser<Options>::AddAlias(const char* from,
127			const std::vector<std::string>& to) {
128		65148	aliases_[from] = to;
129		65148	}
130
131			template <typename Options>
132		65148	void OptionsParser<Options>::AddAlias(
133			const char* from,
134			const std::initializer_list<std::string>& to) {
135		65148	AddAlias(from, std::vector<std::string>(to));
136		65148	}
137
138			template <typename Options>
139		108580	void OptionsParser<Options>::Implies(const char* from,
140			const char* to) {
141		108580	auto it = options_.find(to);
142	✗✓	108580	CHECK_NE(it, options_.end());
143	✓✓✗✓ ✗✓	108580	CHECK(it->second.type == kBoolean \|\| it->second.type == kV8Option);
144		217160	implications_.emplace(
145		217160	from, Implication{it->second.type, to, it->second.field, true});
146		108580	}
147
148			template <typename Options>
149		21716	void OptionsParser<Options>::ImpliesNot(const char* from,
150			const char* to) {
151		21716	auto it = options_.find(to);
152	✗✓	21716	CHECK_NE(it, options_.end());
153	✗✓	21716	CHECK_EQ(it->second.type, kBoolean);
154		43432	implications_.emplace(
155		43432	from, Implication{it->second.type, to, it->second.field, false});
156		21716	}
157
158			template <typename Options>
159			template <typename OriginalField, typename ChildOptions>
160		2356186	auto OptionsParser<Options>::Convert(
161			std::shared_ptr<OriginalField> original,
162			ChildOptions* (Options::* get_child)()) {
163			// If we have a field on ChildOptions, and we want to access it from an
164			// Options instance, we call get_child() on the original Options and then
165			// access it, i.e. this class implements a kind of function chaining.
166			struct AdaptedField : BaseOptionField {
167		1169900	void* LookupImpl(Options* options) const override {
168		1169900	return original->LookupImpl((options->*get_child)());
169			}
170
171		1178093	AdaptedField(
172			std::shared_ptr<OriginalField> original,
173			ChildOptions* (Options::* get_child)())
174		1178093	: original(original), get_child(get_child) {}
175
176			std::shared_ptr<OriginalField> original;
177			ChildOptions* (Options::* get_child)();
178			};
179
180			return std::shared_ptr<BaseOptionField>(
181		2356186	new AdaptedField(original, get_child));
182			}
183			template <typename Options>
184			template <typename ChildOptions>
185		2204174	auto OptionsParser<Options>::Convert(
186			typename OptionsParser<ChildOptions>::OptionInfo original,
187			ChildOptions* (Options::* get_child)()) {
188		2204174	return OptionInfo{original.type,
189		2204174	Convert(original.field, get_child),
190		2204174	original.env_setting,
191		2204174	original.help_text,
192		2204174	original.default_is_true};
193			}
194
195			template <typename Options>
196			template <typename ChildOptions>
197		152012	auto OptionsParser<Options>::Convert(
198			typename OptionsParser<ChildOptions>::Implication original,
199			ChildOptions* (Options::* get_child)()) {
200			return Implication{
201		152012	original.type,
202		152012	original.name,
203		152012	Convert(original.target_field, get_child),
204		152012	original.target_value,
205		152012	};
206			}
207
208			template <typename Options>
209			template <typename ChildOptions>
210		32574	void OptionsParser<Options>::Insert(
211			const OptionsParser<ChildOptions>& child_options_parser,
212			ChildOptions* (Options::* get_child)()) {
213		32574	aliases_.insert(std::begin(child_options_parser.aliases_),
214		32574	std::end(child_options_parser.aliases_));
215
216	✓✓	2236748	for (const auto& pair : child_options_parser.options_)
217		2204174	options_.emplace(pair.first, Convert(pair.second, get_child));
218
219	✓✓	184586	for (const auto& pair : child_options_parser.implications_)
220		152012	implications_.emplace(pair.first, Convert(pair.second, get_child));
221		32574	}
222
223		18	inline std::string NotAllowedInEnvErr(const std::string& arg) {
224		18	return arg + " is not allowed in NODE_OPTIONS";
225			}
226
227		7	inline std::string RequiresArgumentErr(const std::string& arg) {
228		7	return arg + " requires an argument";
229			}
230
231		1	inline std::string NegationImpliesBooleanError(const std::string& arg) {
232		1	return arg + " is an invalid negation because it is not a boolean option";
233			}
234
235			// We store some of the basic information around a single Parse call inside
236			// this struct, to separate storage of command line arguments and their
237			// handling. In particular, this makes it easier to introduce 'synthetic'
238			// arguments that get inserted by expanding option aliases.
239			struct ArgsInfo {
240			// Generally, the idea here is that the first entry in `*underlying` stores
241			// the "0th" argument (the program name), then `synthetic_args` are inserted,
242			// followed by the remainder of `*underlying`.
243			std::vector<std::string>* underlying;
244			std::vector<std::string> synthetic_args;
245
246			std::vector<std::string>* exec_args;
247
248		11303	ArgsInfo(std::vector<std::string>* args,
249			std::vector<std::string>* exec_args)
250		11303	: underlying(args), exec_args(exec_args) {}
251
252		17058	size_t remaining() const {
253			// -1 to account for the program name.
254		17058	return underlying->size() - 1 + synthetic_args.size();
255			}
256
257		17058	bool empty() const { return remaining() == 0; }
258		11303	const std::string& program_name() const { return underlying->at(0); }
259
260		22404	std::string& first() {
261	✓✓	22404	return synthetic_args.empty() ? underlying->at(1) : synthetic_args.front();
262			}
263
264		3279	std::string pop_first() {
265		3279	std::string ret = std::move(first());
266	✓✓	3279	if (synthetic_args.empty()) {
267			// Only push arguments to `exec_args` that were also originally passed
268			// on the command line (i.e. not generated through alias expansion).
269			// '--' is a special case here since its purpose is to end `exec_argv`,
270			// which is why we do not include it.
271	✓✓✓✓ ✓✓	3076	if (exec_args != nullptr && ret != "--")
272		2954	exec_args->push_back(ret);
273		3076	underlying->erase(underlying->begin() + 1);
274			} else {
275		203	synthetic_args.erase(synthetic_args.begin());
276			}
277		3279	return ret;
278			}
279			};
280
281			template <typename Options>
282		22606	void OptionsParser<Options>::Parse(
283			std::vector<std::string>* const orig_args,
284			std::vector<std::string>* const exec_args,
285			std::vector<std::string>* const v8_args,
286			Options* const options,
287			OptionEnvvarSettings required_env_settings,
288			std::vector<std::string>* const errors) const {
289		45212	ArgsInfo args(orig_args, exec_args);
290
291			// The first entry is the process name. Make sure it ends up in the V8 argv,
292			// since V8::SetFlagsFromCommandLine() expects that to hold true for that
293			// array as well.
294	✓✗	22606	if (v8_args->empty())
295		22606	v8_args->push_back(args.program_name());
296
297	✓✓✓✗ ✓✓	27424	while (!args.empty() && errors->empty()) {
298	✓✓✓✓ ✓✓	14694	if (args.first().size() <= 1 \|\| args.first()[0] != '-') break;
299
300			// We know that we're either going to consume this
301			// argument or fail completely.
302		4900	const std::string arg = args.pop_first();
303
304	✓✓	4900	if (arg == "--") {
305	✓✓	32	if (required_env_settings == kAllowedInEnvironment)
306		2	errors->push_back(NotAllowedInEnvErr("--"));
307		32	break;
308			}
309
310			// Only allow --foo=bar notation for options starting with double dashes.
311			// (E.g. -e=a is not allowed as shorthand for --eval=a, which would
312			// otherwise be the result of alias expansion.)
313		4868	const std::string::size_type equals_index =
314	✓✗✓✓	4868	arg[0] == '-' && arg[1] == '-' ? arg.find('=') : std::string::npos;
315	✓✓	4868	std::string name =
316			equals_index == std::string::npos ? arg : arg.substr(0, equals_index);
317
318			// Store the 'original name' of the argument. This name differs from
319			// 'name' in that it contains a possible '=' sign and is not affected
320			// by alias expansion.
321		4868	std::string original_name = name;
322	✓✓	4868	if (equals_index != std::string::npos)
323		470	original_name += '=';
324
325		4889	auto missing_argument = [&]() {
326		7	errors->push_back(RequiresArgumentErr(original_name));
327			};
328
329			// Normalize by replacing `_` with `-` in options.
330	✓✓	58820	for (std::string::size_type i = 2; i < name.size(); ++i) {
331	✓✓	53952	if (name[i] == '_')
332		78	name[i] = '-';
333			}
334
335			// Convert --no-foo to --foo and keep in mind that we're negating.
336		4868	bool is_negation = false;
337	✓✓	4868	if (name.find("--no-") == 0) {
338		336	name.erase(2, 3); // remove no-
339		336	is_negation = true;
340			}
341
342			{
343		4868	auto it = aliases_.end();
344			// Expand aliases:
345			// - If `name` can be found in `aliases_`.
346			// - If `name` + '=' can be found in `aliases_`.
347			// - If `name` + " <arg>" can be found in `aliases_`, and we have
348			// a subsequent argument that does not start with '-' itself.
349	✓✓	13372	while ((it = aliases_.find(name)) != aliases_.end() \|\|
350	✓✓	596	(equals_index != std::string::npos &&
351	✓✓✓✓	25380	(it = aliases_.find(name + '=')) != aliases_.end()) \|\|
352	✓✓	5024	(!args.empty() &&
353	✓✓	4518	!args.first().empty() &&
354	✓✓✓✓	7840	args.first()[0] != '-' &&
355	✓✓✓✓	9870	(it = aliases_.find(name + " <arg>")) != aliases_.end())) {
356		1680	const std::string prev_name = std::move(name);
357		1680	const std::vector<std::string>& expansion = it->second;
358
359			// Use the first entry in the expansion as the new 'name'.
360		1680	name = expansion.front();
361
362	✓✓	1680	if (expansion.size() > 1) {
363			// The other arguments, if any, are going to be handled later.
364		1224	args.synthetic_args.insert(
365		408	args.synthetic_args.begin(),
366		816	expansion.begin() + 1,
367			expansion.end());
368			}
369
370	✓✓	1680	if (name == prev_name) break;
371			}
372			}
373
374		4868	auto it = options_.find(name);
375
376		4868	if ((it == options_.end() \|\|
377	✓✓✓✓ ✓✓✓✓	4868	it->second.env_setting == kDisallowedInEnvironment) &&
378			required_env_settings == kAllowedInEnvironment) {
379		34	errors->push_back(NotAllowedInEnvErr(original_name));
380		34	break;
381			}
382
383			{
384		9668	std::string implied_name = name;
385	✓✓	4834	if (is_negation) {
386			// Implications for negated options are defined with "--no-".
387		336	implied_name.insert(2, "no-");
388			}
389		4834	auto implications = implications_.equal_range(implied_name);
390	✓✓	5868	for (auto it = implications.first; it != implications.second; ++it) {
391	✓✓	1034	if (it->second.type == kV8Option) {
392		2	v8_args->push_back(it->second.name);
393			} else {
394		1032	*it->second.target_field->template Lookup<bool>(options) =
395		1032	it->second.target_value;
396			}
397			}
398			}
399
400	✓✓	4834	if (it == options_.end()) {
401		212	v8_args->push_back(arg);
402		212	continue;
403			}
404
405		4622	const OptionInfo& info = it->second;
406
407			// Some V8 options can be negated and they are validated by V8 later.
408	✓✓✓✓ ✓✗	4622	if (is_negation && info.type != kBoolean && info.type != kV8Option) {
409		2	errors->push_back(NegationImpliesBooleanError(arg));
410		2	break;
411			}
412
413		4620	std::string value;
414	✓✓✓✗ ✓✓	4620	if (info.type != kBoolean && info.type != kNoOp && info.type != kV8Option) {
415	✓✓	2110	if (equals_index != std::string::npos) {
416		442	value = arg.substr(equals_index + 1);
417	✓✓	442	if (value.empty()) {
418		4	missing_argument();
419		4	break;
420			}
421			} else {
422	✓✓	1668	if (args.empty()) {
423		10	missing_argument();
424		10	break;
425			}
426
427		1658	value = args.pop_first();
428
429	✓✓✗✓ ✗✓	1658	if (!value.empty() && value[0] == '-') {
430			missing_argument();
431			break;
432			} else {
433	✓✓✓✓ ✓✗✓✓	1658	if (!value.empty() && value[0] == '\\' && value[1] == '-')
434		2	value = value.substr(1); // Treat \- as escaping an -.
435			}
436			}
437			}
438
439	✓✓✓✓ ✓✓✗✓ ✗	4606	switch (info.type) {
440		2420	case kBoolean:
441		2420	*Lookup<bool>(info.field, options) = !is_negation;
442		2420	break;
443		12	case kInteger:
444		12	*Lookup<int64_t>(info.field, options) = std::atoll(value.c_str());
445		12	break;
446		62	case kUInteger:
447		62	*Lookup<uint64_t>(info.field, options) = std::stoull(value);
448		62	break;
449		1496	case kString:
450		1496	*Lookup<std::string>(info.field, options) = value;
451		1496	break;
452		326	case kStringList:
453		652	Lookup<std::vector<std::string>>(info.field, options)
454		326	->emplace_back(std::move(value));
455		326	break;
456		200	case kHostPort:
457		200	Lookup<HostPort>(info.field, options)
458			->Update(SplitHostPort(value, errors));
459		200	break;
460			case kNoOp:
461			break;
462		90	case kV8Option:
463		90	v8_args->push_back(arg);
464		90	break;
465			default:
466			UNREACHABLE();
467			}
468			}
469		22606	options->CheckOptions(errors);
470			}
471
472			} // namespace options_parser
473			} // namespace node
474
475			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
476
477			#endif // SRC_NODE_OPTIONS_INL_H_