|
 |
26e14f |
/****************************************************************************/
|
|
|
26e14f |
/* argv.h: a thread-safe argument vector parser and usage screen generator */
|
|
|
9572ed |
/* Copyright (C) 2015--2024 SysDeer Technologies, LLC */
|
|
|
26e14f |
/* Released under GPLv2 and GPLv3; see COPYING.NTUX. */
|
|
|
26e14f |
/****************************************************************************/
|
|
|
26e14f |
|
|
|
26e14f |
#ifndef ARGV_H
|
|
|
26e14f |
#define ARGV_H
|
|
|
26e14f |
|
|
|
26e14f |
#include <stdbool.h>
|
|
|
26e14f |
#include <stdint.h>
|
|
|
26e14f |
#include <stddef.h>
|
|
|
26e14f |
#include <string.h>
|
|
|
26e14f |
#include <stdlib.h>
|
|
|
26e14f |
#include <stdio.h>
|
|
|
aef26f |
#include <ctype.h>
|
|
|
26e14f |
#include <unistd.h>
|
|
|
26e14f |
|
|
|
26e14f |
#define ARGV_VERBOSITY_NONE 0x00
|
|
|
26e14f |
#define ARGV_VERBOSITY_ERRORS 0x01
|
|
|
26e14f |
#define ARGV_VERBOSITY_STATUS 0x02
|
|
|
26e14f |
#define ARGV_CLONE_VECTOR 0x80
|
|
|
26e14f |
|
|
|
26e14f |
#ifndef ARGV_TAB_WIDTH
|
|
|
26e14f |
#define ARGV_TAB_WIDTH 8
|
|
|
26e14f |
#endif
|
|
|
26e14f |
|
|
|
26e14f |
/*******************************************/
|
|
|
26e14f |
/* */
|
|
|
26e14f |
/* support of hybrid options */
|
|
|
26e14f |
/* ------------------------- */
|
|
|
26e14f |
/* hybrid options are very similar to */
|
|
|
26e14f |
/* long options, yet are prefixed by */
|
|
|
26e14f |
/* a single dash rather than two */
|
|
|
26e14f |
/* (i.e. -std, -isystem). */
|
|
|
26e14f |
/* hybrid options are supported by this */
|
|
|
26e14f |
/* driver for compatibility with legacy */
|
|
|
26e14f |
/* tools; note, however, that the use */
|
|
|
26e14f |
/* of hybrid options should be strongly */
|
|
|
26e14f |
/* discouraged due to the limitations */
|
|
|
26e14f |
/* they impose on short options (for */
|
|
|
26e14f |
/* example, a driver implementing -std */
|
|
|
26e14f |
/* may not provide -s as a short option */
|
|
|
26e14f |
/* that takes an arbitrary value). */
|
|
|
26e14f |
/* */
|
|
|
26e14f |
/* SPACE: -hybrid VALUE (i.e. -MF file) */
|
|
|
26e14f |
/* EQUAL: -hybrid=VALUE (i.e. -std=c99) */
|
|
|
26e14f |
/* COMMA: -hybrid,VALUE (i.e. -Wl,<arg>) */
|
|
|
26e14f |
/* ONLY: -opt accepted, --opt rejected */
|
|
|
26e14f |
/* JOINED: -optVALUE */
|
|
|
26e14f |
/* */
|
|
|
26e14f |
/*******************************************/
|
|
|
26e14f |
|
|
|
26e14f |
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_NONE 0x00
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_ONLY 0x01
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_SPACE 0x02
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_EQUAL 0x04
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_COMMA 0x08
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_JOINED 0x10
|
|
|
aef26f |
|
|
|
aef26f |
#define ARGV_OPTION_KEYVAL_PAIR 0X20
|
|
|
aef26f |
#define ARGV_OPTION_KEYVAL_ARRAY 0X40
|
|
|
aef26f |
#define ARGV_OPTION_KEYVAL_MASK (ARGV_OPTION_KEYVAL_PAIR \
|
|
|
aef26f |
| ARGV_OPTION_KEYVAL_ARRAY)
|
|
|
aef26f |
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_CIRCUS (ARGV_OPTION_HYBRID_SPACE \
|
|
|
26e14f |
| ARGV_OPTION_HYBRID_JOINED)
|
|
|
aef26f |
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_DUAL (ARGV_OPTION_HYBRID_SPACE \
|
|
|
26e14f |
| ARGV_OPTION_HYBRID_EQUAL)
|
|
|
aef26f |
|
|
|
26e14f |
#define ARGV_OPTION_HYBRID_SWITCH (ARGV_OPTION_HYBRID_ONLY \
|
|
|
26e14f |
| ARGV_OPTION_HYBRID_SPACE \
|
|
|
26e14f |
| ARGV_OPTION_HYBRID_EQUAL \
|
|
|
26e14f |
| ARGV_OPTION_HYBRID_COMMA \
|
|
|
26e14f |
| ARGV_OPTION_HYBRID_JOINED)
|
|
|
26e14f |
|
|
|
aef26f |
#define ARGV_KEYVAL_ASSIGN 0x01
|
|
|
aef26f |
#define ARGV_KEYVAL_OVERRIDE 0x02
|
|
|
aef26f |
|
|
|
26e14f |
enum argv_optarg {
|
|
|
26e14f |
ARGV_OPTARG_NONE,
|
|
|
26e14f |
ARGV_OPTARG_REQUIRED,
|
|
|
26e14f |
ARGV_OPTARG_OPTIONAL,
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
26e14f |
enum argv_mode {
|
|
|
26e14f |
ARGV_MODE_SCAN,
|
|
|
26e14f |
ARGV_MODE_COPY,
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
26e14f |
enum argv_error {
|
|
|
26e14f |
ARGV_ERROR_OK,
|
|
|
26e14f |
ARGV_ERROR_INTERNAL,
|
|
|
26e14f |
ARGV_ERROR_SHORT_OPTION,
|
|
|
26e14f |
ARGV_ERROR_LONG_OPTION,
|
|
|
9572ed |
ARGV_ERROR_VENDOR_OPTION,
|
|
|
26e14f |
ARGV_ERROR_OPTARG_NONE,
|
|
|
26e14f |
ARGV_ERROR_OPTARG_REQUIRED,
|
|
|
26e14f |
ARGV_ERROR_OPTARG_PARADIGM,
|
|
|
26e14f |
ARGV_ERROR_HYBRID_NONE,
|
|
|
26e14f |
ARGV_ERROR_HYBRID_ONLY,
|
|
|
26e14f |
ARGV_ERROR_HYBRID_SPACE,
|
|
|
26e14f |
ARGV_ERROR_HYBRID_EQUAL,
|
|
|
26e14f |
ARGV_ERROR_HYBRID_COMMA,
|
|
|
aef26f |
ARGV_ERROR_KEYVAL_KEY,
|
|
|
aef26f |
ARGV_ERROR_KEYVAL_VALUE,
|
|
|
aef26f |
ARGV_ERROR_KEYVAL_ALLOC,
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
26e14f |
struct argv_option {
|
|
|
26e14f |
const char * long_name;
|
|
|
26e14f |
const char short_name;
|
|
|
26e14f |
int tag;
|
|
|
26e14f |
enum argv_optarg optarg;
|
|
|
26e14f |
int flags;
|
|
|
26e14f |
const char * paradigm;
|
|
|
26e14f |
const char * argname;
|
|
|
26e14f |
const char * description;
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
aef26f |
struct argv_keyval {
|
|
|
aef26f |
const char * keyword;
|
|
|
aef26f |
const char * value;
|
|
|
aef26f |
int flags;
|
|
|
aef26f |
};
|
|
|
aef26f |
|
|
|
26e14f |
struct argv_entry {
|
|
|
789000 |
const char * arg;
|
|
|
aef26f |
struct argv_keyval * keyv;
|
|
|
789000 |
int tag;
|
|
|
789000 |
bool fopt;
|
|
|
789000 |
bool fval;
|
|
|
789000 |
bool fnoscan;
|
|
|
789000 |
enum argv_error errcode;
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
26e14f |
struct argv_meta {
|
|
|
26e14f |
char ** argv;
|
|
|
26e14f |
struct argv_entry * entries;
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
26e14f |
struct argv_ctx {
|
|
|
26e14f |
int flags;
|
|
|
26e14f |
int mode;
|
|
|
26e14f |
int nentries;
|
|
|
2404cd |
intptr_t unitidx;
|
|
|
2404cd |
intptr_t erridx;
|
|
|
26e14f |
enum argv_error errcode;
|
|
|
26e14f |
const char * errch;
|
|
|
26e14f |
const struct argv_option * erropt;
|
|
|
26e14f |
const char * program;
|
|
|
aef26f |
size_t keyvlen;
|
|
|
26e14f |
};
|
|
|
26e14f |
|
|
|
26e14f |
#ifdef ARGV_DRIVER
|
|
|
26e14f |
|
|
|
f3c634 |
struct argv_meta_impl {
|
|
|
f3c634 |
char ** argv;
|
|
|
f3c634 |
char * strbuf;
|
|
|
aef26f |
char * keyvbuf;
|
|
|
aef26f |
char * keyvmark;
|
|
|
f3c634 |
struct argv_meta meta;
|
|
|
f3c634 |
};
|
|
|
f3c634 |
|
|
|
2404cd |
static int argv_optv_init(
|
|
|
2404cd |
const struct argv_option[],
|
|
|
2404cd |
const struct argv_option **);
|
|
|
2404cd |
|
|
|
26e14f |
static const char * argv_program_name(const char *);
|
|
|
26e14f |
|
|
|
26e14f |
static void argv_usage(
|
|
|
1a5016 |
int fd,
|
|
|
26e14f |
const char * header,
|
|
|
2404cd |
const struct argv_option **,
|
|
|
26e14f |
const char * mode);
|
|
|
26e14f |
|
|
|
edf2db |
static void argv_usage_plain(
|
|
|
edf2db |
int fd,
|
|
|
edf2db |
const char * header,
|
|
|
edf2db |
const struct argv_option **,
|
|
|
edf2db |
const char * mode);
|
|
|
edf2db |
|
|
|
26e14f |
static struct argv_meta * argv_get(
|
|
|
26e14f |
char **,
|
|
|
2404cd |
const struct argv_option **,
|
|
|
1a5016 |
int flags,
|
|
|
1a5016 |
int fd);
|
|
|
26e14f |
|
|
|
26e14f |
static void argv_free(struct argv_meta *);
|
|
|
26e14f |
|
|
|
1a5016 |
#ifndef argv_dprintf
|
|
|
1a5016 |
#define argv_dprintf dprintf
|
|
|
1a5016 |
#endif
|
|
|
26e14f |
|
|
|
26e14f |
|
|
|
26e14f |
|
|
|
26e14f |
/*------------------------------------*/
|
|
|
26e14f |
/* implementation of static functions */
|
|
|
26e14f |
/*------------------------------------*/
|
|
|
26e14f |
|
|
|
2404cd |
static int argv_optv_init(
|
|
|
2404cd |
const struct argv_option options[],
|
|
|
2404cd |
const struct argv_option ** optv)
|
|
|
2404cd |
{
|
|
|
2404cd |
const struct argv_option * option;
|
|
|
2404cd |
int i;
|
|
|
2404cd |
|
|
|
2404cd |
for (option=options,i=0; option->long_name || option->short_name; option++)
|
|
|
2404cd |
optv[i++] = option;
|
|
|
2404cd |
|
|
|
2404cd |
optv[i] = 0;
|
|
|
2404cd |
return i;
|
|
|
2404cd |
}
|
|
|
2404cd |
|
|
|
26e14f |
static const struct argv_option * argv_short_option(
|
|
|
26e14f |
const char * ch,
|
|
|
2404cd |
const struct argv_option ** optv,
|
|
|
26e14f |
struct argv_entry * entry)
|
|
|
26e14f |
{
|
|
|
26e14f |
const struct argv_option * option;
|
|
|
26e14f |
|
|
|
2404cd |
for (; *optv; optv++) {
|
|
|
2404cd |
option = *optv;
|
|
|
2404cd |
|
|
|
26e14f |
if (option->short_name == *ch) {
|
|
|
26e14f |
entry->tag = option->tag;
|
|
|
26e14f |
entry->fopt = true;
|
|
|
26e14f |
return option;
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static const struct argv_option * argv_long_option(
|
|
|
26e14f |
const char * ch,
|
|
|
2404cd |
const struct argv_option ** optv,
|
|
|
26e14f |
struct argv_entry * entry)
|
|
|
26e14f |
{
|
|
|
26e14f |
const struct argv_option * option;
|
|
|
26e14f |
const char * arg;
|
|
|
26e14f |
size_t len;
|
|
|
26e14f |
|
|
|
2404cd |
for (; *optv; optv++) {
|
|
|
2404cd |
option = *optv;
|
|
|
2404cd |
len = option->long_name ? strlen(option->long_name) : 0;
|
|
|
26e14f |
|
|
|
26e14f |
if (len && !(strncmp(option->long_name,ch,len))) {
|
|
|
26e14f |
arg = ch + len;
|
|
|
26e14f |
|
|
|
26e14f |
if (!*arg
|
|
|
26e14f |
|| (*arg == '=')
|
|
|
26e14f |
|| (option->flags & ARGV_OPTION_HYBRID_JOINED)
|
|
|
26e14f |
|| ((option->flags & ARGV_OPTION_HYBRID_COMMA)
|
|
|
26e14f |
&& (*arg == ','))) {
|
|
|
26e14f |
entry->tag = option->tag;
|
|
|
26e14f |
entry->fopt = true;
|
|
|
26e14f |
return option;
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static inline bool is_short_option(const char * arg)
|
|
|
26e14f |
{
|
|
|
26e14f |
return (arg[0]=='-') && arg[1] && (arg[1]!='-');
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static inline bool is_long_option(const char * arg)
|
|
|
26e14f |
{
|
|
|
26e14f |
return (arg[0]=='-') && (arg[1]=='-') && arg[2];
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static inline bool is_last_option(const char * arg)
|
|
|
26e14f |
{
|
|
|
26e14f |
return (arg[0]=='-') && (arg[1]=='-') && !arg[2];
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static inline bool is_hybrid_option(
|
|
|
26e14f |
const char * arg,
|
|
|
2404cd |
const struct argv_option ** optv)
|
|
|
26e14f |
{
|
|
|
26e14f |
const struct argv_option * option;
|
|
|
26e14f |
struct argv_entry entry;
|
|
|
26e14f |
|
|
|
26e14f |
if (!is_short_option(arg))
|
|
|
26e14f |
return false;
|
|
|
26e14f |
|
|
|
2404cd |
if (!(option = argv_long_option(++arg,optv,&entry)))
|
|
|
26e14f |
return false;
|
|
|
26e14f |
|
|
|
26e14f |
if (!(option->flags & ARGV_OPTION_HYBRID_SWITCH))
|
|
|
2404cd |
if (argv_short_option(arg,optv,&entry))
|
|
|
26e14f |
return false;
|
|
|
26e14f |
|
|
|
26e14f |
return true;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static inline bool is_arg_in_paradigm(const char * arg, const char * paradigm)
|
|
|
26e14f |
{
|
|
|
26e14f |
size_t len;
|
|
|
26e14f |
const char * ch;
|
|
|
26e14f |
|
|
|
26e14f |
for (ch=paradigm,len=strlen(arg); ch; ) {
|
|
|
26e14f |
if (!strncmp(arg,ch,len)) {
|
|
|
26e14f |
if (!*(ch += len))
|
|
|
26e14f |
return true;
|
|
|
26e14f |
else if (*ch == '|')
|
|
|
26e14f |
return true;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if ((ch = strchr(ch,'|')))
|
|
|
26e14f |
ch++;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
return false;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static inline const struct argv_option * option_from_tag(
|
|
|
2404cd |
const struct argv_option ** optv,
|
|
|
26e14f |
int tag)
|
|
|
26e14f |
{
|
|
|
2404cd |
for (; *optv; optv++)
|
|
|
2404cd |
if (optv[0]->tag == tag)
|
|
|
2404cd |
return optv[0];
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
aef26f |
static inline int argv_scan_keyval_array(struct argv_meta_impl * meta, struct argv_entry * entry)
|
|
|
aef26f |
{
|
|
|
aef26f |
const char * ch;
|
|
|
aef26f |
char * dst;
|
|
|
aef26f |
int ncomma;
|
|
|
aef26f |
int cint;
|
|
|
aef26f |
struct argv_keyval * keyv;
|
|
|
aef26f |
|
|
|
aef26f |
/* count key[val] elements, assume no comma after last element */
|
|
|
aef26f |
for (ch=entry->arg,ncomma=1; *ch; ch++) {
|
|
|
aef26f |
if ((ch[0]=='\\') && (ch[1]==',')) {
|
|
|
aef26f |
ch++;
|
|
|
aef26f |
|
|
|
aef26f |
} else if ((ch[0]==',')) {
|
|
|
aef26f |
ncomma++;
|
|
|
aef26f |
}
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
aef26f |
/* keyval string buffer */
|
|
|
aef26f |
dst = meta->keyvmark;
|
|
|
aef26f |
|
|
|
aef26f |
/* allocate keyval array */
|
|
|
aef26f |
if (!(entry->keyv = calloc(ncomma+1,sizeof(*entry->keyv))))
|
|
|
aef26f |
return ARGV_ERROR_KEYVAL_ALLOC;
|
|
|
aef26f |
|
|
|
aef26f |
/* create keyval array */
|
|
|
aef26f |
entry->keyv->keyword = dst;
|
|
|
aef26f |
|
|
|
aef26f |
for (ch=entry->arg,keyv=entry->keyv; *ch; ch++) {
|
|
|
aef26f |
if ((ch[0]=='\\') && (ch[1]==',')) {
|
|
|
aef26f |
*dst++ = ',';
|
|
|
aef26f |
ch++;
|
|
|
aef26f |
|
|
|
aef26f |
} else if ((ch[0]==':') && (ch[1]=='=')) {
|
|
|
aef26f |
if (!keyv->keyword[0])
|
|
|
aef26f |
return ARGV_ERROR_KEYVAL_KEY;
|
|
|
aef26f |
|
|
|
aef26f |
keyv->flags = ARGV_KEYVAL_OVERRIDE;
|
|
|
aef26f |
keyv->value = ++dst;
|
|
|
aef26f |
ch++;
|
|
|
aef26f |
|
|
|
aef26f |
} else if ((ch[0]=='=')) {
|
|
|
aef26f |
if (!keyv->keyword[0])
|
|
|
aef26f |
return ARGV_ERROR_KEYVAL_KEY;
|
|
|
aef26f |
|
|
|
aef26f |
keyv->flags = ARGV_KEYVAL_ASSIGN;
|
|
|
aef26f |
keyv->value = ++dst;
|
|
|
aef26f |
|
|
|
aef26f |
} else if ((ch[0]==',')) {
|
|
|
aef26f |
for (; isblank(cint = ch[1]); )
|
|
|
aef26f |
ch++;
|
|
|
aef26f |
|
|
|
aef26f |
if (ch[1]) {
|
|
|
aef26f |
keyv++;
|
|
|
aef26f |
keyv->keyword = ++dst;
|
|
|
aef26f |
}
|
|
|
aef26f |
} else {
|
|
|
aef26f |
*dst++ = *ch;
|
|
|
aef26f |
}
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
aef26f |
/* keyval string buffer */
|
|
|
aef26f |
meta->keyvmark = ++dst;
|
|
|
aef26f |
|
|
|
aef26f |
return ARGV_ERROR_OK;
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
aef26f |
static inline int argv_scan_keyval_pair(struct argv_meta_impl * meta, struct argv_entry * entry)
|
|
|
aef26f |
{
|
|
|
aef26f |
const char * ch;
|
|
|
aef26f |
char * dst;
|
|
|
aef26f |
struct argv_keyval * keyv;
|
|
|
aef26f |
|
|
|
aef26f |
/* keyval string buffer */
|
|
|
aef26f |
dst = meta->keyvmark;
|
|
|
aef26f |
|
|
|
aef26f |
/* allocate keyval array */
|
|
|
aef26f |
if (!(entry->keyv = calloc(2,sizeof(*entry->keyv))))
|
|
|
aef26f |
return ARGV_ERROR_KEYVAL_ALLOC;
|
|
|
aef26f |
|
|
|
aef26f |
/* create keyval array */
|
|
|
aef26f |
entry->keyv->keyword = dst;
|
|
|
aef26f |
|
|
|
aef26f |
for (ch=entry->arg,keyv=entry->keyv; *ch && !keyv->flags; ch++) {
|
|
|
aef26f |
if ((ch[0]=='\\') && (ch[1]==',')) {
|
|
|
aef26f |
*dst++ = ',';
|
|
|
aef26f |
ch++;
|
|
|
aef26f |
|
|
|
aef26f |
} else if ((ch[0]==':') && (ch[1]=='=')) {
|
|
|
aef26f |
if (!keyv->keyword[0])
|
|
|
aef26f |
return ARGV_ERROR_KEYVAL_KEY;
|
|
|
aef26f |
|
|
|
aef26f |
keyv->flags = ARGV_KEYVAL_OVERRIDE;
|
|
|
aef26f |
keyv->value = ++dst;
|
|
|
aef26f |
ch++;
|
|
|
aef26f |
|
|
|
aef26f |
} else if ((ch[0]=='=')) {
|
|
|
aef26f |
if (!keyv->keyword[0])
|
|
|
aef26f |
return ARGV_ERROR_KEYVAL_KEY;
|
|
|
aef26f |
|
|
|
aef26f |
keyv->flags = ARGV_KEYVAL_ASSIGN;
|
|
|
aef26f |
keyv->value = ++dst;
|
|
|
aef26f |
|
|
|
aef26f |
} else {
|
|
|
aef26f |
*dst++ = *ch;
|
|
|
aef26f |
}
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
aef26f |
for (; *ch; )
|
|
|
aef26f |
*dst++ = *ch++;
|
|
|
aef26f |
|
|
|
aef26f |
/* keyval string buffer */
|
|
|
aef26f |
meta->keyvmark = ++dst;
|
|
|
aef26f |
|
|
|
aef26f |
return ARGV_ERROR_OK;
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
26e14f |
static void argv_scan(
|
|
|
26e14f |
char ** argv,
|
|
|
2404cd |
const struct argv_option ** optv,
|
|
|
26e14f |
struct argv_ctx * ctx,
|
|
|
26e14f |
struct argv_meta * meta)
|
|
|
26e14f |
{
|
|
|
aef26f |
struct argv_meta_impl * imeta;
|
|
|
aef26f |
uintptr_t addr;
|
|
|
26e14f |
char ** parg;
|
|
|
26e14f |
const char * ch;
|
|
|
26e14f |
const char * val;
|
|
|
26e14f |
const struct argv_option * option;
|
|
|
26e14f |
struct argv_entry entry;
|
|
|
26e14f |
struct argv_entry * mentry;
|
|
|
26e14f |
enum argv_error ferr;
|
|
|
26e14f |
bool fval;
|
|
|
26e14f |
bool fnext;
|
|
|
26e14f |
bool fshort;
|
|
|
26e14f |
bool fhybrid;
|
|
|
26e14f |
bool fnoscan;
|
|
|
26e14f |
|
|
|
aef26f |
addr = (uintptr_t)meta - offsetof(struct argv_meta_impl,meta);
|
|
|
aef26f |
imeta = (struct argv_meta_impl *)addr;
|
|
|
aef26f |
|
|
|
26e14f |
parg = &argv[1];
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
ferr = ARGV_ERROR_OK;
|
|
|
26e14f |
fshort = false;
|
|
|
26e14f |
fnoscan = false;
|
|
|
26e14f |
fval = false;
|
|
|
26e14f |
mentry = meta ? meta->entries : 0;
|
|
|
26e14f |
|
|
|
26e14f |
ctx->unitidx = 0;
|
|
|
26e14f |
ctx->erridx = 0;
|
|
|
26e14f |
|
|
|
26e14f |
while (ch && (ferr == ARGV_ERROR_OK)) {
|
|
|
26e14f |
option = 0;
|
|
|
26e14f |
fhybrid = false;
|
|
|
26e14f |
|
|
|
26e14f |
if (fnoscan)
|
|
|
26e14f |
fval = true;
|
|
|
26e14f |
|
|
|
26e14f |
else if (is_last_option(ch))
|
|
|
26e14f |
fnoscan = true;
|
|
|
26e14f |
|
|
|
2404cd |
else if (!fshort && is_hybrid_option(ch,optv))
|
|
|
26e14f |
fhybrid = true;
|
|
|
26e14f |
|
|
|
26e14f |
if (!fnoscan && !fhybrid && (fshort || is_short_option(ch))) {
|
|
|
26e14f |
if (!fshort)
|
|
|
26e14f |
ch++;
|
|
|
26e14f |
|
|
|
2404cd |
if ((option = argv_short_option(ch,optv,&entry))) {
|
|
|
26e14f |
if (ch[1]) {
|
|
|
26e14f |
ch++;
|
|
|
26e14f |
fnext = false;
|
|
|
26e14f |
fshort = (option->optarg == ARGV_OPTARG_NONE);
|
|
|
26e14f |
} else {
|
|
|
26e14f |
parg++;
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
fnext = true;
|
|
|
26e14f |
fshort = false;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (option->optarg == ARGV_OPTARG_NONE) {
|
|
|
105c6c |
if (!fnext && ch && (*ch == '-')) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_NONE;
|
|
|
105c6c |
} else {
|
|
|
26e14f |
fval = false;
|
|
|
105c6c |
}
|
|
|
105c6c |
|
|
|
105c6c |
} else if (!fnext) {
|
|
|
26e14f |
fval = true;
|
|
|
105c6c |
|
|
|
105c6c |
} else if (option->optarg == ARGV_OPTARG_REQUIRED) {
|
|
|
26e14f |
if (ch && is_short_option(ch))
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
26e14f |
else if (ch && is_long_option(ch))
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
26e14f |
else if (ch && is_last_option(ch))
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
26e14f |
else if (ch)
|
|
|
26e14f |
fval = true;
|
|
|
26e14f |
else
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
26e14f |
} else {
|
|
|
26e14f |
/* ARGV_OPTARG_OPTIONAL */
|
|
|
26e14f |
if (ch && is_short_option(ch))
|
|
|
26e14f |
fval = false;
|
|
|
26e14f |
else if (ch && is_long_option(ch))
|
|
|
26e14f |
fval = false;
|
|
|
26e14f |
else if (ch && is_last_option(ch))
|
|
|
26e14f |
fval = false;
|
|
|
f74847 |
else if (fnext)
|
|
|
f74847 |
fval = false;
|
|
|
26e14f |
else
|
|
|
26e14f |
fval = ch;
|
|
|
26e14f |
}
|
|
|
105c6c |
} else {
|
|
|
9572ed |
if ((ch == &parg[0][1]) && (ch[0] == 'W') && ch[1]) {
|
|
|
9572ed |
ferr = ARGV_ERROR_VENDOR_OPTION;
|
|
|
9572ed |
} else {
|
|
|
9572ed |
ferr = ARGV_ERROR_SHORT_OPTION;
|
|
|
9572ed |
}
|
|
|
105c6c |
}
|
|
|
26e14f |
|
|
|
26e14f |
} else if (!fnoscan && (fhybrid || is_long_option(ch))) {
|
|
|
26e14f |
ch += (fhybrid ? 1 : 2);
|
|
|
26e14f |
|
|
|
2404cd |
if ((option = argv_long_option(ch,optv,&entry))) {
|
|
|
26e14f |
val = ch + strlen(option->long_name);
|
|
|
26e14f |
|
|
|
26e14f |
/* val[0] is either '=' (or ',') or '\0' */
|
|
|
26e14f |
if (!val[0]) {
|
|
|
26e14f |
parg++;
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
8d9037 |
/* now verify the proper setting of option values */
|
|
|
8d9037 |
if (fhybrid && !(option->flags & ARGV_OPTION_HYBRID_SWITCH)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_HYBRID_NONE;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (!fhybrid && (option->flags & ARGV_OPTION_HYBRID_ONLY)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_HYBRID_ONLY;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (option->optarg == ARGV_OPTARG_NONE) {
|
|
|
26e14f |
if (val[0]) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_NONE;
|
|
|
26e14f |
ctx->errch = val + 1;
|
|
|
8d9037 |
} else {
|
|
|
26e14f |
fval = false;
|
|
|
8d9037 |
}
|
|
|
8d9037 |
|
|
|
26e14f |
} else if (val[0] && (option->flags & ARGV_OPTION_HYBRID_JOINED)) {
|
|
|
26e14f |
fval = true;
|
|
|
26e14f |
ch = val;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (fhybrid && !val[0] && !(option->flags & ARGV_OPTION_HYBRID_SPACE)) {
|
|
|
6dd82b |
if (option->optarg == ARGV_OPTARG_OPTIONAL) {
|
|
|
6dd82b |
fval = false;
|
|
|
6dd82b |
|
|
|
6dd82b |
} else {
|
|
|
6dd82b |
ferr = ARGV_ERROR_HYBRID_SPACE;
|
|
|
6dd82b |
}
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (fhybrid && (val[0]=='=') && !(option->flags & ARGV_OPTION_HYBRID_EQUAL)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_HYBRID_EQUAL;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (fhybrid && (val[0]==',') && !(option->flags & ARGV_OPTION_HYBRID_COMMA)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_HYBRID_COMMA;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (!fhybrid && (val[0]==',')) {
|
|
|
26e14f |
ferr = ARGV_ERROR_HYBRID_COMMA;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (val[0] && !val[1]) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (val[0] && val[1]) {
|
|
|
26e14f |
fval = true;
|
|
|
26e14f |
ch = ++val;
|
|
|
8d9037 |
|
|
|
26e14f |
} else if (option->optarg == ARGV_OPTARG_REQUIRED) {
|
|
|
8d9037 |
if (!val[0] && !*parg) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (*parg && is_short_option(*parg)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (*parg && is_long_option(*parg)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else if (*parg && is_last_option(*parg)) {
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_REQUIRED;
|
|
|
8d9037 |
|
|
|
8d9037 |
} else {
|
|
|
26e14f |
fval = true;
|
|
|
8d9037 |
}
|
|
|
26e14f |
} else {
|
|
|
26e14f |
/* ARGV_OPTARG_OPTIONAL */
|
|
|
26e14f |
fval = val[0];
|
|
|
26e14f |
}
|
|
|
8d9037 |
} else {
|
|
|
26e14f |
ferr = ARGV_ERROR_LONG_OPTION;
|
|
|
8d9037 |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (ferr == ARGV_ERROR_OK)
|
|
|
26e14f |
if (option && fval && option->paradigm)
|
|
|
26e14f |
if (!is_arg_in_paradigm(ch,option->paradigm))
|
|
|
26e14f |
ferr = ARGV_ERROR_OPTARG_PARADIGM;
|
|
|
26e14f |
|
|
|
26e14f |
if (ferr == ARGV_ERROR_OK)
|
|
|
26e14f |
if (!option && !ctx->unitidx)
|
|
|
26e14f |
ctx->unitidx = parg - argv;
|
|
|
26e14f |
|
|
|
aef26f |
if (ferr == ARGV_ERROR_OK)
|
|
|
aef26f |
if (option && (option->flags & ARGV_OPTION_KEYVAL_MASK))
|
|
|
aef26f |
if (ctx->mode == ARGV_MODE_SCAN)
|
|
|
aef26f |
ctx->keyvlen += strlen(ch) + 1;
|
|
|
aef26f |
|
|
|
26e14f |
if (ferr != ARGV_ERROR_OK) {
|
|
|
26e14f |
ctx->errcode = ferr;
|
|
|
26e14f |
ctx->errch = ctx->errch ? ctx->errch : ch;
|
|
|
26e14f |
ctx->erropt = option;
|
|
|
26e14f |
ctx->erridx = parg - argv;
|
|
|
26e14f |
return;
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
aef26f |
if (ctx->mode == ARGV_MODE_SCAN) {
|
|
|
26e14f |
if (!fnoscan)
|
|
|
26e14f |
ctx->nentries++;
|
|
|
26e14f |
else if (fval)
|
|
|
26e14f |
ctx->nentries++;
|
|
|
26e14f |
|
|
|
26e14f |
if (fval || !option) {
|
|
|
26e14f |
parg++;
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
}
|
|
|
aef26f |
|
|
|
26e14f |
} else if (ctx->mode == ARGV_MODE_COPY) {
|
|
|
26e14f |
if (fnoscan) {
|
|
|
26e14f |
if (fval) {
|
|
|
26e14f |
mentry->arg = ch;
|
|
|
26e14f |
mentry->fnoscan = true;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
parg++;
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
} else if (option) {
|
|
|
26e14f |
mentry->arg = fval ? ch : 0;
|
|
|
26e14f |
mentry->tag = option->tag;
|
|
|
26e14f |
mentry->fopt = true;
|
|
|
26e14f |
mentry->fval = fval;
|
|
|
26e14f |
|
|
|
26e14f |
if (fval) {
|
|
|
26e14f |
parg++;
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
}
|
|
|
26e14f |
} else {
|
|
|
26e14f |
mentry->arg = ch;
|
|
|
26e14f |
parg++;
|
|
|
26e14f |
ch = *parg;
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
aef26f |
|
|
|
aef26f |
if (option && (option->flags & ARGV_OPTION_KEYVAL_PAIR))
|
|
|
aef26f |
if (ctx->mode == ARGV_MODE_COPY)
|
|
|
aef26f |
ferr = argv_scan_keyval_pair(imeta,mentry);
|
|
|
aef26f |
|
|
|
aef26f |
if (option && (option->flags & ARGV_OPTION_KEYVAL_ARRAY))
|
|
|
aef26f |
if (ctx->mode == ARGV_MODE_COPY)
|
|
|
aef26f |
ferr = argv_scan_keyval_array(imeta,mentry);
|
|
|
aef26f |
|
|
|
aef26f |
if (ferr != ARGV_ERROR_OK) {
|
|
|
aef26f |
ctx->errcode = ferr;
|
|
|
aef26f |
ctx->errch = ctx->errch ? ctx->errch : ch;
|
|
|
aef26f |
ctx->erropt = option;
|
|
|
aef26f |
ctx->erridx = parg - argv;
|
|
|
aef26f |
return;
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
aef26f |
mentry++;
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static const char * argv_program_name(const char * program_path)
|
|
|
26e14f |
{
|
|
|
26e14f |
const char * ch;
|
|
|
26e14f |
|
|
|
26e14f |
if (program_path) {
|
|
|
26e14f |
if ((ch = strrchr(program_path,'/')))
|
|
|
26e14f |
return *(++ch) ? ch : 0;
|
|
|
26e14f |
|
|
|
26e14f |
if ((ch = strrchr(program_path,'\\')))
|
|
|
26e14f |
return *(++ch) ? ch : 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
return program_path;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
1a5016 |
static void argv_show_error(int fd, struct argv_ctx * ctx)
|
|
|
26e14f |
{
|
|
|
4e4fd2 |
const char * src;
|
|
|
4e4fd2 |
char * dst;
|
|
|
4e4fd2 |
char * cap;
|
|
|
4e4fd2 |
char opt_vendor_buf[256];
|
|
|
4e4fd2 |
char opt_short_name[2] = {0,0};
|
|
|
26e14f |
|
|
|
26e14f |
if (ctx->erropt && ctx->erropt->short_name)
|
|
|
26e14f |
opt_short_name[0] = ctx->erropt->short_name;
|
|
|
26e14f |
|
|
|
1a5016 |
argv_dprintf(fd,"%s: error: ",ctx->program);
|
|
|
26e14f |
|
|
|
26e14f |
switch (ctx->errcode) {
|
|
|
26e14f |
case ARGV_ERROR_SHORT_OPTION:
|
|
|
1a5016 |
argv_dprintf(fd,"'-%c' is not a valid short option\n",*ctx->errch);
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
case ARGV_ERROR_LONG_OPTION:
|
|
|
1a5016 |
argv_dprintf(fd,"'--%s' is not a valid long option\n",ctx->errch);
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
9572ed |
case ARGV_ERROR_VENDOR_OPTION:
|
|
|
4e4fd2 |
src = ctx->errch;
|
|
|
4e4fd2 |
dst = opt_vendor_buf;
|
|
|
9572ed |
cap = &opt_vendor_buf[sizeof(opt_vendor_buf)];
|
|
|
9572ed |
|
|
|
4e4fd2 |
for (; src && *src && dst
|
|
|
4e4fd2 |
if ((*src == '=') || (*src == ',') || (*src == ':')) {
|
|
|
4e4fd2 |
src = 0;
|
|
|
4e4fd2 |
} else {
|
|
|
4e4fd2 |
*dst++ = *src++;
|
|
|
4e4fd2 |
}
|
|
|
4e4fd2 |
}
|
|
|
4e4fd2 |
|
|
|
4e4fd2 |
if (dst == cap)
|
|
|
4e4fd2 |
dst--;
|
|
|
4e4fd2 |
|
|
|
4e4fd2 |
*dst = '\0';
|
|
|
9572ed |
|
|
|
9572ed |
argv_dprintf(fd,"'-%s' is not a valid vendor option\n",opt_vendor_buf);
|
|
|
9572ed |
break;
|
|
|
9572ed |
|
|
|
26e14f |
case ARGV_ERROR_OPTARG_NONE:
|
|
|
1a5016 |
argv_dprintf(fd,"'%s' is not a valid option value for [%s%s%s%s%s] "
|
|
|
26e14f |
"(option values may not be specified)\n",
|
|
|
26e14f |
ctx->errch,
|
|
|
26e14f |
opt_short_name[0] ? "-" : "",
|
|
|
26e14f |
opt_short_name,
|
|
|
26e14f |
opt_short_name[0] ? "," : "",
|
|
|
26e14f |
ctx->erropt->long_name ? "--" : "",
|
|
|
26e14f |
ctx->erropt->long_name);
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
case ARGV_ERROR_OPTARG_REQUIRED:
|
|
|
1a5016 |
argv_dprintf(fd,"option [%s%s%s%s%s] requires %s %s%s%s\n",
|
|
|
26e14f |
opt_short_name[0] ? "-" : "",
|
|
|
26e14f |
opt_short_name,
|
|
|
26e14f |
opt_short_name[0] ? "," : "",
|
|
|
8146f5 |
ctx->erropt->long_name
|
|
|
8146f5 |
? (ctx->erropt->flags & ARGV_OPTION_HYBRID_ONLY) ? "-" : "--"
|
|
|
8146f5 |
: "",
|
|
|
26e14f |
ctx->erropt->long_name,
|
|
|
26e14f |
ctx->erropt->paradigm ? "one of the following values:" : "a value",
|
|
|
26e14f |
ctx->erropt->paradigm ? "{" : "",
|
|
|
26e14f |
ctx->erropt->paradigm ? ctx->erropt->paradigm : "",
|
|
|
26e14f |
ctx->erropt->paradigm ? "}" : "");
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
case ARGV_ERROR_OPTARG_PARADIGM:
|
|
|
1a5016 |
argv_dprintf(fd,"'%s' is not a valid option value for [%s%s%s%s%s]={%s}\n",
|
|
|
26e14f |
ctx->errch,
|
|
|
26e14f |
opt_short_name[0] ? "-" : "",
|
|
|
26e14f |
opt_short_name,
|
|
|
26e14f |
opt_short_name[0] ? "," : "",
|
|
|
26e14f |
ctx->erropt->long_name ? "--" : "",
|
|
|
26e14f |
ctx->erropt->long_name,
|
|
|
26e14f |
ctx->erropt->paradigm);
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
case ARGV_ERROR_HYBRID_NONE:
|
|
|
1a5016 |
argv_dprintf(fd,"-%s is not a synonym for --%s\n",
|
|
|
26e14f |
ctx->erropt->long_name,
|
|
|
26e14f |
ctx->erropt->long_name);
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
case ARGV_ERROR_HYBRID_ONLY:
|
|
|
1a5016 |
argv_dprintf(fd,"--%s is not a synonym for -%s\n",
|
|
|
26e14f |
ctx->erropt->long_name,
|
|
|
26e14f |
ctx->erropt->long_name);
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
case ARGV_ERROR_HYBRID_SPACE:
|
|
|
26e14f |
case ARGV_ERROR_HYBRID_EQUAL:
|
|
|
26e14f |
case ARGV_ERROR_HYBRID_COMMA:
|
|
|
1a5016 |
argv_dprintf(fd,"-%s: illegal value assignment; valid syntax is "
|
|
|
26e14f |
"-%s%sVAL\n",
|
|
|
26e14f |
ctx->erropt->long_name,
|
|
|
26e14f |
ctx->erropt->long_name,
|
|
|
26e14f |
(ctx->erropt->flags & ARGV_OPTION_HYBRID_SPACE)
|
|
|
26e14f |
? " " : (ctx->erropt->flags & ARGV_OPTION_HYBRID_EQUAL)
|
|
|
26e14f |
? "=" : (ctx->erropt->flags & ARGV_OPTION_HYBRID_COMMA)
|
|
|
26e14f |
? "," : "");
|
|
|
26e14f |
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
aef26f |
case ARGV_ERROR_KEYVAL_KEY:
|
|
|
aef26f |
argv_dprintf(fd,"illegal key detected in keyval argument\n");
|
|
|
aef26f |
break;
|
|
|
aef26f |
|
|
|
aef26f |
case ARGV_ERROR_KEYVAL_VALUE:
|
|
|
aef26f |
argv_dprintf(fd,"illegal value detected in keyval argument\n");
|
|
|
aef26f |
break;
|
|
|
aef26f |
|
|
|
26e14f |
case ARGV_ERROR_INTERNAL:
|
|
|
1a5016 |
argv_dprintf(fd,"internal error");
|
|
|
26e14f |
break;
|
|
|
26e14f |
|
|
|
26e14f |
default:
|
|
|
26e14f |
break;
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static void argv_show_status(
|
|
|
1a5016 |
int fd,
|
|
|
2404cd |
const struct argv_option ** optv,
|
|
|
26e14f |
struct argv_ctx * ctx,
|
|
|
26e14f |
struct argv_meta * meta)
|
|
|
26e14f |
{
|
|
|
58d730 |
int i;
|
|
|
26e14f |
int argc;
|
|
|
26e14f |
char ** argv;
|
|
|
58d730 |
struct argv_keyval * keyv;
|
|
|
26e14f |
struct argv_entry * entry;
|
|
|
26e14f |
const struct argv_option * option;
|
|
|
26e14f |
char short_name[2] = {0};
|
|
|
26e14f |
const char * space = "";
|
|
|
26e14f |
|
|
|
26e14f |
(void)ctx;
|
|
|
26e14f |
|
|
|
1a5016 |
argv_dprintf(fd,"\n\nconcatenated command line:\n");
|
|
|
26e14f |
for (argv=meta->argv; *argv; argv++) {
|
|
|
1a5016 |
argv_dprintf(fd,"%s%s",space,*argv);
|
|
|
26e14f |
space = " ";
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
1a5016 |
argv_dprintf(fd,"\n\nargument vector:\n");
|
|
|
26e14f |
for (argc=0,argv=meta->argv; *argv; argc++,argv++)
|
|
|
1a5016 |
argv_dprintf(fd,"argv[%d]: %s\n",argc,*argv);
|
|
|
26e14f |
|
|
|
1a5016 |
argv_dprintf(fd,"\n\nparsed entries:\n");
|
|
|
d17b46 |
for (entry=meta->entries; entry->arg || entry->fopt; entry++) {
|
|
|
26e14f |
if (entry->fopt) {
|
|
|
2404cd |
option = option_from_tag(optv,entry->tag);
|
|
|
26e14f |
short_name[0] = option->short_name;
|
|
|
26e14f |
|
|
|
26e14f |
if (entry->fval)
|
|
|
1a5016 |
argv_dprintf(fd,"[-%s,--%s] := %s\n",
|
|
|
26e14f |
short_name,option->long_name,entry->arg);
|
|
|
26e14f |
else
|
|
|
1a5016 |
argv_dprintf(fd,"[-%s,--%s]\n",
|
|
|
26e14f |
short_name,option->long_name);
|
|
|
58d730 |
|
|
|
58d730 |
if (entry->keyv) {
|
|
|
58d730 |
for (i=0,keyv=entry->keyv; keyv->keyword; i++,keyv++) {
|
|
|
58d730 |
switch (keyv->flags) {
|
|
|
58d730 |
case ARGV_KEYVAL_ASSIGN:
|
|
|
58d730 |
argv_dprintf(fd,"\tkeyval[%d]: <%s>=%s\n",
|
|
|
58d730 |
i,keyv->keyword,keyv->value);
|
|
|
58d730 |
break;
|
|
|
58d730 |
|
|
|
58d730 |
case ARGV_KEYVAL_OVERRIDE:
|
|
|
58d730 |
argv_dprintf(fd,"\tkeyval[%d]: <%s>:=%s\n",
|
|
|
58d730 |
i,keyv->keyword,keyv->value);
|
|
|
58d730 |
break;
|
|
|
58d730 |
|
|
|
58d730 |
default:
|
|
|
58d730 |
argv_dprintf(fd,"\tkeyval[%d]: <%s>\n",
|
|
|
58d730 |
i,keyv->keyword);
|
|
|
58d730 |
break;
|
|
|
58d730 |
}
|
|
|
58d730 |
}
|
|
|
58d730 |
}
|
|
|
d17b46 |
} else {
|
|
|
1a5016 |
argv_dprintf(fd,"<program arg> := %s\n",entry->arg);
|
|
|
d17b46 |
}
|
|
|
d17b46 |
}
|
|
|
26e14f |
|
|
|
1a5016 |
argv_dprintf(fd,"\n\n");
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static struct argv_meta * argv_free_impl(struct argv_meta_impl * imeta)
|
|
|
26e14f |
{
|
|
|
aef26f |
struct argv_entry * entry;
|
|
|
aef26f |
void * addr;
|
|
|
aef26f |
|
|
|
aef26f |
if (imeta->keyvbuf)
|
|
|
aef26f |
for (entry=imeta->meta.entries; entry->fopt || entry->arg; entry++)
|
|
|
aef26f |
if (entry->keyv)
|
|
|
aef26f |
free((addr = entry->keyv));
|
|
|
aef26f |
|
|
|
aef26f |
if (imeta->keyvbuf)
|
|
|
aef26f |
free(imeta->keyvbuf);
|
|
|
aef26f |
|
|
|
26e14f |
if (imeta->argv)
|
|
|
26e14f |
free(imeta->argv);
|
|
|
26e14f |
|
|
|
26e14f |
if (imeta->strbuf)
|
|
|
26e14f |
free(imeta->strbuf);
|
|
|
26e14f |
|
|
|
26e14f |
if (imeta->meta.entries)
|
|
|
26e14f |
free(imeta->meta.entries);
|
|
|
26e14f |
|
|
|
26e14f |
free(imeta);
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static struct argv_meta * argv_alloc(char ** argv, struct argv_ctx * ctx)
|
|
|
26e14f |
{
|
|
|
26e14f |
struct argv_meta_impl * imeta;
|
|
|
26e14f |
char ** vector;
|
|
|
26e14f |
char * dst;
|
|
|
26e14f |
size_t size;
|
|
|
26e14f |
int argc;
|
|
|
26e14f |
int i;
|
|
|
26e14f |
|
|
|
26e14f |
if (!(imeta = calloc(1,sizeof(*imeta))))
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
|
|
|
26e14f |
if (ctx->flags & ARGV_CLONE_VECTOR) {
|
|
|
26e14f |
for (vector=argv,argc=0,size=0; *vector; vector++) {
|
|
|
26e14f |
size += strlen(*vector) + 1;
|
|
|
26e14f |
argc++;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (!(imeta->argv = calloc(argc+1,sizeof(char *))))
|
|
|
26e14f |
return argv_free_impl(imeta);
|
|
|
d8764d |
|
|
|
d8764d |
if (!(imeta->strbuf = calloc(1,size+1)))
|
|
|
26e14f |
return argv_free_impl(imeta);
|
|
|
26e14f |
|
|
|
26e14f |
for (i=0,dst=imeta->strbuf; i
|
|
|
26e14f |
strcpy(dst,argv[i]);
|
|
|
26e14f |
imeta->argv[i] = dst;
|
|
|
26e14f |
dst += strlen(dst)+1;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
imeta->meta.argv = imeta->argv;
|
|
|
d8764d |
} else {
|
|
|
26e14f |
imeta->meta.argv = argv;
|
|
|
d8764d |
}
|
|
|
26e14f |
|
|
|
d8764d |
imeta->meta.entries = calloc(
|
|
|
d8764d |
ctx->nentries+1,
|
|
|
d8764d |
sizeof(struct argv_entry));
|
|
|
d8764d |
|
|
|
d8764d |
if (!imeta->meta.entries)
|
|
|
26e14f |
return argv_free_impl(imeta);
|
|
|
d8764d |
|
|
|
aef26f |
if (ctx->keyvlen) {
|
|
|
aef26f |
imeta->keyvbuf = calloc(
|
|
|
aef26f |
ctx->keyvlen,
|
|
|
aef26f |
sizeof(char));
|
|
|
aef26f |
|
|
|
aef26f |
if (!(imeta->keyvmark = imeta->keyvbuf))
|
|
|
aef26f |
return argv_free_impl(imeta);
|
|
|
aef26f |
}
|
|
|
aef26f |
|
|
|
d8764d |
return &imeta->meta;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static struct argv_meta * argv_get(
|
|
|
a1a795 |
char ** argv,
|
|
|
2404cd |
const struct argv_option ** optv,
|
|
|
1a5016 |
int flags,
|
|
|
1a5016 |
int fd)
|
|
|
26e14f |
{
|
|
|
26e14f |
struct argv_meta * meta;
|
|
|
aef26f |
struct argv_ctx ctx = {flags,ARGV_MODE_SCAN,0,0,0,0,0,0,0,0};
|
|
|
26e14f |
|
|
|
2404cd |
argv_scan(argv,optv,&ctx,0);
|
|
|
26e14f |
|
|
|
26e14f |
if (ctx.errcode != ARGV_ERROR_OK) {
|
|
|
26e14f |
ctx.program = argv_program_name(argv[0]);
|
|
|
26e14f |
|
|
|
26e14f |
if (ctx.flags & ARGV_VERBOSITY_ERRORS)
|
|
|
1a5016 |
argv_show_error(fd,&ctx;;
|
|
|
26e14f |
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (!(meta = argv_alloc(argv,&ctx)))
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
|
|
|
26e14f |
ctx.mode = ARGV_MODE_COPY;
|
|
|
2404cd |
argv_scan(meta->argv,optv,&ctx,meta);
|
|
|
26e14f |
|
|
|
26e14f |
if (ctx.errcode != ARGV_ERROR_OK) {
|
|
|
26e14f |
ctx.program = argv[0];
|
|
|
26e14f |
ctx.errcode = ARGV_ERROR_INTERNAL;
|
|
|
1a5016 |
argv_show_error(fd,&ctx;;
|
|
|
26e14f |
argv_free(meta);
|
|
|
26e14f |
|
|
|
26e14f |
return 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (ctx.flags & ARGV_VERBOSITY_STATUS)
|
|
|
1a5016 |
argv_show_status(fd,optv,&ctx,meta);
|
|
|
26e14f |
|
|
|
26e14f |
return meta;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
static void argv_free(struct argv_meta * xmeta)
|
|
|
26e14f |
{
|
|
|
26e14f |
struct argv_meta_impl * imeta;
|
|
|
26e14f |
uintptr_t addr;
|
|
|
26e14f |
|
|
|
26e14f |
if (xmeta) {
|
|
|
26e14f |
addr = (uintptr_t)xmeta - offsetof(struct argv_meta_impl,meta);
|
|
|
26e14f |
imeta = (struct argv_meta_impl *)addr;
|
|
|
26e14f |
argv_free_impl(imeta);
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
edf2db |
static void argv_usage_impl(
|
|
|
1a5016 |
int fd,
|
|
|
26e14f |
const char * header,
|
|
|
2404cd |
const struct argv_option ** options,
|
|
|
edf2db |
const char * mode,
|
|
|
edf2db |
int fcolor)
|
|
|
26e14f |
{
|
|
|
2404cd |
const struct argv_option ** optv;
|
|
|
26e14f |
const struct argv_option * option;
|
|
|
9f82d5 |
int nlong;
|
|
|
26e14f |
bool fshort,flong,fboth;
|
|
|
26e14f |
size_t len,optlen,desclen;
|
|
|
26e14f |
char cache;
|
|
|
26e14f |
char * prefix;
|
|
|
26e14f |
char * desc;
|
|
|
26e14f |
char * mark;
|
|
|
26e14f |
char * cap;
|
|
|
26e14f |
char description[4096];
|
|
|
26e14f |
char optstr [72];
|
|
|
26e14f |
const size_t optcap = 64;
|
|
|
26e14f |
const size_t width = 80;
|
|
|
26e14f |
const char indent[] = " ";
|
|
|
26e14f |
const char creset[] = "\x1b[0m";
|
|
|
26e14f |
const char cbold [] = "\x1b[1m";
|
|
|
26e14f |
const char cgreen[] = "\x1b[32m";
|
|
|
26e14f |
const char cblue [] = "\x1b[34m";
|
|
|
26e14f |
const char ccyan [] = "\x1b[36m";
|
|
|
26e14f |
const char * color = ccyan;
|
|
|
edf2db |
|
|
|
edf2db |
(void)argv_usage;
|
|
|
edf2db |
(void)argv_usage_plain;
|
|
|
26e14f |
|
|
|
26e14f |
fshort = mode ? !strcmp(mode,"short") : 0;
|
|
|
26e14f |
flong = fshort ? 0 : mode && !strcmp(mode,"long");
|
|
|
26e14f |
fboth = !fshort && !flong;
|
|
|
26e14f |
|
|
|
26e14f |
if (fcolor)
|
|
|
1a5016 |
argv_dprintf(fd,"%s%s",cbold,cgreen);
|
|
|
26e14f |
|
|
|
26e14f |
if (header)
|
|
|
1a5016 |
argv_dprintf(fd,"%s",header);
|
|
|
26e14f |
|
|
|
9f82d5 |
for (optlen=0,nlong=0,optv=options; *optv; optv++) {
|
|
|
2404cd |
option = *optv;
|
|
|
26e14f |
|
|
|
26e14f |
/* indent + comma */
|
|
|
26e14f |
len = fboth ? sizeof(indent) + 1 : sizeof(indent);
|
|
|
26e14f |
|
|
|
26e14f |
/* -o */
|
|
|
26e14f |
if (fshort || fboth)
|
|
|
26e14f |
len += option->short_name
|
|
|
26e14f |
? 2 : 0;
|
|
|
26e14f |
|
|
|
26e14f |
/* --option */
|
|
|
26e14f |
if (flong || fboth)
|
|
|
26e14f |
len += option->long_name
|
|
|
26e14f |
? 2 + strlen(option->long_name) : 0;
|
|
|
26e14f |
|
|
|
26e14f |
/* optlen */
|
|
|
26e14f |
if (len > optlen)
|
|
|
26e14f |
optlen = len;
|
|
|
9f82d5 |
|
|
|
9f82d5 |
/* long (vs. hybrid-only) option? */
|
|
|
9f82d5 |
if (option->long_name)
|
|
|
9f82d5 |
if (!(option->flags & ARGV_OPTION_HYBRID_ONLY))
|
|
|
9f82d5 |
nlong++;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (optlen >= optcap) {
|
|
|
1a5016 |
argv_dprintf(fd,
|
|
|
26e14f |
"Option strings exceed %zu characters, "
|
|
|
26e14f |
"please generate the usage screen manually.\n",
|
|
|
26e14f |
optcap);
|
|
|
26e14f |
return;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
optlen += ARGV_TAB_WIDTH;
|
|
|
26e14f |
optlen &= (~(ARGV_TAB_WIDTH-1));
|
|
|
26e14f |
desclen = (optlen < width / 2) ? width - optlen : optlen;
|
|
|
26e14f |
|
|
|
2404cd |
for (optv=options; *optv; optv++) {
|
|
|
2404cd |
option = *optv;
|
|
|
2404cd |
|
|
|
26e14f |
/* color */
|
|
|
26e14f |
if (fcolor) {
|
|
|
26e14f |
color = (color == ccyan) ? cblue : ccyan;
|
|
|
9b9ab0 |
argv_dprintf(fd,color,0);
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
/* description, using either paradigm or argname if applicable */
|
|
|
26e14f |
snprintf(description,sizeof(description),option->description,
|
|
|
26e14f |
option->paradigm
|
|
|
26e14f |
? option->paradigm
|
|
|
26e14f |
: option->argname ? option->argname : "");
|
|
|
26e14f |
description[sizeof(description)-1] = 0;
|
|
|
26e14f |
|
|
|
26e14f |
/* long/hybrid option prefix (-/--) */
|
|
|
26e14f |
prefix = option->flags & ARGV_OPTION_HYBRID_ONLY
|
|
|
872148 |
? " -" : " --";
|
|
|
26e14f |
|
|
|
9f82d5 |
/* avoid extra <stace> when all long opts are hybrid-only */
|
|
|
9f82d5 |
if (nlong == 0)
|
|
|
9f82d5 |
prefix++;
|
|
|
9f82d5 |
|
|
|
26e14f |
/* option string */
|
|
|
26e14f |
if (fboth && option->short_name && option->long_name)
|
|
|
26e14f |
sprintf(optstr,"%s-%c,%s%s",
|
|
|
26e14f |
indent,option->short_name,prefix,option->long_name);
|
|
|
26e14f |
|
|
|
26e14f |
else if ((fshort || fboth) && option->short_name)
|
|
|
26e14f |
sprintf(optstr,"%s-%c",indent,option->short_name);
|
|
|
26e14f |
|
|
|
26e14f |
else if (flong && option->long_name)
|
|
|
26e14f |
sprintf(optstr,"%s%s%s",
|
|
|
26e14f |
indent,prefix,option->long_name);
|
|
|
26e14f |
|
|
|
26e14f |
else if (fboth && option->long_name)
|
|
|
26e14f |
sprintf(optstr,"%s %s%s",
|
|
|
26e14f |
indent,prefix,option->long_name);
|
|
|
26e14f |
|
|
|
26e14f |
else
|
|
|
26e14f |
optstr[0] = 0;
|
|
|
26e14f |
|
|
|
26e14f |
/* right-indented option buffer */
|
|
|
26e14f |
if (description[0]) {
|
|
|
26e14f |
len = strlen(optstr);
|
|
|
26e14f |
sprintf(&optstr[len],"%-*c",(int)(optlen-len),' ');
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
/* single line? */
|
|
|
26e14f |
if (optlen + strlen(description) < width) {
|
|
|
1a5016 |
argv_dprintf(fd,"%s%s\n",optstr,description);
|
|
|
26e14f |
|
|
|
26e14f |
} else {
|
|
|
26e14f |
desc = description;
|
|
|
26e14f |
cap = desc + strlen(description);
|
|
|
26e14f |
|
|
|
26e14f |
while (desc < cap) {
|
|
|
26e14f |
mark = (desc + desclen >= cap)
|
|
|
26e14f |
? cap : desc + desclen;
|
|
|
26e14f |
|
|
|
26e14f |
while (*mark && (mark > desc)
|
|
|
26e14f |
&& (*mark != ' ')
|
|
|
26e14f |
&& (*mark != '|')
|
|
|
26e14f |
&& (*mark != '\t')
|
|
|
26e14f |
&& (*mark != '\n'))
|
|
|
26e14f |
mark--;
|
|
|
26e14f |
|
|
|
26e14f |
if (mark == desc) {
|
|
|
26e14f |
mark = (desc + desclen >= cap)
|
|
|
26e14f |
? cap : desc + desclen;
|
|
|
26e14f |
cache = *mark;
|
|
|
26e14f |
*mark = 0;
|
|
|
26e14f |
} else if (*mark == '|') {
|
|
|
26e14f |
cache = *mark;
|
|
|
26e14f |
*mark = 0;
|
|
|
26e14f |
} else {
|
|
|
26e14f |
cache = 0;
|
|
|
26e14f |
*mark = 0;
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
/* first line? */
|
|
|
26e14f |
if (desc == description)
|
|
|
1a5016 |
argv_dprintf(fd,"%s%s\n",optstr,desc);
|
|
|
26e14f |
else
|
|
|
1a5016 |
argv_dprintf(fd,"%-*c %s\n",
|
|
|
26e14f |
(*desc == '|')
|
|
|
26e14f |
? (int)(optlen+1)
|
|
|
26e14f |
: (int)optlen,
|
|
|
26e14f |
' ',desc);
|
|
|
26e14f |
|
|
|
26e14f |
if (cache)
|
|
|
26e14f |
*mark = cache;
|
|
|
26e14f |
else
|
|
|
26e14f |
mark++;
|
|
|
26e14f |
|
|
|
26e14f |
desc = mark;
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
26e14f |
if (fcolor)
|
|
|
1a5016 |
argv_dprintf(fd,creset);
|
|
|
26e14f |
}
|
|
|
26e14f |
|
|
|
edf2db |
static void argv_usage(
|
|
|
edf2db |
int fd,
|
|
|
edf2db |
const char * header,
|
|
|
edf2db |
const struct argv_option ** options,
|
|
|
edf2db |
const char * mode)
|
|
|
edf2db |
{
|
|
|
edf2db |
argv_usage_impl(fd,header,options,mode,isatty(fd));
|
|
|
edf2db |
}
|
|
|
edf2db |
|
|
|
edf2db |
static void argv_usage_plain(
|
|
|
edf2db |
int fd,
|
|
|
edf2db |
const char * header,
|
|
|
edf2db |
const struct argv_option ** options,
|
|
|
edf2db |
const char * mode)
|
|
|
edf2db |
{
|
|
|
edf2db |
argv_usage_impl(fd,header,options,mode,0);
|
|
|
edf2db |
}
|
|
|
edf2db |
|
|
|
26e14f |
#endif
|
|
|
26e14f |
|
|
|
26e14f |
#endif
|