2.11BSD/src/local/qterm/options.c
/*
* Copyright (c) 1990 Michael A. Cooper.
* This software may be freely distributed provided it is not sold for
* profit and the author is credited appropriately.
*/
#if !defined(lint) && defined(DOSCCS)
static char *RCSid = "$Header: options.c,v 1.13.1 96/3/23 18:13:28 sms Exp $";
#endif
/*
* $Log: options.c,v $
* Revision 1.13 90/12/15 18:13:28 mcooper
* Add copywrite notice.
*
* Revision 1.12 90/12/15 17:51:46 mcooper
* Add #ifdef HAS_VARARGS around include for <varargs>.
*
* Revision 1.11 90/11/13 16:39:28 mcooper
* Add #ifdef HAS_VARARGS for systems without
* varargs.
*
* Revision 1.10 90/11/13 15:28:01 mcooper
* - Add OptBool cvtarg routine.
* - Print default values in HelpOptions()
* when appropriate.
*
* Revision 1.9 90/11/13 15:19:00 mcooper
* Added supported for options being both
* SepArg and StickyArg.
*
* Revision 1.8 90/10/30 21:02:31 mcooper
* Need to exit() if -help is specified.
*
* Revision 1.7 90/10/30 20:24:33 mcooper
* Fixed bug in UsageString().
*
* Revision 1.6 90/10/30 19:53:05 mcooper
* Cleaned up some NeXT cc and lint stuff.
*
* Revision 1.5 90/10/30 19:45:31 mcooper
* Remove unneeded paramter to HelpOptions().
*
* Revision 1.4 90/10/29 14:47:42 mcooper
* Added real function UsageString() to
* handle formating usage option strings.
*
* Revision 1.3 90/10/29 14:17:00 mcooper
* Allow options to be abbreviated
* (for all non StickArg options).
*
* Revision 1.2 90/10/26 15:56:11 mcooper
* - Fix bug in SepArg code that ate arguments.
* - Cleanup help message.
* - Add ArgHidden code.
*
* Revision 1.1 90/10/26 14:42:51 mcooper
* Initial revision
*
*/
/*
* Functions to parse options.
*/
#include "options.h"
#ifdef HAS_VARARGS
#include <varargs.h>
#endif
char *OptionChars = "-+"; /* Default option switching characters */
char *ProgramName = NULL; /* Name of this program */
char *UsageString();
static int isopt();
static int suppress_help_msg = 0;
char *strcat();
/*
* ParseOptions - Parse options found in argv using "options".
* Returns the number of options parsed if there
* were no errors. Returns -1 if an error occurs.
*/
int ParseOptions(options, num_options, argc, argv)
OptionDescRec *options;
int num_options;
int argc;
char **argv;
{
OptionDescRec *opt;
register int x;
char *p;
if (ProgramName == NULL)
ProgramName = argv[0];
#ifdef OPTION_DEBUG
(void) printf("Option list is:\n");
for (x = 0; x < num_options; ++x) {
opt = &options[x];
(void) printf("%s\n", opt->option);
}
(void) printf("Arguments (%d):", argc);
for (x = 0; x < argc; ++x) {
(void) printf(" %s", argv[x]);
}
(void) printf("\n");
#endif /* OPTION_DEBUG */
for (x = 1; x < argc; ++x) {
if (strcmp(HELPSTR, argv[x]) == 0) {
HelpOptions(options, num_options, (char **)NULL);
exit(0);
}
opt = FindOption(options, num_options, argv[x]);
if (opt == NULL) {
if (isopt(argv[x])) { /* this was suppose to be an option */
UsageOptions(options, num_options, argv[x]);
return(-1);
} else { /* must be end of options */
break;
}
}
if (opt->flags & NoArg) {
if (!(*opt->cvtarg)(opt, opt->value, FALSE)) {
UsageOptions(options, num_options, opt->option);
return(-1);
}
} else if (opt->flags & IsArg) {
if (!(*opt->cvtarg)(opt, opt->option, FALSE)) {
UsageOptions(options, num_options, opt->option);
return(-1);
}
} else if ((opt->flags & StickyArg) && (opt->flags & SepArg)) {
p = (char *) &argv[x][strlen(opt->option)];
if (!*p) { /*** SepArg ***/
if (x + 1 >= argc || isopt(argv[x+1])) {
if (opt->value == (caddr_t) NULL) {
UserError("%s: Option requires an argument.", argv[x]);
UsageOptions(options, num_options, opt->option);
return(-1);
}
p = opt->value;
} else {
p = argv[++x];
}
}
if (!(*opt->cvtarg)(opt, p, TRUE)) {
UsageOptions(options, num_options, opt->option);
return(-1);
}
} else if (opt->flags & StickyArg) {
p = (char *) &argv[x][strlen(opt->option)];
if (!*p) {
if (opt->value == (caddr_t) NULL) {
UserError("%s: Option requires an argument.", argv[x]);
UsageOptions(options, num_options, opt->option);
return(-1);
} else {
p = opt->value;
}
}
if (!(*opt->cvtarg)(opt, p, TRUE)) {
UsageOptions(options, num_options, opt->option);
return(-1);
}
} else if (opt->flags & SepArg) {
if (x + 1 >= argc || isopt(argv[x+1])) {
if (opt->value == (caddr_t) NULL) {
UserError("%s: Option requires an argument.", argv[x]);
UsageOptions(options, num_options, opt->option);
return(-1);
} else {
p = opt->value;
}
} else {
p = argv[++x];
}
if (!(*opt->cvtarg)(opt, p, TRUE)) {
UsageOptions(options, num_options, opt->option);
return(-1);
}
} else if (opt->flags & SkipArg) {
x += 2;
} else if (opt->flags & SkipLine) {
return(x);
} else if (opt->flags & SkipNArgs) {
if (opt->value) {
x += atoi(opt->value);
} else {
UserError("Internal Error: No 'value' set for SkipNArgs.");
return(-1);
}
} else {
UserError("Internal Error: Unknown argument type for option '%s'.",
opt->option);
return(-1);
}
}
return(x);
}
/*
* FindOption - Find "option" in "options". Returns NULL if not found.
*/
OptionDescRec *FindOption(options, num_options, option)
OptionDescRec *options;
int num_options;
char *option;
{
OptionDescRec *opt;
register int x;
for (x = 0; x < num_options; ++x) {
opt = &options[x];
if (opt->flags & StickyArg) {
if (strncmp(option, opt->option, strlen(opt->option)) == 0)
return(opt);
} else {
if (strncmp(option, opt->option, strlen(option)) == 0)
return(opt);
}
}
return(NULL);
}
/*
* isopt - Is "str" an option string? Compare first char of str against
* list of option switch characters. Returns TRUE if it is an option.
*/
static int isopt(str)
char *str;
{
register char *p;
for (p = OptionChars; p && *p; *++p) {
if (*str == *p) {
return(TRUE);
}
}
return(FALSE);
}
/*
* UsageOptions - Print a usage message based on "options".
*/
void UsageOptions(options, num_opts, badOption)
OptionDescRec *options;
int num_opts;
char *badOption;
{
OptionDescRec *opt;
char *optstr;
register int x;
int col, len;
if (badOption)
(void) fprintf (stderr, "%s: bad command line option \"%s\"\r\n\n",
ProgramName, badOption);
(void) fprintf (stderr, "usage: %s", ProgramName);
col = 8 + strlen(ProgramName);
for (x = 0; x < num_opts; x++) {
opt = &options[x];
if (opt->flags & ArgHidden)
continue;
optstr = UsageString(opt);
len = strlen(optstr) + 3; /* space [ string ] */
if (col + len > 79) {
(void) fprintf (stderr, "\r\n "); /* 3 spaces */
col = 3;
}
(void) fprintf (stderr, " [%s]", optstr);
col += len;
}
if (suppress_help_msg)
(void) fprintf(stderr, "\r\n\n");
else
(void) fprintf(stderr,
"\r\n\nType \"%s %s\" for a full description.\r\n\n",
ProgramName, HELPSTR);
}
/*
* HelpOptions - Print a nice help/usage message based on options.
*/
void HelpOptions(options, num_opts, message)
OptionDescRec *options;
int num_opts;
char **message;
{
OptionDescRec *opt;
register int x;
char **cpp;
suppress_help_msg = 1;
UsageOptions(options, num_opts, (char *)NULL);
suppress_help_msg = 0;
(void) fprintf (stderr, "where options include:\n");
for (x = 0; x < num_opts; x++) {
opt = &options[x];
if (opt->flags & ArgHidden)
continue;
(void) fprintf (stderr, " %-28s %s\n", UsageString(opt),
(opt->desc) ? opt->desc : "");
if (opt->value && opt->cvtarg != OptBool)
(void) fprintf (stderr, " %-28s [ Default value is %s ]\n",
"", opt->value);
}
if (message) {
(void) putc ('\n', stderr);
for (cpp = message; *cpp; cpp++) {
(void) fputs (*cpp, stderr);
(void) putc ('\n', stderr);
}
(void) putc ('\n', stderr);
}
}
/*
* UserError - Print a user error.
*/
#ifdef HAS_VARARGS
void UserError(va_alist)
va_dcl
{
va_list args;
char *fmt;
va_start(args);
if (ProgramName)
(void) fprintf(stderr, "%s: ", ProgramName);
fmt = (char *) va_arg(args, char *);
(void) vfprintf(stderr, fmt, args);
va_end(args);
(void) fprintf(stderr, "\n");
}
#else
void UserError(fmt, a1, a2, a3, a4, a5, a6)
char *fmt;
{
if (ProgramName)
(void) fprintf(stderr, "%s: ", ProgramName);
(void) fprintf(stderr, fmt, a1, a2, a3, a4, a5, a6);
(void) fprintf(stderr, "\n");
}
#endif
OptBool(opt, value, docopy)
OptionDescRec *opt;
caddr_t value;
int docopy; /*ARGSUSED*/
{
char *vpp;
*(int *) opt->valp = (int) strtol(value, &vpp, 0);
if (*vpp) {
UserError("Invalid integer argument for '%s'.", opt->option);
return(FALSE);
} else {
return(TRUE);
}
}
OptInt(opt, value, docopy)
OptionDescRec *opt;
caddr_t value;
int docopy; /*ARGSUSED*/
{
char *vpp;
*(int *) opt->valp = (int) strtol(value, &vpp, 0);
if (*vpp) {
UserError("Invalid integer argument for '%s'.", opt->option);
return(FALSE);
} else {
return(TRUE);
}
}
OptShort(opt, value, docopy)
OptionDescRec *opt;
caddr_t value;
int docopy; /*ARGSUSED*/
{
char *vpp;
*(short *) opt->valp = (short) strtol(value, &vpp, 0);
if (*vpp) {
UserError("Invalid integer argument for '%s'.", opt->option);
return(FALSE);
} else {
return(TRUE);
}
}
OptLong(opt, value, docopy)
OptionDescRec *opt;
caddr_t value;
int docopy; /*ARGSUSED*/
{
char *vpp;
*(long *) opt->valp = (long) strtol(value, &vpp, 0);
if (*vpp) {
UserError("Invalid integer argument for '%s'.", opt->option);
return(FALSE);
} else {
return(TRUE);
}
}
OptStr(opt, value, docopy)
OptionDescRec *opt;
caddr_t value;
int docopy;
{
char *p;
if (docopy) {
if ((p = (char *) malloc((unsigned)strlen(value)+1)) == NULL) {
UserError("Cannot malloc memory.");
return(FALSE);
}
(void) strcpy(p, value);
} else {
p = value;
}
*(char **) opt->valp = p;
return(TRUE);
}
static char *UsageString(opt)
OptionDescRec *opt;
{
static char buf[BUFSIZ], buf2[BUFSIZ];
(void) sprintf(buf, opt->option);
(void) strcpy(buf2, "");
if (opt->usage) {
(void) sprintf(buf2, "%s%s%s%s",
((opt->flags & StickyArg) &&
!((opt->flags & StickyArg) && (opt->flags & SepArg)))
? "" : " ",
(opt->value) ? "[" : "",
opt->usage,
(opt->value) ? "]" : ""
);
}
(void) strcat(buf, buf2);
return(buf);
}