Strategies for Handling Command Line Arguments

[thetinman]

I have a number of command line programs that take a variety of inputs. Depending on the inputs the program functions differently. For example, the program could take A and C as inputs and produce B and D as outputs. Alternatively, the program could take B and D as inputs and produce A and C as outputs. As another alternative, the program could take A and D as inputs and produce B and C as outputs.

The thing is that I have seven inputs and a handful of outputs. The problem is that the part of my program that handles user input is very messy. I don't have any particularly good strategy to fix this. Has anyone dealt with this issue before? Are there any good ways to clean up the mess?

[Dave_Sinkula]

How about something like compiler switches?

foo -iInFile1 -oOutFile -iInFile2 -iInFile3

[DougDbug]

Can you explain this a bit more? Why is it "messy"? As you describe it, it sounds fairly straightforward... Ask the user for the inputs, and then ask the user for outputs...

Then, use if-statements (or a switch statement) to make the program function correctly with the given conditions.

Does all of this information need to be entered on the command-line when the program is run? Or, is there a user-input "screen" (or two)?

Are the input and output selections limited, so that you can use menus? In that case, you can create input and output menus, and the user can enter a number or letter to select a menu item(s). Can the user actually enter "A" and/or "B", or is that just a symbolic example?

Or, is the user entering more free-form data, like file-names?

In any case, you should check for invalid input and allow the user to re-try. (Sometimes I'll have the program make a "default" selection, if the user enters something invalid.)

[thetinman]

What I am using is something like compiler switches. It's essentially

foo A S D F G -i Q -o W -f E

By messy, I am referring to the way that all of these inputs are handled within the program. (And yes, the letters "A" and "B" where symbolic, although it doesn't make much difference.) This gets messy, because the variables are used to produce new variables, and then the switches tell the program how to use the variables. My code works okay, I just would not describe it as "clean," "pretty," or "elegant."

[anon]

So the messiness results from one program doing many things? Or what makes you think it's the command line arguments that make it messy?

[thetinman]

I can see the messiness in the code. It results from the way the input variables are handled, the error checking of the input variables, and the multiple things that the program can do.

[Dino]

If you are UNIX, have you looked at getopt()? (man 3 getopt)

Todd

[OogyBoogy]

I prefer to seperate the handling of the command-line options from the main program. As an example, I created a program that took a bitmap picture, and sliced it up into tiles (of any size), then saved the resulting tile-map to a new bitmap file, while having the option to create a .map and to go into verbose-mode.

So I created an OPTION structure to hold all the command-line options / switches first:

typedef struct Options
{
	char	*source,	// source filename
		*tiles,	// tile bmp filename
		*map;	// map filename
	int	x,	// tiles width
		y;	// tiles height
	BOOL	v;	// verbose (on/off)
} OPTIONS;

Then, I created the function that scans the command-line and fills in the OPTION structure:

void OPT_Parse (int argc, char *argv[], OPTIONS *opt)
{
	int i = 2;

	/* Clear the opt structure
		before we fill it in. */

	memset (opt, 0, sizeof (OPTIONS));

	/* See if there even are
		any arguments given. */

	if (argc > 1)
	{
		/* The first argument is
			always the source file. */

		opt->source = argv[1];

		while (++ i <= argc)
		{
			/* Argument -c creates a tile BMP. */

			if (! (strncmp (argv[i - 1], "-c", 2)))

				opt->tiles = argv[i ++];

			/* Argument -m creates a map file. */

			else if (! (strncmp (argv[i - 1], "-m", 2)))

				opt->map = argv[i ++];

			/* Argument -x sets the tile width. */

			else if (! (strncmp (argv[i - 1], "-x", 2)))

				opt->x = atoi (argv[i ++]);

			/* Argument -y sets the tile height. */

			else if (! (strncmp (argv[i - 1], "-y", 2)))

				opt->y = atoi (argv[i ++]);

			/* Turn on verbose mode. */

			else if (! (strncmp (argv[i - 1], "-v", 2)))

				opt->v = TRUE;
		}

		/* If no tile width- or height was
			specified, we use the default values. */

		if (! opt->x)

			opt->x = 8;

		if (! opt->y)

			opt->y = 8;
	}
}

This has an added bonus that the order of the commands and/or switches do not matter, the only thing it expects is that the first argument is the source filename, which is why I declared the index variable i as 2, as argv[2] is the first place an option should exist.

Then the main code can check the OPTIONS structure and do things accordingly.

Hope this helps a bit.