--- /dev/null	Mon Jul 21 17:23:00 2014
+++ new/usr/src/test/util-tests/tests/libnvpair_json/print_json.c	Mon Jul 21 17:23:00 2014
@@ -0,0 +1,827 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright 2014 Joyent, Inc.
+ */
+
+/*
+ * This program implements a small domain-specific language (DSL) for the
+ * generation of nvlists, and subsequent printing in JSON-formatted output.
+ * The test suite uses this tool to drive the JSON formatting routines in
+ * libnvpair(3LIB) for testing.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <locale.h>
+
+#include <libnvpair.h>
+
+#define	MAX_ARGS	100
+#define	CMD_NAME_LEN	50
+
+/*
+ * As we are parsing a language that allows the creation of arbitrarily nested
+ * state, i.e. both nested nvlists and arrays of nested nvlists, we store that
+ * state in a stack.  The top frame in the stack represents the nested nvlist
+ * (or nvlists, for an array) that we are currently building.
+ *
+ * When creating an array, the "next" directive advances lw_pos and allocates a
+ * new nvlist.  The "end" directive commits either the nvlist, or array of
+ * nvlists, into the parent nvlist.  It then pops and frees the stack frame
+ * before returning control to the parser.
+ */
+
+typedef struct list_wrap {
+	nvlist_t *lw_nvl[MAX_ARGS];
+	char *lw_name;
+	int lw_pos;
+	boolean_t lw_array;
+	struct list_wrap *lw_next;
+} list_wrap_t;
+
+int
+list_wrap_depth(list_wrap_t *lw)
+{
+	int d = 0;
+
+	while (lw != NULL) {
+		d++;
+		lw = lw->lw_next;
+	}
+
+	return (d);
+}
+
+list_wrap_t *
+list_wrap_alloc(list_wrap_t *next)
+{
+	list_wrap_t *out = calloc(1, sizeof (list_wrap_t));
+
+	if (out == NULL)
+		abort();
+
+	out->lw_next = next;
+
+	return (out);
+}
+
+list_wrap_t *
+list_wrap_pop_and_free(list_wrap_t *lw)
+{
+	list_wrap_t *next = lw->lw_next;
+
+	free(lw->lw_name);
+	free(lw);
+
+	return (next);
+}
+
+/*
+ * Generic integer and floating point parsing routines:
+ */
+
+int
+parse_int(char *in, int64_t *val, int64_t min, int64_t max)
+{
+	int64_t t;
+	char *end = NULL;
+
+	errno = 0;
+	t = strtoll(in, &end, 10);
+	if (errno != 0 || end == in || *end != '\0') {
+		if (errno == ERANGE) {
+			(void) fprintf(stderr, "ERROR: integer %s not in "
+			    "range [%lld,%lld]\n", in, min, max);
+			return (-1);
+		}
+		(void) fprintf(stderr, "ERROR: could not parse \"%s\" as "
+		    "signed integer (%s)\n", in, strerror(errno));
+		return (-1);
+	}
+
+	if (t < min || t > max) {
+		(void) fprintf(stderr, "ERROR: integer %lld not in range "
+		    "[%lld,%lld]\n", t, min, max);
+		return (-1);
+	}
+
+	*val = t;
+	return (0);
+}
+
+int
+parse_uint(char *in, uint64_t *val, uint64_t min, uint64_t max)
+{
+	uint64_t t;
+	char *end = NULL;
+
+	errno = 0;
+	t = strtoull(in, &end, 10);
+	if (errno != 0 || end == in || *end != '\0') {
+		if (errno == ERANGE) {
+			(void) fprintf(stderr, "ERROR: integer %s not in "
+			    "range [%llu,%llu]\n", in, min, max);
+			return (-1);
+		}
+		(void) fprintf(stderr, "ERROR: could not parse \"%s\" as "
+		    "unsigned integer (%s)\n", in, strerror(errno));
+		return (-1);
+	}
+
+	if (t < min || t > max) {
+		(void) fprintf(stderr, "ERROR: integer %llu not in range "
+		    "[%llu,%llu]\n", t, min, max);
+		return (-1);
+	}
+
+	*val = t;
+	return (0);
+}
+
+int
+parse_double(char *in, double *val)
+{
+	double t;
+	char *end = NULL;
+
+	errno = 0;
+	t = strtod(in, &end);
+	if (errno != 0 || end == in || *end != '\0') {
+		(void) fprintf(stderr, "ERROR: could not parse \"%s\" as "
+		    "double\n", in);
+		return (-1);
+	}
+
+	*val = t;
+	return (0);
+}
+
+/*
+ * Command-specific handlers for directives specified in the DSL input:
+ */
+
+typedef int (*command_handler_t)(list_wrap_t **, boolean_t, int,
+    char **);
+
+static int
+ch_add_string(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	if (array) {
+		if (nvlist_add_string_array(nvl, argv[0], &argv[1],
+		    argc - 1) != 0) {
+			(void) fprintf(stderr, "fail at "
+			    "nvlist_add_string_array\n");
+			return (-1);
+		}
+	} else {
+		if (nvlist_add_string(nvl, argv[0], argv[1]) != 0) {
+			(void) fprintf(stderr, "fail at nvlist_add_string\n");
+			return (-1);
+		}
+	}
+
+	return (0);
+}
+
+static int
+ch_add_boolean(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	if (array)
+		abort();
+
+	if (nvlist_add_boolean(nvl, argv[0]) != 0) {
+		(void) fprintf(stderr, "fail at nvlist_add_boolean\n");
+		return (-1);
+	}
+	return (0);
+}
+
+static int
+ch_add_boolean_value(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	int i;
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+	boolean_t arrval[MAX_ARGS];
+
+	for (i = 1; i < argc; i++) {
+		if (strcmp(argv[i], "true") == 0) {
+			arrval[i - 1] = B_TRUE;
+		} else if (strcmp(argv[i], "false") == 0) {
+			arrval[i - 1] = B_FALSE;
+		} else {
+			(void) fprintf(stderr, "invalid boolean value: %s\n",
+			    argv[i]);
+			return (-1);
+		}
+	}
+
+	if (array) {
+		if (nvlist_add_boolean_array(nvl, argv[0], arrval,
+		    argc - 1) != 0) {
+			(void) fprintf(stderr, "fail at "
+			    "nvlist_add_boolean_array\n");
+			return (-1);
+		}
+	} else {
+		if (nvlist_add_boolean_value(nvl, argv[0], arrval[0]) != 0) {
+			(void) fprintf(stderr, "fail at "
+			    "nvlist_add_boolean_value\n");
+			return (-1);
+		}
+	}
+
+	return (0);
+}
+
+
+/*
+ * The confluence of a strongly typed C API for libnvpair(3LIB) and the
+ * combinatorial explosion of both sizes and signedness is unfortunate.  Rather
+ * than reproduce the same code over and over, this macro parses an integer,
+ * checks applicable bounds based on size and signedness, and stores the value
+ * (or array of values).
+ */
+#define	DO_CMD_NUMBER(typ, nam, min, max, ptyp, func)			\
+	ptyp val;							\
+	typ ## _t arrval[MAX_ARGS];					\
+	int i;								\
+	for (i = 1; i < argc; i++) {					\
+		if (func(argv[i], &val, min, max) != 0) {		\
+			return (-1);					\
+		}							\
+		arrval[i - 1] = (typ ## _t) val;			\
+	}								\
+	if (array) {							\
+		if (nvlist_add_ ## nam ## _array(nvl, argv[0],		\
+		    arrval, argc - 1) != 0) {				\
+			(void) fprintf(stderr, "fail at "		\
+			    "nvlist_add_" #nam "_array\n");		\
+			return (-1);					\
+		}							\
+	} else {							\
+		if (nvlist_add_ ## nam(nvl, argv[0],			\
+		    arrval[0]) == -1) {					\
+			(void) fprintf(stderr, "fail at "		\
+			    "nvlist_add_" #nam "\n");			\
+			return (-1);					\
+		}							\
+	}								\
+	return (0);
+
+static int
+ch_add_byte(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(uchar, byte, 0, UCHAR_MAX, uint64_t, parse_uint)
+}
+
+static int
+ch_add_int8(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(int8, int8, INT8_MIN, INT8_MAX, int64_t, parse_int)
+}
+
+static int
+ch_add_uint8(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(uint8, uint8, 0, UINT8_MAX, uint64_t, parse_uint)
+}
+
+static int
+ch_add_int16(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(int16, int16, INT16_MIN, INT16_MAX, int64_t, parse_int)
+}
+
+static int
+ch_add_uint16(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(uint16, uint16, 0, UINT16_MAX, uint64_t, parse_uint)
+}
+
+static int
+ch_add_int32(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(int32, int32, INT32_MIN, INT32_MAX, int64_t, parse_int)
+}
+
+static int
+ch_add_uint32(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(uint32, uint32, 0, UINT32_MAX, uint64_t, parse_uint)
+}
+
+static int
+ch_add_int64(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(int64, int64, INT64_MIN, INT64_MAX, int64_t, parse_int)
+}
+
+static int
+ch_add_uint64(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+
+	DO_CMD_NUMBER(uint64, uint64, 0, UINT64_MAX, uint64_t, parse_uint)
+}
+
+static int
+ch_add_double(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
+	double val;
+
+	if (array)
+		abort();
+
+	if (parse_double(argv[1], &val) != 0) {
+		return (-1);
+	}
+
+	if (nvlist_add_double(nvl, argv[0], val) != 0) {
+		(void) fprintf(stderr, "fail at nvlist_add_double_value\n");
+		return (-1);
+	}
+
+	return (0);
+}
+
+static int
+ch_end(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	nvlist_t *parent;
+	char *name;
+
+	if (list_wrap_depth(*lw) < 2) {
+		(void) fprintf(stderr, "ERROR: not nested, cannot end.\n");
+		return (-1);
+	}
+
+	parent = (*lw)->lw_next->lw_nvl[(*lw)->lw_next->lw_pos];
+	name = (*lw)->lw_name;
+	if ((*lw)->lw_array) {
+		/*
+		 * This was an array of objects.
+		 */
+		nvlist_t **children = (*lw)->lw_nvl;
+		int nelems = (*lw)->lw_pos + 1;
+
+		if (nvlist_add_nvlist_array(parent, name, children,
+		    nelems) != 0) {
+			(void) fprintf(stderr, "fail at "
+			    "nvlist_add_nvlist_array\n");
+			return (-1);
+		}
+	} else {
+		/*
+		 * This was a single object.
+		 */
+		nvlist_t *child = (*lw)->lw_nvl[0];
+
+		if ((*lw)->lw_pos != 0)
+			abort();
+
+		if (nvlist_add_nvlist(parent, name, child) != 0) {
+			(void) fprintf(stderr, "fail at nvlist_add_nvlist\n");
+			return (-1);
+		}
+	}
+
+	*lw = list_wrap_pop_and_free(*lw);
+
+	return (0);
+}
+
+static int
+ch_next(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	if (!(*lw)->lw_array) {
+		(void) fprintf(stderr, "ERROR: cannot use 'next' outside an "
+		    "object array.\n");
+		return (-1);
+	}
+
+	if ((*lw)->lw_pos++ >= MAX_ARGS) {
+		(void) fprintf(stderr, "ERROR: object array too long\n");
+		return (-1);
+	}
+
+	if (nvlist_alloc(&(*lw)->lw_nvl[(*lw)->lw_pos], NV_UNIQUE_NAME,
+	    0) != 0) {
+		(void) fprintf(stderr, "ERROR: failed at nvlist_alloc\n");
+		return (-1);
+	}
+
+	return (0);
+}
+
+static int
+ch_add_object(list_wrap_t **lw, boolean_t array, int argc, char **argv)
+{
+	*lw = list_wrap_alloc(*lw);
+
+	(*lw)->lw_name = strdup(argv[0]);
+	(*lw)->lw_array = array;
+
+	if (nvlist_alloc(&(*lw)->lw_nvl[0], NV_UNIQUE_NAME, 0) != 0) {
+		(void) fprintf(stderr, "fail at nvlist_alloc\n");
+		return (-1);
+	}
+
+	return (0);
+}
+
+typedef struct command {
+	char cmd_name[CMD_NAME_LEN];
+	command_handler_t cmd_func;
+	int cmd_min_args;
+	int cmd_max_args;
+	boolean_t cmd_array_mode;
+} command_t;
+
+/*
+ * These are the commands we support in the testing DSL, and their
+ * handling functions:
+ */
+command_t command_handlers[] = {
+	{ "add_boolean", ch_add_boolean, 1, 1, B_FALSE },
+	{ "add_boolean_value", ch_add_boolean_value, 2, 2, B_FALSE },
+	{ "add_byte", ch_add_byte, 2, 2, B_FALSE },
+	{ "add_int8", ch_add_int8, 2, 2, B_FALSE },
+	{ "add_uint8", ch_add_uint8, 2, 2, B_FALSE },
+	{ "add_int16", ch_add_int16, 2, 2, B_FALSE },
+	{ "add_uint16", ch_add_uint16, 2, 2, B_FALSE },
+	{ "add_int32", ch_add_int32, 2, 2, B_FALSE },
+	{ "add_uint32", ch_add_uint32, 2, 2, B_FALSE },
+	{ "add_int64", ch_add_int64, 2, 2, B_FALSE },
+	{ "add_uint64", ch_add_uint64, 2, 2, B_FALSE },
+	{ "add_double", ch_add_double, 2, 2, B_FALSE },
+	{ "add_string", ch_add_string, 2, 2, B_FALSE },
+	{ "add_object", ch_add_object, 1, 1, B_FALSE },
+	{ "add_boolean_array", ch_add_boolean_value, 1, MAX_ARGS, B_TRUE },
+	{ "add_byte_array", ch_add_byte, 1, MAX_ARGS, B_TRUE },
+	{ "add_int8_array", ch_add_int8, 1, MAX_ARGS, B_TRUE },
+	{ "add_uint8_array", ch_add_uint8, 1, MAX_ARGS, B_TRUE },
+	{ "add_int16_array", ch_add_int16, 1, MAX_ARGS, B_TRUE },
+	{ "add_uint16_array", ch_add_uint16, 1, MAX_ARGS, B_TRUE },
+	{ "add_int32_array", ch_add_int32, 1, MAX_ARGS, B_TRUE },
+	{ "add_uint32_array", ch_add_uint32, 1, MAX_ARGS, B_TRUE },
+	{ "add_int64_array", ch_add_int64, 1, MAX_ARGS, B_TRUE },
+	{ "add_uint64_array", ch_add_uint64, 1, MAX_ARGS, B_TRUE },
+	{ "add_string_array", ch_add_string, 1, MAX_ARGS, B_TRUE },
+	{ "add_object_array", ch_add_object, 1, 1, B_TRUE },
+	{ "end", ch_end, 0, 0, B_FALSE },
+	{ "next", ch_next, 0, 0, B_FALSE },
+	{ 0 }
+};
+
+/*
+ * This function determines which command we are executing, checks argument
+ * counts, and dispatches to the appropriate handler:
+ */
+static int
+command_call(list_wrap_t **lw, char *command, int argc, char **argv)
+{
+	int ch;
+
+	for (ch = 0; command_handlers[ch].cmd_name[0] != '\0'; ch++) {
+		if (strcmp(command, command_handlers[ch].cmd_name) != 0)
+			continue;
+
+		if (argc > command_handlers[ch].cmd_max_args ||
+		    argc < command_handlers[ch].cmd_min_args) {
+
+			(void) fprintf(stderr, "ERROR: command \"%s\""
+			    " expects between %d and %d arguments,"
+			    " but %d were provided.\n", command,
+			    command_handlers[ch].cmd_min_args,
+			    command_handlers[ch].cmd_max_args,
+			    argc);
+
+			return (-1);
+		}
+
+		return (command_handlers[ch].cmd_func(lw,
+		    command_handlers[ch].cmd_array_mode, argc, argv));
+	}
+
+	(void) fprintf(stderr, "ERROR: invalid command: \"%s\"\n", command);
+
+	return (-1);
+}
+
+/*
+ * The primary state machine for parsing the input DSL is implemented in
+ * this function:
+ */
+
+typedef enum state {
+	STATE_REST = 1,
+	STATE_COMMAND,
+	STATE_ARG_FIND,
+	STATE_ARG,
+	STATE_ARG_ESCAPE,
+	STATE_ARG_ESCAPE_HEX,
+	STATE_C_COMMENT_0,
+	STATE_C_COMMENT_1,
+	STATE_C_COMMENT_2
+} state_t;
+
+int
+parse(FILE *in, list_wrap_t **lw)
+{
+	char b[8192];
+	int bp;
+	state_t st = STATE_REST;
+	int argc = 0;
+	char *argv[MAX_ARGS];
+	int line = 1;
+	char hex[3];
+	int nhex = 0;
+
+	b[0] = '\0';
+	bp = 0;
+
+	for (;;) {
+		int c = fgetc(in);
+
+		/*
+		 * Signal an error if the file ends part way through a
+		 * construct:
+		 */
+		if (st != STATE_REST && c == EOF) {
+			(void) fprintf(stderr, "ERROR: unexpected end of "
+			    "file\n");
+			return (-1);
+		} else if (c == EOF) {
+			return (0);
+		}
+
+		if (c == '\n')
+			line++;
+
+		switch (st) {
+		case STATE_REST:
+			if (isalpha(c) || c == '_') {
+				argc = 0;
+				bp = 0;
+				b[bp++] = c;
+				b[bp] = '\0';
+				st = STATE_COMMAND;
+				continue;
+			} else if (c == ' ' || c == '\t' || c == '\n') {
+				/*
+				 * Ignore whitespace.
+				 */
+				continue;
+			} else if (c == '/') {
+				st = STATE_C_COMMENT_0;
+				continue;
+			} else {
+				goto unexpected;
+			}
+
+		case STATE_C_COMMENT_0:
+			if (c != '*') {
+				goto unexpected;
+			}
+			st = STATE_C_COMMENT_1;
+			continue;
+
+		case STATE_C_COMMENT_1:
+			if (c == '*') {
+				st = STATE_C_COMMENT_2;
+			}
+			continue;
+
+		case STATE_C_COMMENT_2:
+			if (c == '/') {
+				st = STATE_REST;
+			} else if (c != '*') {
+				st = STATE_C_COMMENT_1;
+			}
+			continue;
+
+		case STATE_COMMAND:
+			if (isalnum(c) || c == '_') {
+				b[bp++] = c;
+				b[bp] = '\0';
+				st = STATE_COMMAND;
+
+				continue;
+
+			} else if (isspace(c)) {
+				/*
+				 * Start collecting arguments into 'b'
+				 * after the command.
+				 */
+				st = STATE_ARG_FIND;
+				bp++;
+
+				continue;
+			} else if (c == ';') {
+				/*
+				 * This line was _just_ a command,
+				 * so break out and process now:
+				 */
+				goto execute;
+			} else {
+				goto unexpected;
+			}
+
+		case STATE_ARG_FIND:
+			if (isspace(c)) {
+				/*
+				 * Whitespace, ignore.
+				 */
+				continue;
+
+			} else if (c == ';') {
+				/*
+				 * Break out to process command.
+				 */
+				goto execute;
+
+			} else if (c == '"') {
+				st = STATE_ARG;
+
+				argv[argc] = &b[++bp];
+				b[bp] = '\0';
+
+				continue;
+			} else {
+				goto unexpected;
+			}
+
+		case STATE_ARG:
+			if (c == '"') {
+				if (argc++ >= MAX_ARGS) {
+					(void) fprintf(stderr, "ERROR: too "
+					    "many args\n");
+					return (-1);
+				}
+				st = STATE_ARG_FIND;
+				continue;
+			} else if (c == '\n') {
+				(void) fprintf(stderr, "ERROR: line not "
+				    "finished\n");
+				return (-1);
+			} else if (c == '\\') {
+				st = STATE_ARG_ESCAPE;
+				continue;
+			} else {
+				b[bp++] = c;
+				b[bp] = '\0';
+				continue;
+			}
+
+		case STATE_ARG_ESCAPE:
+			if (c == 'a') {
+				c = '\a';
+			} else if (c == 'b') {
+				c = '\b';
+			} else if (c == 'f') {
+				c = '\f';
+			} else if (c == 'n') {
+				c = '\n';
+			} else if (c == 'r') {
+				c = '\r';
+			} else if (c == 't') {
+				c = '\t';
+			} else if (c == 'v') {
+				c = '\v';
+			} else if (c == 'x') {
+				st = STATE_ARG_ESCAPE_HEX;
+				hex[0] = hex[1] = hex[2] = '\0';
+				nhex = 0;
+				continue;
+			} else if (c != '\\' && c != '"') {
+				goto unexpected;
+			}
+
+			b[bp++] = c;
+			b[bp] = '\0';
+			st = STATE_ARG;
+			continue;
+
+		case STATE_ARG_ESCAPE_HEX:
+			if (!isxdigit(c)) {
+				goto unexpected;
+			}
+			hex[nhex] = c;
+			if (nhex++ >= 1) {
+				/*
+				 * The hex escape pair is complete, parse
+				 * the integer and insert it as a character:
+				 */
+				int x;
+				errno = 0;
+				if ((x = strtol(hex, NULL, 16)) == 0 ||
+				    errno != 0) {
+					goto unexpected;
+				}
+				b[bp++] = (char)x;
+				b[bp] = '\0';
+				st = STATE_ARG;
+			}
+			continue;
+		}
+
+		/*
+		 * We do not ever expect to break out of the switch block
+		 * above.  If we do, it's a programmer error.
+		 */
+		abort();
+
+execute:
+		if (command_call(lw, b, argc, argv) == -1)
+			return (-1);
+
+		st = STATE_REST;
+		continue;
+
+unexpected:
+		(void) fprintf(stderr, "ERROR: (line %d) unexpected "
+		    "character: %c\n", line, c);
+		return (-1);
+	}
+}
+
+/*
+ * Entry point:
+ */
+int
+main(int argc, char **argv)
+{
+	int rc = EXIT_FAILURE;
+	list_wrap_t *lw;
+
+	/*
+	 * Be locale-aware.  The JSON output functions will process multibyte
+	 * characters in the current locale, and emit a correct JSON encoding
+	 * for unprintable characters.
+	 */
+	if (setlocale(LC_ALL, "") == NULL) {
+		(void) fprintf(stderr, "Could not set locale: %s\n",
+		    strerror(errno));
+		goto out;
+	}
+
+	lw = list_wrap_alloc(NULL);
+
+	if (nvlist_alloc(&lw->lw_nvl[0], NV_UNIQUE_NAME, 0) != 0)
+		goto out;
+
+	/*
+	 * Generate the list from the commands passed to us on stdin:
+	 */
+	if (parse(stdin, &lw) != 0)
+		goto out;
+
+	/*
+	 * Print the resultant list, and a terminating newline:
+	 */
+	if (nvlist_print_json(stdout, lw->lw_nvl[0]) != 0 ||
+	    fprintf(stdout, "\n") < 0)
+		goto out;
+
+	rc = EXIT_SUCCESS;
+
+out:
+	(void) list_wrap_pop_and_free(lw);
+
+	return (rc);
+}
