How to handle C command line argument flags in a neater way? - c

Question

I have this little piece of C code, which takes a set of command-line arguments --help, -h, -d and -o (each correspondingly representing "Help", "Hexadecimal", "Decimal", "Octal"), and I am calling certain functions depending in which argument is passed, -h will call hexaFlag(), -dh will call hexaFlag() and decFlag(). However, in order to do this, I am employing a block of if else that is messy. Is there any less convoluted way to achieve this? I was told to use a switch statement, but I do not know how I could use it here considering I am checking for different conditions each time.
main() function of the code I am referring to:
int main(int argc, char* argv[]){
if(argc == 1){
printf("%s",usage());
printf("Use --help for more options.\n");
}
else if(strcmp(argv[1], "--help") == 0){
printf("%s", usage());
printf("Options are:\n -h = Hexadecimal values\n -d = Decimal values\n -o = Octal values\n --help = Shows this message\n");
}
else if(strchr(argv[1], '-') != NULL){
if(strchr(argv[1], 'h') != NULL){
hexaFlag(argc, argv);
}
if(strchr(argv[1], 'd') != NULL){
decFlag(2, argc, argv);
}
if(strchr(argv[1], 'o') != NULL){
octaFlag(argc, argv);
}
}
else {
decFlag(1, argc, argv);
}
return 0;
}

Answer 1

I think you should modify the function signature a bit to make them consistent. That would allow you to do something like:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libgen.h>
void hexaFlag(int x, int argc, char **argv) { printf("%d:%s\n", x, __func__); }
void decFlag(int x, int argc, char **argv) { printf("%d:%s\n", x, __func__); }
void octaFlag(int x, int argc, char **argv) { printf("%d:%s\n", x, __func__); }
struct args {
void (*f)(int, int, char **);
int x;
};
void
parse_args(int argc, char *argv[], struct args *A)
{
int c;
if( argc == 1 || !strcmp(argv[1], "--help") ){
printf("usage: %s [-hdo] [--help] arg [arg...]\n",
basename(argv[0]));
exit(EXIT_SUCCESS);
}
A->f = decFlag;
A->x = 1;
while( (c = getopt(argc, argv, "hdo")) != -1 ) {
switch( c ){
case 'h': A->f = hexaFlag; break;
case 'd': A->f = decFlag; A->x = 2; break;
case 'o': A->f = octaFlag; break;
default: exit(EXIT_FAILURE);
}
}
}
int
main(int argc, char* argv[])
{
struct args A;
parse_args(argc, argv, &A);
A.f(A.x, argc, argv);
return 0;
}
You should probably not pass argc/argv directly to the worker functions, but should extract what you need from them into the struct args in parse_args().

Answer 2

My basic switch processing (example), very functional but maybe not beautiful, is:
int main (int argc, char *argv[])
{
int i=0, number, files=0;
/* process switches; other prms are considered files (2)
that are opened for input/output. Files not specified
are taken as stdin and stdout. Prms can be in any order.
*/
while (++i < argc)
switch (argv[i][0]) {
case '-': while (*++argv[i])
switch (*argv[i]) {
case 'N':
++argv[i]; number= 0;
while (isdigit(*argv[i]))
number = number *10 + *argv[i]++ - '0';
argv[i]--;
break;
case 'P' : printf ("Prm: P\n"); break;
case 'O' : printf ("Prm: O\n"); break;
case 'o' : printf ("Prm: o\n"); break;
default :
printf ("Bad switch %c, ignored.\n",*argv[i]);
}
break;
default :
switch (files) {
case 0: if ((inf=fopen(argv[i],"r")) == 0)
pexit("Error opening input file %s.", argv[i]);
files++; break;
case 1: if ((outf=fopen(argv[i],"w")) == 0)
pexit ("Error creating output file %s.", argv[i]);
files++; break;
case 2: fprintf (stderr,"Too many file arguments: %s ignored.\n",argv[i]);
break;
} /* end switch files */
} /* end switch argc */
if (files <1) inf = stdin;
if (files <2) outf = stdout;