Parsing command line options on UNIX-like systems

Introduction

One of the important tasks of any program, be it console or graphical, is the interpretation of command line arguments . Formally, all the words in the command line (including the name of the command itself) broken by a separator (as a rule, this is a space and a tab) are called arguments, while quotation marks allow including separators in arguments.
Arguments can be divided into options and operands . Options change the behavior of the program or provide it with additional information. An option may have its own arguments, which are information necessary only for this option.

Posix

The POSIX standard describes the expected behavior of programs on UNIX-like systems. When writing a program, no one will force you to strictly follow the standard, however, this is a good idea, as this will make your users life easier. Here are the basic rules for command arguments:

• the program name must contain at least 2 and no more than 9 characters;
• program names should be written only in lowercase characters and numbers;
• The option name must be a simple alphanumeric character. Multi-digit options are disabled;
• All options must begin with a "-";
• for options with no arguments, the ability to combine options must be implemented (for example, foo -a -b -c and foo -abc );
• option argument must be separated from it by a space;
• option argument may not be optional;
• if options require multiple argument values, they must be passed as a string, separated by commas or a separator;
• options must go before operands;
• the argument "-" indicates the end of all options;
• the order of options should not play a role, except when options are mutually exclusive, then the latter wins;
• the order of the arguments may matter;
• programs that read or write named files should treat the single argument "-" as standard input or standard output, respectively.

Long options

GNU programs also use long options whose behavior is not described in POSIX; long options start with "-" The following conventions are also implemented for these options in GNU:

• each short option must have its own version of the long option;
• the long option can be shortened to the shortest line, ensuring its uniqueness;
• The arguments of the long option are separated either by a delimiter, or by the "=" sign.

Where do the parameters in the program come from

as it is known, the main () function in C is defined as:
int main(int argc, char *argv[])
Here there are two parameters: argc determines the number of arguments on the command line, and argv stores an array of pointers to these arguments.
It should be noted that argv [0] is always the name of the command, and argv [argc] == NULL , these two facts may be useful in development.
')

Parsing options

In the 1980s, the Unix support team noticed that each Unix program uses its own method of parsing options. This prompted the development of the getopt () function to make it easier to write code that follows standard conventions.
The GNU getopt_long () function is compatible with getopt () , and also simplifies the parsing of long options.

getopt

Announcement:
#include <unistd.h>
int getopt(int argc, char *argv[], const char *optstring);
extern char *optarg;
extern int optind, opterr, optopt;

The argc and argv arguments are passed directly from the main () function, and optstring is a string of option characters. If any letter in the line is followed by a colon, then this option takes an argument.
To use getopt (), it is called again in a loop, until it returns -1 . Each time a valid option character is found, the function returns this character. If the option takes an argument, then the pointer to it is placed in the variable optarg .
The optind variable stores the current index in argv . When the opterr variable is not zero (the default is 0 ), getopt () itself displays messages in case of an invalid option or no argument. If opterr is zero, then if an error occurs, getopt () returns "?" or ":" , depending on whether an invalid option is found or the required argument of the option is omitted, the detected symbol will be found in the optopt variable.
It should be noted that the standard getopt () function stops as soon as it finds the first argument that does not begin with the “-” character, the GNU option scans the option line for the entire command line. The behavior of the GNU functions can be changed (but this is beyond the scope of the article).

sample program using getopt ()

Courtesy of iv_s

1. #include <unistd.h>
2. #include <stdlib.h>
3. #include <stdio.h>
5. int main ( int argc, char ** argv) {
6. if (argc == 1) { // if we run without arguments, display help
7. printf ( "getopt test \ n" );
8. printf ( "usage: \ n" );
9. printf ( "opts -an -bm -os \ n" );
10. printf ( "example: \ n" );
11. printf ( "$ opts -a 323 -b 23 -o '-' \ n" );
12. printf ( "323 - 23 = 300 \ n" );
13. return 0;
14. }
15. char * opts = "a: b: o:" ; // available options, each takes an argument
16. int a, b; // store numbers here
17. char op; // and here is the operator
18. int opt; // each next option gets here
19. while ((opt = getopt (argc, argv, opts))! = -1) { // call getopt until it returns -1
20. switch (opt) {
21. case 'a' : // if the -a option, convert the string with the argument to a number
22. a = atoi (optarg);
23. break ;
24. case 'b' : // for -b too
25. b = atoi (optarg);
26. break ;
27. case 'o' : // in op save the statement
28. op = optarg [0];
29. break ;
30. }
31. }
32. switch (op) {
33. case '+' : // if opator + add, etc.
34. printf ( "% d +% d =% d \ n" , a, b, a + b);
35. break ;
36. case '-' :
37. printf ( "% d -% d =% d \ n" , a, b, a - b);
38. break ;
39. case '*' :
40. printf ( "% d *% d =% d \ n" , a, b, a * b);
41. break ;
42. case '/' :
43. printf ( "% d /% d =% d \ n" , a, b, a / b);
44. break ;
45. }
46. return 0;
47. }

* This source code was highlighted with Source Code Highlighter .

getopt_long ()

Announcement:
#include <getopt.h>

int getopt_long(int argc, char *argv[], const char *optstring, const struct option *longopts, int *longindex);

the first three arguments are the same as in getopt () , longopts is a pointer to an array of long options, longindex points to a variable in which the index of the detected long options is placed in longopts , if this may not be necessary NULL .

The option structure is defined as follows:
struct option
{
const char *name;
int has_arg;
int *flag;
int val;
}


name - the name of the option without preceding dashes;
has_arg - as the name implies, the variable describes whether the long option has an argument that can take three values:

• 0 - does not accept the argument;
• 1 is a required argument;
• 2 is an optional argument.

flag - if this pointer is NULL , then getopt_long () returns the value of the val field, otherwise it returns 0 , and the variable pointed to by flag is filled with the value of val ;
val - usually contains some symbolic constant, if the long option is short, then this constant must be the same as the one that appears in the argument optstring .
It is important to note that the last element of the longopts array must be filled with zeros.

Sample program using getopt_long ()

Courtesy of shuffle

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <getopt.h>
6. void usage ( char * name)
7. {
8. printf ( "usage:% s \ n \ \ th this message \ n \ \ tc [config file] \ n \ \ t - help this message \ n \ \ t - config = config_file \ n", name);
9. return ;
10. }
12. int main ( int argc, char * argv [])
13. {
14. int c;
15. while (1) {
16. static struct option long_opt [] = {
17. { "Help" , 0, 0, 'h' },
18. { "Config" , 1, 0, 'c' },
19. {0,0,0,0}
20. };
21. int optIdx;
23. if ((c = getopt_long (argc, argv, "c: h" , long_opt, & optIdx)) == -1)
24. break ;
25. switch (c) {
26. case 'h' :
27. usage (argv [0]);
28. return (-1);
30. case 'c' :
31. printf ( "option 'c' selected, filename:% s \ n" , optarg);
32. return (1);
34. default :
35. usage (argv [0]);
36. return (-1);
37. }
38. }
40. return (0);
41. }

* This source code was highlighted with Source Code Highlighter .

Conclusion

The article describes the basics of using the functions of parsing command line arguments on UNIX-like systems. This material can be more extensive, but any interested person is able to learn and learn all the subtleties on their own.

The article was prepared on the basis of the book by Arnold Robbins "Linux programming in examples" ISBN 5-9579-0059-1