4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as
8 * published by the Free Software Foundation; either version 2.1 of the
9 * License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
21 * Copyright (c) 2014, 2017, Intel Corporation.
24 * Amir Shehata <amir.shehata@intel.com>
28 * The cYAML tree is constructed as an n-tree.
32 * cmd 2 -> attr1 -> attr2
35 * attr2.1 -> attr2.1.1 -> attr2.1.2
47 #include "libcfs/util/list.h"
55 * This structure contains print information
56 * required when printing the node
58 struct cYAML_print_info {
66 * Linked list of different trees representing YAML
70 struct list_head list;
72 struct cYAML_print_info *print_info;
75 static void print_value(FILE *f, struct list_head *stack);
77 enum cYAML_handler_error {
79 CYAML_ERROR_UNEXPECTED_STATE = -1,
80 CYAML_ERROR_NOT_SUPPORTED = -2,
81 CYAML_ERROR_OUT_OF_MEM = -3,
82 CYAML_ERROR_BAD_VALUE = -4,
83 CYAML_ERROR_PARSE = -5,
86 enum cYAML_tree_state {
87 TREE_STATE_COMPLETE = 0,
89 TREE_STATE_TREE_STARTED,
90 TREE_STATE_BLK_STARTED,
92 TREE_STATE_KEY_FILLED,
97 struct cYAML_tree_node {
99 /* cur is the current node we're operating on */
101 enum cYAML_tree_state state;
102 int from_blk_map_start;
103 /* represents the tree depth */
107 typedef enum cYAML_handler_error (*yaml_token_handler)(yaml_token_t *token,
108 struct cYAML_tree_node *);
110 static enum cYAML_handler_error yaml_parse_error(yaml_token_t *token,
111 struct cYAML_tree_node *tree);
112 static enum cYAML_handler_error yaml_stream_start(yaml_token_t *token,
113 struct cYAML_tree_node *tree);
114 static enum cYAML_handler_error yaml_stream_end(yaml_token_t *token,
115 struct cYAML_tree_node *tree);
116 static enum cYAML_handler_error yaml_not_supported(yaml_token_t *token,
117 struct cYAML_tree_node *tree);
118 static enum cYAML_handler_error yaml_document_start(yaml_token_t *token,
119 struct cYAML_tree_node *tree);
120 static enum cYAML_handler_error yaml_document_end(yaml_token_t *token,
121 struct cYAML_tree_node *tree);
122 static enum cYAML_handler_error yaml_blk_seq_start(yaml_token_t *token,
123 struct cYAML_tree_node *tree);
124 static enum cYAML_handler_error yaml_blk_mapping_start(yaml_token_t *token,
125 struct cYAML_tree_node *tree);
126 static enum cYAML_handler_error yaml_block_end(yaml_token_t *token,
127 struct cYAML_tree_node *tree);
128 static enum cYAML_handler_error yaml_key(yaml_token_t *token,
129 struct cYAML_tree_node *tree);
130 static enum cYAML_handler_error yaml_value(yaml_token_t *token,
131 struct cYAML_tree_node *tree);
132 static enum cYAML_handler_error yaml_scalar(yaml_token_t *token,
133 struct cYAML_tree_node *tree);
134 static enum cYAML_handler_error yaml_entry_token(yaml_token_t *token,
135 struct cYAML_tree_node *tree);
138 static yaml_token_handler dispatch_tbl[] = {
139 [YAML_NO_TOKEN] = yaml_parse_error,
140 [YAML_STREAM_START_TOKEN] = yaml_stream_start,
141 [YAML_STREAM_END_TOKEN] = yaml_stream_end,
142 [YAML_VERSION_DIRECTIVE_TOKEN] = yaml_not_supported,
143 [YAML_TAG_DIRECTIVE_TOKEN] = yaml_not_supported,
144 [YAML_DOCUMENT_START_TOKEN] = yaml_document_start,
145 [YAML_DOCUMENT_END_TOKEN] = yaml_document_end,
146 [YAML_BLOCK_SEQUENCE_START_TOKEN] = yaml_blk_seq_start,
147 [YAML_BLOCK_MAPPING_START_TOKEN] = yaml_blk_mapping_start,
148 [YAML_BLOCK_END_TOKEN] = yaml_block_end,
149 [YAML_FLOW_SEQUENCE_START_TOKEN] = yaml_not_supported,
150 [YAML_FLOW_SEQUENCE_END_TOKEN] = yaml_not_supported,
151 [YAML_FLOW_MAPPING_START_TOKEN] = yaml_not_supported,
152 [YAML_FLOW_MAPPING_END_TOKEN] = yaml_not_supported,
153 [YAML_BLOCK_ENTRY_TOKEN] = yaml_entry_token,
154 [YAML_FLOW_ENTRY_TOKEN] = yaml_not_supported,
155 [YAML_KEY_TOKEN] = yaml_key,
156 [YAML_VALUE_TOKEN] = yaml_value,
157 [YAML_ALIAS_TOKEN] = yaml_not_supported,
158 [YAML_ANCHOR_TOKEN] = yaml_not_supported,
159 [YAML_TAG_TOKEN] = yaml_not_supported,
160 [YAML_SCALAR_TOKEN] = yaml_scalar,
164 static char *token_type_string[] = {
165 [YAML_NO_TOKEN] = "YAML_NO_TOKEN",
166 [YAML_STREAM_START_TOKEN] = "YAML_STREAM_START_TOKEN",
167 [YAML_STREAM_END_TOKEN] = "YAML_STREAM_END_TOKEN",
168 [YAML_VERSION_DIRECTIVE_TOKEN] = "YAML_VERSION_DIRECTIVE_TOKEN",
169 [YAML_TAG_DIRECTIVE_TOKEN] = "YAML_TAG_DIRECTIVE_TOKEN",
170 [YAML_DOCUMENT_START_TOKEN] = "YAML_DOCUMENT_START_TOKEN",
171 [YAML_DOCUMENT_END_TOKEN] = "YAML_DOCUMENT_END_TOKEN",
172 [YAML_BLOCK_SEQUENCE_START_TOKEN] = "YAML_BLOCK_SEQUENCE_START_TOKEN",
173 [YAML_BLOCK_MAPPING_START_TOKEN] = "YAML_BLOCK_MAPPING_START_TOKEN",
174 [YAML_BLOCK_END_TOKEN] = "YAML_BLOCK_END_TOKEN",
175 [YAML_FLOW_SEQUENCE_START_TOKEN] = "YAML_FLOW_SEQUENCE_START_TOKEN",
176 [YAML_FLOW_SEQUENCE_END_TOKEN] = "YAML_FLOW_SEQUENCE_END_TOKEN",
177 [YAML_FLOW_MAPPING_START_TOKEN] = "YAML_FLOW_MAPPING_START_TOKEN",
178 [YAML_FLOW_MAPPING_END_TOKEN] = "YAML_FLOW_MAPPING_END_TOKEN",
179 [YAML_BLOCK_ENTRY_TOKEN] = "YAML_BLOCK_ENTRY_TOKEN",
180 [YAML_FLOW_ENTRY_TOKEN] = "YAML_FLOW_ENTRY_TOKEN",
181 [YAML_KEY_TOKEN] = "YAML_KEY_TOKEN",
182 [YAML_VALUE_TOKEN] = "YAML_VALUE_TOKEN",
183 [YAML_ALIAS_TOKEN] = "YAML_ALIAS_TOKEN",
184 [YAML_ANCHOR_TOKEN] = "YAML_ANCHOR_TOKEN",
185 [YAML_TAG_TOKEN] = "YAML_TAG_TOKEN",
186 [YAML_SCALAR_TOKEN] = "YAML_SCALAR_TOKEN",
189 static char *state_string[] = {
190 [TREE_STATE_COMPLETE] = "COMPLETE",
191 [TREE_STATE_INITED] = "INITED",
192 [TREE_STATE_TREE_STARTED] = "TREE_STARTED",
193 [TREE_STATE_BLK_STARTED] = "BLK_STARTED",
194 [TREE_STATE_KEY] = "KEY",
195 [TREE_STATE_KEY_FILLED] = "KEY_FILLED",
196 [TREE_STATE_VALUE] = "VALUE",
197 [TREE_STATE_SEQ_START] = "SEQ_START",
200 static void cYAML_ll_free(struct list_head *ll)
202 struct cYAML_ll *node, *tmp;
204 list_for_each_entry_safe(node, tmp, ll, list) {
205 free(node->print_info);
210 static int cYAML_ll_push(struct cYAML *obj,
211 const struct cYAML_print_info *print_info,
212 struct list_head *list)
214 struct cYAML_ll *node = calloc(1, sizeof(*node));
218 INIT_LIST_HEAD(&node->list);
221 node->print_info = calloc(1, sizeof(*print_info));
222 if (node->print_info == NULL) {
226 *node->print_info = *print_info;
230 list_add(&node->list, list);
235 static struct cYAML *cYAML_ll_pop(struct list_head *list,
236 struct cYAML_print_info **print_info)
238 struct cYAML_ll *pop;
239 struct cYAML *obj = NULL;
241 if (!list_empty(list)) {
242 pop = list_entry(list->next, struct cYAML_ll, list);
245 if (print_info != NULL)
246 *print_info = pop->print_info;
247 list_del(&pop->list);
249 if (print_info == NULL)
250 free(pop->print_info);
257 static int cYAML_ll_count(struct list_head *ll)
260 struct list_head *node;
262 list_for_each(node, ll)
268 static int cYAML_tree_init(struct cYAML_tree_node *tree)
270 struct cYAML *obj = NULL, *cur = NULL;
275 obj = calloc(1, sizeof(*obj));
280 /* append the node */
282 while (cur->cy_next != NULL)
289 obj->cy_type = CYAML_TYPE_OBJECT;
292 tree->state = TREE_STATE_COMPLETE;
294 /* free it and start anew */
295 if (!list_empty(&tree->ll))
296 cYAML_ll_free(&tree->ll);
301 static struct cYAML *create_child(struct cYAML *parent)
308 obj = calloc(1, sizeof(*obj));
312 /* set the type to OBJECT and let the value change that */
313 obj->cy_type = CYAML_TYPE_OBJECT;
315 parent->cy_child = obj;
320 static struct cYAML *create_sibling(struct cYAML *sibling)
327 obj = calloc(1, sizeof(*obj));
331 /* set the type to OBJECT and let the value change that */
332 obj->cy_type = CYAML_TYPE_OBJECT;
334 sibling->cy_next = obj;
335 obj->cy_prev = sibling;
340 /* Parse the input text to generate a number,
341 * and populate the result into item. */
342 static bool parse_number(struct cYAML *item, const char *input)
344 double n = 0, sign = 1, scale = 0;
345 int subscale = 0, signsubscale = 1;
346 const char *num = input;
356 if (*num >= '1' && *num <= '9') {
358 n = (n * 10.0) + (*num++ - '0');
359 } while (*num >= '0' && *num <= '9');
362 if (*num == '.' && num[1] >= '0' && num[1] <= '9') {
365 n = (n * 10.0) + (*num++ - '0');
367 } while (*num >= '0' && *num <= '9');
370 if (*num == 'e' || *num == 'E') {
374 } else if (*num == '-') {
378 while (*num >= '0' && *num <= '9')
379 subscale = (subscale * 10) + (*num++ - '0');
382 /* check to see if the entire string is consumed. If not then
383 * that means this is a string with a number in it */
384 if (num != (input + strlen(input)))
387 /* number = +/- number.fraction * 10^+/- exponent */
388 n = sign * n * pow(10.0, (scale + subscale * signsubscale));
390 item->cy_valuedouble = n;
391 item->cy_valueint = (int)n;
392 item->cy_type = CYAML_TYPE_NUMBER;
397 static int assign_type_value(struct cYAML *obj, const char *value)
402 if (strcmp(value, "null") == 0)
403 obj->cy_type = CYAML_TYPE_NULL;
404 else if (strcmp(value, "false") == 0) {
405 obj->cy_type = CYAML_TYPE_FALSE;
406 obj->cy_valueint = 0;
407 } else if (strcmp(value, "true") == 0) {
408 obj->cy_type = CYAML_TYPE_TRUE;
409 obj->cy_valueint = 1;
410 } else if (*value == '-' || (*value >= '0' && *value <= '9')) {
411 if (parse_number(obj, value) == 0) {
412 obj->cy_valuestring = strdup(value);
413 obj->cy_type = CYAML_TYPE_STRING;
416 obj->cy_valuestring = strdup(value);
417 obj->cy_type = CYAML_TYPE_STRING;
425 * Builds the YAML tree rpresentation as the tokens are passed in
427 * if token == STREAM_START && tree_state != COMPLETE
428 * something wrong. fail.
429 * else tree_state = INITIED
430 * if token == DOCUMENT_START && tree_state != COMPLETE || INITED
431 * something wrong, fail.
432 * else tree_state = TREE_STARTED
433 * if token == DOCUMENT_END
434 * tree_state = INITED if no STREAM START, else tree_state = COMPLETE
435 * erase everything on ll
436 * if token == STREAM_END && tree_state != INITED
437 * something wrong fail.
438 * else tree_state = COMPLETED
439 * if token == YAML_KEY_TOKEN && state != TREE_STARTED
440 * something wrong, fail.
441 * if token == YAML_SCALAR_TOKEN && state != KEY || VALUE
443 * else if tree_state == KEY
444 * create a new sibling under the current head of the ll (if ll is
445 * empty insert the new node there and it becomes the root.)
446 * add the scalar value in the "string"
447 * tree_state = KEY_FILLED
448 * else if tree_state == VALUE
449 * try and figure out whether this is a double, int or string and store
451 * state = TREE_STARTED
452 * else if token == YAML_BLOCK_MAPPING_START_TOKEN && tree_state != VALUE
454 * else push the current node on the ll && state = TREE_STARTED
455 * if token == YAML_BLOCK_END_TOKEN && state != TREE_STARTED
457 * else pop the current token off the ll and make it the cur
458 * if token == YAML_VALUE_TOKEN && state != KEY_FILLED
463 static enum cYAML_handler_error yaml_parse_error(yaml_token_t *token,
464 struct cYAML_tree_node *tree)
466 return CYAML_ERROR_PARSE;
469 static enum cYAML_handler_error yaml_stream_start(yaml_token_t *token,
470 struct cYAML_tree_node *tree)
472 enum cYAML_handler_error rc;
474 /* with each new stream initialize a new tree */
475 rc = cYAML_tree_init(tree);
477 if (rc != CYAML_ERROR_NONE)
480 tree->state = TREE_STATE_INITED;
482 return CYAML_ERROR_NONE;
485 static enum cYAML_handler_error yaml_stream_end(yaml_token_t *token,
486 struct cYAML_tree_node *tree)
488 if (tree->state != TREE_STATE_TREE_STARTED &&
489 tree->state != TREE_STATE_COMPLETE &&
490 tree->state != TREE_STATE_INITED)
491 return CYAML_ERROR_UNEXPECTED_STATE;
493 tree->state = TREE_STATE_INITED;
495 return CYAML_ERROR_NONE;
498 static enum cYAML_handler_error
499 yaml_document_start(yaml_token_t *token, struct cYAML_tree_node *tree)
501 if (tree->state != TREE_STATE_INITED)
502 return CYAML_ERROR_UNEXPECTED_STATE;
504 /* go to started state since we're expecting more tokens to come */
505 tree->state = TREE_STATE_TREE_STARTED;
507 return CYAML_ERROR_NONE;
510 static enum cYAML_handler_error yaml_document_end(yaml_token_t *token,
511 struct cYAML_tree_node *tree)
513 if (tree->state != TREE_STATE_COMPLETE)
514 return CYAML_ERROR_UNEXPECTED_STATE;
516 tree->state = TREE_STATE_TREE_STARTED;
518 return CYAML_ERROR_NONE;
521 static enum cYAML_handler_error yaml_key(yaml_token_t *token,
522 struct cYAML_tree_node *tree)
524 if (tree->state != TREE_STATE_BLK_STARTED &&
525 tree->state != TREE_STATE_VALUE)
526 return CYAML_ERROR_UNEXPECTED_STATE;
528 if (tree->from_blk_map_start == 0 ||
529 tree->state == TREE_STATE_VALUE)
530 tree->cur = create_sibling(tree->cur);
532 tree->from_blk_map_start = 0;
534 tree->state = TREE_STATE_KEY;
536 return CYAML_ERROR_NONE;
539 static enum cYAML_handler_error yaml_scalar(yaml_token_t *token,
540 struct cYAML_tree_node *tree)
542 if (tree->state == TREE_STATE_KEY) {
543 /* assign the scalar value to the key that was created */
544 tree->cur->cy_string =
545 strdup((const char *)token->data.scalar.value);
547 tree->state = TREE_STATE_KEY_FILLED;
548 } else if (tree->state == TREE_STATE_VALUE) {
549 if (assign_type_value(tree->cur,
550 (char *)token->data.scalar.value))
551 /* failed to assign a value */
552 return CYAML_ERROR_BAD_VALUE;
553 tree->state = TREE_STATE_BLK_STARTED;
555 return CYAML_ERROR_UNEXPECTED_STATE;
558 return CYAML_ERROR_NONE;
561 static enum cYAML_handler_error yaml_value(yaml_token_t *token,
562 struct cYAML_tree_node *tree)
564 if (tree->state != TREE_STATE_KEY_FILLED)
565 return CYAML_ERROR_UNEXPECTED_STATE;
567 tree->state = TREE_STATE_VALUE;
569 return CYAML_ERROR_NONE;
572 static enum cYAML_handler_error yaml_blk_seq_start(yaml_token_t *token,
573 struct cYAML_tree_node *tree)
575 if (tree->state != TREE_STATE_VALUE)
576 return CYAML_ERROR_UNEXPECTED_STATE;
578 /* Since a sequenc start event determines that this is the start
579 * of an array, then that means the current node we're at is an
580 * array and we need to flag it as such */
581 tree->cur->cy_type = CYAML_TYPE_ARRAY;
582 tree->state = TREE_STATE_SEQ_START;
584 return CYAML_ERROR_NONE;
587 static enum cYAML_handler_error yaml_entry_token(yaml_token_t *token,
588 struct cYAML_tree_node *tree)
592 if (tree->state != TREE_STATE_SEQ_START &&
593 tree->state != TREE_STATE_BLK_STARTED &&
594 tree->state != TREE_STATE_VALUE)
595 return CYAML_ERROR_UNEXPECTED_STATE;
597 if (tree->state == TREE_STATE_SEQ_START) {
598 obj = create_child(tree->cur);
600 if (cYAML_ll_push(tree->cur, NULL, &tree->ll))
601 return CYAML_ERROR_OUT_OF_MEM;
605 tree->cur = create_sibling(tree->cur);
606 tree->state = TREE_STATE_SEQ_START;
609 return CYAML_ERROR_NONE;
612 static enum cYAML_handler_error
613 yaml_blk_mapping_start(yaml_token_t *token,
614 struct cYAML_tree_node *tree)
618 if (tree->state != TREE_STATE_VALUE &&
619 tree->state != TREE_STATE_INITED &&
620 tree->state != TREE_STATE_SEQ_START &&
621 tree->state != TREE_STATE_TREE_STARTED)
622 return CYAML_ERROR_UNEXPECTED_STATE;
624 /* block_mapping_start means we're entering another block
625 * indentation, so we need to go one level deeper
626 * create a child of cur */
627 obj = create_child(tree->cur);
629 /* push cur on the stack */
630 if (cYAML_ll_push(tree->cur, NULL, &tree->ll))
631 return CYAML_ERROR_OUT_OF_MEM;
633 /* adding the new child to cur */
636 tree->state = TREE_STATE_BLK_STARTED;
638 tree->from_blk_map_start = 1;
640 return CYAML_ERROR_NONE;
643 static enum cYAML_handler_error yaml_block_end(yaml_token_t *token,
644 struct cYAML_tree_node *tree)
646 if (tree->state != TREE_STATE_BLK_STARTED &&
647 tree->state != TREE_STATE_VALUE)
648 return CYAML_ERROR_UNEXPECTED_STATE;
650 tree->cur = cYAML_ll_pop(&tree->ll, NULL);
652 /* if you have popped all the way to the top level, then move to
653 * the complete state. */
654 if (cYAML_ll_count(&tree->ll) == 0)
655 tree->state = TREE_STATE_COMPLETE;
656 else if (tree->state == TREE_STATE_VALUE)
657 tree->state = TREE_STATE_BLK_STARTED;
659 return CYAML_ERROR_NONE;
662 static enum cYAML_handler_error yaml_not_supported(yaml_token_t *token,
663 struct cYAML_tree_node *tree)
665 return CYAML_ERROR_NOT_SUPPORTED;
668 static bool clean_usr_data(struct cYAML *node, void *usr_data, void **out)
670 cYAML_user_data_free_cb free_cb = usr_data;
672 if (free_cb && node && node->cy_user_data) {
673 free_cb(node->cy_user_data);
674 node->cy_user_data = NULL;
680 static bool free_node(struct cYAML *node, void *user_data, void **out)
685 if (node->cy_type == CYAML_TYPE_STRING)
686 free(node->cy_valuestring);
688 free(node->cy_string);
694 static bool find_obj_iter(struct cYAML *node, void *usr_data, void **out)
696 char *name = usr_data;
698 if (node != NULL && node->cy_string != NULL &&
699 strcmp(node->cy_string, name) == 0) {
707 struct cYAML *cYAML_get_object_item(struct cYAML *parent, const char *name)
709 struct cYAML *node = parent, *found = NULL;
714 if (node->cy_string) {
715 if (strcmp(node->cy_string, name) == 0)
720 found = cYAML_get_object_item(node->cy_child, name);
722 if (!found && node->cy_next)
723 found = cYAML_get_object_item(node->cy_next, name);
728 struct cYAML *cYAML_get_next_seq_item(struct cYAML *seq, struct cYAML **itm)
730 if (*itm != NULL && (*itm)->cy_next != NULL) {
731 *itm = (*itm)->cy_next;
735 if (*itm == NULL && seq->cy_type == CYAML_TYPE_ARRAY) {
736 *itm = seq->cy_child;
743 bool cYAML_is_sequence(struct cYAML *node)
745 return (node != NULL ? node->cy_type == CYAML_TYPE_ARRAY : 0);
748 void cYAML_tree_recursive_walk(struct cYAML *node, cYAML_walk_cb cb,
757 if (!cb(node, usr_data, out))
762 cYAML_tree_recursive_walk(node->cy_child, cb,
763 cb_first, usr_data, out);
766 cYAML_tree_recursive_walk(node->cy_next, cb,
767 cb_first, usr_data, out);
770 if (!cb(node, usr_data, out))
775 struct cYAML *cYAML_find_object(struct cYAML *root, const char *name)
777 struct cYAML *found = NULL;
779 cYAML_tree_recursive_walk(root, find_obj_iter, true,
780 (void *)name, (void **)&found);
785 void cYAML_clean_usr_data(struct cYAML *node, cYAML_user_data_free_cb free_cb)
787 cYAML_tree_recursive_walk(node, clean_usr_data, false, free_cb, NULL);
790 void cYAML_free_tree(struct cYAML *node)
792 cYAML_tree_recursive_walk(node, free_node, false, NULL, NULL);
795 static inline void print_simple(FILE *f, struct cYAML *node,
796 struct cYAML_print_info *cpi)
798 int level = cpi->level;
799 int ind = cpi->extra_ind;
801 if (cpi->array_first_elem)
802 fprintf(f, "%*s- ", INDENT * level, "");
804 fprintf(f, "%*s""%s: %d\n", (cpi->array_first_elem) ? 0 :
805 INDENT * level + ind, "", node->cy_string,
809 static void print_string(FILE *f, struct cYAML *node,
810 struct cYAML_print_info *cpi)
813 int level = cpi->level;
814 int ind = cpi->extra_ind;
816 if (cpi->array_first_elem)
817 fprintf(f, "%*s- ", INDENT * level, "");
819 new_line = strchr(node->cy_valuestring, '\n');
820 if (new_line == NULL)
821 fprintf(f, "%*s""%s: %s\n", (cpi->array_first_elem) ?
822 0 : INDENT * level + ind, "",
823 node->cy_string, node->cy_valuestring);
826 fprintf(f, "%*s""%s: ", (cpi->array_first_elem) ?
827 0 : INDENT * level + ind, "",
829 char *l = node->cy_valuestring;
832 fprintf(f, "%*s""%s\n", indent, "", l);
833 indent = INDENT * level + ind +
834 strlen(node->cy_string) + 2;
837 new_line = strchr(l, '\n');
839 fprintf(f, "%*s""%s\n", indent, "", l);
843 static void print_number(FILE *f, struct cYAML *node,
844 struct cYAML_print_info *cpi)
846 double d = node->cy_valuedouble;
847 int level = cpi->level;
848 int ind = cpi->extra_ind;
850 if (cpi->array_first_elem)
851 fprintf(f, "%*s- ", INDENT * level, "");
853 if ((fabs(((double)node->cy_valueint) - d) <= DBL_EPSILON) &&
854 (d <= INT_MAX) && (d >= INT_MIN))
855 fprintf(f, "%*s""%s: %d\n", (cpi->array_first_elem) ? 0 :
856 INDENT * level + ind, "",
857 node->cy_string, node->cy_valueint);
859 if ((fabs(floor(d) - d) <= DBL_EPSILON) &&
861 fprintf(f, "%*s""%s: %.0f\n",
862 (cpi->array_first_elem) ? 0 :
863 INDENT * level + ind, "",
865 else if ((fabs(d) < 1.0e-6) || (fabs(d) > 1.0e9))
866 fprintf(f, "%*s""%s: %e\n",
867 (cpi->array_first_elem) ? 0 :
868 INDENT * level + ind, "",
871 fprintf(f, "%*s""%s: %f\n",
872 (cpi->array_first_elem) ? 0 :
873 INDENT * level + ind, "",
878 static void print_object(FILE *f, struct cYAML *node,
879 struct list_head *stack,
880 struct cYAML_print_info *cpi)
882 struct cYAML_print_info print_info;
883 struct cYAML *child = node->cy_child;
885 if (node->cy_string != NULL)
886 fprintf(f, "%*s""%s%s:\n", (cpi->array_first_elem) ?
887 INDENT * cpi->level :
888 INDENT * cpi->level + cpi->extra_ind,
889 "", (cpi->array_first_elem) ? "- " : "",
892 print_info.level = (node->cy_string != NULL) ? cpi->level + 1 :
894 print_info.array_first_elem = (node->cy_string == NULL) ?
895 cpi->array_first_elem : 0;
896 print_info.extra_ind = (cpi->array_first_elem) ? EXTRA_IND :
900 if (cYAML_ll_push(child, &print_info, stack) != 0)
902 print_value(f, stack);
903 print_info.array_first_elem = 0;
904 child = child->cy_next;
908 static void print_array(FILE *f, struct cYAML *node,
909 struct list_head *stack,
910 struct cYAML_print_info *cpi)
912 struct cYAML_print_info print_info;
913 struct cYAML *child = node->cy_child;
915 if (node->cy_string != NULL) {
916 fprintf(f, "%*s""%s:\n", INDENT * cpi->level + cpi->extra_ind,
917 "", node->cy_string);
920 print_info.level = (node->cy_string != NULL) ? cpi->level + 1 :
922 print_info.array_first_elem = 1;
923 print_info.extra_ind = EXTRA_IND;
926 if (cYAML_ll_push(child, &print_info, stack) != 0)
928 print_value(f, stack);
929 child = child->cy_next;
933 static void print_value(FILE *f, struct list_head *stack)
935 struct cYAML_print_info *cpi = NULL;
936 struct cYAML *node = cYAML_ll_pop(stack, &cpi);
941 switch (node->cy_type) {
942 case CYAML_TYPE_FALSE:
943 case CYAML_TYPE_TRUE:
944 case CYAML_TYPE_NULL:
945 print_simple(f, node, cpi);
947 case CYAML_TYPE_STRING:
948 print_string(f, node, cpi);
950 case CYAML_TYPE_NUMBER:
951 print_number(f, node, cpi);
953 case CYAML_TYPE_ARRAY:
954 print_array(f, node, stack, cpi);
956 case CYAML_TYPE_OBJECT:
957 print_object(f, node, stack, cpi);
967 void cYAML_print_tree(struct cYAML *node)
969 struct cYAML_print_info print_info;
970 struct list_head list;
972 INIT_LIST_HEAD(&list);
977 memset(&print_info, 0, sizeof(struct cYAML_print_info));
979 if (cYAML_ll_push(node, &print_info, &list) == 0)
980 print_value(stdout, &list);
983 void cYAML_print_tree2file(FILE *f, struct cYAML *node)
985 struct cYAML_print_info print_info;
986 struct list_head list;
988 INIT_LIST_HEAD(&list);
993 memset(&print_info, 0, sizeof(struct cYAML_print_info));
995 if (cYAML_ll_push(node, &print_info, &list) == 0)
996 print_value(f, &list);
999 static struct cYAML *insert_item(struct cYAML *parent, char *key,
1000 enum cYAML_object_type type)
1002 struct cYAML *node = calloc(1, sizeof(*node));
1008 node->cy_string = strdup(key);
1010 node->cy_type = type;
1012 cYAML_insert_child(parent, node);
1017 struct cYAML *cYAML_create_seq(struct cYAML *parent, char *key)
1019 return insert_item(parent, key, CYAML_TYPE_ARRAY);
1022 struct cYAML *cYAML_create_seq_item(struct cYAML *seq)
1024 return insert_item(seq, NULL, CYAML_TYPE_OBJECT);
1027 struct cYAML *cYAML_create_object(struct cYAML *parent, char *key)
1029 return insert_item(parent, key, CYAML_TYPE_OBJECT);
1032 struct cYAML *cYAML_create_string(struct cYAML *parent, char *key, char *value)
1034 struct cYAML *node = calloc(1, sizeof(*node));
1038 node->cy_string = strdup(key);
1039 node->cy_valuestring = strdup(value);
1040 node->cy_type = CYAML_TYPE_STRING;
1042 cYAML_insert_child(parent, node);
1047 struct cYAML *cYAML_create_number(struct cYAML *parent, char *key, double value)
1049 struct cYAML *node = calloc(1, sizeof(*node));
1053 node->cy_string = strdup(key);
1054 node->cy_valuedouble = value;
1055 node->cy_valueint = (int)value;
1056 node->cy_type = CYAML_TYPE_NUMBER;
1058 cYAML_insert_child(parent, node);
1063 void cYAML_insert_child(struct cYAML *parent, struct cYAML *node)
1067 if (parent && node) {
1068 if (parent->cy_child == NULL) {
1069 parent->cy_child = node;
1073 cur = parent->cy_child;
1075 while (cur->cy_next)
1078 cur->cy_next = node;
1079 node->cy_prev = cur;
1083 void cYAML_insert_sibling(struct cYAML *root, struct cYAML *sibling)
1085 struct cYAML *last = NULL;
1086 if (root == NULL || sibling == NULL)
1090 while (last->cy_next != NULL)
1091 last = last->cy_next;
1093 last->cy_next = sibling;
1096 void cYAML_build_error(int rc, int seq_no, char *cmd,
1097 char *entity, char *err_str,
1098 struct cYAML **root)
1100 struct cYAML *r = NULL, *err, *s, *itm, *cmd_obj;
1104 /* add to the tail of the root that's passed in */
1105 if ((*root) == NULL) {
1106 *root = cYAML_create_object(NULL, NULL);
1107 if ((*root) == NULL)
1113 /* look for the command */
1114 cmd_obj = cYAML_get_object_item(r, (const char *)cmd);
1115 if (cmd_obj != NULL && cmd_obj->cy_type == CYAML_TYPE_ARRAY)
1116 itm = cYAML_create_seq_item(cmd_obj);
1117 else if (cmd_obj == NULL) {
1118 s = cYAML_create_seq(r, cmd);
1119 itm = cYAML_create_seq_item(s);
1120 } else if (cmd_obj != NULL && cmd_obj->cy_type != CYAML_TYPE_ARRAY)
1123 err = cYAML_create_object(itm, entity);
1128 cYAML_create_number(err, "seq_no", seq_no) == NULL)
1131 if (cYAML_create_number(err, "errno", rc) == NULL)
1134 if (cYAML_create_string(err, "descr", err_str) == NULL)
1140 /* Only reason we get here is if we run out of memory */
1143 fprintf(stderr, "error:\n\tfatal: out of memory\n");
1146 struct cYAML *cYAML_build_tree(char *yaml_file,
1147 const char *yaml_blk,
1148 size_t yaml_blk_size,
1149 struct cYAML **err_rc,
1152 yaml_parser_t parser;
1154 struct cYAML_tree_node tree;
1155 enum cYAML_handler_error rc;
1156 yaml_token_type_t token_type;
1161 memset(&tree, 0, sizeof(struct cYAML_tree_node));
1163 INIT_LIST_HEAD(&tree.ll);
1165 /* Create the Parser object. */
1166 yaml_parser_initialize(&parser);
1168 /* file always takes precedence */
1169 if (yaml_file != NULL) {
1170 /* Set a file input. */
1171 input = fopen(yaml_file, "rb");
1172 if (input == NULL) {
1173 snprintf(err_str, sizeof(err_str),
1174 "Failed to open file: %s", yaml_file);
1175 cYAML_build_error(-1, -1, "yaml", "builder",
1181 yaml_parser_set_input_file(&parser, input);
1182 } else if (yaml_blk != NULL) {
1183 yaml_parser_set_input_string(&parser,
1184 (const unsigned char *) yaml_blk,
1187 /* assume that we're getting our input froms stdin */
1188 yaml_parser_set_input_file(&parser, stdin);
1190 /* Read the event sequence. */
1193 * Go through the parser and build a cYAML representation
1194 * of the passed in YAML text
1196 yaml_parser_scan(&parser, &token);
1199 fprintf(stderr, "tree.state(%p:%d) = %s, token.type ="
1201 &tree, tree.state, state_string[tree.state],
1202 token_type_string[token.type],
1203 (token.type == YAML_SCALAR_TOKEN) ?
1204 (char*)token.data.scalar.value : "");
1205 rc = dispatch_tbl[token.type](&token, &tree);
1206 if (rc != CYAML_ERROR_NONE) {
1207 snprintf(err_str, sizeof(err_str),
1208 "Failed to handle token:%d "
1209 "[state=%d, rc=%d]",
1210 token.type, tree.state, rc);
1211 cYAML_build_error(-1, -1, "yaml", "builder",
1215 /* Are we finished? */
1216 done = (rc != CYAML_ERROR_NONE ||
1217 token.type == YAML_STREAM_END_TOKEN ||
1218 token.type == YAML_NO_TOKEN);
1220 token_type = token.type;
1222 yaml_token_delete(&token);
1225 /* Destroy the Parser object. */
1226 yaml_parser_delete(&parser);
1231 if (token_type == YAML_STREAM_END_TOKEN &&
1232 rc == CYAML_ERROR_NONE)
1235 cYAML_free_tree(tree.root);