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::() } } 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::() 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 \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::() 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::(); struct TagDirectives { start: *mut yaml_tag_directive_t, end: *mut yaml_tag_directive_t, } let mut tag_directives = TagDirectives { start: ptr::null_mut::(), end: ptr::null_mut::(), }; 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::() 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::(); let fresh10 = addr_of_mut!((*event).data.document_start.tag_directives.start); *fresh10 = ptr::null_mut::(); let fresh11 = addr_of_mut!((*event).data.document_start.tag_directives.end); *fresh11 = ptr::null_mut::(); (*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 \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::() 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::(); 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::() 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::() 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::(); let mut tag_handle: *mut yaml_char_t = ptr::null_mut::(); let mut tag_suffix: *mut yaml_char_t = ptr::null_mut::(); let mut tag: *mut yaml_char_t = ptr::null_mut::(); 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::() 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::(); 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::(); 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::() 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::() 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::() 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::() 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::() 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::() 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::() 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::() 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::() 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::() 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 { (*parser).state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; yaml_parser_process_empty_scalar(event, mark) } } else { (*parser).state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; yaml_parser_process_empty_scalar(event, (*token).start_mark) } } unsafe fn yaml_parser_parse_flow_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_FLOW_SEQUENCE_END_TOKEN { if !first { if (*token).type_ == YAML_FLOW_ENTRY_TOKEN { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if token.is_null() { return FAIL; } } else { yaml_parser_set_parser_error_context( parser, b"while parsing a flow sequence\0" as *const u8 as *const libc::c_char, POP!((*parser).marks), b"did not find expected ',' or ']'\0" as *const u8 as *const libc::c_char, (*token).start_mark, ); return FAIL; } } if (*token).type_ == YAML_KEY_TOKEN { (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE; memset( event as *mut libc::c_void, 0, size_of::() as libc::c_ulong, ); (*event).type_ = YAML_MAPPING_START_EVENT; (*event).start_mark = (*token).start_mark; (*event).end_mark = (*token).end_mark; let fresh99 = addr_of_mut!((*event).data.mapping_start.anchor); *fresh99 = ptr::null_mut::(); let fresh100 = addr_of_mut!((*event).data.mapping_start.tag); *fresh100 = ptr::null_mut::(); (*event).data.mapping_start.implicit = true; (*event).data.mapping_start.style = YAML_FLOW_MAPPING_STYLE; SKIP_TOKEN(parser); return OK; } else if (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN { PUSH!((*parser).states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE); return yaml_parser_parse_node(parser, event, false, false); } } (*parser).state = POP!((*parser).states); let _ = POP!((*parser).marks); memset( event as *mut libc::c_void, 0, size_of::() 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 } unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key( 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_VALUE_TOKEN && (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN { PUSH!( (*parser).states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE ); yaml_parser_parse_node(parser, event, false, false) } else { let mark: yaml_mark_t = (*token).end_mark; SKIP_TOKEN(parser); (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; yaml_parser_process_empty_scalar(event, mark) } } unsafe fn yaml_parser_parse_flow_sequence_entry_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 { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if token.is_null() { return FAIL; } if (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN { PUSH!( (*parser).states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE ); return yaml_parser_parse_node(parser, event, false, false); } } (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE; yaml_parser_process_empty_scalar(event, (*token).start_mark) } unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end( 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; } (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE; memset( event as *mut libc::c_void, 0, size_of::() as libc::c_ulong, ); (*event).type_ = YAML_MAPPING_END_EVENT; (*event).start_mark = (*token).start_mark; (*event).end_mark = (*token).start_mark; OK } unsafe fn yaml_parser_parse_flow_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_FLOW_MAPPING_END_TOKEN { if !first { if (*token).type_ == YAML_FLOW_ENTRY_TOKEN { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if token.is_null() { return FAIL; } } else { yaml_parser_set_parser_error_context( parser, b"while parsing a flow mapping\0" as *const u8 as *const libc::c_char, POP!((*parser).marks), b"did not find expected ',' or '}'\0" as *const u8 as *const libc::c_char, (*token).start_mark, ); return FAIL; } } if (*token).type_ == YAML_KEY_TOKEN { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if token.is_null() { return FAIL; } if (*token).type_ != YAML_VALUE_TOKEN && (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN { PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_VALUE_STATE); return yaml_parser_parse_node(parser, event, false, false); } else { (*parser).state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE; return yaml_parser_process_empty_scalar(event, (*token).start_mark); } } else if (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN { PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE); return yaml_parser_parse_node(parser, event, false, false); } } (*parser).state = POP!((*parser).states); let _ = POP!((*parser).marks); memset( event as *mut libc::c_void, 0, size_of::() 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 } unsafe fn yaml_parser_parse_flow_mapping_value( parser: *mut yaml_parser_t, event: *mut yaml_event_t, empty: bool, ) -> Success { let mut token: *mut yaml_token_t; token = PEEK_TOKEN(parser); if token.is_null() { return FAIL; } if empty { (*parser).state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; return yaml_parser_process_empty_scalar(event, (*token).start_mark); } if (*token).type_ == YAML_VALUE_TOKEN { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if token.is_null() { return FAIL; } if (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN { PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_KEY_STATE); return yaml_parser_parse_node(parser, event, false, false); } } (*parser).state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; yaml_parser_process_empty_scalar(event, (*token).start_mark) } unsafe fn yaml_parser_process_empty_scalar(event: *mut yaml_event_t, mark: yaml_mark_t) -> Success { let value: *mut yaml_char_t = yaml_malloc(1_u64) as *mut yaml_char_t; *value = b'\0'; memset( event as *mut libc::c_void, 0, size_of::() as libc::c_ulong, ); (*event).type_ = YAML_SCALAR_EVENT; (*event).start_mark = mark; (*event).end_mark = mark; let fresh138 = addr_of_mut!((*event).data.scalar.anchor); *fresh138 = ptr::null_mut::(); let fresh139 = addr_of_mut!((*event).data.scalar.tag); *fresh139 = ptr::null_mut::(); let fresh140 = addr_of_mut!((*event).data.scalar.value); *fresh140 = value; (*event).data.scalar.length = 0_u64; (*event).data.scalar.plain_implicit = true; (*event).data.scalar.quoted_implicit = false; (*event).data.scalar.style = YAML_PLAIN_SCALAR_STYLE; OK } unsafe fn yaml_parser_process_directives( parser: *mut yaml_parser_t, version_directive_ref: *mut *mut yaml_version_directive_t, tag_directives_start_ref: *mut *mut yaml_tag_directive_t, tag_directives_end_ref: *mut *mut yaml_tag_directive_t, ) -> Success { let mut current_block: u64; let mut default_tag_directives: [yaml_tag_directive_t; 3] = [ yaml_tag_directive_t { handle: b"!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t, prefix: b"!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t, }, yaml_tag_directive_t { handle: b"!!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t, prefix: b"tag:yaml.org,2002:\0" as *const u8 as *const libc::c_char as *mut yaml_char_t, }, yaml_tag_directive_t { handle: ptr::null_mut::(), prefix: ptr::null_mut::(), }, ]; let mut default_tag_directive: *mut yaml_tag_directive_t; let mut version_directive: *mut yaml_version_directive_t = ptr::null_mut::(); struct TagDirectives { start: *mut yaml_tag_directive_t, end: *mut yaml_tag_directive_t, top: *mut yaml_tag_directive_t, } let mut tag_directives = TagDirectives { start: ptr::null_mut::(), end: ptr::null_mut::(), top: ptr::null_mut::(), }; let mut token: *mut yaml_token_t; STACK_INIT!(tag_directives, yaml_tag_directive_t); token = PEEK_TOKEN(parser); if !token.is_null() { loop { if !((*token).type_ == YAML_VERSION_DIRECTIVE_TOKEN || (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN) { current_block = 16924917904204750491; break; } if (*token).type_ == YAML_VERSION_DIRECTIVE_TOKEN { if !version_directive.is_null() { yaml_parser_set_parser_error( parser, b"found duplicate %YAML directive\0" as *const u8 as *const libc::c_char, (*token).start_mark, ); current_block = 17143798186130252483; break; } else if (*token).data.version_directive.major != 1 || (*token).data.version_directive.minor != 1 && (*token).data.version_directive.minor != 2 { yaml_parser_set_parser_error( parser, b"found incompatible YAML document\0" as *const u8 as *const libc::c_char, (*token).start_mark, ); current_block = 17143798186130252483; break; } else { version_directive = yaml_malloc(size_of::() as libc::c_ulong) as *mut yaml_version_directive_t; (*version_directive).major = (*token).data.version_directive.major; (*version_directive).minor = (*token).data.version_directive.minor; } } else if (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN { let value = yaml_tag_directive_t { handle: (*token).data.tag_directive.handle, prefix: (*token).data.tag_directive.prefix, }; if yaml_parser_append_tag_directive(parser, value, false, (*token).start_mark).fail { current_block = 17143798186130252483; break; } PUSH!(tag_directives, value); } SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if token.is_null() { current_block = 17143798186130252483; break; } } if current_block != 17143798186130252483 { default_tag_directive = default_tag_directives.as_mut_ptr(); loop { if (*default_tag_directive).handle.is_null() { current_block = 18377268871191777778; break; } if yaml_parser_append_tag_directive( parser, *default_tag_directive, true, (*token).start_mark, ) .fail { current_block = 17143798186130252483; break; } default_tag_directive = default_tag_directive.wrapping_offset(1); } if current_block != 17143798186130252483 { if !version_directive_ref.is_null() { *version_directive_ref = version_directive; } if !tag_directives_start_ref.is_null() { if STACK_EMPTY!(tag_directives) { *tag_directives_end_ref = ptr::null_mut::(); *tag_directives_start_ref = *tag_directives_end_ref; STACK_DEL!(tag_directives); } else { *tag_directives_start_ref = tag_directives.start; *tag_directives_end_ref = tag_directives.top; } } else { STACK_DEL!(tag_directives); } if version_directive_ref.is_null() { yaml_free(version_directive as *mut libc::c_void); } return OK; } } } yaml_free(version_directive as *mut libc::c_void); while !STACK_EMPTY!(tag_directives) { let tag_directive = POP!(tag_directives); yaml_free(tag_directive.handle as *mut libc::c_void); yaml_free(tag_directive.prefix as *mut libc::c_void); } STACK_DEL!(tag_directives); FAIL } unsafe fn yaml_parser_append_tag_directive( parser: *mut yaml_parser_t, value: yaml_tag_directive_t, allow_duplicates: bool, mark: yaml_mark_t, ) -> Success { let mut tag_directive: *mut yaml_tag_directive_t; let mut copy = yaml_tag_directive_t { handle: ptr::null_mut::(), prefix: ptr::null_mut::(), }; tag_directive = (*parser).tag_directives.start; while tag_directive != (*parser).tag_directives.top { if strcmp( value.handle as *mut libc::c_char, (*tag_directive).handle as *mut libc::c_char, ) == 0 { if allow_duplicates { return OK; } yaml_parser_set_parser_error( parser, b"found duplicate %TAG directive\0" as *const u8 as *const libc::c_char, mark, ); return FAIL; } tag_directive = tag_directive.wrapping_offset(1); } copy.handle = yaml_strdup(value.handle); copy.prefix = yaml_strdup(value.prefix); PUSH!((*parser).tag_directives, copy); OK }