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 }