size_t cmdlen;
int ambig;
int best;
+ struct cmd_item *alias;
/* Allow --long-style options. */
if (aname[0] == '-' && aname[1] == '-' && aname[2] && aname[3]) {
return i;
if (strlen(as->parms[i].name) < cmdlen)
continue;
- /* A hidden option must be a full match (no best matches) */
- if (as->parms[i].flags & CMD_HIDE || !enableAbbreviation)
+
+ /* Check for aliases, which must be full matches */
+ alias = as->parms[i].aliases;
+ while (alias != NULL) {
+ if (strcmp(alias->data, aname) == 0)
+ return i;
+ alias = alias->next;
+ }
+
+ /* A hidden option, or one which cannot be abbreviated,
+ * must be a full match (no best matches) */
+ if (as->parms[i].flags & CMD_HIDE ||
+ as->parms[i].flags & CMD_NOABBRV ||
+ !enableAbbreviation)
continue;
if (strncmp(as->parms[i].name, aname, cmdlen) == 0) {
}
/* print the help for a single parameter */
-static void
-PrintParmHelp(struct cmd_parmdesc *aparm)
+static char *
+ParmHelpString(struct cmd_parmdesc *aparm)
{
+ char *str;
if (aparm->type == CMD_FLAG) {
-#ifdef notdef
- /* doc people don't like seeing this information */
- if (aparm->help)
- printf(" (%s)", aparm->help);
-#endif
- } else if (aparm->help) {
- printf(" <%s>", aparm->help);
- if (aparm->type == CMD_LIST)
- printf("+");
- } else if (aparm->type == CMD_SINGLE)
- printf(" <arg>");
- else if (aparm->type == CMD_LIST)
- printf(" <arg>+");
+ return strdup("");
+ } else {
+ asprintf(&str, " %s<%s>%s%s",
+ aparm->type == CMD_SINGLE_OR_FLAG?"[":"",
+ aparm->help?aparm->help:"arg",
+ aparm->type == CMD_LIST?"+":"",
+ aparm->type == CMD_SINGLE_OR_FLAG?"]":"");
+ return str;
+ }
}
extern char *AFSVersion;
{
int i;
struct cmd_parmdesc *tp;
+ char *str;
+ char *name;
+ size_t len;
+ size_t xtralen;
/* now print usage, from syntax table */
if (noOpcodes)
- printf("Usage: %s", as->a0name);
+ asprintf(&str, "Usage: %s", as->a0name);
else {
if (!strcmp(as->name, initcmd_opcode))
- printf("Usage: %s[%s]", NName(as->a0name, " "), as->name);
+ asprintf(&str, "Usage: %s[%s]", NName(as->a0name, " "), as->name);
else
- printf("Usage: %s%s", NName(as->a0name, " "), as->name);
+ asprintf(&str, "Usage: %s%s", NName(as->a0name, " "), as->name);
}
+ len = strlen(str);
+ printf("%s", str);
+ free(str);
+
for (i = 0; i < CMD_MAXPARMS; i++) {
tp = &as->parms[i];
if (tp->type == 0)
continue; /* seeked over slot */
if (tp->flags & CMD_HIDE)
continue; /* skip hidden options */
- printf(" ");
- if (tp->flags & CMD_OPTIONAL)
- printf("[");
- printf("%s", tp->name);
- PrintParmHelp(tp);
- if (tp->flags & CMD_OPTIONAL)
- printf("]");
+
+ /* The parameter name is the real name, plus any aliases */
+ if (!tp->aliases) {
+ name = strdup(tp->name);
+ } else {
+ size_t namelen;
+ struct cmd_item *alias;
+ namelen = strlen(tp->name) + 1;
+ for (alias = tp->aliases; alias != NULL; alias = alias->next)
+ namelen+=strlen(alias->data) + 3;
+
+ name = malloc(namelen);
+ strlcpy(name, tp->name, namelen);
+
+ for (alias = tp->aliases; alias != NULL; alias = alias->next) {
+ strlcat(name, " | ", namelen);
+ strlcat(name, alias->data, namelen);
+ }
+ }
+
+ /* Work out if we can fit what we want to on this line, or if we need to
+ * start a new one */
+ str = ParmHelpString(tp);
+ xtralen = 1 + strlen(name) + strlen(str) +
+ ((tp->flags & CMD_OPTIONAL)? 2: 0);
+
+ if (len + xtralen > 78) {
+ printf("\n ");
+ len = 8;
+ }
+
+ printf(" %s%s%s%s",
+ tp->flags & CMD_OPTIONAL?"[":"",
+ name,
+ str,
+ tp->flags & CMD_OPTIONAL?"]":"");
+ free(str);
+ len+=xtralen;
}
printf("\n");
}
}
int
-cmd_AddParm(struct cmd_syndesc *as, char *aname, int atype,
- afs_int32 aflags, char *ahelp)
+cmd_AddParmAtOffset(struct cmd_syndesc *as, int ref, char *aname, int atype,
+ afs_int32 aflags, char *ahelp)
{
struct cmd_parmdesc *tp;
- if (as->nParms >= CMD_MAXPARMS)
+ if (ref >= CMD_MAXPARMS)
return CMD_EXCESSPARMS;
- tp = &as->parms[as->nParms++];
+ tp = &as->parms[ref];
tp->name = malloc(strlen(aname) + 1);
assert(tp->name);
strcpy(tp->help, ahelp);
} else
tp->help = NULL;
+
+ tp->aliases = NULL;
+
+ if (as->nParms <= ref)
+ as->nParms = ref+1;
+
+ return 0;
+}
+
+int
+cmd_AddParm(struct cmd_syndesc *as, char *aname, int atype,
+ afs_int32 aflags, char *ahelp)
+{
+ if (as->nParms >= CMD_MAXPARMS)
+ return CMD_EXCESSPARMS;
+
+ return cmd_AddParmAtOffset(as, as->nParms++, aname, atype, aflags, ahelp);
+}
+
+int
+cmd_AddParmAlias(struct cmd_syndesc *as, int pos, char *alias)
+{
+ struct cmd_item *item;
+
+ if (pos > as->nParms)
+ return CMD_EXCESSPARMS;
+
+ item = calloc(1, sizeof(struct cmd_item));
+ item->data = strdup(alias);
+ item->next = as->parms[pos].aliases;
+ as->parms[pos].aliases = item;
+
return 0;
}
/* add a text item to the end of the parameter list */
static int
-AddItem(struct cmd_parmdesc *aparm, char *aval)
+AddItem(struct cmd_parmdesc *aparm, char *aval, char *pname)
{
struct cmd_item *ti, *ni;
+
+ if (aparm->type == CMD_SINGLE ||
+ aparm->type == CMD_SINGLE_OR_FLAG) {
+ if (aparm->items) {
+ fprintf(stderr, "%sToo many values after switch %s\n",
+ NName(pname, ": "), aparm->name);
+ return CMD_NOTLIST;
+ }
+ }
+
ti = calloc(1, sizeof(struct cmd_item));
assert(ti);
ti->data = malloc(strlen(aval) + 1);
tp = as->parms;
for (i = 0; i < CMD_MAXPARMS; i++, tp++) {
switch (tp->type) {
+ case CMD_SINGLE_OR_FLAG:
+ if (tp->items == &dummy)
+ break;
+ /* Deliberately fall through here */
case CMD_SINGLE:
case CMD_LIST:
/* free whole list in both cases, just for fun */
return 1;
}
+/* Add help, apropos commands once */
+static void
+initSyntax(void)
+{
+ struct cmd_syndesc *ts;
+
+ if (!noOpcodes) {
+ ts = cmd_CreateSyntax("help", HelpProc, NULL,
+ "get help on commands");
+ cmd_AddParm(ts, "-topic", CMD_LIST, CMD_OPTIONAL, "help string");
+ cmd_AddParm(ts, "-admin", CMD_FLAG, CMD_OPTIONAL, NULL);
+
+ ts = cmd_CreateSyntax("apropos", AproposProc, NULL,
+ "search by help text");
+ cmd_AddParm(ts, "-topic", CMD_SINGLE, CMD_REQUIRED, "help string");
+
+ cmd_CreateSyntax("version", VersionProc, NULL,
+ (char *)CMD_HIDDEN);
+ cmd_CreateSyntax("-version", VersionProc, NULL,
+ (char *)CMD_HIDDEN);
+ cmd_CreateSyntax("-help", HelpProc, NULL,
+ (char *)CMD_HIDDEN);
+ cmd_CreateSyntax("--version", VersionProc, NULL,
+ (char *)CMD_HIDDEN);
+ cmd_CreateSyntax("--help", HelpProc, NULL,
+ (char *)CMD_HIDDEN);
+ }
+}
+
/* Call the appropriate function, or return syntax error code. Note: if
* no opcode is specified, an initialization routine exists, and it has
* NOT been called before, we invoke the special initialization opcode
*/
int
-cmd_Dispatch(int argc, char **argv)
+cmd_Parse(int argc, char **argv, struct cmd_syndesc **outsyntax)
{
char *pname;
- struct cmd_syndesc *ts;
+ struct cmd_syndesc *ts = NULL;
struct cmd_parmdesc *tparm;
- afs_int32 i, j;
+ int i;
int curType;
int positional;
int ambig;
+ int code = 0;
+ char *param = NULL;
+ char *embeddedvalue = NULL;
static int initd = 0; /*Is this the first time this routine has been called? */
static int initcmdpossible = 1; /*Should be consider parsing the initial command? */
+ *outsyntax = NULL;
+
if (!initd) {
initd = 1;
- /* Add help, apropos commands once */
- if (!noOpcodes) {
- ts = cmd_CreateSyntax("help", HelpProc, NULL,
- "get help on commands");
- cmd_AddParm(ts, "-topic", CMD_LIST, CMD_OPTIONAL, "help string");
- cmd_AddParm(ts, "-admin", CMD_FLAG, CMD_OPTIONAL, NULL);
-
- ts = cmd_CreateSyntax("apropos", AproposProc, NULL,
- "search by help text");
- cmd_AddParm(ts, "-topic", CMD_SINGLE, CMD_REQUIRED,
- "help string");
- ts = cmd_CreateSyntax("version", VersionProc, NULL,
- (char *)CMD_HIDDEN);
- ts = cmd_CreateSyntax("-version", VersionProc, NULL,
- (char *)CMD_HIDDEN);
- ts = cmd_CreateSyntax("-help", HelpProc, NULL,
- (char *)CMD_HIDDEN);
- ts = cmd_CreateSyntax("--version", VersionProc, NULL,
- (char *)CMD_HIDDEN);
- ts = cmd_CreateSyntax("--help", HelpProc, NULL,
- (char *)CMD_HIDDEN);
- }
+ initSyntax();
}
/*Remember the program name */
if (argc == 1) {
if (!NoParmsOK(allSyntax)) {
printf("%s: Type '%s -help' for help\n", pname, pname);
- return (CMD_USAGE);
+ code = CMD_USAGE;
+ goto out;
}
}
} else {
if (argc < 2) {
/* if there is an initcmd, don't print an error message, just
* setup to use the initcmd below. */
- if (!(initcmdpossible && FindSyntax(initcmd_opcode, (int *)0))) {
+ if (!(initcmdpossible && FindSyntax(initcmd_opcode, NULL))) {
printf("%s: Type '%s help' or '%s help <topic>' for help\n",
pname, pname, pname);
- return (CMD_USAGE);
+ code = CMD_USAGE;
+ goto out;
}
}
}
* see if there is a descriptor for the initialization opcode.
* Only try this once. */
initcmdpossible = 0;
- ts = FindSyntax(initcmd_opcode, (int *)0);
+ ts = FindSyntax(initcmd_opcode, NULL);
if (!ts) {
/*There is no initialization opcode available, so we declare
* an error */
"Unrecognized operation '%s'; type '%shelp' for list\n",
argv[1], NName(pname, " "));
}
- return (CMD_UNKNOWNCMD);
+ code = CMD_UNKNOWNCMD;
+ goto out;
} else {
/*Found syntax structure for an initialization opcode. Fix
* up argv and argc to relect what the user
fprintf(stderr,
"%sCan't insert implicit init opcode into command line\n",
NName(pname, ": "));
- return (CMD_INTERNALERROR);
+ code = CMD_INTERNALERROR;
+ goto out;
}
}
} /*Initial opcode not yet attempted */
"Unrecognized operation '%s'; type '%shelp' for list\n",
argv[1], NName(pname, " "));
}
- return CMD_UNKNOWNCMD;
+ code = CMD_UNKNOWNCMD;
+ goto out;
}
} /*Argv[1] is not a valid opcode */
} /*Opcodes are defined */
i = noOpcodes ? 1 : 2;
SetupExpandsFlag(ts);
for (; i < argc; i++) {
+ if (param) {
+ free(param);
+ param = NULL;
+ embeddedvalue = NULL;
+ }
+
/* Only tokens that start with a hyphen and are not followed by a digit
* are considered switches. This allow negative numbers. */
+
if ((argv[i][0] == '-') && !isdigit(argv[i][1])) {
+ int j;
+
/* Find switch */
- j = FindType(ts, argv[i]);
+ if (strrchr(argv[i], '=') != NULL) {
+ param = strdup(argv[i]);
+ embeddedvalue = strrchr(param, '=');
+ *embeddedvalue = '\0';
+ embeddedvalue ++;
+ j = FindType(ts, param);
+ } else {
+ j = FindType(ts, argv[i]);
+ }
+
if (j < 0) {
fprintf(stderr,
"%sUnrecognized or ambiguous switch '%s'; type ",
else
fprintf(stderr, "'%shelp %s' for detailed help\n",
NName(argv[0], " "), ts->name);
- ResetSyntax(ts);
- return (CMD_UNKNOWNSWITCH);
+ code = CMD_UNKNOWNSWITCH;
+ goto out;
}
if (j >= CMD_MAXPARMS) {
fprintf(stderr, "%sInternal parsing error\n",
NName(pname, ": "));
- ResetSyntax(ts);
- return (CMD_INTERNALERROR);
+ code = CMD_INTERNALERROR;
+ goto out;
}
if (ts->parms[j].type == CMD_FLAG) {
ts->parms[j].items = &dummy;
+
+ if (embeddedvalue) {
+ fprintf(stderr, "%sSwitch '%s' doesn't take an argument\n",
+ NName(pname, ": "), ts->parms[j].name);
+ code = CMD_TOOMANY;
+ goto out;
+ }
} else {
positional = 0;
curType = j;
ts->parms[j].flags |= CMD_PROCESSED;
+
+ if (embeddedvalue) {
+ AddItem(&ts->parms[curType], embeddedvalue, pname);
+ }
}
} else {
/* Try to fit in this descr */
if (curType >= CMD_MAXPARMS) {
fprintf(stderr, "%sToo many arguments\n", NName(pname, ": "));
- ResetSyntax(ts);
- return (CMD_TOOMANY);
+ code = CMD_TOOMANY;
+ goto out;
}
tparm = &ts->parms[curType];
continue;
}
- if (tparm->type == CMD_SINGLE) {
+ if (tparm->type == CMD_SINGLE ||
+ tparm->type == CMD_SINGLE_OR_FLAG) {
if (tparm->items) {
fprintf(stderr, "%sToo many values after switch %s\n",
- NName(pname, ": "), tparm->name);
- ResetSyntax(ts);
- return (CMD_NOTLIST);
+ NName(pname, ": "), tparm->name);
+ code = CMD_NOTLIST;
+ goto out;
}
- AddItem(tparm, argv[i]); /* Add to end of list */
+ AddItem(tparm, argv[i], pname); /* Add to end of list */
} else if (tparm->type == CMD_LIST) {
- AddItem(tparm, argv[i]); /* Add to end of list */
+ AddItem(tparm, argv[i], pname); /* Add to end of list */
}
+
/* Now, if we're in positional mode, advance to the next item */
if (positional)
curType = AdvanceType(ts, curType);
/* Display full help syntax if we don't have subcommands */
if (noOpcodes)
PrintFlagHelp(ts);
- ResetSyntax(ts);
- return 0;
+ code = CMD_USAGE;
+ goto out;
}
/* Parsing done, see if we have all of our required parameters */
if (tparm->type == 0)
continue; /* Skipped parm slot */
if ((tparm->flags & CMD_PROCESSED) && tparm->items == 0) {
- fprintf(stderr, "%s The field '%s' isn't completed properly\n",
+ if (tparm->type == CMD_SINGLE_OR_FLAG) {
+ tparm->items = &dummy;
+ } else {
+ fprintf(stderr, "%s The field '%s' isn't completed properly\n",
NName(pname, ": "), tparm->name);
- ResetSyntax(ts);
- tparm->flags &= ~CMD_PROCESSED;
- return (CMD_TOOFEW);
+ code = CMD_TOOFEW;
+ goto out;
+ }
}
if (!(tparm->flags & CMD_OPTIONAL) && tparm->items == 0) {
fprintf(stderr, "%sMissing required parameter '%s'\n",
NName(pname, ": "), tparm->name);
- ResetSyntax(ts);
- tparm->flags &= ~CMD_PROCESSED;
- return (CMD_TOOFEW);
+ code = CMD_TOOFEW;
+ goto out;
}
tparm->flags &= ~CMD_PROCESSED;
}
+ *outsyntax = ts;
+
+out:
+ if (code && ts != NULL)
+ ResetSyntax(ts);
+
+ return code;
+}
+
+int
+cmd_Dispatch(int argc, char **argv)
+{
+ struct cmd_syndesc *ts = NULL;
+ int code;
+
+ code = cmd_Parse(argc, argv, &ts);
+ if (code)
+ return code;
/*
* Before calling the beforeProc and afterProc and all the implications
* now.
*/
if ((ts->proc == HelpProc) || (ts->proc == AproposProc)) {
- i = (*ts->proc) (ts, ts->rock);
- ResetSyntax(ts);
- return (i);
+ code = (*ts->proc) (ts, ts->rock);
+ goto out;
}
/* Now, we just call the procedure and return */
if (beforeProc)
- i = (*beforeProc) (ts, beforeRock);
- else
- i = 0;
- if (i) {
- ResetSyntax(ts);
- return (i);
- }
- i = (*ts->proc) (ts, ts->rock);
+ code = (*beforeProc) (ts, beforeRock);
+
+ if (code)
+ goto out;
+
+ code = (*ts->proc) (ts, ts->rock);
+
if (afterProc)
(*afterProc) (ts, afterRock);
- ResetSyntax(ts); /* Reset and free things */
- return (i);
+out:
+ cmd_FreeOptions(&ts);
+ return code;
+}
+
+void
+cmd_FreeOptions(struct cmd_syndesc **ts)
+{
+ if (*ts != NULL) {
+ ResetSyntax(*ts);
+ *ts = NULL;
+ }
}
/* free token list returned by parseLine */
}
}
}
+
+int
+cmd_OptionAsInt(struct cmd_syndesc *syn, int pos, int *value)
+{
+ if (pos > syn->nParms)
+ return CMD_EXCESSPARMS;
+ if (syn->parms[pos].items == NULL ||
+ syn->parms[pos].items->data == NULL)
+ return CMD_MISSING;
+ if (syn->parms[pos].items == &dummy)
+ return 0;
+
+ *value = strtol(syn->parms[pos].items->data, NULL, 10);
+
+ return 0;
+}
+
+int
+cmd_OptionAsUint(struct cmd_syndesc *syn, int pos,
+ unsigned int *value)
+{
+ if (pos > syn->nParms)
+ return CMD_EXCESSPARMS;
+ if (syn->parms[pos].items == NULL ||
+ syn->parms[pos].items->data == NULL)
+ return CMD_MISSING;
+ if (syn->parms[pos].items == &dummy)
+ return 0;
+
+ *value = strtoul(syn->parms[pos].items->data, NULL, 10);
+
+ return 0;
+}
+
+int
+cmd_OptionAsString(struct cmd_syndesc *syn, int pos, char **value)
+{
+ if (pos > syn->nParms)
+ return CMD_EXCESSPARMS;
+ if (syn->parms[pos].items == NULL || syn->parms[pos].items->data == NULL)
+ return CMD_MISSING;
+ if (syn->parms[pos].items == &dummy)
+ return 0;
+
+ if (*value)
+ free(*value);
+
+ *value = strdup(syn->parms[pos].items->data);
+
+ return 0;
+}
+
+int
+cmd_OptionAsList(struct cmd_syndesc *syn, int pos, struct cmd_item **value)
+{
+ if (pos > syn->nParms)
+ return CMD_EXCESSPARMS;
+ if (syn->parms[pos].items == NULL)
+ return CMD_MISSING;
+
+ *value = syn->parms[pos].items;
+ return 0;
+}
+
+int
+cmd_OptionAsFlag(struct cmd_syndesc *syn, int pos, int *value)
+{
+ if (pos > syn->nParms)
+ return CMD_EXCESSPARMS;
+ if (syn->parms[pos].items == NULL)
+ return CMD_MISSING;
+
+ *value = 1;
+ return 0;
+}
+
+int
+cmd_OptionPresent(struct cmd_syndesc *syn, int pos)
+{
+ if (pos > syn->nParms || syn->parms[pos].items == NULL)
+ return 0;
+
+ return 1;
+}