Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
** File: plgetopt.c
** Description: utilities to parse argc/argv
*/
#include "prmem.h"
#include "prlog.h"
#include "prerror.h"
#include "plstr.h"
#include "plgetopt.h"
#include <string.h>
static char static_Nul = 0;
struct PLOptionInternal {
const char* options; /* client options list specification */
PRIntn argc; /* original number of arguments */
char** argv; /* vector of pointers to arguments */
PRIntn xargc; /* which one we're processing now */
const char* xargv; /* where within *argv[xargc] */
PRIntn minus; /* do we already have the '-'? */
const PLLongOpt* longOpts; /* Caller's array */
PRBool endOfOpts; /* have reached a "--" argument */
PRIntn optionsLen; /* is strlen(options) */
};
/*
** Create the state in which to parse the tokens.
**
** argc the sum of the number of options and their values
** argv the options and their values
** options vector of single character options w/ | w/o ':
*/
PR_IMPLEMENT(PLOptState*)
PL_CreateOptState(PRIntn argc, char** argv, const char* options) {
return PL_CreateLongOptState(argc, argv, options, NULL);
} /* PL_CreateOptState */
PR_IMPLEMENT(PLOptState*)
PL_CreateLongOptState(PRIntn argc, char** argv, const char* options,
const PLLongOpt* longOpts) {
PLOptState* opt = NULL;
PLOptionInternal* internal;
if (NULL == options) {
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
return opt;
}
opt = PR_NEWZAP(PLOptState);
if (NULL == opt) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return opt;
}
internal = PR_NEW(PLOptionInternal);
if (NULL == internal) {
PR_DELETE(opt);
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return NULL;
}
opt->option = 0;
opt->value = NULL;
opt->internal = internal;
opt->longOption = 0;
opt->longOptIndex = -1;
internal->argc = argc;
internal->argv = argv;
internal->xargc = 0;
internal->xargv = &static_Nul;
internal->minus = 0;
internal->options = options;
internal->longOpts = longOpts;
internal->endOfOpts = PR_FALSE;
internal->optionsLen = PL_strlen(options);
return opt;
} /* PL_CreateLongOptState */
/*
** Destroy object created by CreateOptState()
*/
PR_IMPLEMENT(void) PL_DestroyOptState(PLOptState* opt) {
PR_DELETE(opt->internal);
PR_DELETE(opt);
} /* PL_DestroyOptState */
PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(PLOptState* opt) {
PLOptionInternal* internal = opt->internal;
opt->longOption = 0;
opt->longOptIndex = -1;
/*
** If the current xarg points to nul, advance to the next
** element of the argv vector. If the vector index is equal
** to argc, we're out of arguments, so return an EOL.
** Note whether the first character of the new argument is
** a '-' and skip by it if it is.
*/
while (0 == *internal->xargv) {
internal->xargc += 1;
if (internal->xargc >= internal->argc) {
opt->option = 0;
opt->value = NULL;
return PL_OPT_EOL;
}
internal->xargv = internal->argv[internal->xargc];
internal->minus = 0;
if (!internal->endOfOpts && ('-' == *internal->xargv)) {
internal->minus++;
internal->xargv++; /* and consume */
if ('-' == *internal->xargv && internal->longOpts) {
internal->minus++;
internal->xargv++;
if (0 == *internal->xargv) {
internal->endOfOpts = PR_TRUE;
}
}
}
}
/*
** If we already have a '-' or '--' in hand, xargv points to the next
** option. See if we can find a match in the list of possible
** options supplied.
*/
if (internal->minus == 2) {
char* foundEqual = strchr(internal->xargv, '=');
PRIntn optNameLen =
foundEqual ? (foundEqual - internal->xargv) : strlen(internal->xargv);
const PLLongOpt* longOpt = internal->longOpts;
PLOptStatus result = PL_OPT_BAD;
opt->option = 0;
opt->value = NULL;
for (; longOpt->longOptName; ++longOpt) {
if (strncmp(longOpt->longOptName, internal->xargv, optNameLen)) {
continue; /* not a possible match */
}
if (strlen(longOpt->longOptName) != optNameLen) {
continue; /* not a match */
}
/* option name match */
opt->longOptIndex = longOpt - internal->longOpts;
opt->longOption = longOpt->longOption;
/* value is part of the current argv[] element if = was found */
/* note: this sets value even for long options that do not
* require option if specified as --long=value */
if (foundEqual) {
opt->value = foundEqual + 1;
} else if (longOpt->valueRequired) {
/* value is the next argv[] element, if any */
if (internal->xargc + 1 < internal->argc) {
opt->value = internal->argv[++(internal->xargc)];
}
/* missing value */
else {
break; /* return PL_OPT_BAD */
}
}
result = PL_OPT_OK;
break;
}
internal->xargv = &static_Nul; /* consume this */
return result;
}
if (internal->minus) {
PRIntn cop;
PRIntn eoo = internal->optionsLen;
for (cop = 0; cop < eoo; ++cop) {
if (internal->options[cop] == *internal->xargv) {
opt->option = *internal->xargv++;
opt->longOption = opt->option & 0xff;
/*
** if options indicates that there's an associated
** value, it must be provided, either as part of this
** argv[] element or as the next one
*/
if (':' == internal->options[cop + 1]) {
/* value is part of the current argv[] element */
if (0 != *internal->xargv) {
opt->value = internal->xargv;
}
/* value is the next argv[] element, if any */
else if (internal->xargc + 1 < internal->argc) {
opt->value = internal->argv[++(internal->xargc)];
}
/* missing value */
else {
return PL_OPT_BAD;
}
internal->xargv = &static_Nul;
internal->minus = 0;
} else {
opt->value = NULL;
}
return PL_OPT_OK;
}
}
internal->xargv += 1; /* consume that option */
return PL_OPT_BAD;
}
/*
** No '-', so it must be a standalone value. The option is nul.
*/
opt->value = internal->argv[internal->xargc];
internal->xargv = &static_Nul;
opt->option = 0;
return PL_OPT_OK;
} /* PL_GetNextOpt */
/* plgetopt.c */