-/* Licensed under GPLv3+ - see LICENSE file for details */
+/* Licensed under GPLv2+ - see LICENSE file for details */
#ifndef CCAN_OPT_H
#define CCAN_OPT_H
#include <ccan/compiler/compiler.h>
* string (or see opt_set_alloc) and return false.
*
* Example:
- * static char *explode(const char *optarg, void *unused)
+ * static char *explode(const char *optarg, void *unused UNNEEDED)
* {
* errx(1, "BOOM! %s", optarg);
* }
_opt_register((names), OPT_CB_ARG((cb), OPT_EARLY, (show),(arg)), \
(arg), (desc))
+/**
+ * opt_unregister - unregister an option.
+ * @names: the names it was registered with.
+ *
+ * This undoes opt_register[_early]_[no]arg. Returns true if the option was
+ * found, otherwise false.
+ */
+bool opt_unregister(const char *names);
+
/**
* opt_parse - parse arguments.
* @argc: pointer to argc
bool opt_early_parse(int argc, char *argv[],
void (*errlog)(const char *fmt, ...));
+/**
+ * opt_early_parse_incomplete - parse early arguments, ignoring unknown ones.
+ * @argc: argc
+ * @argv: argv array.
+ * @errlog: the function to print errors
+ *
+ * If you have plugins, you might need to do early parsing (eg. to find the
+ * plugin directory) but you don't know what options the plugins will want.
+ *
+ * Thus, this function is just like opt_early_parse, but ignores unknown options.
+ *
+ * Example:
+ * if (!opt_early_parse_incomplete(argc, argv, opt_log_stderr)) {
+ * printf("You screwed up, aborting!\n");
+ * exit(1);
+ * }
+ *
+ * See Also:
+ * opt_early_parse()
+ */
+bool opt_early_parse_incomplete(int argc, char *argv[],
+ void (*errlog)(const char *fmt, ...));
+
+
/**
* opt_free_table - reset the opt library.
*
*/
char *opt_usage(const char *argv0, const char *extra);
+/**
+ * opt_usage_exit_fail - complain about bad usage to stderr, exit with status 1.
+ * @msg...: printf-style message to output.
+ *
+ * This prints argv[0] (if opt_parse has been called), a colon, then
+ * the message to stderr (just like errx()). Then it prints out the
+ * usage message, taken from any registered option which uses
+ * opt_usage_and_exit() as described in opt_usage(argv0, NULL) above.
+ * Then it exits with status 1.
+ *
+ * Example:
+ * if (argc != 5)
+ * opt_usage_exit_fail("Need 5 arguments, only got %u", argc);
+ */
+void opt_usage_exit_fail(const char *msg, ...) NORETURN;
+
/**
* opt_hidden - string for undocumented options.
*
char *opt_set_ulongval(const char *arg, unsigned long *ul);
void opt_show_ulongval(char buf[OPT_SHOW_LEN], const unsigned long *ul);
+/* Set an floating point value, various forms. */
+char *opt_set_floatval(const char *arg, float *f);
+void opt_show_floatval(char buf[OPT_SHOW_LEN], const float *f);
+char *opt_set_doubleval(const char *arg, double *d);
+void opt_show_doubleval(char buf[OPT_SHOW_LEN], const double *d);
+
/* the following setting functions accept k, M, G, T, P, or E suffixes, which
multiplies the numeric value by the corresponding power of 1000 or 1024
(for the _si and _bi versions, respectively).
-/* Increment. */
+/* Increment and decrement. */
char *opt_inc_intval(int *i);
+char *opt_dec_intval(int *i);
/* Display version string to stdout, exit(0). */
char *opt_version_and_exit(const char *version);
/* Display usage string to stdout, exit(0). */
char *opt_usage_and_exit(const char *extra);
+/**
+ * opt_find_long: low-level access to the parser
+ * @arg: string of form 'arg' or 'arg=val'.
+ * @optarg: set to `val` of present in arg, otherwise NULL. Can be NULL.
+ *
+ * Returns NULL if option is unknown. Sets *@optarg to NULL if
+ * there's no '='.
+ */
+struct opt_table *opt_find_long(const char *arg, const char **optarg);
+
+/**
+ * opt_find_short: low-level access to the parser
+ * @arg: character representing short option
+ *
+ * Returns NULL if option is unknown.
+ */
+struct opt_table *opt_find_short(char arg);
+
+/* opt_type bits reserved for users to play with (ignored!).
+ * You can set bits in type e.g. (1<<OPT_USER_START) to (1<<OPT_USER_END)
+ * when calling _opt_register. */
+#define OPT_USER_START 8
+#define OPT_USER_END 15
+
/* Below here are private declarations. */
/* You can use this directly to build tables, but the macros will ensure
* consistency and type safety. */
OPT_SUBTABLE = 4, /* Actually, longopt points to a subtable... */
OPT_EARLY = 8, /* Parse this from opt_early_parse() only. */
OPT_END = 16, /* End of the table. */
+
+ /* Make sure no compiler will assume we never have large
+ * values in the enum! */
+ OPT_USER_MIN = (1 << OPT_USER_START),
+ OPT_USER_MAX = (1 << OPT_USER_END),
};
struct opt_table {