{"id":4878,"date":"2021-07-24T00:01:50","date_gmt":"2021-07-24T07:01:50","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=4878"},"modified":"2021-07-17T09:35:15","modified_gmt":"2021-07-17T16:35:15","slug":"discovering-command-line-options-part-v","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=4878","title":{"rendered":"Discovering Command Line Options, Part V"},"content":{"rendered":"

Somewhere along the line, shell commands developed longer, verbose versions of their original, short command line switches. So in addition to -o<\/code> you also could use --output<\/code>. These switches offer readability and are easier to remember. Alas, the getopt()<\/em> function doesn’t process them, but its sibling function getopt_long()<\/em> does.
\n
\nThe getopt_long()<\/em> function works like getopt()<\/em>, but allows for switches longer than a single character. These verbose switches are prefixed by two dashes, which aren’t processed by getopt()<\/em>. The longer switches can be unique or they can map to existing short switches. So your program can use both the -o<\/code> and --output<\/code> switches to set the same option; the user can specify either switch.<\/p>\n

The format for getopt_long()<\/em> is the same as for getopt()<\/em>, but with two additional arguments: the address of an option<\/code> structure array and an integer index<\/code> value. Here is the man<\/em> page format:<\/p>\n

int getopt_long(int argc, char * const *argv, const char *optstring,
\n    const struct option *longopts, int *longindex);<\/code><\/p>\n

The fourth option, longopts<\/em><\/code>, is the address of an array of option<\/code> structures. Each structure in the array contains four members that describe the long option:<\/p>\n

struct option {
\n    char *name;
\n    int has_arg;
\n    int *flag;
\n    int val;
\n};<\/code><\/p>\n

name<\/em><\/code> is a the option word. This string is the name only; the two dashes are supplied by the user at the command prompt.<\/p>\n

has_arg<\/em><\/code> is an int<\/em> value: 0 or no_argument<\/code> for options without arguments; 1 or required_argument<\/code> for options that require an argument; and 2 or optional_argument<\/code> for an optional argument. Values or the defined constants can be specified.<\/p>\n

flag<\/em><\/code> allows the getopt_long()<\/em> function’s return value to be saved in a specific variable as opposed to being returned from the function directly. Otherwise, specify NULL<\/code>.<\/p>\n

The val<\/em><\/code> member is the value to return when the option is found. The int<\/em> value can be the same as an existing, single-letter switch. This way you can map a long, verbose switch to an existing, shorter switch.<\/p>\n

Though the man<\/em> page specifies a pointer to the longopts<\/code><\/em> argument, setting the array’s name is sufficient. The last structure in the array is filled with zeros, which is how the function knows it’s read them all. (See the sample code below.)<\/p>\n

Unlike the getopts()<\/em> function, which is defined in the unistd.h<\/code> header file, getopts_long()<\/em> is defined in the getopt.h<\/code> header file.<\/p>\n

In the sample code below, the program accepts switches -a<\/code>, --alpha<\/code>, --greek<\/code>, and -z<\/code>. The -a<\/code> and --alpha<\/code> switches represent the same option:<\/p>\n

2021_07_24-Lesson.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <getopt.h>\r\n\r\nint main(int argc, char *argv[])\r\n{\r\n    int r;\r\n    struct option args[3] = {\r\n        { \"alpha\", 0, NULL, 'a' },\r\n        { \"greek\", 0, NULL, 'g' },\r\n        { 0, 0, 0, 0 }\r\n    };\r\n\r\n    \/* supress the default error message *\/<\/span>\r\n    opterr = 0;\r\n\r\n    \/* configure long option arguments *\/<\/span>\r\n\r\n    while( (r=getopt_long(argc,argv,\"az\",args,0)) != -1 )\r\n    {\r\n        switch(r)\r\n        {\r\n            case 'a':\r\n                \/* -a or --alpha argument *\/<\/span>\r\n                puts(\"Option -a or --alpha is set\");\r\n                break;\r\n            case 'g':\r\n                \/* --greek argument *\/<\/span>\r\n                puts(\"The --greek argument is set\");\r\n                break;\r\n            case 'z':\r\n                \/* -z argument *\/<\/span>\r\n                puts(\"Option -z is set\");\r\n                break;\r\n            case '?':\r\n                printf(\"Inavlid option: %c\\n\",optopt);\r\n                break;\r\n            default:\r\n                puts(\"Unkonwn argument\");\r\n        }\r\n    }\r\n\r\n    return(0);\r\n}<\/pre>\n
The getopt_long()<\/em> function appears at Line 18, embedded in the while<\/em> loop’s condition. The function’s fourth argument is args<\/code>, which references the args[]<\/code> array of option<\/code> structures defined at Line 7. <\/p>\n
Long argument \"alpha\"<\/code> is defined in the first structure in the args[]<\/code> array at Line 8. Structure member 'a'<\/code> is the value returned when --alpha<\/code> is specified on the command line. This value is caught with the case<\/em> statement at Line 22.<\/p>\n
Long argument \"greek\"<\/code> is defined in the structure at Line 9. It returns argument 'g'<\/code>, caught at Line 26.<\/p>\n
At Line 10, the final structure in the array is filled with zeros.<\/p>\n
Here are some sample runs:<\/p>\n
$ .\/a.out -a --greek
\nOption -a or --alpha is set
\nThe --greek argument is set
\n$ .\/a.out -a --greek -z
\nOption -a or --alpha is set
\nThe --greek argument is set
\nOption -z is set
\n$ .\/a.out -g
\nInavlid option: g<\/code><\/p>\n
Long or short, the getopt()<\/em> and getopt_long()<\/em> functions help your code process command line switches. Uses these functions is easier than cobbling together your own loops and whatnot, especially when your program requires a variety of switches.<\/p>\n","protected":false},"excerpt":{"rendered":"
To read more verbose command line switches, use the getopt_long()<\/em> function. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-4878","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4878","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4878"}],"version-history":[{"count":8,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4878\/revisions"}],"predecessor-version":[{"id":4890,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4878\/revisions\/4890"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4878"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4878"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4878"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}