580 lines
20 KiB
Rust
580 lines
20 KiB
Rust
use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
|
|
use crate::externs::{memset, strcmp};
|
|
use crate::success::{Success, FAIL, OK};
|
|
use crate::yaml::yaml_char_t;
|
|
use crate::{
|
|
libc, yaml_alias_data_t, yaml_document_delete, yaml_document_t, yaml_event_t, yaml_mark_t,
|
|
yaml_node_item_t, yaml_node_pair_t, yaml_node_t, yaml_parser_parse, yaml_parser_t, PointerExt,
|
|
YAML_ALIAS_EVENT, YAML_COMPOSER_ERROR, YAML_DOCUMENT_END_EVENT, YAML_DOCUMENT_START_EVENT,
|
|
YAML_MAPPING_END_EVENT, YAML_MAPPING_NODE, YAML_MAPPING_START_EVENT, YAML_MEMORY_ERROR,
|
|
YAML_SCALAR_EVENT, YAML_SCALAR_NODE, YAML_SEQUENCE_END_EVENT, YAML_SEQUENCE_NODE,
|
|
YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_START_EVENT,
|
|
};
|
|
use core::mem::{size_of, MaybeUninit};
|
|
use core::ptr::{self, addr_of_mut};
|
|
|
|
#[repr(C)]
|
|
struct loader_ctx {
|
|
start: *mut libc::c_int,
|
|
end: *mut libc::c_int,
|
|
top: *mut libc::c_int,
|
|
}
|
|
|
|
/// Parse the input stream and produce the next YAML document.
|
|
///
|
|
/// Call this function subsequently to produce a sequence of documents
|
|
/// constituting the input stream.
|
|
///
|
|
/// If the produced document has no root node, it means that the document end
|
|
/// has been reached.
|
|
///
|
|
/// An application is responsible for freeing any data associated with the
|
|
/// produced document object using the yaml_document_delete() function.
|
|
///
|
|
/// An application must not alternate the calls of yaml_parser_load() with the
|
|
/// calls of yaml_parser_scan() or yaml_parser_parse(). Doing this will break
|
|
/// the parser.
|
|
pub unsafe fn yaml_parser_load(
|
|
parser: *mut yaml_parser_t,
|
|
document: *mut yaml_document_t,
|
|
) -> Success {
|
|
let current_block: u64;
|
|
let mut event = MaybeUninit::<yaml_event_t>::uninit();
|
|
let event = event.as_mut_ptr();
|
|
__assert!(!parser.is_null());
|
|
__assert!(!document.is_null());
|
|
memset(
|
|
document as *mut libc::c_void,
|
|
0,
|
|
size_of::<yaml_document_t>() as libc::c_ulong,
|
|
);
|
|
STACK_INIT!((*document).nodes, yaml_node_t);
|
|
if !(*parser).stream_start_produced {
|
|
if yaml_parser_parse(parser, event).fail {
|
|
current_block = 6234624449317607669;
|
|
} else {
|
|
__assert!((*event).type_ == YAML_STREAM_START_EVENT);
|
|
current_block = 7815301370352969686;
|
|
}
|
|
} else {
|
|
current_block = 7815301370352969686;
|
|
}
|
|
if current_block != 6234624449317607669 {
|
|
if (*parser).stream_end_produced {
|
|
return OK;
|
|
}
|
|
if yaml_parser_parse(parser, event).ok {
|
|
if (*event).type_ == YAML_STREAM_END_EVENT {
|
|
return OK;
|
|
}
|
|
STACK_INIT!((*parser).aliases, yaml_alias_data_t);
|
|
let fresh6 = addr_of_mut!((*parser).document);
|
|
*fresh6 = document;
|
|
if yaml_parser_load_document(parser, event).ok {
|
|
yaml_parser_delete_aliases(parser);
|
|
let fresh7 = addr_of_mut!((*parser).document);
|
|
*fresh7 = ptr::null_mut::<yaml_document_t>();
|
|
return OK;
|
|
}
|
|
}
|
|
}
|
|
yaml_parser_delete_aliases(parser);
|
|
yaml_document_delete(document);
|
|
let fresh8 = addr_of_mut!((*parser).document);
|
|
*fresh8 = ptr::null_mut::<yaml_document_t>();
|
|
FAIL
|
|
}
|
|
|
|
unsafe fn yaml_parser_set_composer_error(
|
|
parser: *mut yaml_parser_t,
|
|
problem: *const libc::c_char,
|
|
problem_mark: yaml_mark_t,
|
|
) -> Success {
|
|
(*parser).error = YAML_COMPOSER_ERROR;
|
|
let fresh9 = addr_of_mut!((*parser).problem);
|
|
*fresh9 = problem;
|
|
(*parser).problem_mark = problem_mark;
|
|
FAIL
|
|
}
|
|
|
|
unsafe fn yaml_parser_set_composer_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,
|
|
) -> Success {
|
|
(*parser).error = YAML_COMPOSER_ERROR;
|
|
let fresh10 = addr_of_mut!((*parser).context);
|
|
*fresh10 = context;
|
|
(*parser).context_mark = context_mark;
|
|
let fresh11 = addr_of_mut!((*parser).problem);
|
|
*fresh11 = problem;
|
|
(*parser).problem_mark = problem_mark;
|
|
FAIL
|
|
}
|
|
|
|
unsafe fn yaml_parser_delete_aliases(parser: *mut yaml_parser_t) {
|
|
while !STACK_EMPTY!((*parser).aliases) {
|
|
yaml_free(POP!((*parser).aliases).anchor as *mut libc::c_void);
|
|
}
|
|
STACK_DEL!((*parser).aliases);
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_document(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
) -> Success {
|
|
let mut ctx = loader_ctx {
|
|
start: ptr::null_mut::<libc::c_int>(),
|
|
end: ptr::null_mut::<libc::c_int>(),
|
|
top: ptr::null_mut::<libc::c_int>(),
|
|
};
|
|
__assert!((*event).type_ == YAML_DOCUMENT_START_EVENT);
|
|
let fresh16 = addr_of_mut!((*(*parser).document).version_directive);
|
|
*fresh16 = (*event).data.document_start.version_directive;
|
|
let fresh17 = addr_of_mut!((*(*parser).document).tag_directives.start);
|
|
*fresh17 = (*event).data.document_start.tag_directives.start;
|
|
let fresh18 = addr_of_mut!((*(*parser).document).tag_directives.end);
|
|
*fresh18 = (*event).data.document_start.tag_directives.end;
|
|
(*(*parser).document).start_implicit = (*event).data.document_start.implicit;
|
|
(*(*parser).document).start_mark = (*event).start_mark;
|
|
STACK_INIT!(ctx, libc::c_int);
|
|
if yaml_parser_load_nodes(parser, addr_of_mut!(ctx)).fail {
|
|
STACK_DEL!(ctx);
|
|
return FAIL;
|
|
}
|
|
STACK_DEL!(ctx);
|
|
OK
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_nodes(parser: *mut yaml_parser_t, ctx: *mut loader_ctx) -> Success {
|
|
let mut event = MaybeUninit::<yaml_event_t>::uninit();
|
|
let event = event.as_mut_ptr();
|
|
loop {
|
|
if yaml_parser_parse(parser, event).fail {
|
|
return FAIL;
|
|
}
|
|
match (*event).type_ {
|
|
YAML_ALIAS_EVENT => {
|
|
if yaml_parser_load_alias(parser, event, ctx).fail {
|
|
return FAIL;
|
|
}
|
|
}
|
|
YAML_SCALAR_EVENT => {
|
|
if yaml_parser_load_scalar(parser, event, ctx).fail {
|
|
return FAIL;
|
|
}
|
|
}
|
|
YAML_SEQUENCE_START_EVENT => {
|
|
if yaml_parser_load_sequence(parser, event, ctx).fail {
|
|
return FAIL;
|
|
}
|
|
}
|
|
YAML_SEQUENCE_END_EVENT => {
|
|
if yaml_parser_load_sequence_end(parser, event, ctx).fail {
|
|
return FAIL;
|
|
}
|
|
}
|
|
YAML_MAPPING_START_EVENT => {
|
|
if yaml_parser_load_mapping(parser, event, ctx).fail {
|
|
return FAIL;
|
|
}
|
|
}
|
|
YAML_MAPPING_END_EVENT => {
|
|
if yaml_parser_load_mapping_end(parser, event, ctx).fail {
|
|
return FAIL;
|
|
}
|
|
}
|
|
YAML_DOCUMENT_END_EVENT => {}
|
|
_ => {
|
|
__assert!(false);
|
|
}
|
|
}
|
|
if (*event).type_ == YAML_DOCUMENT_END_EVENT {
|
|
break;
|
|
}
|
|
}
|
|
(*(*parser).document).end_implicit = (*event).data.document_end.implicit;
|
|
(*(*parser).document).end_mark = (*event).end_mark;
|
|
OK
|
|
}
|
|
|
|
unsafe fn yaml_parser_register_anchor(
|
|
parser: *mut yaml_parser_t,
|
|
index: libc::c_int,
|
|
anchor: *mut yaml_char_t,
|
|
) -> Success {
|
|
let mut data = MaybeUninit::<yaml_alias_data_t>::uninit();
|
|
let data = data.as_mut_ptr();
|
|
let mut alias_data: *mut yaml_alias_data_t;
|
|
if anchor.is_null() {
|
|
return OK;
|
|
}
|
|
(*data).anchor = anchor;
|
|
(*data).index = index;
|
|
(*data).mark = (*(*(*parser).document)
|
|
.nodes
|
|
.start
|
|
.wrapping_offset((index - 1) as isize))
|
|
.start_mark;
|
|
alias_data = (*parser).aliases.start;
|
|
while alias_data != (*parser).aliases.top {
|
|
if strcmp(
|
|
(*alias_data).anchor as *mut libc::c_char,
|
|
anchor as *mut libc::c_char,
|
|
) == 0
|
|
{
|
|
yaml_free(anchor as *mut libc::c_void);
|
|
return yaml_parser_set_composer_error_context(
|
|
parser,
|
|
b"found duplicate anchor; first occurrence\0" as *const u8 as *const libc::c_char,
|
|
(*alias_data).mark,
|
|
b"second occurrence\0" as *const u8 as *const libc::c_char,
|
|
(*data).mark,
|
|
);
|
|
}
|
|
alias_data = alias_data.wrapping_offset(1);
|
|
}
|
|
PUSH!((*parser).aliases, *data);
|
|
OK
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_node_add(
|
|
parser: *mut yaml_parser_t,
|
|
ctx: *mut loader_ctx,
|
|
index: libc::c_int,
|
|
) -> Success {
|
|
if STACK_EMPTY!(*ctx) {
|
|
return OK;
|
|
}
|
|
let parent_index: libc::c_int = *(*ctx).top.wrapping_offset(-1_isize);
|
|
let parent: *mut yaml_node_t = addr_of_mut!(
|
|
*((*(*parser).document).nodes.start).wrapping_offset((parent_index - 1) as isize)
|
|
);
|
|
let current_block_17: u64;
|
|
match (*parent).type_ {
|
|
YAML_SEQUENCE_NODE => {
|
|
if STACK_LIMIT!(parser, (*parent).data.sequence.items).fail {
|
|
return FAIL;
|
|
}
|
|
PUSH!((*parent).data.sequence.items, index);
|
|
}
|
|
YAML_MAPPING_NODE => {
|
|
let mut pair = MaybeUninit::<yaml_node_pair_t>::uninit();
|
|
let pair = pair.as_mut_ptr();
|
|
if !STACK_EMPTY!((*parent).data.mapping.pairs) {
|
|
let p: *mut yaml_node_pair_t =
|
|
(*parent).data.mapping.pairs.top.wrapping_offset(-1_isize);
|
|
if (*p).key != 0 && (*p).value == 0 {
|
|
(*p).value = index;
|
|
current_block_17 = 11307063007268554308;
|
|
} else {
|
|
current_block_17 = 17407779659766490442;
|
|
}
|
|
} else {
|
|
current_block_17 = 17407779659766490442;
|
|
}
|
|
match current_block_17 {
|
|
11307063007268554308 => {}
|
|
_ => {
|
|
(*pair).key = index;
|
|
(*pair).value = 0;
|
|
if STACK_LIMIT!(parser, (*parent).data.mapping.pairs).fail {
|
|
return FAIL;
|
|
}
|
|
PUSH!((*parent).data.mapping.pairs, *pair);
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
__assert!(false);
|
|
}
|
|
}
|
|
OK
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_alias(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
ctx: *mut loader_ctx,
|
|
) -> Success {
|
|
let anchor: *mut yaml_char_t = (*event).data.alias.anchor;
|
|
let mut alias_data: *mut yaml_alias_data_t;
|
|
alias_data = (*parser).aliases.start;
|
|
while alias_data != (*parser).aliases.top {
|
|
if strcmp(
|
|
(*alias_data).anchor as *mut libc::c_char,
|
|
anchor as *mut libc::c_char,
|
|
) == 0
|
|
{
|
|
yaml_free(anchor as *mut libc::c_void);
|
|
return yaml_parser_load_node_add(parser, ctx, (*alias_data).index);
|
|
}
|
|
alias_data = alias_data.wrapping_offset(1);
|
|
}
|
|
yaml_free(anchor as *mut libc::c_void);
|
|
yaml_parser_set_composer_error(
|
|
parser,
|
|
b"found undefined alias\0" as *const u8 as *const libc::c_char,
|
|
(*event).start_mark,
|
|
)
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_scalar(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
ctx: *mut loader_ctx,
|
|
) -> Success {
|
|
let current_block: u64;
|
|
let mut node = MaybeUninit::<yaml_node_t>::uninit();
|
|
let node = node.as_mut_ptr();
|
|
let index: libc::c_int;
|
|
let mut tag: *mut yaml_char_t = (*event).data.scalar.tag;
|
|
if STACK_LIMIT!(parser, (*(*parser).document).nodes).ok {
|
|
if tag.is_null()
|
|
|| strcmp(
|
|
tag as *mut libc::c_char,
|
|
b"!\0" as *const u8 as *const libc::c_char,
|
|
) == 0
|
|
{
|
|
yaml_free(tag as *mut libc::c_void);
|
|
tag = yaml_strdup(
|
|
b"tag:yaml.org,2002:str\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
|
|
);
|
|
if tag.is_null() {
|
|
current_block = 10579931339944277179;
|
|
} else {
|
|
current_block = 11006700562992250127;
|
|
}
|
|
} else {
|
|
current_block = 11006700562992250127;
|
|
}
|
|
if current_block != 10579931339944277179 {
|
|
memset(
|
|
node as *mut libc::c_void,
|
|
0,
|
|
size_of::<yaml_node_t>() as libc::c_ulong,
|
|
);
|
|
(*node).type_ = YAML_SCALAR_NODE;
|
|
(*node).tag = tag;
|
|
(*node).start_mark = (*event).start_mark;
|
|
(*node).end_mark = (*event).end_mark;
|
|
(*node).data.scalar.value = (*event).data.scalar.value;
|
|
(*node).data.scalar.length = (*event).data.scalar.length;
|
|
(*node).data.scalar.style = (*event).data.scalar.style;
|
|
PUSH!((*(*parser).document).nodes, *node);
|
|
index = (*(*parser).document)
|
|
.nodes
|
|
.top
|
|
.c_offset_from((*(*parser).document).nodes.start)
|
|
as libc::c_int;
|
|
if yaml_parser_register_anchor(parser, index, (*event).data.scalar.anchor).fail {
|
|
return FAIL;
|
|
}
|
|
return yaml_parser_load_node_add(parser, ctx, index);
|
|
}
|
|
}
|
|
yaml_free(tag as *mut libc::c_void);
|
|
yaml_free((*event).data.scalar.anchor as *mut libc::c_void);
|
|
yaml_free((*event).data.scalar.value as *mut libc::c_void);
|
|
FAIL
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_sequence(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
ctx: *mut loader_ctx,
|
|
) -> Success {
|
|
let current_block: u64;
|
|
let mut node = MaybeUninit::<yaml_node_t>::uninit();
|
|
let node = node.as_mut_ptr();
|
|
struct Items {
|
|
start: *mut yaml_node_item_t,
|
|
end: *mut yaml_node_item_t,
|
|
top: *mut yaml_node_item_t,
|
|
}
|
|
let mut items = Items {
|
|
start: ptr::null_mut::<yaml_node_item_t>(),
|
|
end: ptr::null_mut::<yaml_node_item_t>(),
|
|
top: ptr::null_mut::<yaml_node_item_t>(),
|
|
};
|
|
let index: libc::c_int;
|
|
let mut tag: *mut yaml_char_t = (*event).data.sequence_start.tag;
|
|
if STACK_LIMIT!(parser, (*(*parser).document).nodes).ok {
|
|
if tag.is_null()
|
|
|| strcmp(
|
|
tag as *mut libc::c_char,
|
|
b"!\0" as *const u8 as *const libc::c_char,
|
|
) == 0
|
|
{
|
|
yaml_free(tag as *mut libc::c_void);
|
|
tag = yaml_strdup(
|
|
b"tag:yaml.org,2002:seq\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
|
|
);
|
|
if tag.is_null() {
|
|
current_block = 13474536459355229096;
|
|
} else {
|
|
current_block = 6937071982253665452;
|
|
}
|
|
} else {
|
|
current_block = 6937071982253665452;
|
|
}
|
|
if current_block != 13474536459355229096 {
|
|
STACK_INIT!(items, yaml_node_item_t);
|
|
memset(
|
|
node as *mut libc::c_void,
|
|
0,
|
|
size_of::<yaml_node_t>() as libc::c_ulong,
|
|
);
|
|
(*node).type_ = YAML_SEQUENCE_NODE;
|
|
(*node).tag = tag;
|
|
(*node).start_mark = (*event).start_mark;
|
|
(*node).end_mark = (*event).end_mark;
|
|
(*node).data.sequence.items.start = items.start;
|
|
(*node).data.sequence.items.end = items.end;
|
|
(*node).data.sequence.items.top = items.start;
|
|
(*node).data.sequence.style = (*event).data.sequence_start.style;
|
|
PUSH!((*(*parser).document).nodes, *node);
|
|
index = (*(*parser).document)
|
|
.nodes
|
|
.top
|
|
.c_offset_from((*(*parser).document).nodes.start)
|
|
as libc::c_int;
|
|
if yaml_parser_register_anchor(parser, index, (*event).data.sequence_start.anchor).fail
|
|
{
|
|
return FAIL;
|
|
}
|
|
if yaml_parser_load_node_add(parser, ctx, index).fail {
|
|
return FAIL;
|
|
}
|
|
if STACK_LIMIT!(parser, *ctx).fail {
|
|
return FAIL;
|
|
}
|
|
PUSH!(*ctx, index);
|
|
return OK;
|
|
}
|
|
}
|
|
yaml_free(tag as *mut libc::c_void);
|
|
yaml_free((*event).data.sequence_start.anchor as *mut libc::c_void);
|
|
FAIL
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_sequence_end(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
ctx: *mut loader_ctx,
|
|
) -> Success {
|
|
__assert!(((*ctx).top).c_offset_from((*ctx).start) as libc::c_long > 0_i64);
|
|
let index: libc::c_int = *(*ctx).top.wrapping_offset(-1_isize);
|
|
__assert!(
|
|
(*((*(*parser).document).nodes.start).wrapping_offset((index - 1) as isize)).type_
|
|
== YAML_SEQUENCE_NODE
|
|
);
|
|
(*(*(*parser).document)
|
|
.nodes
|
|
.start
|
|
.wrapping_offset((index - 1) as isize))
|
|
.end_mark = (*event).end_mark;
|
|
let _ = POP!(*ctx);
|
|
OK
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_mapping(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
ctx: *mut loader_ctx,
|
|
) -> Success {
|
|
let current_block: u64;
|
|
let mut node = MaybeUninit::<yaml_node_t>::uninit();
|
|
let node = node.as_mut_ptr();
|
|
struct Pairs {
|
|
start: *mut yaml_node_pair_t,
|
|
end: *mut yaml_node_pair_t,
|
|
top: *mut yaml_node_pair_t,
|
|
}
|
|
let mut pairs = Pairs {
|
|
start: ptr::null_mut::<yaml_node_pair_t>(),
|
|
end: ptr::null_mut::<yaml_node_pair_t>(),
|
|
top: ptr::null_mut::<yaml_node_pair_t>(),
|
|
};
|
|
let index: libc::c_int;
|
|
let mut tag: *mut yaml_char_t = (*event).data.mapping_start.tag;
|
|
if STACK_LIMIT!(parser, (*(*parser).document).nodes).ok {
|
|
if tag.is_null()
|
|
|| strcmp(
|
|
tag as *mut libc::c_char,
|
|
b"!\0" as *const u8 as *const libc::c_char,
|
|
) == 0
|
|
{
|
|
yaml_free(tag as *mut libc::c_void);
|
|
tag = yaml_strdup(
|
|
b"tag:yaml.org,2002:map\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
|
|
);
|
|
if tag.is_null() {
|
|
current_block = 13635467803606088781;
|
|
} else {
|
|
current_block = 6937071982253665452;
|
|
}
|
|
} else {
|
|
current_block = 6937071982253665452;
|
|
}
|
|
if current_block != 13635467803606088781 {
|
|
STACK_INIT!(pairs, yaml_node_pair_t);
|
|
memset(
|
|
node as *mut libc::c_void,
|
|
0,
|
|
size_of::<yaml_node_t>() as libc::c_ulong,
|
|
);
|
|
(*node).type_ = YAML_MAPPING_NODE;
|
|
(*node).tag = tag;
|
|
(*node).start_mark = (*event).start_mark;
|
|
(*node).end_mark = (*event).end_mark;
|
|
(*node).data.mapping.pairs.start = pairs.start;
|
|
(*node).data.mapping.pairs.end = pairs.end;
|
|
(*node).data.mapping.pairs.top = pairs.start;
|
|
(*node).data.mapping.style = (*event).data.mapping_start.style;
|
|
PUSH!((*(*parser).document).nodes, *node);
|
|
index = (*(*parser).document)
|
|
.nodes
|
|
.top
|
|
.c_offset_from((*(*parser).document).nodes.start)
|
|
as libc::c_int;
|
|
if yaml_parser_register_anchor(parser, index, (*event).data.mapping_start.anchor).fail {
|
|
return FAIL;
|
|
}
|
|
if yaml_parser_load_node_add(parser, ctx, index).fail {
|
|
return FAIL;
|
|
}
|
|
if STACK_LIMIT!(parser, *ctx).fail {
|
|
return FAIL;
|
|
}
|
|
PUSH!(*ctx, index);
|
|
return OK;
|
|
}
|
|
}
|
|
yaml_free(tag as *mut libc::c_void);
|
|
yaml_free((*event).data.mapping_start.anchor as *mut libc::c_void);
|
|
FAIL
|
|
}
|
|
|
|
unsafe fn yaml_parser_load_mapping_end(
|
|
parser: *mut yaml_parser_t,
|
|
event: *mut yaml_event_t,
|
|
ctx: *mut loader_ctx,
|
|
) -> Success {
|
|
__assert!(((*ctx).top).c_offset_from((*ctx).start) as libc::c_long > 0_i64);
|
|
let index: libc::c_int = *(*ctx).top.wrapping_offset(-1_isize);
|
|
__assert!(
|
|
(*((*(*parser).document).nodes.start).wrapping_offset((index - 1) as isize)).type_
|
|
== YAML_MAPPING_NODE
|
|
);
|
|
(*(*(*parser).document)
|
|
.nodes
|
|
.start
|
|
.wrapping_offset((index - 1) as isize))
|
|
.end_mark = (*event).end_mark;
|
|
let _ = POP!(*ctx);
|
|
OK
|
|
}
|