| 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 { |
| (*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::<yaml_event_t>() 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::<yaml_char_t>(); |
| let fresh100 = addr_of_mut!((*event).data.mapping_start.tag); |
| *fresh100 = ptr::null_mut::<yaml_char_t>(); |
| (*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::<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 |
| } |
| |
| 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::<yaml_event_t>() 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::<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 |
| } |
| |
| 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::<yaml_event_t>() 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::<yaml_char_t>(); |
| let fresh139 = addr_of_mut!((*event).data.scalar.tag); |
| *fresh139 = ptr::null_mut::<yaml_char_t>(); |
| 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::<yaml_char_t>(), |
| prefix: ptr::null_mut::<yaml_char_t>(), |
| }, |
| ]; |
| let mut default_tag_directive: *mut yaml_tag_directive_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, |
| top: *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>(), |
| top: ptr::null_mut::<yaml_tag_directive_t>(), |
| }; |
| 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::<yaml_version_directive_t>() 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::<yaml_tag_directive_t>(); |
| *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::<yaml_char_t>(), |
| prefix: ptr::null_mut::<yaml_char_t>(), |
| }; |
| 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 |
| } |
