xref: /illumos-gate/usr/src/test/util-tests/tests/libnvpair_json/print_json.c (revision 1ed6b69a5ca1ca3ee5e9a4931f74e2237c7e1c9f)
1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 
12 /*
13  * Copyright 2014 Joyent, Inc.
14  */
15 
16 /*
17  * This program implements a small domain-specific language (DSL) for the
18  * generation of nvlists, and subsequent printing in JSON-formatted output.
19  * The test suite uses this tool to drive the JSON formatting routines in
20  * libnvpair(3LIB) for testing.
21  */
22 
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <errno.h>
26 #include <string.h>
27 #include <ctype.h>
28 #include <limits.h>
29 #include <locale.h>
30 
31 #include <libnvpair.h>
32 
33 #define	MAX_ARGS	100
34 #define	CMD_NAME_LEN	50
35 
36 /*
37  * As we are parsing a language that allows the creation of arbitrarily nested
38  * state, i.e. both nested nvlists and arrays of nested nvlists, we store that
39  * state in a stack.  The top frame in the stack represents the nested nvlist
40  * (or nvlists, for an array) that we are currently building.
41  *
42  * When creating an array, the "next" directive advances lw_pos and allocates a
43  * new nvlist.  The "end" directive commits either the nvlist, or array of
44  * nvlists, into the parent nvlist.  It then pops and frees the stack frame
45  * before returning control to the parser.
46  */
47 
48 typedef struct list_wrap {
49 	nvlist_t *lw_nvl[MAX_ARGS];
50 	char *lw_name;
51 	int lw_pos;
52 	boolean_t lw_array;
53 	struct list_wrap *lw_next;
54 } list_wrap_t;
55 
56 int
57 list_wrap_depth(list_wrap_t *lw)
58 {
59 	int d = 0;
60 
61 	while (lw != NULL) {
62 		d++;
63 		lw = lw->lw_next;
64 	}
65 
66 	return (d);
67 }
68 
69 list_wrap_t *
70 list_wrap_alloc(list_wrap_t *next)
71 {
72 	list_wrap_t *out = calloc(1, sizeof (list_wrap_t));
73 
74 	if (out == NULL)
75 		abort();
76 
77 	out->lw_next = next;
78 
79 	return (out);
80 }
81 
82 list_wrap_t *
83 list_wrap_pop_and_free(list_wrap_t *lw)
84 {
85 	list_wrap_t *next = lw->lw_next;
86 
87 	free(lw->lw_name);
88 	free(lw);
89 
90 	return (next);
91 }
92 
93 /*
94  * Generic integer and floating point parsing routines:
95  */
96 
97 int
98 parse_int(char *in, int64_t *val, int64_t min, int64_t max)
99 {
100 	int64_t t;
101 	char *end = NULL;
102 
103 	errno = 0;
104 	t = strtoll(in, &end, 10);
105 	if (errno != 0 || end == in || *end != '\0') {
106 		if (errno == ERANGE) {
107 			(void) fprintf(stderr, "ERROR: integer %s not in "
108 			    "range [%lld,%lld]\n", in, min, max);
109 			return (-1);
110 		}
111 		(void) fprintf(stderr, "ERROR: could not parse \"%s\" as "
112 		    "signed integer (%s)\n", in, strerror(errno));
113 		return (-1);
114 	}
115 
116 	if (t < min || t > max) {
117 		(void) fprintf(stderr, "ERROR: integer %lld not in range "
118 		    "[%lld,%lld]\n", t, min, max);
119 		return (-1);
120 	}
121 
122 	*val = t;
123 	return (0);
124 }
125 
126 int
127 parse_uint(char *in, uint64_t *val, uint64_t min, uint64_t max)
128 {
129 	uint64_t t;
130 	char *end = NULL;
131 
132 	errno = 0;
133 	t = strtoull(in, &end, 10);
134 	if (errno != 0 || end == in || *end != '\0') {
135 		if (errno == ERANGE) {
136 			(void) fprintf(stderr, "ERROR: integer %s not in "
137 			    "range [%llu,%llu]\n", in, min, max);
138 			return (-1);
139 		}
140 		(void) fprintf(stderr, "ERROR: could not parse \"%s\" as "
141 		    "unsigned integer (%s)\n", in, strerror(errno));
142 		return (-1);
143 	}
144 
145 	if (t < min || t > max) {
146 		(void) fprintf(stderr, "ERROR: integer %llu not in range "
147 		    "[%llu,%llu]\n", t, min, max);
148 		return (-1);
149 	}
150 
151 	*val = t;
152 	return (0);
153 }
154 
155 int
156 parse_double(char *in, double *val)
157 {
158 	double t;
159 	char *end = NULL;
160 
161 	errno = 0;
162 	t = strtod(in, &end);
163 	if (errno != 0 || end == in || *end != '\0') {
164 		(void) fprintf(stderr, "ERROR: could not parse \"%s\" as "
165 		    "double\n", in);
166 		return (-1);
167 	}
168 
169 	*val = t;
170 	return (0);
171 }
172 
173 /*
174  * Command-specific handlers for directives specified in the DSL input:
175  */
176 
177 typedef int (*command_handler_t)(list_wrap_t **, boolean_t, int,
178     char **);
179 
180 static int
181 ch_add_string(list_wrap_t **lw, boolean_t array, int argc, char **argv)
182 {
183 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
184 
185 	if (array) {
186 		if (nvlist_add_string_array(nvl, argv[0], &argv[1],
187 		    argc - 1) != 0) {
188 			(void) fprintf(stderr, "fail at "
189 			    "nvlist_add_string_array\n");
190 			return (-1);
191 		}
192 	} else {
193 		if (nvlist_add_string(nvl, argv[0], argv[1]) != 0) {
194 			(void) fprintf(stderr, "fail at nvlist_add_string\n");
195 			return (-1);
196 		}
197 	}
198 
199 	return (0);
200 }
201 
202 static int
203 ch_add_boolean(list_wrap_t **lw, boolean_t array, int argc, char **argv)
204 {
205 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
206 
207 	if (array)
208 		abort();
209 
210 	if (nvlist_add_boolean(nvl, argv[0]) != 0) {
211 		(void) fprintf(stderr, "fail at nvlist_add_boolean\n");
212 		return (-1);
213 	}
214 	return (0);
215 }
216 
217 static int
218 ch_add_boolean_value(list_wrap_t **lw, boolean_t array, int argc, char **argv)
219 {
220 	int i;
221 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
222 	boolean_t arrval[MAX_ARGS];
223 
224 	for (i = 1; i < argc; i++) {
225 		if (strcmp(argv[i], "true") == 0) {
226 			arrval[i - 1] = B_TRUE;
227 		} else if (strcmp(argv[i], "false") == 0) {
228 			arrval[i - 1] = B_FALSE;
229 		} else {
230 			(void) fprintf(stderr, "invalid boolean value: %s\n",
231 			    argv[i]);
232 			return (-1);
233 		}
234 	}
235 
236 	if (array) {
237 		if (nvlist_add_boolean_array(nvl, argv[0], arrval,
238 		    argc - 1) != 0) {
239 			(void) fprintf(stderr, "fail at "
240 			    "nvlist_add_boolean_array\n");
241 			return (-1);
242 		}
243 	} else {
244 		if (nvlist_add_boolean_value(nvl, argv[0], arrval[0]) != 0) {
245 			(void) fprintf(stderr, "fail at "
246 			    "nvlist_add_boolean_value\n");
247 			return (-1);
248 		}
249 	}
250 
251 	return (0);
252 }
253 
254 
255 /*
256  * The confluence of a strongly typed C API for libnvpair(3LIB) and the
257  * combinatorial explosion of both sizes and signedness is unfortunate.  Rather
258  * than reproduce the same code over and over, this macro parses an integer,
259  * checks applicable bounds based on size and signedness, and stores the value
260  * (or array of values).
261  */
262 #define	DO_CMD_NUMBER(typ, nam, min, max, ptyp, func)			\
263 	ptyp val;							\
264 	typ ## _t arrval[MAX_ARGS];					\
265 	int i;								\
266 	for (i = 1; i < argc; i++) {					\
267 		if (func(argv[i], &val, min, max) != 0) {		\
268 			return (-1);					\
269 		}							\
270 		arrval[i - 1] = (typ ## _t) val;			\
271 	}								\
272 	if (array) {							\
273 		if (nvlist_add_ ## nam ## _array(nvl, argv[0],		\
274 		    arrval, argc - 1) != 0) {				\
275 			(void) fprintf(stderr, "fail at "		\
276 			    "nvlist_add_" #nam "_array\n");		\
277 			return (-1);					\
278 		}							\
279 	} else {							\
280 		if (nvlist_add_ ## nam(nvl, argv[0],			\
281 		    arrval[0]) == -1) {					\
282 			(void) fprintf(stderr, "fail at "		\
283 			    "nvlist_add_" #nam "\n");			\
284 			return (-1);					\
285 		}							\
286 	}								\
287 	return (0);
288 
289 static int
290 ch_add_byte(list_wrap_t **lw, boolean_t array, int argc, char **argv)
291 {
292 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
293 
294 	DO_CMD_NUMBER(uchar, byte, 0, UCHAR_MAX, uint64_t, parse_uint)
295 }
296 
297 static int
298 ch_add_int8(list_wrap_t **lw, boolean_t array, int argc, char **argv)
299 {
300 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
301 
302 	DO_CMD_NUMBER(int8, int8, INT8_MIN, INT8_MAX, int64_t, parse_int)
303 }
304 
305 static int
306 ch_add_uint8(list_wrap_t **lw, boolean_t array, int argc, char **argv)
307 {
308 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
309 
310 	DO_CMD_NUMBER(uint8, uint8, 0, UINT8_MAX, uint64_t, parse_uint)
311 }
312 
313 static int
314 ch_add_int16(list_wrap_t **lw, boolean_t array, int argc, char **argv)
315 {
316 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
317 
318 	DO_CMD_NUMBER(int16, int16, INT16_MIN, INT16_MAX, int64_t, parse_int)
319 }
320 
321 static int
322 ch_add_uint16(list_wrap_t **lw, boolean_t array, int argc, char **argv)
323 {
324 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
325 
326 	DO_CMD_NUMBER(uint16, uint16, 0, UINT16_MAX, uint64_t, parse_uint)
327 }
328 
329 static int
330 ch_add_int32(list_wrap_t **lw, boolean_t array, int argc, char **argv)
331 {
332 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
333 
334 	DO_CMD_NUMBER(int32, int32, INT32_MIN, INT32_MAX, int64_t, parse_int)
335 }
336 
337 static int
338 ch_add_uint32(list_wrap_t **lw, boolean_t array, int argc, char **argv)
339 {
340 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
341 
342 	DO_CMD_NUMBER(uint32, uint32, 0, UINT32_MAX, uint64_t, parse_uint)
343 }
344 
345 static int
346 ch_add_int64(list_wrap_t **lw, boolean_t array, int argc, char **argv)
347 {
348 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
349 
350 	DO_CMD_NUMBER(int64, int64, INT64_MIN, INT64_MAX, int64_t, parse_int)
351 }
352 
353 static int
354 ch_add_uint64(list_wrap_t **lw, boolean_t array, int argc, char **argv)
355 {
356 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
357 
358 	DO_CMD_NUMBER(uint64, uint64, 0, UINT64_MAX, uint64_t, parse_uint)
359 }
360 
361 static int
362 ch_add_double(list_wrap_t **lw, boolean_t array, int argc, char **argv)
363 {
364 	nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos];
365 	double val;
366 
367 	if (array)
368 		abort();
369 
370 	if (parse_double(argv[1], &val) != 0) {
371 		return (-1);
372 	}
373 
374 	if (nvlist_add_double(nvl, argv[0], val) != 0) {
375 		(void) fprintf(stderr, "fail at nvlist_add_double_value\n");
376 		return (-1);
377 	}
378 
379 	return (0);
380 }
381 
382 static int
383 ch_end(list_wrap_t **lw, boolean_t array, int argc, char **argv)
384 {
385 	nvlist_t *parent;
386 	char *name;
387 
388 	if (list_wrap_depth(*lw) < 2) {
389 		(void) fprintf(stderr, "ERROR: not nested, cannot end.\n");
390 		return (-1);
391 	}
392 
393 	parent = (*lw)->lw_next->lw_nvl[(*lw)->lw_next->lw_pos];
394 	name = (*lw)->lw_name;
395 	if ((*lw)->lw_array) {
396 		/*
397 		 * This was an array of objects.
398 		 */
399 		nvlist_t **children = (*lw)->lw_nvl;
400 		int nelems = (*lw)->lw_pos + 1;
401 
402 		if (nvlist_add_nvlist_array(parent, name, children,
403 		    nelems) != 0) {
404 			(void) fprintf(stderr, "fail at "
405 			    "nvlist_add_nvlist_array\n");
406 			return (-1);
407 		}
408 	} else {
409 		/*
410 		 * This was a single object.
411 		 */
412 		nvlist_t *child = (*lw)->lw_nvl[0];
413 
414 		if ((*lw)->lw_pos != 0)
415 			abort();
416 
417 		if (nvlist_add_nvlist(parent, name, child) != 0) {
418 			(void) fprintf(stderr, "fail at nvlist_add_nvlist\n");
419 			return (-1);
420 		}
421 	}
422 
423 	*lw = list_wrap_pop_and_free(*lw);
424 
425 	return (0);
426 }
427 
428 static int
429 ch_next(list_wrap_t **lw, boolean_t array, int argc, char **argv)
430 {
431 	if (!(*lw)->lw_array) {
432 		(void) fprintf(stderr, "ERROR: cannot use 'next' outside an "
433 		    "object array.\n");
434 		return (-1);
435 	}
436 
437 	if ((*lw)->lw_pos++ >= MAX_ARGS) {
438 		(void) fprintf(stderr, "ERROR: object array too long\n");
439 		return (-1);
440 	}
441 
442 	if (nvlist_alloc(&(*lw)->lw_nvl[(*lw)->lw_pos], NV_UNIQUE_NAME,
443 	    0) != 0) {
444 		(void) fprintf(stderr, "ERROR: failed at nvlist_alloc\n");
445 		return (-1);
446 	}
447 
448 	return (0);
449 }
450 
451 static int
452 ch_add_object(list_wrap_t **lw, boolean_t array, int argc, char **argv)
453 {
454 	*lw = list_wrap_alloc(*lw);
455 
456 	(*lw)->lw_name = strdup(argv[0]);
457 	(*lw)->lw_array = array;
458 
459 	if (nvlist_alloc(&(*lw)->lw_nvl[0], NV_UNIQUE_NAME, 0) != 0) {
460 		(void) fprintf(stderr, "fail at nvlist_alloc\n");
461 		return (-1);
462 	}
463 
464 	return (0);
465 }
466 
467 typedef struct command {
468 	char cmd_name[CMD_NAME_LEN];
469 	command_handler_t cmd_func;
470 	int cmd_min_args;
471 	int cmd_max_args;
472 	boolean_t cmd_array_mode;
473 } command_t;
474 
475 /*
476  * These are the commands we support in the testing DSL, and their
477  * handling functions:
478  */
479 command_t command_handlers[] = {
480 	{ "add_boolean", ch_add_boolean, 1, 1, B_FALSE },
481 	{ "add_boolean_value", ch_add_boolean_value, 2, 2, B_FALSE },
482 	{ "add_byte", ch_add_byte, 2, 2, B_FALSE },
483 	{ "add_int8", ch_add_int8, 2, 2, B_FALSE },
484 	{ "add_uint8", ch_add_uint8, 2, 2, B_FALSE },
485 	{ "add_int16", ch_add_int16, 2, 2, B_FALSE },
486 	{ "add_uint16", ch_add_uint16, 2, 2, B_FALSE },
487 	{ "add_int32", ch_add_int32, 2, 2, B_FALSE },
488 	{ "add_uint32", ch_add_uint32, 2, 2, B_FALSE },
489 	{ "add_int64", ch_add_int64, 2, 2, B_FALSE },
490 	{ "add_uint64", ch_add_uint64, 2, 2, B_FALSE },
491 	{ "add_double", ch_add_double, 2, 2, B_FALSE },
492 	{ "add_string", ch_add_string, 2, 2, B_FALSE },
493 	{ "add_object", ch_add_object, 1, 1, B_FALSE },
494 	{ "add_boolean_array", ch_add_boolean_value, 1, MAX_ARGS, B_TRUE },
495 	{ "add_byte_array", ch_add_byte, 1, MAX_ARGS, B_TRUE },
496 	{ "add_int8_array", ch_add_int8, 1, MAX_ARGS, B_TRUE },
497 	{ "add_uint8_array", ch_add_uint8, 1, MAX_ARGS, B_TRUE },
498 	{ "add_int16_array", ch_add_int16, 1, MAX_ARGS, B_TRUE },
499 	{ "add_uint16_array", ch_add_uint16, 1, MAX_ARGS, B_TRUE },
500 	{ "add_int32_array", ch_add_int32, 1, MAX_ARGS, B_TRUE },
501 	{ "add_uint32_array", ch_add_uint32, 1, MAX_ARGS, B_TRUE },
502 	{ "add_int64_array", ch_add_int64, 1, MAX_ARGS, B_TRUE },
503 	{ "add_uint64_array", ch_add_uint64, 1, MAX_ARGS, B_TRUE },
504 	{ "add_string_array", ch_add_string, 1, MAX_ARGS, B_TRUE },
505 	{ "add_object_array", ch_add_object, 1, 1, B_TRUE },
506 	{ "end", ch_end, 0, 0, B_FALSE },
507 	{ "next", ch_next, 0, 0, B_FALSE },
508 	{ 0 }
509 };
510 
511 /*
512  * This function determines which command we are executing, checks argument
513  * counts, and dispatches to the appropriate handler:
514  */
515 static int
516 command_call(list_wrap_t **lw, char *command, int argc, char **argv)
517 {
518 	int ch;
519 
520 	for (ch = 0; command_handlers[ch].cmd_name[0] != '\0'; ch++) {
521 		if (strcmp(command, command_handlers[ch].cmd_name) != 0)
522 			continue;
523 
524 		if (argc > command_handlers[ch].cmd_max_args ||
525 		    argc < command_handlers[ch].cmd_min_args) {
526 
527 			(void) fprintf(stderr, "ERROR: command \"%s\""
528 			    " expects between %d and %d arguments,"
529 			    " but %d were provided.\n", command,
530 			    command_handlers[ch].cmd_min_args,
531 			    command_handlers[ch].cmd_max_args,
532 			    argc);
533 
534 			return (-1);
535 		}
536 
537 		return (command_handlers[ch].cmd_func(lw,
538 		    command_handlers[ch].cmd_array_mode, argc, argv));
539 	}
540 
541 	(void) fprintf(stderr, "ERROR: invalid command: \"%s\"\n", command);
542 
543 	return (-1);
544 }
545 
546 /*
547  * The primary state machine for parsing the input DSL is implemented in
548  * this function:
549  */
550 
551 typedef enum state {
552 	STATE_REST = 1,
553 	STATE_COMMAND,
554 	STATE_ARG_FIND,
555 	STATE_ARG,
556 	STATE_ARG_ESCAPE,
557 	STATE_ARG_ESCAPE_HEX,
558 	STATE_C_COMMENT_0,
559 	STATE_C_COMMENT_1,
560 	STATE_C_COMMENT_2
561 } state_t;
562 
563 int
564 parse(FILE *in, list_wrap_t **lw)
565 {
566 	char b[8192];
567 	int bp;
568 	state_t st = STATE_REST;
569 	int argc = 0;
570 	char *argv[MAX_ARGS];
571 	int line = 1;
572 	char hex[3];
573 	int nhex = 0;
574 
575 	b[0] = '\0';
576 	bp = 0;
577 
578 	for (;;) {
579 		int c = fgetc(in);
580 
581 		/*
582 		 * Signal an error if the file ends part way through a
583 		 * construct:
584 		 */
585 		if (st != STATE_REST && c == EOF) {
586 			(void) fprintf(stderr, "ERROR: unexpected end of "
587 			    "file\n");
588 			return (-1);
589 		} else if (c == EOF) {
590 			return (0);
591 		}
592 
593 		if (c == '\n')
594 			line++;
595 
596 		switch (st) {
597 		case STATE_REST:
598 			if (isalpha(c) || c == '_') {
599 				argc = 0;
600 				bp = 0;
601 				b[bp++] = c;
602 				b[bp] = '\0';
603 				st = STATE_COMMAND;
604 				continue;
605 			} else if (c == ' ' || c == '\t' || c == '\n') {
606 				/*
607 				 * Ignore whitespace.
608 				 */
609 				continue;
610 			} else if (c == '/') {
611 				st = STATE_C_COMMENT_0;
612 				continue;
613 			} else {
614 				goto unexpected;
615 			}
616 
617 		case STATE_C_COMMENT_0:
618 			if (c != '*') {
619 				goto unexpected;
620 			}
621 			st = STATE_C_COMMENT_1;
622 			continue;
623 
624 		case STATE_C_COMMENT_1:
625 			if (c == '*') {
626 				st = STATE_C_COMMENT_2;
627 			}
628 			continue;
629 
630 		case STATE_C_COMMENT_2:
631 			if (c == '/') {
632 				st = STATE_REST;
633 			} else if (c != '*') {
634 				st = STATE_C_COMMENT_1;
635 			}
636 			continue;
637 
638 		case STATE_COMMAND:
639 			if (isalnum(c) || c == '_') {
640 				b[bp++] = c;
641 				b[bp] = '\0';
642 				st = STATE_COMMAND;
643 
644 				continue;
645 
646 			} else if (isspace(c)) {
647 				/*
648 				 * Start collecting arguments into 'b'
649 				 * after the command.
650 				 */
651 				st = STATE_ARG_FIND;
652 				bp++;
653 
654 				continue;
655 			} else if (c == ';') {
656 				/*
657 				 * This line was _just_ a command,
658 				 * so break out and process now:
659 				 */
660 				goto execute;
661 			} else {
662 				goto unexpected;
663 			}
664 
665 		case STATE_ARG_FIND:
666 			if (isspace(c)) {
667 				/*
668 				 * Whitespace, ignore.
669 				 */
670 				continue;
671 
672 			} else if (c == ';') {
673 				/*
674 				 * Break out to process command.
675 				 */
676 				goto execute;
677 
678 			} else if (c == '"') {
679 				st = STATE_ARG;
680 
681 				argv[argc] = &b[++bp];
682 				b[bp] = '\0';
683 
684 				continue;
685 			} else {
686 				goto unexpected;
687 			}
688 
689 		case STATE_ARG:
690 			if (c == '"') {
691 				if (argc++ >= MAX_ARGS) {
692 					(void) fprintf(stderr, "ERROR: too "
693 					    "many args\n");
694 					return (-1);
695 				}
696 				st = STATE_ARG_FIND;
697 				continue;
698 			} else if (c == '\n') {
699 				(void) fprintf(stderr, "ERROR: line not "
700 				    "finished\n");
701 				return (-1);
702 			} else if (c == '\\') {
703 				st = STATE_ARG_ESCAPE;
704 				continue;
705 			} else {
706 				b[bp++] = c;
707 				b[bp] = '\0';
708 				continue;
709 			}
710 
711 		case STATE_ARG_ESCAPE:
712 			if (c == 'a') {
713 				c = '\a';
714 			} else if (c == 'b') {
715 				c = '\b';
716 			} else if (c == 'f') {
717 				c = '\f';
718 			} else if (c == 'n') {
719 				c = '\n';
720 			} else if (c == 'r') {
721 				c = '\r';
722 			} else if (c == 't') {
723 				c = '\t';
724 			} else if (c == 'v') {
725 				c = '\v';
726 			} else if (c == 'x') {
727 				st = STATE_ARG_ESCAPE_HEX;
728 				hex[0] = hex[1] = hex[2] = '\0';
729 				nhex = 0;
730 				continue;
731 			} else if (c != '\\' && c != '"') {
732 				goto unexpected;
733 			}
734 
735 			b[bp++] = c;
736 			b[bp] = '\0';
737 			st = STATE_ARG;
738 			continue;
739 
740 		case STATE_ARG_ESCAPE_HEX:
741 			if (!isxdigit(c)) {
742 				goto unexpected;
743 			}
744 			hex[nhex] = c;
745 			if (nhex++ >= 1) {
746 				/*
747 				 * The hex escape pair is complete, parse
748 				 * the integer and insert it as a character:
749 				 */
750 				int x;
751 				errno = 0;
752 				if ((x = strtol(hex, NULL, 16)) == 0 ||
753 				    errno != 0) {
754 					goto unexpected;
755 				}
756 				b[bp++] = (char)x;
757 				b[bp] = '\0';
758 				st = STATE_ARG;
759 			}
760 			continue;
761 		}
762 
763 		/*
764 		 * We do not ever expect to break out of the switch block
765 		 * above.  If we do, it's a programmer error.
766 		 */
767 		abort();
768 
769 execute:
770 		if (command_call(lw, b, argc, argv) == -1)
771 			return (-1);
772 
773 		st = STATE_REST;
774 		continue;
775 
776 unexpected:
777 		(void) fprintf(stderr, "ERROR: (line %d) unexpected "
778 		    "character: %c\n", line, c);
779 		return (-1);
780 	}
781 }
782 
783 /*
784  * Entry point:
785  */
786 int
787 main(int argc, char **argv)
788 {
789 	int rc = EXIT_FAILURE;
790 	list_wrap_t *lw;
791 
792 	/*
793 	 * Be locale-aware.  The JSON output functions will process multibyte
794 	 * characters in the current locale, and emit a correct JSON encoding
795 	 * for unprintable characters.
796 	 */
797 	if (setlocale(LC_ALL, "") == NULL) {
798 		(void) fprintf(stderr, "Could not set locale: %s\n",
799 		    strerror(errno));
800 		goto out;
801 	}
802 
803 	lw = list_wrap_alloc(NULL);
804 
805 	if (nvlist_alloc(&lw->lw_nvl[0], NV_UNIQUE_NAME, 0) != 0)
806 		goto out;
807 
808 	/*
809 	 * Generate the list from the commands passed to us on stdin:
810 	 */
811 	if (parse(stdin, &lw) != 0)
812 		goto out;
813 
814 	/*
815 	 * Print the resultant list, and a terminating newline:
816 	 */
817 	if (nvlist_print_json(stdout, lw->lw_nvl[0]) != 0 ||
818 	    fprintf(stdout, "\n") < 0)
819 		goto out;
820 
821 	rc = EXIT_SUCCESS;
822 
823 out:
824 	(void) list_wrap_pop_and_free(lw);
825 
826 	return (rc);
827 }
828