1 files changed, 260 insertions, 23 deletions

diff --git a/src/internal/argv/argv.h b/src/internal/argv/argv.h
index 0be1d0e..66f80b4 100644
--- a/src/internal/argv/argv.h
+++ b/src/internal/argv/argv.h
@@ -13,6 +13,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <ctype.h>
 #include <unistd.h>
 
 #define ARGV_VERBOSITY_NONE		0x00
@@ -57,16 +58,27 @@
 #define ARGV_OPTION_HYBRID_EQUAL	0x04
 #define ARGV_OPTION_HYBRID_COMMA	0x08
 #define ARGV_OPTION_HYBRID_JOINED	0x10
+
+#define ARGV_OPTION_KEYVAL_PAIR         0X20
+#define ARGV_OPTION_KEYVAL_ARRAY        0X40
+#define ARGV_OPTION_KEYVAL_MASK         (ARGV_OPTION_KEYVAL_PAIR \
+					| ARGV_OPTION_KEYVAL_ARRAY)
+
 #define ARGV_OPTION_HYBRID_CIRCUS	(ARGV_OPTION_HYBRID_SPACE \
 					| ARGV_OPTION_HYBRID_JOINED)
+
 #define ARGV_OPTION_HYBRID_DUAL		(ARGV_OPTION_HYBRID_SPACE \
 					| ARGV_OPTION_HYBRID_EQUAL)
+
 #define ARGV_OPTION_HYBRID_SWITCH	(ARGV_OPTION_HYBRID_ONLY \
 					| ARGV_OPTION_HYBRID_SPACE \
 					| ARGV_OPTION_HYBRID_EQUAL \
 					| ARGV_OPTION_HYBRID_COMMA \
 					| ARGV_OPTION_HYBRID_JOINED)
 
+#define ARGV_KEYVAL_ASSIGN              0x01
+#define ARGV_KEYVAL_OVERRIDE            0x02
+
 enum argv_optarg {
 	ARGV_OPTARG_NONE,
 	ARGV_OPTARG_REQUIRED,
@@ -92,6 +104,9 @@ enum argv_error {
 	ARGV_ERROR_HYBRID_SPACE,
 	ARGV_ERROR_HYBRID_EQUAL,
 	ARGV_ERROR_HYBRID_COMMA,
+	ARGV_ERROR_KEYVAL_KEY,
+	ARGV_ERROR_KEYVAL_VALUE,
+	ARGV_ERROR_KEYVAL_ALLOC,
 };
 
 struct argv_option {
@@ -105,13 +120,20 @@ struct argv_option {
 	const char *		description;
 };
 
+struct argv_keyval {
+	const char *           keyword;
+	const char *           value;
+	int                    flags;
+};
+
 struct argv_entry {
-	const char *	arg;
-	int		tag;
-	bool		fopt;
-	bool		fval;
-	bool		fnoscan;
-	enum argv_error errcode;
+	const char *            arg;
+	struct argv_keyval *    keyv;
+	int                     tag;
+	bool                    fopt;
+	bool                    fval;
+	bool                    fnoscan;
+	enum argv_error         errcode;
 };
 
 struct argv_meta {
@@ -129,6 +151,7 @@ struct argv_ctx {
 	const char *			errch;
 	const struct argv_option *	erropt;
 	const char *			program;
+	size_t				keyvlen;
 };
 
 #ifdef ARGV_DRIVER
@@ -136,6 +159,8 @@ struct argv_ctx {
 struct argv_meta_impl {
 	char **			argv;
 	char *			strbuf;
+	char *                  keyvbuf;
+	char *                  keyvmark;
 	struct argv_meta	meta;
 };
 
@@ -305,12 +330,131 @@ static inline const struct argv_option * option_from_tag(
 	return 0;
 }
 
+static inline int argv_scan_keyval_array(struct argv_meta_impl * meta, struct argv_entry * entry)
+{
+	const char *            ch;
+	char *                  dst;
+	int                     ncomma;
+	int                     cint;
+	struct argv_keyval *    keyv;
+
+	/* count key[val] elements, assume no comma after last element */
+	for (ch=entry->arg,ncomma=1; *ch; ch++) {
+		if ((ch[0]=='\\') && (ch[1]==',')) {
+			ch++;
+
+		} else if ((ch[0]==',')) {
+			ncomma++;
+		}
+	}
+
+	/* keyval string buffer */
+	dst = meta->keyvmark;
+
+	/* allocate keyval array */
+	if (!(entry->keyv = calloc(ncomma+1,sizeof(*entry->keyv))))
+		return ARGV_ERROR_KEYVAL_ALLOC;
+
+	/* create keyval array */
+	entry->keyv->keyword = dst;
+
+	for (ch=entry->arg,keyv=entry->keyv; *ch; ch++) {
+		if ((ch[0]=='\\') && (ch[1]==',')) {
+			*dst++ = ',';
+			ch++;
+
+		} else if ((ch[0]==':') && (ch[1]=='=')) {
+			if (!keyv->keyword[0])
+				return ARGV_ERROR_KEYVAL_KEY;
+
+			keyv->flags = ARGV_KEYVAL_OVERRIDE;
+			keyv->value = ++dst;
+			ch++;
+
+		} else if ((ch[0]=='=')) {
+			if (!keyv->keyword[0])
+				return ARGV_ERROR_KEYVAL_KEY;
+
+			keyv->flags = ARGV_KEYVAL_ASSIGN;
+			keyv->value = ++dst;
+
+		} else if ((ch[0]==',')) {
+			for (; isblank(cint = ch[1]); )
+				ch++;
+
+			if (ch[1]) {
+				keyv++;
+				keyv->keyword = ++dst;
+			}
+		} else {
+			*dst++ = *ch;
+		}
+	}
+
+	/* keyval string buffer */
+	meta->keyvmark = ++dst;
+
+	return ARGV_ERROR_OK;
+}
+
+static inline int argv_scan_keyval_pair(struct argv_meta_impl * meta, struct argv_entry * entry)
+{
+	const char *            ch;
+	char *                  dst;
+	struct argv_keyval *    keyv;
+
+	/* keyval string buffer */
+	dst = meta->keyvmark;
+
+	/* allocate keyval array */
+	if (!(entry->keyv = calloc(2,sizeof(*entry->keyv))))
+		return ARGV_ERROR_KEYVAL_ALLOC;
+
+	/* create keyval array */
+	entry->keyv->keyword = dst;
+
+	for (ch=entry->arg,keyv=entry->keyv; *ch && !keyv->flags; ch++) {
+		if ((ch[0]=='\\') && (ch[1]==',')) {
+			*dst++ = ',';
+			ch++;
+
+		} else if ((ch[0]==':') && (ch[1]=='=')) {
+			if (!keyv->keyword[0])
+				return ARGV_ERROR_KEYVAL_KEY;
+
+			keyv->flags = ARGV_KEYVAL_OVERRIDE;
+			keyv->value = ++dst;
+			ch++;
+
+		} else if ((ch[0]=='=')) {
+			if (!keyv->keyword[0])
+				return ARGV_ERROR_KEYVAL_KEY;
+
+			keyv->flags = ARGV_KEYVAL_ASSIGN;
+			keyv->value = ++dst;
+
+		} else {
+			*dst++ = *ch;
+		}
+	}
+
+	for (; *ch; )
+		*dst++ = *ch++;
+
+	/* keyval string buffer */
+	meta->keyvmark = ++dst;
+
+	return ARGV_ERROR_OK;
+}
+
 static void argv_scan(
 	char **				argv,
 	const struct argv_option **	optv,
 	struct argv_ctx *		ctx,
 	struct argv_meta *		meta)
 {
+	struct argv_meta_impl *         imeta;
+	uintptr_t                       addr;
 	char **				parg;
 	const char *			ch;
 	const char *			val;
@@ -324,6 +468,9 @@ static void argv_scan(
 	bool				fhybrid;
 	bool				fnoscan;
 
+	addr  = (uintptr_t)meta - offsetof(struct argv_meta_impl,meta);
+	imeta = (struct argv_meta_impl *)addr;
+
 	parg	= &argv[1];
 	ch	= *parg;
 	ferr	= ARGV_ERROR_OK;
@@ -495,13 +642,20 @@ static void argv_scan(
 			if (!option && !ctx->unitidx)
 				ctx->unitidx = parg - argv;
 
+		if (ferr == ARGV_ERROR_OK)
+			if (option && (option->flags & ARGV_OPTION_KEYVAL_MASK))
+				if (ctx->mode == ARGV_MODE_SCAN)
+					ctx->keyvlen += strlen(ch) + 1;
+
 		if (ferr != ARGV_ERROR_OK) {
 			ctx->errcode = ferr;
 			ctx->errch   = ctx->errch ? ctx->errch : ch;
 			ctx->erropt  = option;
 			ctx->erridx  = parg - argv;
 			return;
-		} else if (ctx->mode == ARGV_MODE_SCAN) {
+		}
+
+		if (ctx->mode == ARGV_MODE_SCAN) {
 			if (!fnoscan)
 				ctx->nentries++;
 			else if (fval)
@@ -511,12 +665,12 @@ static void argv_scan(
 				parg++;
 				ch = *parg;
 			}
+
 		} else if (ctx->mode == ARGV_MODE_COPY) {
 			if (fnoscan) {
 				if (fval) {
 					mentry->arg	= ch;
 					mentry->fnoscan = true;
-					mentry++;
 				}
 
 				parg++;
@@ -526,7 +680,6 @@ static void argv_scan(
 				mentry->tag	= option->tag;
 				mentry->fopt	= true;
 				mentry->fval	= fval;
-				mentry++;
 
 				if (fval) {
 					parg++;
@@ -534,11 +687,28 @@ static void argv_scan(
 				}
 			} else {
 				mentry->arg = ch;
-				mentry++;
 				parg++;
 				ch = *parg;
 			}
 		}
+
+		if (option && (option->flags & ARGV_OPTION_KEYVAL_PAIR))
+			if (ctx->mode == ARGV_MODE_COPY)
+				ferr = argv_scan_keyval_pair(imeta,mentry);
+
+		if (option && (option->flags & ARGV_OPTION_KEYVAL_ARRAY))
+			if (ctx->mode == ARGV_MODE_COPY)
+				ferr = argv_scan_keyval_array(imeta,mentry);
+
+		if (ferr != ARGV_ERROR_OK) {
+			ctx->errcode = ferr;
+			ctx->errch   = ctx->errch ? ctx->errch : ch;
+			ctx->erropt  = option;
+			ctx->erridx  = parg - argv;
+			return;
+		}
+
+		mentry++;
 	}
 }
 
@@ -663,6 +833,14 @@ static void argv_show_error(int fd, struct argv_ctx * ctx)
 
 			break;
 
+		case ARGV_ERROR_KEYVAL_KEY:
+			argv_dprintf(fd,"illegal key detected in keyval argument\n");
+			break;
+
+		case ARGV_ERROR_KEYVAL_VALUE:
+			argv_dprintf(fd,"illegal value detected in keyval argument\n");
+			break;
+
 		case ARGV_ERROR_INTERNAL:
 			argv_dprintf(fd,"internal error");
 			break;
@@ -678,8 +856,10 @@ static void argv_show_status(
 	struct argv_ctx *		ctx,
 	struct argv_meta *		meta)
 {
+	int				i;
 	int				argc;
 	char **				argv;
+	struct argv_keyval *            keyv;
 	struct argv_entry *		entry;
 	const struct argv_option *	option;
 	char				short_name[2] = {0};
@@ -698,7 +878,7 @@ static void argv_show_status(
 		argv_dprintf(fd,"argv[%d]: %s\n",argc,*argv);
 
 	argv_dprintf(fd,"\n\nparsed entries:\n");
-	for (entry=meta->entries; entry->arg || entry->fopt; entry++)
+	for (entry=meta->entries; entry->arg || entry->fopt; entry++) {
 		if (entry->fopt) {
 			option = option_from_tag(optv,entry->tag);
 			short_name[0] = option->short_name;
@@ -709,14 +889,48 @@ static void argv_show_status(
 			else
 				argv_dprintf(fd,"[-%s,--%s]\n",
 					short_name,option->long_name);
-		} else
+
+			if (entry->keyv) {
+				for (i=0,keyv=entry->keyv; keyv->keyword; i++,keyv++) {
+					switch (keyv->flags) {
+						case ARGV_KEYVAL_ASSIGN:
+							argv_dprintf(fd,"\tkeyval[%d]: <%s>=%s\n",
+								i,keyv->keyword,keyv->value);
+							break;
+
+						case ARGV_KEYVAL_OVERRIDE:
+							argv_dprintf(fd,"\tkeyval[%d]: <%s>:=%s\n",
+								i,keyv->keyword,keyv->value);
+							break;
+
+						default:
+							argv_dprintf(fd,"\tkeyval[%d]: <%s>\n",
+								i,keyv->keyword);
+						break;
+					}
+				}
+			}
+		} else {
 			argv_dprintf(fd,"<program arg> := %s\n",entry->arg);
+		}
+	}
 
 	argv_dprintf(fd,"\n\n");
 }
 
 static struct argv_meta * argv_free_impl(struct argv_meta_impl * imeta)
 {
+	struct argv_entry * entry;
+	void *              addr;
+
+	if (imeta->keyvbuf)
+		for (entry=imeta->meta.entries; entry->fopt || entry->arg; entry++)
+			if (entry->keyv)
+				free((addr = entry->keyv));
+
+	if (imeta->keyvbuf)
+		free(imeta->keyvbuf);
+
 	if (imeta->argv)
 		free(imeta->argv);
 
@@ -750,7 +964,8 @@ static struct argv_meta * argv_alloc(char ** argv, struct argv_ctx * ctx)
 
 		if (!(imeta->argv = calloc(argc+1,sizeof(char *))))
 			return argv_free_impl(imeta);
-		else if (!(imeta->strbuf = calloc(1,size+1)))
+
+		if (!(imeta->strbuf = calloc(1,size+1)))
 			return argv_free_impl(imeta);
 
 		for (i=0,dst=imeta->strbuf; i<argc; i++) {
@@ -760,15 +975,27 @@ static struct argv_meta * argv_alloc(char ** argv, struct argv_ctx * ctx)
 		}
 
 		imeta->meta.argv = imeta->argv;
-	} else
+	} else {
 		imeta->meta.argv = argv;
+	}
 
-	if (!(imeta->meta.entries = calloc(
-				ctx->nentries+1,
-				sizeof(struct argv_entry))))
+	imeta->meta.entries = calloc(
+		ctx->nentries+1,
+		sizeof(struct argv_entry));
+
+	if (!imeta->meta.entries)
 		return argv_free_impl(imeta);
-	else
-		return &imeta->meta;
+
+	if (ctx->keyvlen) {
+		imeta->keyvbuf = calloc(
+			ctx->keyvlen,
+			sizeof(char));
+
+		if (!(imeta->keyvmark = imeta->keyvbuf))
+			return argv_free_impl(imeta);
+	}
+
+	return &imeta->meta;
 }
 
 static struct argv_meta * argv_get(
@@ -778,7 +1005,7 @@ static struct argv_meta * argv_get(
 	int				fd)
 {
 	struct argv_meta *	meta;
-	struct argv_ctx		ctx = {flags,ARGV_MODE_SCAN,0,0,0,0,0,0,0};
+	struct argv_ctx		ctx = {flags,ARGV_MODE_SCAN,0,0,0,0,0,0,0,0};
 
 	argv_scan(argv,optv,&ctx,0);
 
@@ -833,6 +1060,7 @@ static void argv_usage_impl(
 {
 	const struct argv_option **	optv;
 	const struct argv_option *	option;
+	int                             nlong;
 	bool				fshort,flong,fboth;
 	size_t				len,optlen,desclen;
 	char				cache;
@@ -865,7 +1093,7 @@ static void argv_usage_impl(
 	if (header)
 		argv_dprintf(fd,"%s",header);
 
-	for (optlen=0,optv=options; *optv; optv++) {
+	for (optlen=0,nlong=0,optv=options; *optv; optv++) {
 		option = *optv;
 
 		/* indent + comma */
@@ -884,6 +1112,11 @@ static void argv_usage_impl(
 		/* optlen */
 		if (len > optlen)
 			optlen = len;
+
+		/* long (vs. hybrid-only) option? */
+		if (option->long_name)
+			if (!(option->flags & ARGV_OPTION_HYBRID_ONLY))
+				nlong++;
 	}
 
 	if (optlen >= optcap) {
@@ -904,7 +1137,7 @@ static void argv_usage_impl(
 		/* color */
 		if (fcolor) {
 			color = (color == ccyan) ? cblue : ccyan;
-			argv_dprintf(fd,color);
+			argv_dprintf(fd,color,0);
 		}
 
 		/* description, using either paradigm or argname if applicable */
@@ -916,7 +1149,11 @@ static void argv_usage_impl(
 
 		/* long/hybrid option prefix (-/--) */
 		prefix = option->flags & ARGV_OPTION_HYBRID_ONLY
-				? " -" : "--";
+				? "  -" : " --";
+
+		/* avoid extra <stace> when all long opts are hybrid-only */
+		if (nlong == 0)
+			prefix++;
 
 		/* option string */
 		if (fboth && option->short_name && option->long_name)