自学教程：C++ yaml_strdup函数代码示例

static intyaml_parser_append_tag_directive(yaml_parser_t *parser,                                 yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark){    yaml_tag_directive_t *tag_directive;    yaml_tag_directive_t copy = { NULL, NULL };    for (tag_directive = parser->tag_directives.start;            tag_directive != parser->tag_directives.top; tag_directive ++) {        if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {            if (allow_duplicates)                return 1;            return yaml_parser_set_parser_error(parser,                                                "found duplicate %TAG directive", mark);        }    }    copy.handle = yaml_strdup(value.handle);    copy.prefix = yaml_strdup(value.prefix);    if (!copy.handle || !copy.prefix) {        parser->error = YAML_MEMORY_ERROR;        goto error;    }    if (!PUSH(parser, parser->tag_directives, copy))        goto error;    return 1;error:    yaml_free(copy.handle);    yaml_free(copy.prefix);    return 0;}

yaml_mapping_start_event_initialize(yaml_event_t *event,        yaml_char_t *anchor, yaml_char_t *tag, int implicit,        yaml_mapping_style_t style){    yaml_mark_t mark = { 0, 0, 0 };    yaml_char_t *anchor_copy = NULL;    yaml_char_t *tag_copy = NULL;    assert(event);      /* Non-NULL event object is expected. */    if (anchor) {        if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;        anchor_copy = yaml_strdup(anchor);        if (!anchor_copy) goto error;    }    if (tag) {        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;        tag_copy = yaml_strdup(tag);        if (!tag_copy) goto error;    }    MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,            implicit, style, mark, mark);    return 1;error:    yaml_free(anchor_copy);    yaml_free(tag_copy);    return 0;}

yaml_scalar_event_initialize(yaml_event_t *event,        yaml_char_t *anchor, yaml_char_t *tag,        yaml_char_t *value, int length,        int plain_implicit, int quoted_implicit,        yaml_scalar_style_t style){    yaml_mark_t mark = { 0, 0, 0 };    yaml_char_t *anchor_copy = NULL;    yaml_char_t *tag_copy = NULL;    yaml_char_t *value_copy = NULL;    assert(event);      /* Non-NULL event object is expected. */    /* following line added for Haskell yaml library */    if (!value && !length) value = "";    assert(value);      /* Non-NULL anchor is expected. */    if (anchor) {        if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;        anchor_copy = yaml_strdup(anchor);        if (!anchor_copy) goto error;    }    if (tag) {        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;        tag_copy = yaml_strdup(tag);        if (!tag_copy) goto error;    }    if (length < 0) {        length = strlen((char *)value);    }    if (!yaml_check_utf8(value, length)) goto error;    value_copy = yaml_malloc(length+1);    if (!value_copy) goto error;    memcpy(value_copy, value, length);    value_copy[length] = '/0';    SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,            plain_implicit, quoted_implicit, style, mark, mark);    return 1;error:    yaml_free(anchor_copy);    yaml_free(tag_copy);    yaml_free(value_copy);    return 0;}

static intyaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event){    yaml_node_t node;    int index;    yaml_char_t *tag = first_event->data.scalar.tag;    if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;    if (!tag || strcmp((char *)tag, "!") == 0) {        yaml_free(tag);        tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG);        if (!tag) goto error;    }    SCALAR_NODE_INIT(node, tag, first_event->data.scalar.value,            first_event->data.scalar.length, first_event->data.scalar.style,            first_event->start_mark, first_event->end_mark);    if (!PUSH(parser, parser->document->nodes, node)) goto error;    index = (int)(parser->document->nodes.top - parser->document->nodes.start);    if (!yaml_parser_register_anchor(parser, index,                first_event->data.scalar.anchor)) return 0;    return index;error:    yaml_free(tag);    yaml_free(first_event->data.scalar.anchor);    yaml_free(first_event->data.scalar.value);    return 0;}

static intyaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event){    yaml_event_t event;    yaml_node_t node;    struct {        yaml_node_item_t *start;        yaml_node_item_t *end;        yaml_node_item_t *top;    } items = { NULL, NULL, NULL };    int index, item_index;    yaml_char_t *tag = first_event->data.sequence_start.tag;    if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;    if (!tag || strcmp((char *)tag, "!") == 0) {        yaml_free(tag);        tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG);        if (!tag) goto error;    }    if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error;    SEQUENCE_NODE_INIT(node, tag, items.start, items.end,            first_event->data.sequence_start.style,            first_event->start_mark, first_event->end_mark);    if (!PUSH(parser, parser->document->nodes, node)) goto error;    index = (int)(parser->document->nodes.top - parser->document->nodes.start);    if (!yaml_parser_register_anchor(parser, index,                first_event->data.sequence_start.anchor)) return 0;    if (!yaml_parser_parse(parser, &event)) return 0;    while (event.type != YAML_SEQUENCE_END_EVENT) {        if (!STACK_LIMIT(parser,                    parser->document->nodes.start[index-1].data.sequence.items,                    INT_MAX-1)) return 0;        item_index = yaml_parser_load_node(parser, &event);        if (!item_index) return 0;        if (!PUSH(parser,                    parser->document->nodes.start[index-1].data.sequence.items,                    item_index)) return 0;        if (!yaml_parser_parse(parser, &event)) return 0;    }    parser->document->nodes.start[index-1].end_mark = event.end_mark;    return index;error:    yaml_free(tag);    yaml_free(first_event->data.sequence_start.anchor);    return 0;}

static intyaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event){    yaml_event_t event;    yaml_node_t node;    struct {        yaml_node_pair_t *start;        yaml_node_pair_t *end;        yaml_node_pair_t *top;    } pairs = { NULL, NULL, NULL };    int index;    yaml_node_pair_t pair;    yaml_char_t *tag = first_event->data.mapping_start.tag;    if (!tag || strcmp((char *)tag, "!") == 0) {        yaml_free(tag);        tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG);        if (!tag) goto error;    }    if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error;    MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,            first_event->data.mapping_start.style,            first_event->start_mark, first_event->end_mark);    if (!PUSH(parser, parser->document->nodes, node)) goto error;    index = (int) (parser->document->nodes.top - parser->document->nodes.start);    if (!yaml_parser_register_anchor(parser, index,                first_event->data.mapping_start.anchor)) return 0;    if (!yaml_parser_parse(parser, &event)) return 0;    while (event.type != YAML_MAPPING_END_EVENT) {        pair.key = yaml_parser_load_node(parser, &event);        if (!pair.key) return 0;        if (!yaml_parser_parse(parser, &event)) return 0;        pair.value = yaml_parser_load_node(parser, &event);        if (!pair.value) return 0;        if (!PUSH(parser,                    parser->document->nodes.start[index-1].data.mapping.pairs,                    pair)) return 0;        if (!yaml_parser_parse(parser, &event)) return 0;    }    parser->document->nodes.start[index-1].end_mark = event.end_mark;    return index;error:    yaml_free(tag);    yaml_free(first_event->data.mapping_start.anchor);    return 0;}

static intyaml_parser_load_merge(yaml_parser_t *parser, yaml_event_t *first_event){	yaml_node_t node;	yaml_char_t *tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MERGE_TAG);	if (!tag) goto error;	MERGE_NODE_INIT(node, tag, first_event->start_mark, first_event->end_mark);	if (!PUSH(parser, parser->document->nodes, node)) goto error;	return parser->document->nodes.top - parser->document->nodes.start;error:	yaml_free(tag);	return 0;}

yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor){    yaml_mark_t mark = { 0, 0, 0 };    yaml_char_t *anchor_copy = NULL;    assert(event);      /* Non-NULL event object is expected. */    assert(anchor);     /* Non-NULL anchor is expected. */    if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;    anchor_copy = yaml_strdup(anchor);    if (!anchor_copy)        return 0;    ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);    return 1;}

yaml_document_add_scalar(yaml_document_t *document,        yaml_char_t *tag, yaml_char_t *value, int length,        yaml_scalar_style_t style){    struct {        yaml_error_type_t error;    } context;    yaml_mark_t mark = { 0, 0, 0 };    yaml_char_t *tag_copy = NULL;    yaml_char_t *value_copy = NULL;    yaml_node_t node;    assert(document);   /* Non-NULL document object is expected. */    assert(value);      /* Non-NULL value is expected. */    if (!tag) {        tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;    }    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;    tag_copy = yaml_strdup(tag);    if (!tag_copy) goto error;    if (length < 0) {        length = strlen((char *)value);    }    if (!yaml_check_utf8(value, length)) goto error;    value_copy = yaml_malloc(length+1);    if (!value_copy) goto error;    memcpy(value_copy, value, length);    value_copy[length] = '/0';    SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);    if (!PUSH(&context, document->nodes, node)) goto error;    return document->nodes.top - document->nodes.start;error:    yaml_free(tag_copy);    yaml_free(value_copy);    return 0;}

yaml_document_add_mapping(yaml_document_t *document,        yaml_char_t *tag, yaml_mapping_style_t style){    struct {        yaml_error_type_t error;    } context;    yaml_mark_t mark = { 0, 0, 0 };    yaml_char_t *tag_copy = NULL;    struct {        yaml_node_pair_t *start;        yaml_node_pair_t *end;        yaml_node_pair_t *top;    } pairs = { NULL, NULL, NULL };    yaml_node_t node;    assert(document);   /* Non-NULL document object is expected. */    if (!tag) {        tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;    }    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;    tag_copy = yaml_strdup(tag);    if (!tag_copy) goto error;    if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;    MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,            style, mark, mark);    if (!PUSH(&context, document->nodes, node)) goto error;    return document->nodes.top - document->nodes.start;error:    STACK_DEL(&context, pairs);    yaml_free(tag_copy);    return 0;}

yaml_document_start_event_initialize(yaml_event_t *event,        yaml_version_directive_t *version_directive,        yaml_tag_directive_t *tag_directives_start,        yaml_tag_directive_t *tag_directives_end,        int implicit){    struct {        yaml_error_type_t error;    } context;    yaml_mark_t mark = { 0, 0, 0 };    yaml_version_directive_t *version_directive_copy = NULL;    struct {        yaml_tag_directive_t *start;        yaml_tag_directive_t *end;        yaml_tag_directive_t *top;    } tag_directives_copy = { NULL, NULL, NULL };    yaml_tag_directive_t value = { NULL, NULL };    assert(event);          /* Non-NULL event object is expected. */    assert((tag_directives_start && tag_directives_end) ||            (tag_directives_start == tag_directives_end));                            /* Valid tag directives are expected. */    if (version_directive) {        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));        if (!version_directive_copy) goto error;        version_directive_copy->major = version_directive->major;        version_directive_copy->minor = version_directive->minor;    }    if (tag_directives_start != tag_directives_end) {        yaml_tag_directive_t *tag_directive;        if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))            goto error;        for (tag_directive = tag_directives_start;                tag_directive != tag_directives_end; tag_directive ++) {            assert(tag_directive->handle);            assert(tag_directive->prefix);            if (!yaml_check_utf8(tag_directive->handle,                        strlen((char *)tag_directive->handle)))                goto error;            if (!yaml_check_utf8(tag_directive->prefix,                        strlen((char *)tag_directive->prefix)))                goto error;            value.handle = yaml_strdup(tag_directive->handle);            value.prefix = yaml_strdup(tag_directive->prefix);            if (!value.handle || !value.prefix) goto error;            if (!PUSH(&context, tag_directives_copy, value))                goto error;            value.handle = NULL;            value.prefix = NULL;        }    }    DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,            tag_directives_copy.start, tag_directives_copy.top,            implicit, mark, mark);    return 1;error:    yaml_free(version_directive_copy);    while (!STACK_EMPTY(context, tag_directives_copy)) {        yaml_tag_directive_t value = POP(context, tag_directives_copy);        yaml_free(value.handle);        yaml_free(value.prefix);    }    STACK_DEL(context, tag_directives_copy);    yaml_free(value.handle);    yaml_free(value.prefix);    return 0;}