cam: Extract option parser to separate file

And turn it into an OptionsParser object.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Signed-off-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>

1 files changed, 192 insertions, 0 deletions

diff --git a/src/cam/options.cpp b/src/cam/options.cpp
new file mode 100644
index 00000000..d391a0e5
--- /dev/null
+++ b/src/cam/options.cpp
@@ -0,0 +1,192 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2019, Google Inc.
+ *
+ * options.cpp - cam - Options parsing
+ */
+
+#include <getopt.h>
+#include <iomanip>
+#include <iostream>
+#include <string.h>
+
+#include "options.h"
+
+void OptionsParser::addOption(int opt, const char *help, const char *name,
+			      OptionArgument argument, const char *argumentName)
+{
+	/*
+	 * Options must have at least a short or long name, and a text message.
+	 * If an argument is accepted, it must be described by argumentName.
+	 */
+	if (!isalnum(opt) && !name)
+		return;
+	if (!help || help[0] == '\0')
+		return;
+	if (argument != ArgumentNone && !argumentName)
+		return;
+
+	/* Reject duplicate options. */
+	if (optionsMap_.find(opt) != optionsMap_.end())
+		return;
+
+	options_.push_back(Option({ opt, name, argument, argumentName, help }));
+	optionsMap_[opt] = &options_.back();
+}
+
+OptionsParser::Options OptionsParser::parse(int argc, char **argv)
+{
+	OptionsParser::Options options;
+
+	/*
+	 * Allocate short and long options arrays large enough to contain all
+	 * options.
+	 */
+	char shortOptions[options_.size() * 3 + 2] = {};
+	struct option longOptions[options_.size() + 1] = {};
+	unsigned int ids = 0;
+	unsigned int idl = 0;
+
+	shortOptions[ids++] = ':';
+
+	for (const Option &option : options_) {
+		if (option.hasShortOption()) {
+			shortOptions[ids++] = option.opt;
+			if (option.argument != ArgumentNone)
+				shortOptions[ids++] = ':';
+			if (option.argument == ArgumentOptional)
+				shortOptions[ids++] = ':';
+		}
+
+		if (option.hasLongOption()) {
+			longOptions[idl].name = option.name;
+
+			switch (option.argument) {
+			case ArgumentNone:
+				longOptions[idl].has_arg = no_argument;
+				break;
+			case ArgumentRequired:
+				longOptions[idl].has_arg = required_argument;
+				break;
+			case ArgumentOptional:
+				longOptions[idl].has_arg = optional_argument;
+				break;
+			}
+
+			longOptions[idl].flag = 0;
+			longOptions[idl].val = option.opt;
+			idl++;
+		}
+	}
+
+	opterr = 0;
+
+	while (true) {
+		int c = getopt_long(argc, argv, shortOptions, longOptions, nullptr);
+
+		if (c == -1)
+			break;
+
+		if (c == '?' || c == ':') {
+			if (c == '?')
+				std::cerr << "Invalid option ";
+			else
+				std::cerr << "Missing argument for option ";
+			std::cerr << argv[optind - 1] << std::endl;
+
+			usage();
+			options.clear();
+			break;
+		}
+
+		options.values_[c] = optarg ? optarg : "";
+	}
+
+	return std::move(options);
+}
+
+void OptionsParser::usage()
+{
+	std::cerr << "Options:" << std::endl;
+
+	unsigned int indent = 0;
+
+	for (const Option &option : options_) {
+		unsigned int length = 14;
+		if (option.hasLongOption())
+			length += 2 + strlen(option.name);
+		if (option.argument != ArgumentNone)
+			length += 1 + strlen(option.argumentName);
+		if (option.argument == ArgumentOptional)
+			length += 2;
+
+		if (length > indent)
+			indent = length;
+	}
+
+	indent = (indent + 7) / 8 * 8;
+
+	for (const Option &option : options_) {
+		std::string argument;
+		if (option.hasShortOption())
+			argument = std::string("  -")
+				 + static_cast<char>(option.opt);
+		else
+			argument = "    ";
+
+		if (option.hasLongOption()) {
+			if (option.hasShortOption())
+				argument += ", ";
+			else
+				argument += "  ";
+			argument += std::string("--") + option.name;
+		};
+
+		if (option.argument != ArgumentNone) {
+			argument += std::string(" ");
+			if (option.argument == ArgumentOptional)
+				argument += "[";
+			argument += option.argumentName;
+			if (option.argument == ArgumentOptional)
+				argument += "]";
+		}
+
+		std::cerr << std::setw(indent) << std::left << argument;
+		std::cerr << option.help << std::endl;
+	}
+}
+
+OptionsParser::Options::Options()
+{
+}
+
+OptionsParser::Options::Options(Options &&other)
+	: values_(std::move(other.values_))
+{
+}
+
+OptionsParser::Options &OptionsParser::Options::operator=(Options &&other)
+{
+	values_ = other.values_;
+	return *this;
+}
+
+bool OptionsParser::Options::valid() const
+{
+	return !values_.empty();
+}
+
+bool OptionsParser::Options::isSet(int opt) const
+{
+	return values_.find(opt) != values_.end();
+}
+
+const std::string &OptionsParser::Options::operator[](int opt) const
+{
+	return values_.find(opt)->second;
+}
+
+void OptionsParser::Options::clear()
+{
+	values_.clear();
+}