in src/main/cpp/startup_options.cc [211:408]
blaze_exit_code::ExitCode StartupOptions::ProcessArg(
const string &argstr, const string &next_argstr, const string &rcfile,
bool *is_space_separated, string *error) {
// We have to parse a specific option syntax, so GNU getopts won't do. All
// options begin with "--" or "-". Values are given together with the option
// delimited by '=' or in the next option.
const char* arg = argstr.c_str();
const char *next_arg = next_argstr.empty() ? nullptr : next_argstr.c_str();
const char *value = nullptr;
bool is_nullary;
if (!MaybeCheckValidNullary(argstr, &is_nullary, error)) {
*is_space_separated = false;
return blaze_exit_code::BAD_ARGV;
}
if (is_nullary) {
// 'enabled' is true if 'argstr' is "--foo", and false if it's "--nofoo".
bool enabled = (argstr.compare(0, 4, "--no") != 0);
if (no_rc_nullary_startup_flags_.find(argstr) !=
no_rc_nullary_startup_flags_.end()) {
// no_rc_nullary_startup_flags_ are forbidden in .bazelrc files.
if (!rcfile.empty()) {
*error = std::string("Can't specify ") + argstr + " in the " +
GetRcFileBaseName() + " file.";
return blaze_exit_code::BAD_ARGV;
}
}
if (special_nullary_startup_flags_.find(argstr) !=
special_nullary_startup_flags_.end()) {
// 'argstr' is either "--foo" or "--nofoo", and the map entry is the
// lambda that handles setting the flag's value.
special_nullary_startup_flags_[argstr](enabled);
} else {
// 'argstr' is either "--foo" or "--nofoo", and the map entry is the
// pointer to the bool storing the flag's value.
*all_nullary_startup_flags_[argstr] = enabled;
}
// Use the key "foo" for 'argstr' of "--foo" / "--nofoo", unless there's an
// overridden name we must use.
std::string key = argstr.substr(enabled ? 2 : 4);
if (option_sources_key_override_.find(key) !=
option_sources_key_override_.end()) {
key = option_sources_key_override_[key];
}
option_sources[key] = rcfile;
*is_space_separated = false;
return blaze_exit_code::SUCCESS;
}
if ((value = GetUnaryOption(arg, next_arg, "--output_base")) != nullptr) {
output_base = blaze_util::Path(blaze::AbsolutePathFromFlag(value));
option_sources["output_base"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--install_base")) !=
nullptr) {
install_base = blaze::AbsolutePathFromFlag(value);
option_sources["install_base"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--output_user_root")) !=
nullptr) {
output_user_root = blaze::AbsolutePathFromFlag(value);
option_sources["output_user_root"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--server_jvm_out")) !=
nullptr) {
server_jvm_out = blaze_util::Path(blaze::AbsolutePathFromFlag(value));
option_sources["server_jvm_out"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--failure_detail_out")) !=
nullptr) {
failure_detail_out = blaze_util::Path(blaze::AbsolutePathFromFlag(value));
option_sources["failure_detail_out"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--host_jvm_profile")) !=
nullptr) {
host_jvm_profile = value;
option_sources["host_jvm_profile"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--server_javabase")) !=
nullptr) {
// TODO(bazel-team): Consider examining the javabase and re-execing in case
// of architecture mismatch.
explicit_server_javabase_ =
blaze_util::Path(blaze::AbsolutePathFromFlag(value));
option_sources["server_javabase"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--host_jvm_args")) !=
nullptr) {
host_jvm_args.push_back(value);
option_sources["host_jvm_args"] = rcfile; // NB: This is incorrect
} else if ((value = GetUnaryOption(arg, next_arg, "--io_nice_level")) !=
nullptr) {
if (!blaze_util::safe_strto32(value, &io_nice_level) ||
io_nice_level > 7) {
blaze_util::StringPrintf(error,
"Invalid argument to --io_nice_level: '%s'. Must not exceed 7.",
value);
return blaze_exit_code::BAD_ARGV;
}
option_sources["io_nice_level"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--max_idle_secs")) !=
nullptr) {
if (!blaze_util::safe_strto32(value, &max_idle_secs) ||
max_idle_secs < 0) {
blaze_util::StringPrintf(error,
"Invalid argument to --max_idle_secs: '%s'.", value);
return blaze_exit_code::BAD_ARGV;
}
option_sources["max_idle_secs"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--macos_qos_class")) !=
nullptr) {
// We parse the value of this flag on all platforms even if it is
// macOS-specific to ensure that rc files mentioning it are valid.
// There is also apparently "QOS_CLASS_MAINTENANCE", but this doesn't
// appear to have been exposed in the public headers as of macOS 11.1.
if (strcmp(value, "utility") == 0) {
#if defined(__APPLE__)
macos_qos_class = QOS_CLASS_UTILITY;
#endif
} else if (strcmp(value, "background") == 0) {
#if defined(__APPLE__)
macos_qos_class = QOS_CLASS_BACKGROUND;
#endif
} else {
blaze_util::StringPrintf(
error, "Invalid argument to --macos_qos_class: '%s'.", value);
return blaze_exit_code::BAD_ARGV;
}
option_sources["macos_qos_class"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg,
"--connect_timeout_secs")) != nullptr) {
if (!blaze_util::safe_strto32(value, &connect_timeout_secs) ||
connect_timeout_secs < 1 || connect_timeout_secs > 3600) {
blaze_util::StringPrintf(
error,
"Invalid argument to --connect_timeout_secs: '%s'.\n"
"Must be an integer between 1 and 3600.\n",
value);
return blaze_exit_code::BAD_ARGV;
}
option_sources["connect_timeout_secs"] = rcfile;
} else if ((value = GetUnaryOption(
arg, next_arg, "--local_startup_timeout_secs")) != nullptr) {
if (!blaze_util::safe_strto32(value, &local_startup_timeout_secs) ||
local_startup_timeout_secs < 1) {
blaze_util::StringPrintf(
error,
"Invalid argument to --local_startup_timeout_secs: '%s'.\n"
"Must be a positive integer.\n",
value);
return blaze_exit_code::BAD_ARGV;
}
option_sources["local_startup_timeout_secs"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--digest_function")) !=
nullptr) {
digest_function = value;
option_sources["digest_function"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg,
"--unix_digest_hash_attribute_name")) !=
nullptr) {
unix_digest_hash_attribute_name = value;
option_sources["unix_digest_hash_attribute_name"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--command_port")) !=
nullptr) {
if (!blaze_util::safe_strto32(value, &command_port) ||
command_port < 0 || command_port > 65535) {
blaze_util::StringPrintf(error,
"Invalid argument to --command_port: '%s'.\n"
"Must be a valid port number or 0.\n",
value);
return blaze_exit_code::BAD_ARGV;
}
option_sources["command_port"] = rcfile;
} else if ((value = GetUnaryOption(arg, next_arg, "--invocation_policy")) !=
nullptr) {
if (!have_invocation_policy_) {
have_invocation_policy_ = true;
invocation_policy = value;
option_sources["invocation_policy"] = rcfile;
} else {
*error = "The startup flag --invocation_policy cannot be specified "
"multiple times.";
return blaze_exit_code::BAD_ARGV;
}
} else {
bool extra_argument_processed;
blaze_exit_code::ExitCode process_extra_arg_exit_code = ProcessArgExtra(
arg, next_arg, rcfile, &value, &extra_argument_processed, error);
if (process_extra_arg_exit_code != blaze_exit_code::SUCCESS) {
return process_extra_arg_exit_code;
}
if (!extra_argument_processed) {
blaze_util::StringPrintf(
error,
"Unknown startup option: '%s'.\n"
" For more info, run '%s help startup_options'.",
arg, GetLowercaseProductName().c_str());
return blaze_exit_code::BAD_ARGV;
}
}
*is_space_separated = ((value == next_arg) && (value != nullptr));
return blaze_exit_code::SUCCESS;
}