lib/options.c File Reference

#include "common.h"
#include "hash.h"
#include "verbose.h"
#include "options.h"

Include dependency graph for options.c:

Go to the source code of this file.

Defines
#define	OPTION_TYPE_MASK   (OPTION_BOOLEAN|OPTION_STRING|OPTION_INT|OPTION_FLOAT|OPTION_LONG_LONG|OPTION_DOUBLE)
Functions
static struct optionSpec *	matchingOption (char *name, struct optionSpec *optionSpecs)
static void	validateOption (char *name, char *val, struct optionSpec *optionSpecs)
static void	parseMultiOption (struct hash *hash, char *name, char *val, struct optionSpec *spec)
static boolean	parseAnOption (struct hash *hash, char *arg, struct optionSpec *optionSpecs)
static struct hash *	parseOptions (int *pArgc, char *argv[], boolean justFirst, struct optionSpec *optionSpecs)
hash *	optionParseIntoHash (int *pArgc, char *argv[], boolean justFirst)
static void	setOptions (struct hash *hash)
void	optionHashSome (int *pArgc, char *argv[], boolean justFirst)
void	optionHash (int *pArgc, char *argv[])
void	optionInit (int *pArgc, char *argv[], struct optionSpec *optionSpecs)
static char *	optGet (char *name)
char *	optionVal (char *name, char *defaultVal)
int	optionInt (char *name, int defaultVal)
long long	optionLongLong (char *name, long long defaultVal)
float	optionFloat (char *name, float defaultVal)
slName *	optionMultiVal (char *name, struct slName *defaultVal)
double	optionDouble (char *name, double defaultVal)
boolean	optionExists (char *name)
void	optionMustExist (char *name)
Variables
static char const	rcsid [] = "$Id: options.c,v 1.24 2005/12/12 04:03:40 kent Exp $"
static struct optionSpec	commonOptions []
static struct hash *	options = NULL
static struct optionSpec *	optionSpecification = NULL

---

Define Documentation

#define OPTION_TYPE_MASK   (OPTION_BOOLEAN|OPTION_STRING|OPTION_INT|OPTION_FLOAT|OPTION_LONG_LONG|OPTION_DOUBLE)

Definition at line 22 of file options.c.

Referenced by parseMultiOption(), and validateOption().

---

Function Documentation

static struct optionSpec* matchingOption	(	char *	name,
		struct optionSpec *	optionSpecs
	)			[static, read]

Definition at line 29 of file options.c.

References optionSpec::name, optionSpecs, and sameString.

Referenced by optionVal(), parseAnOption(), and validateOption().

{
while (optionSpecs->name != NULL)
    {
    if (sameString(optionSpecs->name, name))
        return optionSpecs;
    optionSpecs += 1;
    }
return NULL;
}

Here is the caller graph for this function:

static char* optGet

(

char *

name

)

[static]

Definition at line 291 of file options.c.

References errAbort(), hashFindVal(), and options.

Referenced by optionDouble(), optionExists(), optionFloat(), optionInt(), optionLongLong(), optionMustExist(), and optionVal().

{
if (options == NULL)
    errAbort("optGet called before optionHash");
return hashFindVal(options, name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

double optionDouble	(	char *	name,
		double	defaultVal
	)

Definition at line 379 of file options.c.

References errAbort(), and optGet().

{
char *s = optGet(name);
char *valEnd;
double val;
if (s == NULL)
    return defaultVal;

val = strtod(s, &valEnd);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid double: \"%s\"", name, s);
return val;
}

Here is the call graph for this function:

boolean optionExists

(

char *

name

)

Definition at line 394 of file options.c.

References optGet().

Referenced by gfClient(), logDaemonize(), main(), searchOneStrand(), and setOptions().

{
return optGet(name) != NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float optionFloat	(	char *	name,
		float	defaultVal
	)

Definition at line 350 of file options.c.

References errAbort(), and optGet().

Referenced by main().

{
char *s = optGet(name);
char *valEnd;
float val;
if (s == NULL)
    return defaultVal;

val = strtod(s, &valEnd);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid float: \"%s\"", name, s);
return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void optionHash	(	int *	pArgc,
		char *	argv[]
	)

Definition at line 253 of file options.c.

References FALSE, and optionHashSome().

                              :
 *      -option         words starting with dash
 *      option=val      words with = in the middle
 *      -option=val     combining the two.
 * The resulting hash will be keyed by the option name with the val
 * string for value.  For '-option' types the value is 'on'. */
{
optionHashSome(pArgc, argv, FALSE);
}

Here is the call graph for this function:

void optionHashSome	(	int *	pArgc,
		char *	argv[],
		boolean	justFirst
	)

Definition at line 242 of file options.c.

References options, parseOptions(), and setOptions().

Referenced by optionHash().

{
if (options == NULL)
    {
    struct hash *hash = parseOptions(pArgc, argv, justFirst, NULL);
    setOptions(hash);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void optionInit	(	int *	pArgc,
		char *	argv[],
		struct optionSpec *	optionSpecs
	)

Definition at line 265 of file options.c.

References FALSE, options, optionSpecification, optionSpecs, parseOptions(), and setOptions().

Referenced by main().

                              :
 *      -option         words starting with dash
 *      option=val      words with = in the middle
 *      -option=val     combining the two.
 * The resulting hash will be keyed by the option name with the val
 * string for value.  For '-option' types the value is 'on'.
 * The words in argv are parsed in assending order.  If a word of
 * "--" is encountered, argument parsing stops.
 * If optionSpecs is not NULL, it is an array of optionSpec that are
 * used to validate the options.  An option must exist in the array
 * and the value must be convertable to the type specified in flags.
 * Boolean options must no value, all other options must have one.
 * Array is terminated by a optionSpec with a NULL name.
 * If array NULL, no validation is done.
 */
{
if (options == NULL)
    {
    struct hash *hash = parseOptions(pArgc, argv, FALSE, optionSpecs);
    setOptions(hash);
    optionSpecification = optionSpecs;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int optionInt	(	char *	name,
		int	defaultVal
	)

Definition at line 316 of file options.c.

References errAbort(), optGet(), and sameString.

Referenced by main(), and setOptions().

{
char *s = optGet(name);
char *valEnd;
int val;
if (s == NULL)
    return defaultVal;
if (sameString(s,"on"))
    return defaultVal;
val = strtol(s, &valEnd, 10);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid integer: \"%s\"", name, s);
return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

long long optionLongLong	(	char *	name,
		long long	defaultVal
	)

Definition at line 333 of file options.c.

References errAbort(), optGet(), and sameString.

{
char *s = optGet(name);
char *valEnd;
long long val;
if (s == NULL)
    return defaultVal;
if (sameString(s,"on"))
    return defaultVal;
val = strtoll(s, &valEnd, 10);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid long long: \"%s\"", name, s);
return val;
}

Here is the call graph for this function:

struct slName* optionMultiVal	(	char *	name,
		struct slName *	defaultVal
	)			[read]

Definition at line 365 of file options.c.

References errAbort(), hashFindVal(), options, and optionSpecification.

{
struct slName *ret;
if(optionSpecification == NULL)
    errAbort("ERROR: optionMultiVal can only be used after optionInit is called "
             "with a non-NULL optionSpecs");

ret = hashFindVal(options, name);
if (ret == NULL)
     ret = defaultVal;
return ret;
}

Here is the call graph for this function:

void optionMustExist

(

char *

name

)

Definition at line 400 of file options.c.

References errAbort(), and optGet().

{
if (optGet(name) == NULL)
    errAbort("Missing required command line flag %s", name);
}

Here is the call graph for this function:

struct hash* optionParseIntoHash	(	int *	pArgc,
		char *	argv[],
		boolean	justFirst
	)			[read]

Definition at line 218 of file options.c.

References parseOptions().

                                              :
 *      -option         words starting with dash
 *      option=val      words with = in the middle
 *      -option=val     combining the two.
 * The resulting hash will be keyed by the option name with the val
 * string for value.  For '-option' types the value is 'on'. */
{
return parseOptions(pArgc, argv, justFirst, NULL);
}

Here is the call graph for this function:

char* optionVal	(	char *	name,
		char *	defaultVal
	)

Definition at line 299 of file options.c.

References errAbort(), optionSpec::flags, matchingOption(), optGet(), OPTION_MULTI, and optionSpecification.

Referenced by logDaemonize(), and main().

{
char *ret;
/* if a optionSpec was used, make sure this option is not a multi option */
if(optionSpecification != NULL) {
    struct optionSpec *spec = matchingOption(name, optionSpecification);
    if(spec != NULL && (spec->flags & OPTION_MULTI))    
        errAbort("ERROR: optionVal cannot be used to get the value of an OPTION_MULTI");
}

ret = optGet(name);
if (ret == NULL)
     ret = defaultVal;
return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean parseAnOption	(	struct hash *	hash,
		char *	arg,
		struct optionSpec *	optionSpecs
	)			[static]

Definition at line 122 of file options.c.

References FALSE, optionSpec::flags, hashAdd(), matchingOption(), name, OPTION_MULTI, optionSpecs, parseMultiOption(), startsWith(), TRUE, and validateOption().

Referenced by parseOptions().

{
char *name, *val;
char *eqPtr = strchr(arg, '=');

if (!((eqPtr != NULL) || (arg[0] == '-')))
    return FALSE;  /* not an option */

/* A dash by itself is not an option.   It can mean
 * negative strand for some of the DNA oriented utilities. */
if (arg[0] == '-' && (arg[1] == 0 || isspace(arg[1])))
    return FALSE;

/* It's nice to be able to use url's in the command line, but they
 * may have = in them... */
if (startsWith("http://", arg))
    return FALSE;

name = arg;
if (name[0] == '-')
    name++;
if (eqPtr != NULL)
    {
    *eqPtr = '\0';
    val = eqPtr+1;
    }
else
    val = NULL;

if (optionSpecs != NULL)
    validateOption(name, val, optionSpecs);
if (val == NULL)
    val = "on";
if (optionSpecs == NULL)
    hashAdd(hash, name, val);
else
    {
    struct optionSpec *spec = matchingOption(name, optionSpecs);
    if (spec != NULL && (spec->flags & OPTION_MULTI))    /* process multiple instances of option */
        parseMultiOption(hash, name, val, spec);
    else
        hashAdd(hash, name, val);
    }

if (eqPtr != NULL)
    *eqPtr = '=';
return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void parseMultiOption	(	struct hash *	hash,
		char *	name,
		char *	val,
		struct optionSpec *	spec
	)			[static]

Definition at line 98 of file options.c.

References errAbort(), optionSpec::flags, hashAdd(), hashFindVal(), newSlName(), OPTION_STRING, OPTION_TYPE_MASK, and slAddTail().

Referenced by parseAnOption().

{
struct slName *valList;
switch (spec->flags & OPTION_TYPE_MASK)
    {
    case OPTION_STRING:
        valList = hashFindVal(hash, name);
        if (valList == NULL)   /* first multi option */
            {
            valList = newSlName(val);
            hashAdd(hash, name, valList);
            }
        else
            {
            struct slName *el = newSlName(val);
            slAddTail(valList, el); /* added next multi option */
            }
        break;
    default:
        errAbort("UNIMPLEMENTED: multiple instances of a non-string option is not currently implemented");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct hash* parseOptions	(	int *	pArgc,
		char *	argv[],
		boolean	justFirst,
		struct optionSpec *	optionSpecs
	)			[static, read]

Definition at line 176 of file options.c.

References newHash(), optionSpecs, parseAnOption(), and sameString.

Referenced by optionHashSome(), optionInit(), and optionParseIntoHash().

{
int i, origArgc, newArgc = 1;
char **rdPt = argv+1, **wrPt = argv+1;
struct hash *hash = newHash(6);

origArgc = *pArgc;

/* parse arguments */
for (i=1; i<origArgc; ++i)
    {
    if (sameString(*rdPt, "--"))
        {
        rdPt++;
        i++;
        break;
        }
    if (!parseAnOption(hash, *rdPt, optionSpecs))
        {
        /* not an option */
        if (justFirst)
            break;
        *wrPt++ = *rdPt;
        newArgc++;
        }
    rdPt++;
    }

/* copy any remaining positional args */
for (; i<origArgc; ++i)
    {
    *wrPt++ = *rdPt++;
    newArgc++;
    }

*pArgc = newArgc;
*wrPt = NULL; 
return hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void setOptions

(

struct hash *

hash

)

[static]

Definition at line 233 of file options.c.

References optionExists(), optionInt(), options, and verboseSetLevel().

Referenced by optionHashSome(), and optionInit().

{
options = hash;
if (optionExists("verbose"))
    verboseSetLevel(optionInt("verbose", 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void validateOption	(	char *	name,
		char *	val,
		struct optionSpec *	optionSpecs
	)			[static]

Definition at line 42 of file options.c.

References commonOptions, errAbort(), optionSpec::flags, matchingOption(), optionSpec::name, OPTION_BOOLEAN, OPTION_DOUBLE, OPTION_FLOAT, OPTION_INT, OPTION_LONG_LONG, OPTION_STRING, OPTION_TYPE_MASK, and optionSpecs.

Referenced by parseAnOption().

{
char *valEnd;
struct optionSpec *optionSpec = matchingOption(name, optionSpecs);
if (optionSpec == NULL)
    optionSpec = matchingOption(name, commonOptions);
if (optionSpec == NULL)
    errAbort("-%s is not a valid option", name);

switch (optionSpec->flags & OPTION_TYPE_MASK) {
case OPTION_BOOLEAN:
    if (val != NULL)
        errAbort("boolean option -%s must not have value", name);
    break;
case OPTION_STRING:
    if (val == NULL)
        errAbort("string option -%s must have a value", name);
    break;
case OPTION_INT:
    if (val == NULL)
        errAbort("int option -%s must have a value", name);
    strtol(val, &valEnd, 10);
    if ((*val == '\0') || (*valEnd != '\0'))
        errAbort("value of -%s is not a valid integer: \"%s\"",
                 name, val);
    break;
case OPTION_LONG_LONG:
    if (val == NULL)
        errAbort("int option -%s must have a value", name);
    strtoll(val, &valEnd, 10);
    if ((*val == '\0') || (*valEnd != '\0'))
        errAbort("value of -%s is not a valid long long: \"%s\"",
                 name, val);
    break;
case OPTION_FLOAT:
    if (val == NULL)
        errAbort("float option -%s must have a value", name);
    strtod(val, &valEnd);
    if ((*val == '\0') || (*valEnd != '\0'))
        errAbort("value of -%s is not a valid float: \"%s\"",
                 name, val);
    break;
case OPTION_DOUBLE:
    if (val == NULL)
        errAbort("double option -%s must have a value", name);
    strtod(val, &valEnd);
    if ((*val == '\0') || (*valEnd != '\0'))
        errAbort("value of -%s is not a valid double: \"%s\"",
                 name, val);
    break;
default:
    errAbort("bug: invalid type in optionSpec for %s", optionSpec->name);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

struct optionSpec commonOptions[] [static]

Initial value:

 {
   {"verbose", OPTION_INT},
   {NULL, 0},
}

Definition at line 24 of file options.c.

Referenced by validateOption().

struct hash* options = NULL [static]

Definition at line 230 of file options.c.

struct optionSpec* optionSpecification = NULL [static]

Definition at line 231 of file options.c.

Referenced by optionInit(), optionMultiVal(), and optionVal().

char const rcsid[] = "$Id: options.c,v 1.24 2005/12/12 04:03:40 kent Exp $" [static]

Definition at line 15 of file options.c.

---