summaryrefslogtreecommitdiff
path: root/libshouldbeinlibc
diff options
context:
space:
mode:
Diffstat (limited to 'libshouldbeinlibc')
-rw-r--r--libshouldbeinlibc/argp-ex1.c13
-rw-r--r--libshouldbeinlibc/argp-ex2.c32
-rw-r--r--libshouldbeinlibc/argp-ex3.c140
-rw-r--r--libshouldbeinlibc/argp-ex4.c146
4 files changed, 331 insertions, 0 deletions
diff --git a/libshouldbeinlibc/argp-ex1.c b/libshouldbeinlibc/argp-ex1.c
new file mode 100644
index 00000000..7eeb907a
--- /dev/null
+++ b/libshouldbeinlibc/argp-ex1.c
@@ -0,0 +1,13 @@
+/* Argp example #1 -- a minimal program using argp */
+
+/* This is (probably) the smallest possible program that uses argp.
+ It won't do much except give an error messages and exit when there are any
+ arguments, and print a (rather pointless) messages for --help. */
+
+#include <argp.h>
+
+int main (int argc, char **argv)
+{
+ argp_parse (0, argc, argv, 0, 0, 0);
+ exit (0);
+}
diff --git a/libshouldbeinlibc/argp-ex2.c b/libshouldbeinlibc/argp-ex2.c
new file mode 100644
index 00000000..b3c3b212
--- /dev/null
+++ b/libshouldbeinlibc/argp-ex2.c
@@ -0,0 +1,32 @@
+/* Argp example #2 -- a pretty minimal program using argp */
+
+/* This program doesn't use any options or arguments, but uses argp to be
+ compliant with the GNU standard command line format.
+
+ In addition to making sure no arguments are given, and implementing a
+ --help option, this example will have a --version option, and will put the
+ given documentation string and bug address in the --help output, as per
+ GNU standards.
+
+ The variable ARGP contains the argument parser specification; adding
+ fields to this structure is the way most parameters are passed to
+ argp_parse (the first three fields are usually used, but not in this small
+ program). There are also two global variables that argp knows about
+ defined here, ARGP_PROGRAM_VERSION and ARGP_PROGRAM_BUG_ADDRESS (they are
+ global variables becuase they will almost always be constant for a given
+ program, even if it uses different argument parsers for various tasks). */
+
+#include <argp.h>
+
+char *argp_program_version = "argp-ex2 1.0";
+char *argp_program_bug_address = "<bug-gnu-utils@prep.ai.mit.edu>";
+
+static char doc[] = "Argp example #2 -- a pretty minimal program using argp";
+
+static struct argp argp = { 0, 0, 0, doc };
+
+int main (int argc, char **argv)
+{
+ argp_parse (&argp, argc, argv, 0, 0, 0);
+ exit (0);
+}
diff --git a/libshouldbeinlibc/argp-ex3.c b/libshouldbeinlibc/argp-ex3.c
new file mode 100644
index 00000000..a784a646
--- /dev/null
+++ b/libshouldbeinlibc/argp-ex3.c
@@ -0,0 +1,140 @@
+/* Argp example #3 -- a program with options and arguments using argp */
+
+/* This program uses the same features as example 2, and uses options and
+ arguments.
+
+ We now use the first four fields in ARGP, so here's a description of them:
+ OPTIONS -- A pointer to a vector of struct argp_option (see below)
+ PARSER -- A function to parse a single option, called by argp
+ ARGS_DOC -- A string describing how the non-option arguments should look
+ DOC -- A descriptive string about this program; if it contains a
+ vertical tab character (\v), the part after it will be
+ printed *following* the options
+
+ The function PARSER takes the following arguments:
+ KEY -- An integer specifying which option this is (taken
+ from the KEY field in each struct argp_option), or
+ a special key specifying something else; the only
+ special keys we use here are ARGP_KEY_ARG, meaning
+ a non-option argument, and ARGP_KEY_END, meaning
+ that all argumens have been parsed
+ ARG -- For an option KEY, the string value of its
+ argument, or NULL if it has none
+ STATE-- A pointer to a struct argp_state, containing
+ various useful information about the parsing state; used here
+ are the INPUT field, which reflects the INPUT argument to
+ argp_parse, and the ARG_NUM field, which is the number of the
+ current non-option argument being parsed
+ It should return either 0, meaning success, ARGP_ERR_UNKNOWN, meaning the
+ given KEY wasn't recognized, or an errno value indicating some other
+ error.
+
+ Note that in this example, main uses a structure to communicate with the
+ parse_opt function, a pointer to which it passes in the INPUT argument to
+ argp_parse. Of course, it's also possible to use global variables
+ instead, but this is somewhat more flexible.
+
+ The OPTIONS field contains a pointer to a vector of struct argp_option's;
+ that structure has the following fields (if you assign your option
+ structures using array initialization like this example, unspecified
+ fields will be defaulted to 0, and need not be specified):
+ NAME -- The name of this option's long option (may be zero)
+ KEY -- The KEY to pass to the PARSER function when parsing this option,
+ *and* the name of this option's short option, if it is a
+ printable ascii character
+ ARG -- The name of this option's argument, if any
+ FLAGS -- Flags describing this option; some of them are:
+ OPTION_ARG_OPTIONAL -- The argument to this option is optional
+ OPTION_ALIAS -- This option is an alias for the
+ previous option
+ OPTION_HIDDEN -- Don't show this option in --help output
+ DOC -- A documentation string for this option, shown in --help output
+
+ An options vector should be terminated by an option with all fields zero. */
+
+#include <argp.h>
+
+char *argp_program_version = "argp-ex3 1.0";
+char *argp_program_bug_address = "<bug-gnu-utils@prep.ai.mit.edu>";
+
+static char doc[] =
+ "Argp example #3 -- a program with options and arguments using argp";
+static char args_doc[] = "ARG1 ARG2";
+
+static struct argp_option options[] = {
+ {"verbose", 'v', 0, 0, "Produce verbose output" },
+ {"quiet", 'q', 0, 0, "Don't produce any output" },
+ {"silent", 's', 0, OPTION_ALIAS },
+ {"output", 'o', "FILE", 0, "Output to FILE instead of standard output" },
+ { 0 }
+};
+
+/* Used by main to communicate with parse_opt. */
+struct arguments
+{
+ char *args[2]; /* ARG1 & ARG2 */
+ int silent, verbose;
+ char *output_file;
+};
+
+static error_t
+parse_opt (int key, char *arg, struct argp_state *state)
+{
+ /* Get the INPUT argument from argp_parse, which we know is a pointer to
+ our arguments structure. */
+ struct arguments *arguments = state->input;
+
+ switch (key)
+ {
+ case 'q': case 's':
+ arguments->silent = 1;
+ break;
+ case 'v':
+ arguments->verbose = 1;
+ break;
+ case 'o':
+ arguments->output_file = arg;
+ break;
+
+ case ARGP_KEY_ARG:
+ if (state->arg_num >= 2)
+ /* Too many arguments. */
+ argp_usage (state);
+
+ arguments->args[state->arg_num] = arg;
+
+ break;
+
+ case ARGP_KEY_END:
+ if (state->arg_num < 2)
+ /* Not enough arguments. */
+ argp_usage (state);
+ break;
+
+ default:
+ return ARGP_ERR_UNKNOWN;
+ }
+ return 0;
+}
+
+static struct argp argp = { options, parse_opt, args_doc, doc };
+
+int main (int argc, char **argv)
+{
+ struct arguments arguments;
+
+ /* Default values. */
+ arguments.silent = 0;
+ arguments.verbose = 0;
+ arguments.output_file = "-";
+
+ argp_parse (&argp, argc, argv, 0, 0, &arguments);
+
+ printf ("ARG1 = %s\nARG2 = %s\nOUTPUT_FILE = %s\nVERBOSE = %s\nSILENT = %s\n",
+ arguments.args[0], arguments.args[1],
+ arguments.output_file,
+ arguments.verbose ? "yes" : "no",
+ arguments.silent ? "yes" : "no");
+
+ exit (0);
+}
diff --git a/libshouldbeinlibc/argp-ex4.c b/libshouldbeinlibc/argp-ex4.c
new file mode 100644
index 00000000..13ad0983
--- /dev/null
+++ b/libshouldbeinlibc/argp-ex4.c
@@ -0,0 +1,146 @@
+/* Argp example #4 -- a program with somewhat more complicated options */
+
+/* This program uses the same features as example 3, but has more options,
+ and somewhat more structure in the -help output. It also shows how you
+ can `steal' the remainder of the input arguments past a certain point, for
+ programs that accept a list of items. It also shows the special argp KEY
+ value ARGP_KEY_NO_ARGS, which is only given if no non-option arguments
+ were supplied to the program.
+
+ For structuring the help output, two features are used, *headers* which
+ are entries in the options vector with the first four fields being zero,
+ and a two part documentation string (in the variable DOC), which allows
+ documentation both before and after the options; the two parts of DOC are
+ separated by a vertical-tab character ('\v', or '\013'). By convention,
+ the documentation before the options is just a short string saying what
+ the program does, and that afterwards is longer, describing the behavior
+ in more detail. All documentation strings are automatically filled for
+ output, although newlines may be included to force a line break at a
+ particular point. All documenation strings are also passed to the
+ `gettext' function, for possible translation into the current locale. */
+
+#include <stdlib.h>
+#include <error.h>
+#include <argp.h>
+
+char *argp_program_version = "argp-ex4 1.0";
+char *argp_program_bug_address = "<bug-gnu-utils@prep.ai.mit.edu>";
+
+static char doc[] =
+ "Argp example #4 -- a program with somewhat more complicated options\
+\vThis part of the documentation comes *after* the options; note that\
+ it is automatically filled, but it's possible to force a line-break,\
+ e.g.\n<-- here.";
+static char args_doc[] = "ARG1 [STRING...]";
+
+/* Keys for options without short-options. */
+#define OPT_ABORT 1 /* --abort */
+
+static struct argp_option options[] = {
+ {"verbose", 'v', 0, 0, "Produce verbose output" },
+ {"quiet", 'q', 0, 0, "Don't produce any output" },
+ {"silent", 's', 0, OPTION_ALIAS },
+ {"output", 'o', "FILE", 0, "Output to FILE instead of standard output" },
+
+ {0, 0, 0, 0, "The following options should be grouped together:" },
+ {"repeat", 'r', "COUNT", OPTION_ARG_OPTIONAL,
+ "Repeat the output COUNT (default 10) times"},
+ {"abort", OPT_ABORT, 0, 0, "Abort before showing any output"},
+ { 0 }
+};
+
+/* Used by main to communicate with parse_opt. */
+struct arguments
+{
+ char *arg1; /* ARG1 */
+ char **strings; /* [STRING...] */
+ int silent, verbose, abort; /* -s, -v, --abort */
+ char *output_file; /* --output=FILE */
+ int repeat_count; /* --repeat[=COUNT] */
+};
+
+static error_t
+parse_opt (int key, char *arg, struct argp_state *state)
+{
+ /* Get the INPUT argument from argp_parse, which we know is a pointer to
+ our arguments structure. */
+ struct arguments *arguments = state->input;
+
+ switch (key)
+ {
+ case 'q': case 's':
+ arguments->silent = 1;
+ break;
+ case 'v':
+ arguments->verbose = 1;
+ break;
+ case 'o':
+ arguments->output_file = arg;
+ break;
+ case 'r':
+ arguments->repeat_count = arg ? atoi (arg) : 10;
+ break;
+ case OPT_ABORT:
+ arguments->abort = 1;
+ break;
+
+ case ARGP_KEY_NO_ARGS:
+ argp_usage (state);
+
+ case ARGP_KEY_ARG:
+ /* Here we know that STATE->arg_num == 0, since we force argument
+ parsing to end before any more arguments can get here. */
+ arguments->arg1 = arg;
+
+ /* Now we consume all the rest of the arguments. STATE->next is the
+ index in STATE->argv of the next argument to be parsed, which is the
+ first STRING we're interested in, so we can just use
+ `&state->argv[state->next]' as the value for arguments->strings.
+
+ IN ADDITION, by setting STATE->next to the end of the arguments, we
+ can force argp to stop parsing here and return. */
+ arguments->strings = &state->argv[state->next];
+ state->next = state->argc;
+
+ break;
+
+ default:
+ return ARGP_ERR_UNKNOWN;
+ }
+ return 0;
+}
+
+static struct argp argp = { options, parse_opt, args_doc, doc };
+
+int main (int argc, char **argv)
+{
+ int i, j;
+ struct arguments arguments;
+
+ /* Default values. */
+ arguments.silent = 0;
+ arguments.verbose = 0;
+ arguments.output_file = "-";
+ arguments.repeat_count = 1;
+ arguments.abort = 0;
+
+ argp_parse (&argp, argc, argv, 0, 0, &arguments);
+
+ if (arguments.abort)
+ error (10, 0, "ABORTED");
+
+ for (i = 0; i < arguments.repeat_count; i++)
+ {
+ printf ("ARG1 = %s\n", arguments.arg1);
+ printf ("STRINGS = ");
+ for (j = 0; arguments.strings[j]; j++)
+ printf (j == 0 ? "%s" : ", %s", arguments.strings[j]);
+ printf ("\n");
+ printf ("OUTPUT_FILE = %s\nVERBOSE = %s\nSILENT = %s\n",
+ arguments.output_file,
+ arguments.verbose ? "yes" : "no",
+ arguments.silent ? "yes" : "no");
+ }
+
+ exit (0);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-17 06:51:01 +0000