/* args.c Paul Albrecht Jan 1988
. Last revised: 13 May 1995 (by GBM)
Utility subroutines for command line argument processing.
Options and their corresponding arguments are stripped out
of argv[]; argc is adjusted appropriately.
*/
#include <stdio.h>
#ifdef __STDC__
#include <limits.h>
#else
#define MIN(TYPE) ( -1*(1 << (sizeof(TYPE)*8-1)) )
#define MAX(TYPE) ( -(MIN(TYPE)+1) )
#define SHRT_MIN MIN(short)
#define SHRT_MAX MAX(short)
#define INT_MIN MIN(int)
#define INT_MAX MAX(int)
#define LONG_MIN MIN(long)
#define LONG_MAX MAX(long)
#endif
#include "args.h"
static int *argcp, /* pointer to argc in main program */
argcc, /* number of next argument to be processed */
opt_mode, /* 1=found new option, 2=test options, 3=matched option */
help_mode; /* 0=no help, 1=printing help but no option
info printed yet, 2=printing option info */
static char **argv, /* value of argv in the main program */
*option, /* name of option found in argv[] */
*holding_arg;/* leftover chars; for 1 char options only */
opt_init( argc_ptr, argv_value ) /* initialize argument processin */
int *argc_ptr;
char **argv_value;
{
int i;
argcp = argc_ptr;
argv = argv_value;
argcc = 1;
holding_arg = 0;
program_name = argv[0];
for( i=1; i < *argcp; i++ ) {
if( strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0 ) {
help_mode = 1;
printf( "=========================================\n" );
break;
}
}
}
#ifndef __STDC__
opt_help( fmt, args )
char *fmt;
{
if( help_mode ) {
_doprnt( fmt, &args, stdout );
printf( "\n" );
}
}
#else
#include <stdarg.h>
opt_help(char *fmt, ...)
{
va_list args;
va_start(args, fmt);
if( help_mode ) {
vprintf(fmt, args);
printf( "\n" );
}
va_end(args);
}
#endif
opt_get()
/* Parse the argument list and return a 1 if an option is found. */
{
int i;
if( help_mode ) {
if( opt_mode > 0 ) {
printf( "=========================================\n" );
exit( 0 );
}
}
else if( opt_mode == 1 || opt_mode == 2 )
estop( "Unrecognized option `-%s'", option );
if( holding_arg )
estop( "Garbage trailing option `-%c'", *option );
opt_mode = 0;
while( argcc < *argcp && opt_mode == 0 ) {
option = argv[argcc];
if( option[0] == '-' && option[1] != 0 ) {
for( i=argcc; i < *argcp; i++ )
argv[i] = argv[i+1];
(*argcp)--;
option++;
opt_mode = 1;
}
else argcc++;
}
return( opt_mode );
}
opt_match( optname, help_string ) /* Return a 1 if *optname matches *option. */
char *optname, *help_string;
{
switch( opt_mode ) {
case 1: if( help_mode )
printf( "\n" );
opt_mode = 2;
/* flow through */
case 2: if( help_mode && help_string != 0 ) {
printf( "-%s\t", optname );
while( *help_string != 0 && *help_string != '\3' ) {
putchar( *help_string );
help_string++;
}
if( *help_string != '\3' )
putchar( '\n' );
return( 0 );
}
if( strlen(optname) == 1 ) {
if( optname[0] == option[0] ) {
if( option[1] != 0 )
holding_arg = option+1;
option = optname;
opt_mode = 3;
}
}
else { if( strcmp(optname,option) == 0 ) {
option = optname;
opt_mode = 3;
}
}
return( opt_mode == 3 );
}
return( 0 );
}
static struct {
char *name;
short type;
size_t size;
short integer;
long min, max;
} *t, types[] = {
"short", TYPE_SHORT, sizeof(short), 1, SHRT_MIN, SHRT_MAX,
"int", TYPE_INT, sizeof(int), 1, INT_MIN, INT_MAX,
"long", TYPE_LONG, sizeof(long), 1, LONG_MIN, LONG_MAX,
"float", TYPE_FLOAT, sizeof(float), 0, 0, 0,
"double", TYPE_DOUBLE, sizeof(double), 0, 0, 0 };
void opt_argset( address, size, type )
char *address;
{
double dbl, floor();
char line[120], check_char, *arg;
arg = opt_arg();
for( t=types; t->type != type ; t++ ) {
if( t->type == 0 )
estop( "Programming error on option `-%s'", option );
}
if( size != t->size )
estop( "Program bug. Bad variable type used for `-%s'", option );
if( type == TYPE_STR_PTR ) {
*(char **)address = arg;
return;
}
check_char = 0;
sprintf( line, "%s\007", arg );
sscanf( line, "%lf%c", &dbl, &check_char );
if( check_char != 7 )
estop( "`-%s' expected a number, found `%s'", option, arg );
if( t->integer && (floor(dbl) != dbl || dbl < t->min || dbl > t->max) )
estop( "`-%s' expected type (%s), found `%s'", option, t->name, arg );
switch( type ) {
case TYPE_SHORT: *(short *)address = dbl; break;
case TYPE_INT: *(int *)address = dbl; break;
case TYPE_LONG: *(long *)address = dbl; break;
case TYPE_FLOAT: *(float *)address = dbl; break;
case TYPE_DOUBLE: *(double *)address = dbl; break;
}
}
char *opt_arg()
/* Return the address of string following the last detected option. */
{
int i;
char *argument;
if( holding_arg != 0 ) {
argument = holding_arg;
holding_arg = 0;
}
else { argument=argv[argcc];
if( argument == 0 )
estop( "Ran out of arguments for `-%s'", option );
for( i=argcc; i < *argcp; i++ )
argv[i] = argv[i+1];
(*argcp)--;
}
return( argument );
}
double opt_atof() /* return the double value of the next arg */
{
double d;
opt_argset( (char *)&d, sizeof(d), TYPE_DOUBLE );
return( d );
}
long opt_atol() /* return the long value of the next arg */
{
long l;
opt_argset( (char *)&l, sizeof(l), TYPE_LONG );
return( l );
}
opt_atoi() /* return the int value of the next arg */
{
int i;
opt_argset( (char *)&i, sizeof(i), TYPE_INT );
return( i );
}