mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-22 23:50:19 +00:00
98260c5862
Without these attributes present on these custom formatting functions, Clang would warn use about nonliteral format strings. As an added bonus, we now get type checking on these.
350 lines
10 KiB
C++
350 lines
10 KiB
C++
/*
|
|
* Copyright (c) 2020, Sergey Bugaev <bugaevc@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/StringView.h>
|
|
#include <AK/Vector.h>
|
|
#include <getopt.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
int opterr = 1;
|
|
int optopt = 0;
|
|
int optind = 1;
|
|
int optreset = 0;
|
|
char* optarg = nullptr;
|
|
|
|
// POSIX says, "When an element of argv[] contains multiple option characters,
|
|
// it is unspecified how getopt() determines which options have already been
|
|
// processed". Well, this is how we do it.
|
|
static size_t s_index_into_multioption_argument = 0;
|
|
|
|
[[gnu::format(printf, 1, 2)]] static inline void report_error(const char* format, ...)
|
|
{
|
|
if (!opterr)
|
|
return;
|
|
|
|
fputs("\033[31m", stderr);
|
|
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
vfprintf(stderr, format, ap);
|
|
va_end(ap);
|
|
|
|
fputs("\033[0m\n", stderr);
|
|
}
|
|
|
|
namespace {
|
|
|
|
class OptionParser {
|
|
public:
|
|
OptionParser(int argc, char* const* argv, const StringView& short_options, const option* long_options, int* out_long_option_index = nullptr);
|
|
int getopt();
|
|
|
|
private:
|
|
bool lookup_short_option(char option, int& needs_value) const;
|
|
int handle_short_option();
|
|
|
|
const option* lookup_long_option(char* raw) const;
|
|
int handle_long_option();
|
|
|
|
void shift_argv();
|
|
bool find_next_option();
|
|
|
|
size_t m_argc { 0 };
|
|
char* const* m_argv { nullptr };
|
|
StringView m_short_options;
|
|
const option* m_long_options { nullptr };
|
|
int* m_out_long_option_index { nullptr };
|
|
bool m_stop_on_first_non_option { false };
|
|
|
|
size_t m_arg_index { 0 };
|
|
size_t m_consumed_args { 0 };
|
|
};
|
|
|
|
OptionParser::OptionParser(int argc, char* const* argv, const StringView& short_options, const option* long_options, int* out_long_option_index)
|
|
: m_argc(argc)
|
|
, m_argv(argv)
|
|
, m_short_options(short_options)
|
|
, m_long_options(long_options)
|
|
, m_out_long_option_index(out_long_option_index)
|
|
{
|
|
// In the following case:
|
|
// $ foo bar -o baz
|
|
// we want to parse the option (-o baz) first, and leave the argument (bar)
|
|
// in argv after we return -1 when invoked the second time. So we reorder
|
|
// argv to put options first and positional arguments next. To turn this
|
|
// behavior off, start the short options spec with a "+". This is a GNU
|
|
// extension that we support.
|
|
m_stop_on_first_non_option = short_options.starts_with('+');
|
|
|
|
// See if we should reset the internal state.
|
|
if (optreset || optind == 0) {
|
|
optreset = 0;
|
|
optind = 1;
|
|
s_index_into_multioption_argument = 0;
|
|
}
|
|
|
|
optopt = 0;
|
|
optarg = nullptr;
|
|
}
|
|
|
|
int OptionParser::getopt()
|
|
{
|
|
bool should_reorder_argv = !m_stop_on_first_non_option;
|
|
int res = -1;
|
|
|
|
bool found_an_option = find_next_option();
|
|
StringView arg = m_argv[m_arg_index];
|
|
|
|
if (!found_an_option) {
|
|
res = -1;
|
|
if (arg == "--")
|
|
m_consumed_args = 1;
|
|
else
|
|
m_consumed_args = 0;
|
|
} else {
|
|
// Alright, so we have an option on our hands!
|
|
bool is_long_option = arg.starts_with("--");
|
|
if (is_long_option)
|
|
res = handle_long_option();
|
|
else
|
|
res = handle_short_option();
|
|
|
|
// If we encountered an error, return immediately.
|
|
if (res == '?')
|
|
return '?';
|
|
}
|
|
|
|
if (should_reorder_argv)
|
|
shift_argv();
|
|
else
|
|
VERIFY(optind == static_cast<int>(m_arg_index));
|
|
optind += m_consumed_args;
|
|
|
|
return res;
|
|
}
|
|
|
|
bool OptionParser::lookup_short_option(char option, int& needs_value) const
|
|
{
|
|
Vector<StringView> parts = m_short_options.split_view(option, true);
|
|
|
|
VERIFY(parts.size() <= 2);
|
|
if (parts.size() < 2) {
|
|
// Haven't found the option in the spec.
|
|
return false;
|
|
}
|
|
|
|
if (parts[1].starts_with("::")) {
|
|
// If an option is followed by two colons, it optionally accepts an
|
|
// argument.
|
|
needs_value = optional_argument;
|
|
} else if (parts[1].starts_with(':')) {
|
|
// If it's followed by one colon, it requires an argument.
|
|
needs_value = required_argument;
|
|
} else {
|
|
// Otherwise, it doesn't accept arguments.
|
|
needs_value = no_argument;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int OptionParser::handle_short_option()
|
|
{
|
|
StringView arg = m_argv[m_arg_index];
|
|
VERIFY(arg.starts_with('-'));
|
|
|
|
if (s_index_into_multioption_argument == 0) {
|
|
// Just starting to parse this argument, skip the "-".
|
|
s_index_into_multioption_argument = 1;
|
|
}
|
|
char option = arg[s_index_into_multioption_argument];
|
|
s_index_into_multioption_argument++;
|
|
|
|
int needs_value = no_argument;
|
|
bool ok = lookup_short_option(option, needs_value);
|
|
if (!ok) {
|
|
optopt = option;
|
|
report_error("Unrecognized option \033[1m-%c\033[22m", option);
|
|
return '?';
|
|
}
|
|
|
|
// Let's see if we're at the end of this argument already.
|
|
if (s_index_into_multioption_argument < arg.length()) {
|
|
// This not yet the end.
|
|
if (needs_value == no_argument) {
|
|
optarg = nullptr;
|
|
m_consumed_args = 0;
|
|
} else {
|
|
// Treat the rest of the argument as the value, the "-ovalue"
|
|
// syntax.
|
|
optarg = m_argv[m_arg_index] + s_index_into_multioption_argument;
|
|
// Next time, process the next argument.
|
|
s_index_into_multioption_argument = 0;
|
|
m_consumed_args = 1;
|
|
}
|
|
} else {
|
|
s_index_into_multioption_argument = 0;
|
|
if (needs_value != required_argument) {
|
|
optarg = nullptr;
|
|
m_consumed_args = 1;
|
|
} else if (m_arg_index + 1 < m_argc) {
|
|
// Treat the next argument as a value, the "-o value" syntax.
|
|
optarg = m_argv[m_arg_index + 1];
|
|
m_consumed_args = 2;
|
|
} else {
|
|
report_error("Missing value for option \033[1m-%c\033[22m", option);
|
|
return '?';
|
|
}
|
|
}
|
|
|
|
return option;
|
|
}
|
|
|
|
const option* OptionParser::lookup_long_option(char* raw) const
|
|
{
|
|
StringView arg = raw;
|
|
|
|
for (size_t index = 0; m_long_options[index].name; index++) {
|
|
auto& option = m_long_options[index];
|
|
StringView name = option.name;
|
|
|
|
if (!arg.starts_with(name))
|
|
continue;
|
|
|
|
// It would be better to not write out the index at all unless we're
|
|
// sure we've found the right option, but whatever.
|
|
if (m_out_long_option_index)
|
|
*m_out_long_option_index = index;
|
|
|
|
// Can either be "--option" or "--option=value".
|
|
if (arg.length() == name.length()) {
|
|
optarg = nullptr;
|
|
return &option;
|
|
}
|
|
VERIFY(arg.length() > name.length());
|
|
if (arg[name.length()] == '=') {
|
|
optarg = raw + name.length() + 1;
|
|
return &option;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
int OptionParser::handle_long_option()
|
|
{
|
|
VERIFY(StringView(m_argv[m_arg_index]).starts_with("--"));
|
|
|
|
// We cannot set optopt to anything sensible for long options, so set it to 0.
|
|
optopt = 0;
|
|
|
|
auto* option = lookup_long_option(m_argv[m_arg_index] + 2);
|
|
if (!option) {
|
|
report_error("Unrecognized option \033[1m%s\033[22m", m_argv[m_arg_index]);
|
|
return '?';
|
|
}
|
|
// lookup_long_option() will also set optarg if the value of the option is
|
|
// specified using "--option=value" syntax.
|
|
|
|
// Figure out whether this option needs and/or has a value (also called "an
|
|
// argument", but let's not call it that to distinguish it from argv
|
|
// elements).
|
|
switch (option->has_arg) {
|
|
case no_argument:
|
|
if (optarg) {
|
|
report_error("Option \033[1m--%s\033[22m doesn't accept an argument", option->name);
|
|
return '?';
|
|
}
|
|
m_consumed_args = 1;
|
|
break;
|
|
case optional_argument:
|
|
m_consumed_args = 1;
|
|
break;
|
|
case required_argument:
|
|
if (optarg) {
|
|
// Value specified using "--option=value" syntax.
|
|
m_consumed_args = 1;
|
|
} else if (m_arg_index + 1 < m_argc) {
|
|
// Treat the next argument as a value in "--option value" syntax.
|
|
optarg = m_argv[m_arg_index + 1];
|
|
m_consumed_args = 2;
|
|
} else {
|
|
report_error("Missing value for option \033[1m--%s\033[22m", option->name);
|
|
return '?';
|
|
}
|
|
break;
|
|
default:
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
// Now that we've figured the value out, see about reporting this option to
|
|
// our caller.
|
|
if (option->flag) {
|
|
*option->flag = option->val;
|
|
return 0;
|
|
}
|
|
return option->val;
|
|
}
|
|
|
|
void OptionParser::shift_argv()
|
|
{
|
|
// We've just parsed an option (which perhaps has a value).
|
|
// Put the option (along with it value, if any) in front of other arguments.
|
|
VERIFY(optind <= static_cast<int>(m_arg_index));
|
|
|
|
if (optind == static_cast<int>(m_arg_index) || m_consumed_args == 0) {
|
|
// Nothing to do!
|
|
return;
|
|
}
|
|
|
|
auto new_argv = const_cast<char**>(m_argv);
|
|
char* buffer[m_consumed_args];
|
|
memcpy(buffer, &new_argv[m_arg_index], sizeof(char*) * m_consumed_args);
|
|
memmove(&new_argv[optind + m_consumed_args], &new_argv[optind], sizeof(char*) * (m_arg_index - optind));
|
|
memcpy(&new_argv[optind], buffer, sizeof(char*) * m_consumed_args);
|
|
}
|
|
|
|
bool OptionParser::find_next_option()
|
|
{
|
|
for (m_arg_index = optind; m_arg_index < m_argc && m_argv[m_arg_index]; m_arg_index++) {
|
|
StringView arg = m_argv[m_arg_index];
|
|
// Anything that doesn't start with a "-" is not an option.
|
|
if (!arg.starts_with('-')) {
|
|
if (m_stop_on_first_non_option)
|
|
return false;
|
|
continue;
|
|
}
|
|
// As a special case, a single "-" is not an option either.
|
|
// (It's typically used by programs to refer to stdin).
|
|
if (arg == "-")
|
|
continue;
|
|
// As another special case, a "--" is not an option either, and we stop
|
|
// looking for further options if we encounter it.
|
|
if (arg == "--")
|
|
return false;
|
|
// Otherwise, we have found an option!
|
|
return true;
|
|
}
|
|
|
|
// Reached the end and still found no options.
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
int getopt(int argc, char* const* argv, const char* short_options)
|
|
{
|
|
option dummy { nullptr, 0, nullptr, 0 };
|
|
OptionParser parser { argc, argv, short_options, &dummy };
|
|
return parser.getopt();
|
|
}
|
|
|
|
int getopt_long(int argc, char* const* argv, const char* short_options, const struct option* long_options, int* out_long_option_index)
|
|
{
|
|
OptionParser parser { argc, argv, short_options, long_options, out_long_option_index };
|
|
return parser.getopt();
|
|
}
|