use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};

use crate::externs::{memcpy, memset, strcmp, strlen};

use crate::ops::ForceAdd as _;

use crate::scanner::yaml_parser_fetch_more_tokens;

use crate::success::{Success, FAIL, OK};

use crate::yaml::{size_t, yaml_char_t};

use crate::{

    libc, yaml_event_t, yaml_mark_t, yaml_parser_t, yaml_tag_directive_t, yaml_token_t,

    yaml_version_directive_t, YAML_ALIAS_EVENT, YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN,

    YAML_BLOCK_END_TOKEN, YAML_BLOCK_ENTRY_TOKEN, YAML_BLOCK_MAPPING_START_TOKEN,

    YAML_BLOCK_MAPPING_STYLE, YAML_BLOCK_SEQUENCE_START_TOKEN, YAML_BLOCK_SEQUENCE_STYLE,

    YAML_DOCUMENT_END_EVENT, YAML_DOCUMENT_END_TOKEN, YAML_DOCUMENT_START_EVENT,

    YAML_DOCUMENT_START_TOKEN, YAML_FLOW_ENTRY_TOKEN, YAML_FLOW_MAPPING_END_TOKEN,

    YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_MAPPING_STYLE, YAML_FLOW_SEQUENCE_END_TOKEN,

    YAML_FLOW_SEQUENCE_START_TOKEN, YAML_FLOW_SEQUENCE_STYLE, YAML_KEY_TOKEN,

    YAML_MAPPING_END_EVENT, YAML_MAPPING_START_EVENT, YAML_NO_ERROR, YAML_PARSER_ERROR,

    YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE, YAML_PARSE_BLOCK_MAPPING_KEY_STATE,

    YAML_PARSE_BLOCK_MAPPING_VALUE_STATE, YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,

    YAML_PARSE_BLOCK_NODE_STATE, YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,

    YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE, YAML_PARSE_DOCUMENT_CONTENT_STATE,

    YAML_PARSE_DOCUMENT_END_STATE, YAML_PARSE_DOCUMENT_START_STATE, YAML_PARSE_END_STATE,

    YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,

    YAML_PARSE_FLOW_MAPPING_KEY_STATE, YAML_PARSE_FLOW_MAPPING_VALUE_STATE,

    YAML_PARSE_FLOW_NODE_STATE, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,

    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,

    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE, YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,

    YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE, YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,

    YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE, YAML_PARSE_STREAM_START_STATE,

    YAML_PLAIN_SCALAR_STYLE, YAML_SCALAR_EVENT, YAML_SCALAR_TOKEN, YAML_SEQUENCE_END_EVENT,

    YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_END_TOKEN,

    YAML_STREAM_START_EVENT, YAML_STREAM_START_TOKEN, YAML_TAG_DIRECTIVE_TOKEN, YAML_TAG_TOKEN,

    YAML_VALUE_TOKEN, YAML_VERSION_DIRECTIVE_TOKEN,

};

use core::mem::size_of;

use core::ptr::{self, addr_of_mut};

unsafe fn PEEK_TOKEN(parser: *mut yaml_parser_t) -> *mut yaml_token_t {

    if (*parser).token_available || yaml_parser_fetch_more_tokens(parser).ok {

        (*parser).tokens.head

    } else {

        ptr::null_mut::<yaml_token_t>()

    }

}

unsafe fn SKIP_TOKEN(parser: *mut yaml_parser_t) {

    (*parser).token_available = false;

    let fresh3 = addr_of_mut!((*parser).tokens_parsed);

    *fresh3 = (*fresh3).wrapping_add(1);

    (*parser).stream_end_produced = (*(*parser).tokens.head).type_ == YAML_STREAM_END_TOKEN;

    let fresh4 = addr_of_mut!((*parser).tokens.head);

    *fresh4 = (*fresh4).wrapping_offset(1);

}

/// Parse the input stream and produce the next parsing event.

///

/// Call the function subsequently to produce a sequence of events corresponding

/// to the input stream. The initial event has the type YAML_STREAM_START_EVENT

/// while the ending event has the type YAML_STREAM_END_EVENT.

///

/// An application is responsible for freeing any buffers associated with the

/// produced event object using the yaml_event_delete() function.

///

/// An application must not alternate the calls of yaml_parser_parse() with the

/// calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the

/// parser.

pub unsafe fn yaml_parser_parse(parser: *mut yaml_parser_t, event: *mut yaml_event_t) -> Success {

    __assert!(!parser.is_null());

    __assert!(!event.is_null());

    memset(

        event as *mut libc::c_void,

        0,

        size_of::<yaml_event_t>() as libc::c_ulong,

    );

    if (*parser).stream_end_produced

        || (*parser).error != YAML_NO_ERROR

        || (*parser).state == YAML_PARSE_END_STATE

    {

        return OK;

    }

    yaml_parser_state_machine(parser, event)

}

unsafe fn yaml_parser_set_parser_error(

    parser: *mut yaml_parser_t,

    problem: *const libc::c_char,

    problem_mark: yaml_mark_t,

) {

    (*parser).error = YAML_PARSER_ERROR;

    let fresh0 = addr_of_mut!((*parser).problem);

    *fresh0 = problem;

    (*parser).problem_mark = problem_mark;

}

unsafe fn yaml_parser_set_parser_error_context(

    parser: *mut yaml_parser_t,

    context: *const libc::c_char,

    context_mark: yaml_mark_t,

    problem: *const libc::c_char,

    problem_mark: yaml_mark_t,

) {

    (*parser).error = YAML_PARSER_ERROR;

    let fresh1 = addr_of_mut!((*parser).context);

    *fresh1 = context;

    (*parser).context_mark = context_mark;

    let fresh2 = addr_of_mut!((*parser).problem);

    *fresh2 = problem;

    (*parser).problem_mark = problem_mark;

}

unsafe fn yaml_parser_state_machine(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

) -> Success {

    match (*parser).state {

        YAML_PARSE_STREAM_START_STATE => yaml_parser_parse_stream_start(parser, event),

        YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => {

            yaml_parser_parse_document_start(parser, event, true)

        }

        YAML_PARSE_DOCUMENT_START_STATE => yaml_parser_parse_document_start(parser, event, false),

        YAML_PARSE_DOCUMENT_CONTENT_STATE => yaml_parser_parse_document_content(parser, event),

        YAML_PARSE_DOCUMENT_END_STATE => yaml_parser_parse_document_end(parser, event),

        YAML_PARSE_BLOCK_NODE_STATE => yaml_parser_parse_node(parser, event, true, false),

        YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE => {

            yaml_parser_parse_node(parser, event, true, true)

        }

        YAML_PARSE_FLOW_NODE_STATE => yaml_parser_parse_node(parser, event, false, false),

        YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE => {

            yaml_parser_parse_block_sequence_entry(parser, event, true)

        }

        YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE => {

            yaml_parser_parse_block_sequence_entry(parser, event, false)

        }

        YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE => {

            yaml_parser_parse_indentless_sequence_entry(parser, event)

        }

        YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE => {

            yaml_parser_parse_block_mapping_key(parser, event, true)

        }

        YAML_PARSE_BLOCK_MAPPING_KEY_STATE => {

            yaml_parser_parse_block_mapping_key(parser, event, false)

        }

        YAML_PARSE_BLOCK_MAPPING_VALUE_STATE => {

            yaml_parser_parse_block_mapping_value(parser, event)

        }

        YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE => {

            yaml_parser_parse_flow_sequence_entry(parser, event, true)

        }

        YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE => {

            yaml_parser_parse_flow_sequence_entry(parser, event, false)

        }

        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE => {

            yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)

        }

        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE => {

            yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)

        }

        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE => {

            yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)

        }

        YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE => {

            yaml_parser_parse_flow_mapping_key(parser, event, true)

        }

        YAML_PARSE_FLOW_MAPPING_KEY_STATE => {

            yaml_parser_parse_flow_mapping_key(parser, event, false)

        }

        YAML_PARSE_FLOW_MAPPING_VALUE_STATE => {

            yaml_parser_parse_flow_mapping_value(parser, event, false)

        }

        YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE => {

            yaml_parser_parse_flow_mapping_value(parser, event, true)

        }

        _ => FAIL,

    }

}

unsafe fn yaml_parser_parse_stream_start(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

) -> Success {

    let token: *mut yaml_token_t = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ != YAML_STREAM_START_TOKEN {

        yaml_parser_set_parser_error(

            parser,

            b"did not find expected <stream-start>\0" as *const u8 as *const libc::c_char,

            (*token).start_mark,

        );

        return FAIL;

    }

    (*parser).state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;

    memset(

        event as *mut libc::c_void,

        0,

        size_of::<yaml_event_t>() as libc::c_ulong,

    );

    (*event).type_ = YAML_STREAM_START_EVENT;

    (*event).start_mark = (*token).start_mark;

    (*event).end_mark = (*token).start_mark;

    (*event).data.stream_start.encoding = (*token).data.stream_start.encoding;

    SKIP_TOKEN(parser);

    OK

}

unsafe fn yaml_parser_parse_document_start(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

    implicit: bool,

) -> Success {

    let mut token: *mut yaml_token_t;

    let mut version_directive: *mut yaml_version_directive_t =

        ptr::null_mut::<yaml_version_directive_t>();

    struct TagDirectives {

        start: *mut yaml_tag_directive_t,

        end: *mut yaml_tag_directive_t,

    }

    let mut tag_directives = TagDirectives {

        start: ptr::null_mut::<yaml_tag_directive_t>(),

        end: ptr::null_mut::<yaml_tag_directive_t>(),

    };

    token = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if !implicit {

        while (*token).type_ == YAML_DOCUMENT_END_TOKEN {

            SKIP_TOKEN(parser);

            token = PEEK_TOKEN(parser);

            if token.is_null() {

                return FAIL;

            }

        }

    }

    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,

            ptr::null_mut::<*mut yaml_version_directive_t>(),

            ptr::null_mut::<*mut yaml_tag_directive_t>(),

            ptr::null_mut::<*mut yaml_tag_directive_t>(),

        )

        .fail

        {

            return FAIL;

        }

        PUSH!((*parser).states, YAML_PARSE_DOCUMENT_END_STATE);

        (*parser).state = YAML_PARSE_BLOCK_NODE_STATE;

        memset(

            event as *mut libc::c_void,

            0,

            size_of::<yaml_event_t>() as libc::c_ulong,

        );

        (*event).type_ = YAML_DOCUMENT_START_EVENT;

        (*event).start_mark = (*token).start_mark;

        (*event).end_mark = (*token).start_mark;

        let fresh9 = addr_of_mut!((*event).data.document_start.version_directive);

        *fresh9 = ptr::null_mut::<yaml_version_directive_t>();

        let fresh10 = addr_of_mut!((*event).data.document_start.tag_directives.start);

        *fresh10 = ptr::null_mut::<yaml_tag_directive_t>();

        let fresh11 = addr_of_mut!((*event).data.document_start.tag_directives.end);

        *fresh11 = ptr::null_mut::<yaml_tag_directive_t>();

        (*event).data.document_start.implicit = true;

        OK

    } else if (*token).type_ != YAML_STREAM_END_TOKEN {

        let end_mark: yaml_mark_t;

        let start_mark: yaml_mark_t = (*token).start_mark;

        if yaml_parser_process_directives(

            parser,

            addr_of_mut!(version_directive),

            addr_of_mut!(tag_directives.start),

            addr_of_mut!(tag_directives.end),

        )

        .fail

        {

            return FAIL;

        }

        token = PEEK_TOKEN(parser);

        if !token.is_null() {

            if (*token).type_ != YAML_DOCUMENT_START_TOKEN {

                yaml_parser_set_parser_error(

                    parser,

                    b"did not find expected <document start>\0" as *const u8 as *const libc::c_char,

                    (*token).start_mark,

                );

            } else {

                PUSH!((*parser).states, YAML_PARSE_DOCUMENT_END_STATE);

                (*parser).state = YAML_PARSE_DOCUMENT_CONTENT_STATE;

                end_mark = (*token).end_mark;

                memset(

                    event as *mut libc::c_void,

                    0,

                    size_of::<yaml_event_t>() as libc::c_ulong,

                );

                (*event).type_ = YAML_DOCUMENT_START_EVENT;

                (*event).start_mark = start_mark;

                (*event).end_mark = end_mark;

                let fresh14 = addr_of_mut!((*event).data.document_start.version_directive);

                *fresh14 = version_directive;

                let fresh15 = addr_of_mut!((*event).data.document_start.tag_directives.start);

                *fresh15 = tag_directives.start;

                let fresh16 = addr_of_mut!((*event).data.document_start.tag_directives.end);

                *fresh16 = tag_directives.end;

                (*event).data.document_start.implicit = false;

                SKIP_TOKEN(parser);

                tag_directives.end = ptr::null_mut::<yaml_tag_directive_t>();

                tag_directives.start = tag_directives.end;

                return OK;

            }

        }

        yaml_free(version_directive as *mut libc::c_void);

        while tag_directives.start != tag_directives.end {

            yaml_free((*tag_directives.end.wrapping_offset(-1_isize)).handle as *mut libc::c_void);

            yaml_free((*tag_directives.end.wrapping_offset(-1_isize)).prefix as *mut libc::c_void);

            tag_directives.end = tag_directives.end.wrapping_offset(-1);

        }

        yaml_free(tag_directives.start as *mut libc::c_void);

        FAIL

    } else {

        (*parser).state = YAML_PARSE_END_STATE;

        memset(

            event as *mut libc::c_void,

            0,

            size_of::<yaml_event_t>() as libc::c_ulong,

        );

        (*event).type_ = YAML_STREAM_END_EVENT;

        (*event).start_mark = (*token).start_mark;

        (*event).end_mark = (*token).end_mark;

        SKIP_TOKEN(parser);

        OK

    }

}

unsafe fn yaml_parser_parse_document_content(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

) -> Success {

    let token: *mut yaml_token_t = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ == YAML_VERSION_DIRECTIVE_TOKEN

        || (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN

        || (*token).type_ == YAML_DOCUMENT_START_TOKEN

        || (*token).type_ == YAML_DOCUMENT_END_TOKEN

        || (*token).type_ == YAML_STREAM_END_TOKEN

    {

        (*parser).state = POP!((*parser).states);

        yaml_parser_process_empty_scalar(event, (*token).start_mark)

    } else {

        yaml_parser_parse_node(parser, event, true, false)

    }

}

unsafe fn yaml_parser_parse_document_end(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

) -> Success {

    let mut end_mark: yaml_mark_t;

    let mut implicit = true;

    let token: *mut yaml_token_t = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    end_mark = (*token).start_mark;

    let start_mark: yaml_mark_t = end_mark;

    if (*token).type_ == YAML_DOCUMENT_END_TOKEN {

        end_mark = (*token).end_mark;

        SKIP_TOKEN(parser);

        implicit = false;

    }

    while !STACK_EMPTY!((*parser).tag_directives) {

        let tag_directive = POP!((*parser).tag_directives);

        yaml_free(tag_directive.handle as *mut libc::c_void);

        yaml_free(tag_directive.prefix as *mut libc::c_void);

    }

    (*parser).state = YAML_PARSE_DOCUMENT_START_STATE;

    memset(

        event as *mut libc::c_void,

        0,

        size_of::<yaml_event_t>() as libc::c_ulong,

    );

    (*event).type_ = YAML_DOCUMENT_END_EVENT;

    (*event).start_mark = start_mark;

    (*event).end_mark = end_mark;

    (*event).data.document_end.implicit = implicit;

    OK

}

unsafe fn yaml_parser_parse_node(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

    block: bool,

    indentless_sequence: bool,

) -> Success {

    let mut current_block: u64;

    let mut token: *mut yaml_token_t;

    let mut anchor: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();

    let mut tag_handle: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();

    let mut tag_suffix: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();

    let mut tag: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();

    let mut start_mark: yaml_mark_t;

    let mut end_mark: yaml_mark_t;

    let mut tag_mark = yaml_mark_t {

        index: 0,

        line: 0,

        column: 0,

    };

    let implicit;

    token = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ == YAML_ALIAS_TOKEN {

        (*parser).state = POP!((*parser).states);

        memset(

            event as *mut libc::c_void,

            0,

            size_of::<yaml_event_t>() as libc::c_ulong,

        );

        (*event).type_ = YAML_ALIAS_EVENT;

        (*event).start_mark = (*token).start_mark;

        (*event).end_mark = (*token).end_mark;

        let fresh26 = addr_of_mut!((*event).data.alias.anchor);

        *fresh26 = (*token).data.alias.value;

        SKIP_TOKEN(parser);

        OK

    } else {

        end_mark = (*token).start_mark;

        start_mark = end_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.is_null() {

                current_block = 17786380918591080555;

            } else 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.is_null() {

                    current_block = 17786380918591080555;

                } else {

                    current_block = 11743904203796629665;

                }

            } else {

                current_block = 11743904203796629665;

            }

        } else if (*token).type_ == YAML_TAG_TOKEN {

            tag_handle = (*token).data.tag.handle;

            tag_suffix = (*token).data.tag.suffix;

            tag_mark = (*token).start_mark;

            start_mark = tag_mark;

            end_mark = (*token).end_mark;

            SKIP_TOKEN(parser);

            token = PEEK_TOKEN(parser);

            if token.is_null() {

                current_block = 17786380918591080555;

            } else 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.is_null() {

                    current_block = 17786380918591080555;

                } else {

                    current_block = 11743904203796629665;

                }

            } else {

                current_block = 11743904203796629665;

            }

        } else {

            current_block = 11743904203796629665;

        }

        if current_block == 11743904203796629665 {

            if !tag_handle.is_null() {

                if *tag_handle == 0 {

                    tag = tag_suffix;

                    yaml_free(tag_handle as *mut libc::c_void);

                    tag_suffix = ptr::null_mut::<yaml_char_t>();

                    tag_handle = tag_suffix;

                    current_block = 9437013279121998969;

                } else {

                    let mut tag_directive: *mut yaml_tag_directive_t;

                    tag_directive = (*parser).tag_directives.start;

                    loop {

                        if !(tag_directive != (*parser).tag_directives.top) {

                            current_block = 17728966195399430138;

                            break;

                        }

                        if strcmp(

                            (*tag_directive).handle as *mut libc::c_char,

                            tag_handle as *mut libc::c_char,

                        ) == 0

                        {

                            let prefix_len: size_t =

                                strlen((*tag_directive).prefix as *mut libc::c_char);

                            let suffix_len: size_t = strlen(tag_suffix as *mut libc::c_char);

                            tag = yaml_malloc(prefix_len.force_add(suffix_len).force_add(1_u64))

                                as *mut yaml_char_t;

                            memcpy(

                                tag as *mut libc::c_void,

                                (*tag_directive).prefix as *const libc::c_void,

                                prefix_len,

                            );

                            memcpy(

                                tag.wrapping_offset(prefix_len as isize) as *mut libc::c_void,

                                tag_suffix as *const libc::c_void,

                                suffix_len,

                            );

                            *tag.wrapping_offset(prefix_len.force_add(suffix_len) as isize) = b'\0';

                            yaml_free(tag_handle as *mut libc::c_void);

                            yaml_free(tag_suffix as *mut libc::c_void);

                            tag_suffix = ptr::null_mut::<yaml_char_t>();

                            tag_handle = tag_suffix;

                            current_block = 17728966195399430138;

                            break;

                        } else {

                            tag_directive = tag_directive.wrapping_offset(1);

                        }

                    }

                    if current_block != 17786380918591080555 {

                        if tag.is_null() {

                            yaml_parser_set_parser_error_context(

                                parser,

                                b"while parsing a node\0" as *const u8 as *const libc::c_char,

                                start_mark,

                                b"found undefined tag handle\0" as *const u8 as *const libc::c_char,

                                tag_mark,

                            );

                            current_block = 17786380918591080555;

                        } else {

                            current_block = 9437013279121998969;

                        }

                    }

                }

            } else {

                current_block = 9437013279121998969;

            }

            if current_block != 17786380918591080555 {

                implicit = tag.is_null() || *tag == 0;

                if indentless_sequence && (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {

                    end_mark = (*token).end_mark;

                    (*parser).state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_SEQUENCE_START_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh37 = addr_of_mut!((*event).data.sequence_start.anchor);

                    *fresh37 = anchor;

                    let fresh38 = addr_of_mut!((*event).data.sequence_start.tag);

                    *fresh38 = tag;

                    (*event).data.sequence_start.implicit = implicit;

                    (*event).data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;

                    return OK;

                } else if (*token).type_ == YAML_SCALAR_TOKEN {

                    let mut plain_implicit = false;

                    let mut quoted_implicit = false;

                    end_mark = (*token).end_mark;

                    if (*token).data.scalar.style == YAML_PLAIN_SCALAR_STYLE && tag.is_null()

                        || !tag.is_null()

                            && strcmp(

                                tag as *mut libc::c_char,

                                b"!\0" as *const u8 as *const libc::c_char,

                            ) == 0

                    {

                        plain_implicit = true;

                    } else if tag.is_null() {

                        quoted_implicit = true;

                    }

                    (*parser).state = POP!((*parser).states);

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_SCALAR_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh40 = addr_of_mut!((*event).data.scalar.anchor);

                    *fresh40 = anchor;

                    let fresh41 = addr_of_mut!((*event).data.scalar.tag);

                    *fresh41 = tag;

                    let fresh42 = addr_of_mut!((*event).data.scalar.value);

                    *fresh42 = (*token).data.scalar.value;

                    (*event).data.scalar.length = (*token).data.scalar.length;

                    (*event).data.scalar.plain_implicit = plain_implicit;

                    (*event).data.scalar.quoted_implicit = quoted_implicit;

                    (*event).data.scalar.style = (*token).data.scalar.style;

                    SKIP_TOKEN(parser);

                    return OK;

                } else if (*token).type_ == YAML_FLOW_SEQUENCE_START_TOKEN {

                    end_mark = (*token).end_mark;

                    (*parser).state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_SEQUENCE_START_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh45 = addr_of_mut!((*event).data.sequence_start.anchor);

                    *fresh45 = anchor;

                    let fresh46 = addr_of_mut!((*event).data.sequence_start.tag);

                    *fresh46 = tag;

                    (*event).data.sequence_start.implicit = implicit;

                    (*event).data.sequence_start.style = YAML_FLOW_SEQUENCE_STYLE;

                    return OK;

                } else if (*token).type_ == YAML_FLOW_MAPPING_START_TOKEN {

                    end_mark = (*token).end_mark;

                    (*parser).state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_MAPPING_START_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh47 = addr_of_mut!((*event).data.mapping_start.anchor);

                    *fresh47 = anchor;

                    let fresh48 = addr_of_mut!((*event).data.mapping_start.tag);

                    *fresh48 = tag;

                    (*event).data.mapping_start.implicit = implicit;

                    (*event).data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;

                    return OK;

                } else if block && (*token).type_ == YAML_BLOCK_SEQUENCE_START_TOKEN {

                    end_mark = (*token).end_mark;

                    (*parser).state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_SEQUENCE_START_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh49 = addr_of_mut!((*event).data.sequence_start.anchor);

                    *fresh49 = anchor;

                    let fresh50 = addr_of_mut!((*event).data.sequence_start.tag);

                    *fresh50 = tag;

                    (*event).data.sequence_start.implicit = implicit;

                    (*event).data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;

                    return OK;

                } else if block && (*token).type_ == YAML_BLOCK_MAPPING_START_TOKEN {

                    end_mark = (*token).end_mark;

                    (*parser).state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_MAPPING_START_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh51 = addr_of_mut!((*event).data.mapping_start.anchor);

                    *fresh51 = anchor;

                    let fresh52 = addr_of_mut!((*event).data.mapping_start.tag);

                    *fresh52 = tag;

                    (*event).data.mapping_start.implicit = implicit;

                    (*event).data.mapping_start.style = YAML_BLOCK_MAPPING_STYLE;

                    return OK;

                } else if !anchor.is_null() || !tag.is_null() {

                    let value: *mut yaml_char_t = yaml_malloc(1_u64) as *mut yaml_char_t;

                    *value = b'\0';

                    (*parser).state = POP!((*parser).states);

                    memset(

                        event as *mut libc::c_void,

                        0,

                        size_of::<yaml_event_t>() as libc::c_ulong,

                    );

                    (*event).type_ = YAML_SCALAR_EVENT;

                    (*event).start_mark = start_mark;

                    (*event).end_mark = end_mark;

                    let fresh54 = addr_of_mut!((*event).data.scalar.anchor);

                    *fresh54 = anchor;

                    let fresh55 = addr_of_mut!((*event).data.scalar.tag);

                    *fresh55 = tag;

                    let fresh56 = addr_of_mut!((*event).data.scalar.value);

                    *fresh56 = value;

                    (*event).data.scalar.length = 0_u64;

                    (*event).data.scalar.plain_implicit = implicit;

                    (*event).data.scalar.quoted_implicit = false;

                    (*event).data.scalar.style = YAML_PLAIN_SCALAR_STYLE;

                    return OK;

                } else {

                    yaml_parser_set_parser_error_context(

                        parser,

                        if block {

                            b"while parsing a block node\0" as *const u8 as *const libc::c_char

                        } else {

                            b"while parsing a flow node\0" as *const u8 as *const libc::c_char

                        },

                        start_mark,

                        b"did not find expected node content\0" as *const u8 as *const libc::c_char,

                        (*token).start_mark,

                    );

                }

            }

        }

        yaml_free(anchor as *mut libc::c_void);

        yaml_free(tag_handle as *mut libc::c_void);

        yaml_free(tag_suffix as *mut libc::c_void);

        yaml_free(tag as *mut libc::c_void);

        FAIL

    }

}

unsafe fn yaml_parser_parse_block_sequence_entry(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

    first: bool,

) -> Success {

    let mut token: *mut yaml_token_t;

    if first {

        token = PEEK_TOKEN(parser);

        PUSH!((*parser).marks, (*token).start_mark);

        SKIP_TOKEN(parser);

    }

    token = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {

        let mark: yaml_mark_t = (*token).end_mark;

        SKIP_TOKEN(parser);

        token = PEEK_TOKEN(parser);

        if token.is_null() {

            return FAIL;

        }

        if (*token).type_ != YAML_BLOCK_ENTRY_TOKEN && (*token).type_ != YAML_BLOCK_END_TOKEN {

            PUSH!((*parser).states, YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE);

            yaml_parser_parse_node(parser, event, true, false)

        } else {

            (*parser).state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;

            yaml_parser_process_empty_scalar(event, mark)

        }

    } else if (*token).type_ == YAML_BLOCK_END_TOKEN {

        (*parser).state = POP!((*parser).states);

        let _ = POP!((*parser).marks);

        memset(

            event as *mut libc::c_void,

            0,

            size_of::<yaml_event_t>() as libc::c_ulong,

        );

        (*event).type_ = YAML_SEQUENCE_END_EVENT;

        (*event).start_mark = (*token).start_mark;

        (*event).end_mark = (*token).end_mark;

        SKIP_TOKEN(parser);

        OK

    } else {

        yaml_parser_set_parser_error_context(

            parser,

            b"while parsing a block collection\0" as *const u8 as *const libc::c_char,

            POP!((*parser).marks),

            b"did not find expected '-' indicator\0" as *const u8 as *const libc::c_char,

            (*token).start_mark,

        );

        FAIL

    }

}

unsafe fn yaml_parser_parse_indentless_sequence_entry(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

) -> Success {

    let mut token: *mut yaml_token_t;

    token = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {

        let mark: yaml_mark_t = (*token).end_mark;

        SKIP_TOKEN(parser);

        token = PEEK_TOKEN(parser);

        if token.is_null() {

            return FAIL;

        }

        if (*token).type_ != YAML_BLOCK_ENTRY_TOKEN

            && (*token).type_ != YAML_KEY_TOKEN

            && (*token).type_ != YAML_VALUE_TOKEN

            && (*token).type_ != YAML_BLOCK_END_TOKEN

        {

            PUSH!((*parser).states, YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE);

            yaml_parser_parse_node(parser, event, true, false)

        } else {

            (*parser).state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;

            yaml_parser_process_empty_scalar(event, mark)

        }

    } else {

        (*parser).state = POP!((*parser).states);

        memset(

            event as *mut libc::c_void,

            0,

            size_of::<yaml_event_t>() as libc::c_ulong,

        );

        (*event).type_ = YAML_SEQUENCE_END_EVENT;

        (*event).start_mark = (*token).start_mark;

        (*event).end_mark = (*token).start_mark;

        OK

    }

}

unsafe fn yaml_parser_parse_block_mapping_key(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

    first: bool,

) -> Success {

    let mut token: *mut yaml_token_t;

    if first {

        token = PEEK_TOKEN(parser);

        PUSH!((*parser).marks, (*token).start_mark);

        SKIP_TOKEN(parser);

    }

    token = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ == YAML_KEY_TOKEN {

        let mark: yaml_mark_t = (*token).end_mark;

        SKIP_TOKEN(parser);

        token = PEEK_TOKEN(parser);

        if token.is_null() {

            return FAIL;

        }

        if (*token).type_ != YAML_KEY_TOKEN

            && (*token).type_ != YAML_VALUE_TOKEN

            && (*token).type_ != YAML_BLOCK_END_TOKEN

        {

            PUSH!((*parser).states, YAML_PARSE_BLOCK_MAPPING_VALUE_STATE);

            yaml_parser_parse_node(parser, event, true, true)

        } else {

            (*parser).state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;

            yaml_parser_process_empty_scalar(event, mark)

        }

    } else if (*token).type_ == YAML_BLOCK_END_TOKEN {

        (*parser).state = POP!((*parser).states);

        let _ = POP!((*parser).marks);

        memset(

            event as *mut libc::c_void,

            0,

            size_of::<yaml_event_t>() as libc::c_ulong,

        );

        (*event).type_ = YAML_MAPPING_END_EVENT;

        (*event).start_mark = (*token).start_mark;

        (*event).end_mark = (*token).end_mark;

        SKIP_TOKEN(parser);

        OK

    } else {

        yaml_parser_set_parser_error_context(

            parser,

            b"while parsing a block mapping\0" as *const u8 as *const libc::c_char,

            POP!((*parser).marks),

            b"did not find expected key\0" as *const u8 as *const libc::c_char,

            (*token).start_mark,

        );

        FAIL

    }

}

unsafe fn yaml_parser_parse_block_mapping_value(

    parser: *mut yaml_parser_t,

    event: *mut yaml_event_t,

) -> Success {

    let mut token: *mut yaml_token_t;

    token = PEEK_TOKEN(parser);

    if token.is_null() {

        return FAIL;

    }

    if (*token).type_ == YAML_VALUE_TOKEN {

        let mark: yaml_mark_t = (*token).end_mark;

        SKIP_TOKEN(parser);

        token = PEEK_TOKEN(parser);

        if token.is_null() {

            return FAIL;

        }

        if (*token).type_ != YAML_KEY_TOKEN

            && (*token).type_ != YAML_VALUE_TOKEN

            && (*token).type_ != YAML_BLOCK_END_TOKEN

        {

            PUSH!((*parser).states, YAML_PARSE_BLOCK_MAPPING_KEY_STATE);

            yaml_parser_parse_node(parser, event, true, true)

        } else {