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

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_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;}

static intyaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event){    yaml_token_t *token;    yaml_mark_t start_mark, end_mark;    int implicit = 1;    token = PEEK_TOKEN(parser);    if (!token) return 0;    start_mark = end_mark = token->start_mark;    if (token->type == YAML_DOCUMENT_END_TOKEN) {        end_mark = token->end_mark;        SKIP_TOKEN(parser);        implicit = 0;    }    while (!STACK_EMPTY(parser, parser->tag_directives)) {        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);        yaml_free(tag_directive.handle);        yaml_free(tag_directive.prefix);    }    parser->state = YAML_PARSE_DOCUMENT_START_STATE;    DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);    return 1;}

static intyaml_parser_register_anchor(yaml_parser_t *parser,        int index, yaml_char_t *anchor){    yaml_alias_data_t data;    yaml_alias_data_t *alias_data;    if (!anchor) return 1;    data.anchor = anchor;    data.index = index;    data.mark = parser->document->nodes.start[index-1].start_mark;    for (alias_data = parser->aliases.start;            alias_data != parser->aliases.top; alias_data ++) {        if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {            yaml_free(anchor);            return yaml_parser_set_composer_error_context(parser,                    "found duplicate anchor; first occurence",                    alias_data->mark, "second occurence", data.mark);        }    }    if (!PUSH(parser, parser->aliases, data)) {        yaml_free(anchor);        return 0;    }    return 1;}

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;}

static voidyaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter){    int index;    if (!emitter->anchors) {        yaml_document_delete(emitter->document);        emitter->document = NULL;        return;    }    for (index = 0; emitter->document->nodes.start + index            < emitter->document->nodes.top; index ++) {        yaml_node_t node = emitter->document->nodes.start[index];        if (!emitter->anchors[index].serialized) {            yaml_free(node.tag);            if (node.type == YAML_SCALAR_NODE) {                yaml_free(node.data.scalar.value);            }        }        if (node.type == YAML_SEQUENCE_NODE) {            STACK_DEL(emitter, node.data.sequence.items);        }        if (node.type == YAML_MAPPING_NODE) {            STACK_DEL(emitter, node.data.mapping.pairs);        }    }    STACK_DEL(emitter, emitter->document->nodes);    yaml_free(emitter->anchors);    emitter->anchors = NULL;    emitter->last_anchor_id = 0;    emitter->document = NULL;}

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;}

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 voidyaml_parser_delete_aliases(yaml_parser_t *parser){    while (!STACK_EMPTY(parser, parser->aliases)) {        yaml_free(POP(parser, parser->aliases).anchor);    }    STACK_DEL(parser, parser->aliases);}

yaml_token_delete(yaml_token_t *token){    assert(token);  /* Non-NULL token object expected. */    switch (token->type)    {        case YAML_TAG_DIRECTIVE_TOKEN:            yaml_free(token->data.tag_directive.handle);            yaml_free(token->data.tag_directive.prefix);            break;        case YAML_ALIAS_TOKEN:            yaml_free(token->data.alias.value);            break;        case YAML_ANCHOR_TOKEN:            yaml_free(token->data.anchor.value);            break;        case YAML_TAG_TOKEN:            yaml_free(token->data.tag.handle);            yaml_free(token->data.tag.suffix);            break;        case YAML_SCALAR_TOKEN:            yaml_free(token->data.scalar.value);            break;        default:            break;    }    memset(token, 0, sizeof(yaml_token_t));}

static intyaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event){    yaml_char_t *anchor = first_event->data.alias.anchor;    yaml_alias_data_t *alias_data;    for (alias_data = parser->aliases.start;            alias_data != parser->aliases.top; alias_data ++) {        if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {            yaml_free(anchor);            return alias_data->index;        }    }    yaml_free(anchor);    return yaml_parser_set_composer_error(parser, "found undefined alias",            first_event->start_mark);}

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_emitter_delete(yaml_emitter_t *emitter){    assert(emitter);    /* Non-NULL emitter object expected. */    BUFFER_DEL(emitter, emitter->buffer);    BUFFER_DEL(emitter, emitter->raw_buffer);    STACK_DEL(emitter, emitter->states);    while (!QUEUE_EMPTY(emitter, emitter->events)) {        yaml_event_delete(&DEQUEUE(emitter, emitter->events));    }    QUEUE_DEL(emitter, emitter->events);    STACK_DEL(emitter, emitter->indents);    while (!STACK_EMPTY(empty, emitter->tag_directives)) {        yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);        yaml_free(tag_directive.handle);        yaml_free(tag_directive.prefix);    }    STACK_DEL(emitter, emitter->tag_directives);    yaml_free(emitter->anchors);    memset(emitter, 0, sizeof(yaml_emitter_t));}

yaml_parser_delete(yaml_parser_t *parser){    assert(parser); /* Non-NULL parser object expected. */    BUFFER_DEL(parser, parser->raw_buffer);    BUFFER_DEL(parser, parser->buffer);    while (!QUEUE_EMPTY(parser, parser->tokens)) {        yaml_token_delete(&DEQUEUE(parser, parser->tokens));    }    QUEUE_DEL(parser, parser->tokens);    STACK_DEL(parser, parser->indents);    STACK_DEL(parser, parser->simple_keys);    STACK_DEL(parser, parser->states);    STACK_DEL(parser, parser->marks);    while (!STACK_EMPTY(parser, parser->tag_directives)) {        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);        yaml_free(tag_directive.handle);        yaml_free(tag_directive.prefix);    }    STACK_DEL(parser, parser->tag_directives);    memset(parser, 0, sizeof(yaml_parser_t));}

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_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_delete(yaml_document_t *document){    struct {        yaml_error_type_t error;    } context;    (void)context;    yaml_tag_directive_t *tag_directive;    context.error = YAML_NO_ERROR;  /* Eliminate a compliler warning. */    assert(document);   /* Non-NULL document object is expected. */    while (!STACK_EMPTY(&context, document->nodes)) {        yaml_node_t node = POP(&context, document->nodes);        yaml_free(node.tag);        switch (node.type) {            case YAML_SCALAR_NODE:                yaml_free(node.data.scalar.value);                break;            case YAML_SEQUENCE_NODE:                STACK_DEL(&context, node.data.sequence.items);                break;            case YAML_MAPPING_NODE:                STACK_DEL(&context, node.data.mapping.pairs);                break;            default:                assert(0);  /* Should not happen. */        }    }    STACK_DEL(&context, document->nodes);    yaml_free(document->version_directive);    for (tag_directive = document->tag_directives.start;            tag_directive != document->tag_directives.end;            tag_directive++) {        yaml_free(tag_directive->handle);        yaml_free(tag_directive->prefix);    }    yaml_free(document->tag_directives.start);    memset(document, 0, sizeof(yaml_document_t));}

yaml_event_delete(yaml_event_t *event){    yaml_tag_directive_t *tag_directive;    assert(event);  /* Non-NULL event object expected. */    switch (event->type)    {        case YAML_DOCUMENT_START_EVENT:            yaml_free(event->data.document_start.version_directive);            for (tag_directive = event->data.document_start.tag_directives.start;                    tag_directive != event->data.document_start.tag_directives.end;                    tag_directive++) {                yaml_free(tag_directive->handle);                yaml_free(tag_directive->prefix);            }            yaml_free(event->data.document_start.tag_directives.start);            break;        case YAML_ALIAS_EVENT:            yaml_free(event->data.alias.anchor);            break;        case YAML_SCALAR_EVENT:            yaml_free(event->data.scalar.anchor);            yaml_free(event->data.scalar.tag);            yaml_free(event->data.scalar.value);            break;        case YAML_SEQUENCE_START_EVENT:            yaml_free(event->data.sequence_start.anchor);            yaml_free(event->data.sequence_start.tag);            break;        case YAML_MAPPING_START_EVENT:            yaml_free(event->data.mapping_start.anchor);            yaml_free(event->data.mapping_start.tag);            break;        default:            break;    }    memset(event, 0, sizeof(yaml_event_t));}

static intyaml_parser_process_directives(yaml_parser_t *parser,                               yaml_version_directive_t **version_directive_ref,                               yaml_tag_directive_t **tag_directives_start_ref,                               yaml_tag_directive_t **tag_directives_end_ref){    yaml_tag_directive_t default_tag_directives[] = {        {(yaml_char_t *)"!", (yaml_char_t *)"!"},        {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},        {NULL, NULL}    };    yaml_tag_directive_t *default_tag_directive;    yaml_version_directive_t *version_directive = NULL;    struct {        yaml_tag_directive_t *start;        yaml_tag_directive_t *end;        yaml_tag_directive_t *top;    } tag_directives = { NULL, NULL, NULL };    yaml_token_t *token;    if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))        goto error;    token = PEEK_TOKEN(parser);    if (!token) goto error;    while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||            token->type == YAML_TAG_DIRECTIVE_TOKEN)    {        if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {            if (version_directive) {                yaml_parser_set_parser_error(parser,                                             "found duplicate %YAML directive", token->start_mark);                goto error;            }            if (token->data.version_directive.major != 1                    || token->data.version_directive.minor != 1) {                yaml_parser_set_parser_error(parser,                                             "found incompatible YAML document", token->start_mark);                goto error;            }            version_directive = yaml_malloc(sizeof(yaml_version_directive_t));            if (!version_directive) {                parser->error = YAML_MEMORY_ERROR;                goto error;            }            version_directive->major = token->data.version_directive.major;            version_directive->minor = token->data.version_directive.minor;        }        else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {            yaml_tag_directive_t value;            value.handle = token->data.tag_directive.handle;            value.prefix = token->data.tag_directive.prefix;            if (!yaml_parser_append_tag_directive(parser, value, 0,                                                  token->start_mark))                goto error;            if (!PUSH(parser, tag_directives, value))                goto error;        }        SKIP_TOKEN(parser);        token = PEEK_TOKEN(parser);        if (!token) goto error;    }    for (default_tag_directive = default_tag_directives;            default_tag_directive->handle; default_tag_directive++) {        if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,                                              token->start_mark))            goto error;    }    if (version_directive_ref) {        *version_directive_ref = version_directive;    }    if (tag_directives_start_ref) {        if (STACK_EMPTY(parser, tag_directives)) {            *tag_directives_start_ref = *tag_directives_end_ref = NULL;            STACK_DEL(parser, tag_directives);        }        else {            *tag_directives_start_ref = tag_directives.start;            *tag_directives_end_ref = tag_directives.top;        }    }    else {        STACK_DEL(parser, tag_directives);    }    return 1;error:    yaml_free(version_directive);    while (!STACK_EMPTY(parser, tag_directives)) {        yaml_tag_directive_t tag_directive = POP(parser, tag_directives);        yaml_free(tag_directive.handle);        yaml_free(tag_directive.prefix);    }//.........这里部分代码省略.........

static intyaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,                                 int implicit){    yaml_token_t *token;    yaml_version_directive_t *version_directive = NULL;    struct {        yaml_tag_directive_t *start;        yaml_tag_directive_t *end;    } tag_directives = { NULL, NULL };    token = PEEK_TOKEN(parser);    if (!token) return 0;    /* Parse extra document end indicators. */    if (!implicit)    {        while (token->type == YAML_DOCUMENT_END_TOKEN) {            SKIP_TOKEN(parser);            token = PEEK_TOKEN(parser);            if (!token) return 0;        }    }    /* Parse an implicit document. */    if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&            token->type != YAML_TAG_DIRECTIVE_TOKEN &&            token->type != YAML_DOCUMENT_START_TOKEN &&            token->type != YAML_STREAM_END_TOKEN)    {        if (!yaml_parser_process_directives(parser, NULL, NULL, NULL))            return 0;        if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))            return 0;        parser->state = YAML_PARSE_BLOCK_NODE_STATE;        DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1,                                  token->start_mark, token->start_mark);        return 1;    }    /* Parse an explicit document. */    else if (token->type != YAML_STREAM_END_TOKEN)    {        yaml_mark_t start_mark, end_mark;        start_mark = token->start_mark;        if (!yaml_parser_process_directives(parser, &version_directive,                                            &tag_directives.start, &tag_directives.end))            return 0;        token = PEEK_TOKEN(parser);        if (!token) goto error;        if (token->type != YAML_DOCUMENT_START_TOKEN) {            yaml_parser_set_parser_error(parser,                                         "did not find expected <document start>", token->start_mark);            goto error;        }        if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))            goto error;        parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;        end_mark = token->end_mark;        DOCUMENT_START_EVENT_INIT(*event, version_directive,                                  tag_directives.start, tag_directives.end, 0,                                  start_mark, end_mark);        SKIP_TOKEN(parser);        version_directive = NULL;        tag_directives.start = tag_directives.end = NULL;        return 1;    }    /* Parse the stream end. */    else    {        parser->state = YAML_PARSE_END_STATE;        STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark);        SKIP_TOKEN(parser);        return 1;    }error:    yaml_free(version_directive);    while (tag_directives.start != tag_directives.end) {        yaml_free(tag_directives.end[-1].handle);        yaml_free(tag_directives.end[-1].prefix);        tag_directives.end --;    }    yaml_free(tag_directives.start);    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;}

static intyaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,                       int block, int indentless_sequence){    yaml_token_t *token;    yaml_char_t *anchor = NULL;    yaml_char_t *tag_handle = NULL;    yaml_char_t *tag_suffix = NULL;    yaml_char_t *tag = NULL;    yaml_mark_t start_mark, end_mark, tag_mark;    int implicit;    token = PEEK_TOKEN(parser);    if (!token) return 0;    if (token->type == YAML_ALIAS_TOKEN)    {        parser->state = POP(parser, parser->states);        ALIAS_EVENT_INIT(*event, token->data.alias.value,                         token->start_mark, token->end_mark);        SKIP_TOKEN(parser);        return 1;    }    else    {        start_mark = end_mark = tag_mark = token->start_mark;        if (token->type == YAML_ANCHOR_TOKEN)        {            anchor = token->data.anchor.value;            start_mark = token->start_mark;            end_mark = token->end_mark;            SKIP_TOKEN(parser);            token = PEEK_TOKEN(parser);            if (!token) goto error;            if (token->type == YAML_TAG_TOKEN)            {                tag_handle = token->data.tag.handle;                tag_suffix = token->data.tag.suffix;                tag_mark = token->start_mark;                end_mark = token->end_mark;                SKIP_TOKEN(parser);                token = PEEK_TOKEN(parser);                if (!token) goto error;            }        }        else if (token->type == YAML_TAG_TOKEN)        {            tag_handle = token->data.tag.handle;            tag_suffix = token->data.tag.suffix;            start_mark = tag_mark = token->start_mark;            end_mark = token->end_mark;            SKIP_TOKEN(parser);            token = PEEK_TOKEN(parser);            if (!token) goto error;            if (token->type == YAML_ANCHOR_TOKEN)            {                anchor = token->data.anchor.value;                end_mark = token->end_mark;                SKIP_TOKEN(parser);                token = PEEK_TOKEN(parser);                if (!token) goto error;            }        }        if (tag_handle) {            if (!*tag_handle) {                tag = tag_suffix;                yaml_free(tag_handle);                tag_handle = tag_suffix = NULL;            }            else {                yaml_tag_directive_t *tag_directive;                for (tag_directive = parser->tag_directives.start;                        tag_directive != parser->tag_directives.top;                        tag_directive ++) {                    if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {                        size_t prefix_len = strlen((char *)tag_directive->prefix);                        size_t suffix_len = strlen((char *)tag_suffix);                        tag = yaml_malloc(prefix_len+suffix_len+1);                        if (!tag) {                            parser->error = YAML_MEMORY_ERROR;                            goto error;                        }                        memcpy(tag, tag_directive->prefix, prefix_len);                        memcpy(tag+prefix_len, tag_suffix, suffix_len);                        tag[prefix_len+suffix_len] = '/0';                        yaml_free(tag_handle);                        yaml_free(tag_suffix);                        tag_handle = tag_suffix = NULL;                        break;                    }                }                if (!tag) {                    yaml_parser_set_parser_error_context(parser,                                                         "while parsing a node", start_mark,                                                         "found undefined tag handle", tag_mark);                    goto error;                }//.........这里部分代码省略.........