diff options
| -rw-r--r-- | libshouldbeinlibc/argp-ex1.c | 13 | ||||
| -rw-r--r-- | libshouldbeinlibc/argp-ex2.c | 32 | ||||
| -rw-r--r-- | libshouldbeinlibc/argp-ex3.c | 140 | ||||
| -rw-r--r-- | libshouldbeinlibc/argp-ex4.c | 146 |
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); +} |