Mirrors/libyaml-safer
2
0
Fork 0
mirror of https://github.com/simonask/libyaml-safer synced 2025-02-17 04:48:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

Factor out PUSH macro

Browse source
This commit is contained in:
David Tolnay 2022-07-21 23:57:40 -07:00
parent a264646525
commit ff49ac0839
No known key found for this signature in database
GPG key ID: F9BA143B95FF6D82
6 changed files with 139 additions and 849 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

196
src/api.rs
View file

@ -1052,22 +1052,7 @@ pub unsafe fn yaml_document_start_event_initialize(
current_block = 14964981520188694172;
break;
}
if if tag_directives_copy.top != tag_directives_copy.end
|| yaml_stack_extend(
addr_of_mut!(tag_directives_copy.start) as *mut *mut libc::c_void,
addr_of_mut!(tag_directives_copy.top) as *mut *mut libc::c_void,
addr_of_mut!(tag_directives_copy.end) as *mut *mut libc::c_void,
) != 0
{
let fresh163 = tag_directives_copy.top;
tag_directives_copy.top = tag_directives_copy.top.wrapping_offset(1);
*fresh163 = value;
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(addr_of_mut!(context), tag_directives_copy, value) == 0 {
current_block = 14964981520188694172;
break;
}
@ -1668,24 +1653,7 @@ pub unsafe fn yaml_document_initialize(
current_block = 8142820162064489797;
break;
}
if if tag_directives_copy.top != tag_directives_copy.end
|| yaml_stack_extend(
addr_of_mut!(tag_directives_copy.start)
as *mut *mut libc::c_void,
addr_of_mut!(tag_directives_copy.top) as *mut *mut libc::c_void,
addr_of_mut!(tag_directives_copy.end) as *mut *mut libc::c_void,
) != 0
{
let fresh175 = tag_directives_copy.top;
tag_directives_copy.top =
tag_directives_copy.top.wrapping_offset(1);
*fresh175 = value;
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(addr_of_mut!(context), tag_directives_copy, value) == 0 {
current_block = 8142820162064489797;
break;
}
@ -1895,23 +1863,7 @@ pub unsafe fn yaml_document_add_scalar(
(*node).data.scalar.value = value_copy;
(*node).data.scalar.length = length as size_t;
(*node).data.scalar.style = style;
if !(if (*document).nodes.top != (*document).nodes.end
|| yaml_stack_extend(
addr_of_mut!((*document).nodes.start) as *mut *mut libc::c_void,
addr_of_mut!((*document).nodes.top) as *mut *mut libc::c_void,
addr_of_mut!((*document).nodes.end) as *mut *mut libc::c_void,
) != 0
{
let fresh186 = addr_of_mut!((*document).nodes.top);
let fresh187 = *fresh186;
*fresh186 = (*fresh186).wrapping_offset(1);
ptr::copy_nonoverlapping(node, fresh187, 1);
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
if !(PUSH!(addr_of_mut!(context), (*document).nodes, *node) == 0) {
return ((*document).nodes.top).c_offset_from((*document).nodes.start)
as libc::c_long as libc::c_int;
}
@ -1988,23 +1940,7 @@ pub unsafe fn yaml_document_add_sequence(
(*node).data.sequence.items.end = items.end;
(*node).data.sequence.items.top = items.start;
(*node).data.sequence.style = style;
if !(if (*document).nodes.top != (*document).nodes.end
|| yaml_stack_extend(
addr_of_mut!((*document).nodes.start) as *mut *mut libc::c_void,
addr_of_mut!((*document).nodes.top) as *mut *mut libc::c_void,
addr_of_mut!((*document).nodes.end) as *mut *mut libc::c_void,
) != 0
{
let fresh188 = addr_of_mut!((*document).nodes.top);
let fresh189 = *fresh188;
*fresh188 = (*fresh188).wrapping_offset(1);
ptr::copy_nonoverlapping(node, fresh189, 1);
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
if !(PUSH!(addr_of_mut!(context), (*document).nodes, *node) == 0) {
return ((*document).nodes.top).c_offset_from((*document).nodes.start)
as libc::c_long as libc::c_int;
}
@ -2083,23 +2019,7 @@ pub unsafe fn yaml_document_add_mapping(
(*node).data.mapping.pairs.end = pairs.end;
(*node).data.mapping.pairs.top = pairs.start;
(*node).data.mapping.style = style;
if !(if (*document).nodes.top != (*document).nodes.end
|| yaml_stack_extend(
addr_of_mut!((*document).nodes.start) as *mut *mut libc::c_void,
addr_of_mut!((*document).nodes.top) as *mut *mut libc::c_void,
addr_of_mut!((*document).nodes.end) as *mut *mut libc::c_void,
) != 0
{
let fresh190 = addr_of_mut!((*document).nodes.top);
let fresh191 = *fresh190;
*fresh190 = (*fresh190).wrapping_offset(1);
ptr::copy_nonoverlapping(node, fresh191, 1);
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
if !(PUSH!(addr_of_mut!(context), (*document).nodes, *node) == 0) {
return ((*document).nodes.top).c_offset_from((*document).nodes.start)
as libc::c_long as libc::c_int;
}
@ -2141,55 +2061,14 @@ pub unsafe fn yaml_document_append_sequence_item(
item > 0_i32
&& ((*document).nodes.start).wrapping_offset(item as isize) <= (*document).nodes.top
);
if if (*((*document).nodes.start).wrapping_offset((sequence - 1_i32) as isize))
.data
.sequence
.items
.top
!= (*((*document).nodes.start).wrapping_offset((sequence - 1_i32) as isize))
if PUSH!(
addr_of_mut!(context),
(*((*document).nodes.start).wrapping_offset((sequence - 1) as isize))
.data
.sequence
.items
.end
|| yaml_stack_extend(
addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((sequence - 1_i32) as isize))
.data
.sequence
.items
.start
) as *mut *mut libc::c_void,
addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((sequence - 1_i32) as isize))
.data
.sequence
.items
.top
) as *mut *mut libc::c_void,
addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((sequence - 1_i32) as isize))
.data
.sequence
.items
.end
) as *mut *mut libc::c_void,
) != 0
{
let fresh192 = addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((sequence - 1_i32) as isize))
.data
.sequence
.items
.top
);
let fresh193 = *fresh192;
*fresh192 = (*fresh192).wrapping_offset(1);
*fresh193 = item;
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0
.items,
item
) == 0
{
return 0_i32;
}
@ -2228,55 +2107,14 @@ pub unsafe fn yaml_document_append_mapping_pair(
&& ((*document).nodes.start).wrapping_offset(value as isize) <= (*document).nodes.top
);
let pair = yaml_node_pair_t { key, value };
if if (*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
.data
.mapping
.pairs
.top
!= (*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
if PUSH!(
addr_of_mut!(context),
(*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
.data
.mapping
.pairs
.end
|| yaml_stack_extend(
addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
.data
.mapping
.pairs
.start
) as *mut *mut libc::c_void,
addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
.data
.mapping
.pairs
.top
) as *mut *mut libc::c_void,
addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
.data
.mapping
.pairs
.end
) as *mut *mut libc::c_void,
) != 0
{
let fresh194 = addr_of_mut!(
(*((*document).nodes.start).wrapping_offset((mapping - 1_i32) as isize))
.data
.mapping
.pairs
.top
);
let fresh195 = *fresh194;
*fresh194 = (*fresh194).wrapping_offset(1);
*fresh195 = pair;
1_i32
} else {
context.error = YAML_MEMORY_ERROR;
0_i32
} == 0
.pairs,
pair
) == 0
{
return 0_i32;
}

219
src/emitter.rs
View file

@ -233,23 +233,7 @@ unsafe fn yaml_emitter_append_tag_directive(
copy.prefix = yaml_strdup(value.prefix);
if copy.handle.is_null() || copy.prefix.is_null() {
(*emitter).error = YAML_MEMORY_ERROR;
} else if !(if (*emitter).tag_directives.top != (*emitter).tag_directives.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).tag_directives.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).tag_directives.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).tag_directives.end) as *mut *mut libc::c_void,
) != 0
{
let fresh5 = addr_of_mut!((*emitter).tag_directives.top);
let fresh6 = *fresh5;
*fresh5 = (*fresh5).wrapping_offset(1);
*fresh6 = copy;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
} else if !(PUSH!(emitter, (*emitter).tag_directives, copy) == 0) {
return 1_i32;
}
yaml_free(copy.handle as *mut libc::c_void);
@ -262,23 +246,7 @@ unsafe fn yaml_emitter_increase_indent(
flow: libc::c_int,
indentless: libc::c_int,
) -> libc::c_int {
if if (*emitter).indents.top != (*emitter).indents.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).indents.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).indents.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).indents.end) as *mut *mut libc::c_void,
) != 0
{
let fresh7 = addr_of_mut!((*emitter).indents.top);
let fresh8 = *fresh7;
*fresh7 = (*fresh7).wrapping_offset(1);
*fresh8 = (*emitter).indent;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(emitter, (*emitter).indents, (*emitter).indent) == 0 {
return 0_i32;
}
if (*emitter).indent < 0_i32 {
@ -600,23 +568,7 @@ unsafe fn yaml_emitter_emit_document_content(
mut emitter: *mut yaml_emitter_t,
event: *mut yaml_event_t,
) -> libc::c_int {
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh9 = addr_of_mut!((*emitter).states.top);
let fresh10 = *fresh9;
*fresh9 = (*fresh9).wrapping_offset(1);
*fresh10 = YAML_EMIT_DOCUMENT_END_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(emitter, (*emitter).states, YAML_EMIT_DOCUMENT_END_STATE) == 0 {
return 0_i32;
}
yaml_emitter_emit_node(emitter, event, 1_i32, 0_i32, 0_i32, 0_i32)
@ -742,22 +694,11 @@ unsafe fn yaml_emitter_emit_flow_sequence_item(
return 0_i32;
}
}
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh16 = addr_of_mut!((*emitter).states.top);
let fresh17 = *fresh16;
*fresh16 = (*fresh16).wrapping_offset(1);
*fresh17 = YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE
) == 0
{
return 0_i32;
}
@ -840,22 +781,11 @@ unsafe fn yaml_emitter_emit_flow_mapping_key(
}
}
if (*emitter).canonical == 0 && yaml_emitter_check_simple_key(emitter) != 0 {
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh22 = addr_of_mut!((*emitter).states.top);
let fresh23 = *fresh22;
*fresh22 = (*fresh22).wrapping_offset(1);
*fresh23 = YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -871,22 +801,11 @@ unsafe fn yaml_emitter_emit_flow_mapping_key(
{
return 0_i32;
}
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh24 = addr_of_mut!((*emitter).states.top);
let fresh25 = *fresh24;
*fresh24 = (*fresh24).wrapping_offset(1);
*fresh25 = YAML_EMIT_FLOW_MAPPING_VALUE_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_FLOW_MAPPING_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -927,23 +846,7 @@ unsafe fn yaml_emitter_emit_flow_mapping_value(
return 0_i32;
}
}
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh26 = addr_of_mut!((*emitter).states.top);
let fresh27 = *fresh26;
*fresh26 = (*fresh26).wrapping_offset(1);
*fresh27 = YAML_EMIT_FLOW_MAPPING_KEY_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(emitter, (*emitter).states, YAML_EMIT_FLOW_MAPPING_KEY_STATE) == 0 {
return 0_i32;
}
yaml_emitter_emit_node(emitter, event, 0_i32, 0_i32, 1_i32, 0_i32)
@ -986,22 +889,11 @@ unsafe fn yaml_emitter_emit_block_sequence_item(
{
return 0_i32;
}
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh30 = addr_of_mut!((*emitter).states.top);
let fresh31 = *fresh30;
*fresh30 = (*fresh30).wrapping_offset(1);
*fresh31 = YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE
) == 0
{
return 0_i32;
}
@ -1031,22 +923,11 @@ unsafe fn yaml_emitter_emit_block_mapping_key(
return 0_i32;
}
if yaml_emitter_check_simple_key(emitter) != 0 {
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh34 = addr_of_mut!((*emitter).states.top);
let fresh35 = *fresh34;
*fresh34 = (*fresh34).wrapping_offset(1);
*fresh35 = YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -1062,22 +943,11 @@ unsafe fn yaml_emitter_emit_block_mapping_key(
{
return 0_i32;
}
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh36 = addr_of_mut!((*emitter).states.top);
let fresh37 = *fresh36;
*fresh36 = (*fresh36).wrapping_offset(1);
*fresh37 = YAML_EMIT_BLOCK_MAPPING_VALUE_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_MAPPING_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -1116,22 +986,11 @@ unsafe fn yaml_emitter_emit_block_mapping_value(
return 0_i32;
}
}
if if (*emitter).states.top != (*emitter).states.end
|| yaml_stack_extend(
addr_of_mut!((*emitter).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*emitter).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh38 = addr_of_mut!((*emitter).states.top);
let fresh39 = *fresh38;
*fresh38 = (*fresh38).wrapping_offset(1);
*fresh39 = YAML_EMIT_BLOCK_MAPPING_KEY_STATE;
1_i32
} else {
(*emitter).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_MAPPING_KEY_STATE
) == 0
{
return 0_i32;
}

149
src/loader.rs
View file

@ -304,23 +304,7 @@ unsafe fn yaml_parser_register_anchor(
}
alias_data = alias_data.wrapping_offset(1);
}
if if (*parser).aliases.top != (*parser).aliases.end
|| yaml_stack_extend(
addr_of_mut!((*parser).aliases.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).aliases.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).aliases.end) as *mut *mut libc::c_void,
) != 0
{
let fresh19 = addr_of_mut!((*parser).aliases.top);
let fresh20 = *fresh19;
*fresh19 = (*fresh19).wrapping_offset(1);
ptr::copy_nonoverlapping(data, fresh20, 1);
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).aliases, *data) == 0 {
yaml_free(anchor as *mut libc::c_void);
return 0_i32;
}
@ -355,23 +339,7 @@ unsafe fn yaml_parser_load_node_add(
{
return 0_i32;
}
if if (*parent).data.sequence.items.top != (*parent).data.sequence.items.end
|| yaml_stack_extend(
addr_of_mut!((*parent).data.sequence.items.start) as *mut *mut libc::c_void,
addr_of_mut!((*parent).data.sequence.items.top) as *mut *mut libc::c_void,
addr_of_mut!((*parent).data.sequence.items.end) as *mut *mut libc::c_void,
) != 0
{
let fresh21 = addr_of_mut!((*parent).data.sequence.items.top);
let fresh22 = *fresh21;
*fresh21 = (*fresh21).wrapping_offset(1);
*fresh22 = index;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parent).data.sequence.items, index) == 0 {
return 0_i32;
}
}
@ -408,26 +376,7 @@ unsafe fn yaml_parser_load_node_add(
{
return 0_i32;
}
if if (*parent).data.mapping.pairs.top != (*parent).data.mapping.pairs.end
|| yaml_stack_extend(
addr_of_mut!((*parent).data.mapping.pairs.start)
as *mut *mut libc::c_void,
addr_of_mut!((*parent).data.mapping.pairs.top)
as *mut *mut libc::c_void,
addr_of_mut!((*parent).data.mapping.pairs.end)
as *mut *mut libc::c_void,
) != 0
{
let fresh23 = addr_of_mut!((*parent).data.mapping.pairs.top);
let fresh24 = *fresh23;
*fresh23 = (*fresh23).wrapping_offset(1);
ptr::copy_nonoverlapping(pair, fresh24, 1);
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parent).data.mapping.pairs, *pair) == 0 {
return 0_i32;
}
}
@ -520,23 +469,7 @@ unsafe fn yaml_parser_load_scalar(
(*node).data.scalar.value = (*event).data.scalar.value;
(*node).data.scalar.length = (*event).data.scalar.length;
(*node).data.scalar.style = (*event).data.scalar.style;
if !(if (*(*parser).document).nodes.top != (*(*parser).document).nodes.end
|| yaml_stack_extend(
addr_of_mut!((*(*parser).document).nodes.start) as *mut *mut libc::c_void,
addr_of_mut!((*(*parser).document).nodes.top) as *mut *mut libc::c_void,
addr_of_mut!((*(*parser).document).nodes.end) as *mut *mut libc::c_void,
) != 0
{
let fresh25 = addr_of_mut!((*(*parser).document).nodes.top);
let fresh26 = *fresh25;
*fresh25 = (*fresh25).wrapping_offset(1);
ptr::copy_nonoverlapping(node, fresh26, 1);
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
if !(PUSH!(parser, (*(*parser).document).nodes, *node) == 0) {
index = ((*(*parser).document).nodes.top)
.c_offset_from((*(*parser).document).nodes.start)
as libc::c_long as libc::c_int;
@ -631,24 +564,7 @@ unsafe fn yaml_parser_load_sequence(
(*node).data.sequence.items.end = items.end;
(*node).data.sequence.items.top = items.start;
(*node).data.sequence.style = (*event).data.sequence_start.style;
if !(if (*(*parser).document).nodes.top != (*(*parser).document).nodes.end
|| yaml_stack_extend(
addr_of_mut!((*(*parser).document).nodes.start)
as *mut *mut libc::c_void,
addr_of_mut!((*(*parser).document).nodes.top) as *mut *mut libc::c_void,
addr_of_mut!((*(*parser).document).nodes.end) as *mut *mut libc::c_void,
) != 0
{
let fresh27 = addr_of_mut!((*(*parser).document).nodes.top);
let fresh28 = *fresh27;
*fresh27 = (*fresh27).wrapping_offset(1);
ptr::copy_nonoverlapping(node, fresh28, 1);
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
if !(PUSH!(parser, (*(*parser).document).nodes, *node) == 0) {
index = ((*(*parser).document).nodes.top)
.c_offset_from((*(*parser).document).nodes.start)
as libc::c_long as libc::c_int;
@ -674,23 +590,7 @@ unsafe fn yaml_parser_load_sequence(
{
return 0_i32;
}
if if (*ctx).top != (*ctx).end
|| yaml_stack_extend(
addr_of_mut!((*ctx).start) as *mut *mut libc::c_void,
addr_of_mut!((*ctx).top) as *mut *mut libc::c_void,
addr_of_mut!((*ctx).end) as *mut *mut libc::c_void,
) != 0
{
let fresh29 = addr_of_mut!((*ctx).top);
let fresh30 = *fresh29;
*fresh29 = (*fresh29).wrapping_offset(1);
*fresh30 = index;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, *ctx, index) == 0 {
return 0_i32;
}
return 1_i32;
@ -799,24 +699,7 @@ unsafe fn yaml_parser_load_mapping(
(*node).data.mapping.pairs.end = pairs.end;
(*node).data.mapping.pairs.top = pairs.start;
(*node).data.mapping.style = (*event).data.mapping_start.style;
if !(if (*(*parser).document).nodes.top != (*(*parser).document).nodes.end
|| yaml_stack_extend(
addr_of_mut!((*(*parser).document).nodes.start)
as *mut *mut libc::c_void,
addr_of_mut!((*(*parser).document).nodes.top) as *mut *mut libc::c_void,
addr_of_mut!((*(*parser).document).nodes.end) as *mut *mut libc::c_void,
) != 0
{
let fresh32 = addr_of_mut!((*(*parser).document).nodes.top);
let fresh33 = *fresh32;
*fresh32 = (*fresh32).wrapping_offset(1);
ptr::copy_nonoverlapping(node, fresh33, 1);
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
if !(PUSH!(parser, (*(*parser).document).nodes, *node) == 0) {
index = ((*(*parser).document).nodes.top)
.c_offset_from((*(*parser).document).nodes.start)
as libc::c_long as libc::c_int;
@ -842,23 +725,7 @@ unsafe fn yaml_parser_load_mapping(
{
return 0_i32;
}
if if (*ctx).top != (*ctx).end
|| yaml_stack_extend(
addr_of_mut!((*ctx).start) as *mut *mut libc::c_void,
addr_of_mut!((*ctx).top) as *mut *mut libc::c_void,
addr_of_mut!((*ctx).end) as *mut *mut libc::c_void,
) != 0
{
let fresh34 = addr_of_mut!((*ctx).top);
let fresh35 = *fresh34;
*fresh34 = (*fresh34).wrapping_offset(1);
*fresh35 = index;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, *ctx, index) == 0 {
return 0_i32;
}
return 1_i32;

23
src/macros.rs
View file

@ -411,7 +411,28 @@ macro_rules! STACK_LIMIT {
}
macro_rules! PUSH {
() => {}; // TODO
(do $context:expr, $stack:expr, $push:expr) => {
if $stack.top != $stack.end
|| yaml_stack_extend(
addr_of_mut!($stack.start) as *mut *mut libc::c_void,
addr_of_mut!($stack.top) as *mut *mut libc::c_void,
addr_of_mut!($stack.end) as *mut *mut libc::c_void,
) != 0
{
$push;
$stack.top = $stack.top.wrapping_offset(1);
1_i32
} else {
(*$context).error = YAML_MEMORY_ERROR;
0_i32
}
};
($context:expr, $stack:expr, *$value:expr) => {
PUSH!(do $context, $stack, ptr::copy_nonoverlapping($value, $stack.top, 1))
};
($context:expr, $stack:expr, $value:expr) => {
PUSH!(do $context, $stack, ptr::write($stack.top, $value))
};
}
macro_rules! POP {

347
src/parser.rs
View file

@ -246,23 +246,7 @@ unsafe fn yaml_parser_parse_document_start(
{
return 0_i32;
}
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh7 = addr_of_mut!((*parser).states.top);
let fresh8 = *fresh7;
*fresh7 = (*fresh7).wrapping_offset(1);
*fresh8 = YAML_PARSE_DOCUMENT_END_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).states, YAML_PARSE_DOCUMENT_END_STATE) == 0 {
return 0_i32;
}
(*parser).state = YAML_PARSE_BLOCK_NODE_STATE;
@ -305,23 +289,7 @@ unsafe fn yaml_parser_parse_document_start(
b"did not find expected <document start>\0" as *const u8 as *const libc::c_char,
(*token).start_mark,
);
} else if !(if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh12 = addr_of_mut!((*parser).states.top);
let fresh13 = *fresh12;
*fresh12 = (*fresh12).wrapping_offset(1);
*fresh13 = YAML_PARSE_DOCUMENT_END_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
} else if !(PUSH!(parser, (*parser).states, YAML_PARSE_DOCUMENT_END_STATE) == 0) {
(*parser).state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
end_mark = (*token).end_mark;
memset(
@ -821,23 +789,7 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
let mut token: *mut yaml_token_t;
if first != 0 {
token = PEEK_TOKEN!(parser);
if if (*parser).marks.top != (*parser).marks.end
|| yaml_stack_extend(
addr_of_mut!((*parser).marks.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.end) as *mut *mut libc::c_void,
) != 0
{
let fresh57 = addr_of_mut!((*parser).marks.top);
let fresh58 = *fresh57;
*fresh57 = (*fresh57).wrapping_offset(1);
*fresh58 = (*token).start_mark;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).marks, (*token).start_mark) == 0 {
return 0_i32;
}
SKIP_TOKEN!(parser);
@ -856,22 +808,11 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
if (*token).type_ as libc::c_uint != YAML_BLOCK_ENTRY_TOKEN as libc::c_int as libc::c_uint
&& (*token).type_ as libc::c_uint != YAML_BLOCK_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh63 = addr_of_mut!((*parser).states.top);
let fresh64 = *fresh63;
*fresh63 = (*fresh63).wrapping_offset(1);
*fresh64 = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
) == 0
{
return 0_i32;
}
@ -931,22 +872,11 @@ unsafe fn yaml_parser_parse_indentless_sequence_entry(
&& (*token).type_ as libc::c_uint != YAML_VALUE_TOKEN as libc::c_int as libc::c_uint
&& (*token).type_ as libc::c_uint != YAML_BLOCK_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh72 = addr_of_mut!((*parser).states.top);
let fresh73 = *fresh72;
*fresh72 = (*fresh72).wrapping_offset(1);
*fresh73 = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
) == 0
{
return 0_i32;
}
@ -979,23 +909,7 @@ unsafe fn yaml_parser_parse_block_mapping_key(
let mut token: *mut yaml_token_t;
if first != 0 {
token = PEEK_TOKEN!(parser);
if if (*parser).marks.top != (*parser).marks.end
|| yaml_stack_extend(
addr_of_mut!((*parser).marks.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.end) as *mut *mut libc::c_void,
) != 0
{
let fresh75 = addr_of_mut!((*parser).marks.top);
let fresh76 = *fresh75;
*fresh75 = (*fresh75).wrapping_offset(1);
*fresh76 = (*token).start_mark;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).marks, (*token).start_mark) == 0 {
return 0_i32;
}
SKIP_TOKEN!(parser);
@ -1015,22 +929,11 @@ unsafe fn yaml_parser_parse_block_mapping_key(
&& (*token).type_ as libc::c_uint != YAML_VALUE_TOKEN as libc::c_int as libc::c_uint
&& (*token).type_ as libc::c_uint != YAML_BLOCK_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh81 = addr_of_mut!((*parser).states.top);
let fresh82 = *fresh81;
*fresh81 = (*fresh81).wrapping_offset(1);
*fresh82 = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_BLOCK_MAPPING_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -1089,23 +992,7 @@ unsafe fn yaml_parser_parse_block_mapping_value(
&& (*token).type_ as libc::c_uint != YAML_VALUE_TOKEN as libc::c_int as libc::c_uint
&& (*token).type_ as libc::c_uint != YAML_BLOCK_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh90 = addr_of_mut!((*parser).states.top);
let fresh91 = *fresh90;
*fresh90 = (*fresh90).wrapping_offset(1);
*fresh91 = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).states, YAML_PARSE_BLOCK_MAPPING_KEY_STATE) == 0 {
return 0_i32;
}
yaml_parser_parse_node(parser, event, 1_i32, 1_i32)
@ -1127,23 +1014,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
let mut token: *mut yaml_token_t;
if first != 0 {
token = PEEK_TOKEN!(parser);
if if (*parser).marks.top != (*parser).marks.end
|| yaml_stack_extend(
addr_of_mut!((*parser).marks.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.end) as *mut *mut libc::c_void,
) != 0
{
let fresh92 = addr_of_mut!((*parser).marks.top);
let fresh93 = *fresh92;
*fresh92 = (*fresh92).wrapping_offset(1);
*fresh93 = (*token).start_mark;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).marks, (*token).start_mark) == 0 {
return 0_i32;
}
SKIP_TOKEN!(parser);
@ -1196,22 +1067,11 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
} else if (*token).type_ as libc::c_uint
!= YAML_FLOW_SEQUENCE_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh103 = addr_of_mut!((*parser).states.top);
let fresh104 = *fresh103;
*fresh103 = (*fresh103).wrapping_offset(1);
*fresh104 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE
) == 0
{
return 0_i32;
}
@ -1248,22 +1108,11 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
&& (*token).type_ as libc::c_uint
!= YAML_FLOW_SEQUENCE_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh109 = addr_of_mut!((*parser).states.top);
let fresh110 = *fresh109;
*fresh109 = (*fresh109).wrapping_offset(1);
*fresh110 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -1295,22 +1144,11 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
&& (*token).type_ as libc::c_uint
!= YAML_FLOW_SEQUENCE_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh115 = addr_of_mut!((*parser).states.top);
let fresh116 = *fresh115;
*fresh115 = (*fresh115).wrapping_offset(1);
*fresh116 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
) == 0
{
return 0_i32;
}
@ -1349,23 +1187,7 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
let mut token: *mut yaml_token_t;
if first != 0 {
token = PEEK_TOKEN!(parser);
if if (*parser).marks.top != (*parser).marks.end
|| yaml_stack_extend(
addr_of_mut!((*parser).marks.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).marks.end) as *mut *mut libc::c_void,
) != 0
{
let fresh117 = addr_of_mut!((*parser).marks.top);
let fresh118 = *fresh117;
*fresh117 = (*fresh117).wrapping_offset(1);
*fresh118 = (*token).start_mark;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).marks, (*token).start_mark) == 0 {
return 0_i32;
}
SKIP_TOKEN!(parser);
@ -1409,22 +1231,11 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
&& (*token).type_ as libc::c_uint
!= YAML_FLOW_MAPPING_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh126 = addr_of_mut!((*parser).states.top);
let fresh127 = *fresh126;
*fresh126 = (*fresh126).wrapping_offset(1);
*fresh127 = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_MAPPING_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -1436,22 +1247,11 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
} else if (*token).type_ as libc::c_uint
!= YAML_FLOW_MAPPING_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh128 = addr_of_mut!((*parser).states.top);
let fresh129 = *fresh128;
*fresh128 = (*fresh128).wrapping_offset(1);
*fresh129 = YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
if PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE
) == 0
{
return 0_i32;
}
@ -1499,23 +1299,7 @@ unsafe fn yaml_parser_parse_flow_mapping_value(
&& (*token).type_ as libc::c_uint
!= YAML_FLOW_MAPPING_END_TOKEN as libc::c_int as libc::c_uint
{
if if (*parser).states.top != (*parser).states.end
|| yaml_stack_extend(
addr_of_mut!((*parser).states.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).states.end) as *mut *mut libc::c_void,
) != 0
{
let fresh136 = addr_of_mut!((*parser).states.top);
let fresh137 = *fresh136;
*fresh136 = (*fresh136).wrapping_offset(1);
*fresh137 = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).states, YAML_PARSE_FLOW_MAPPING_KEY_STATE) == 0 {
return 0_i32;
}
return yaml_parser_parse_node(parser, event, 0_i32, 0_i32);
@ -1665,22 +1449,7 @@ unsafe fn yaml_parser_process_directives(
current_block = 17143798186130252483;
break;
}
if if tag_directives.top != tag_directives.end
|| yaml_stack_extend(
addr_of_mut!(tag_directives.start) as *mut *mut libc::c_void,
addr_of_mut!(tag_directives.top) as *mut *mut libc::c_void,
addr_of_mut!(tag_directives.end) as *mut *mut libc::c_void,
) != 0
{
let fresh141 = tag_directives.top;
tag_directives.top = tag_directives.top.wrapping_offset(1);
*fresh141 = value;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, tag_directives, value) == 0 {
current_block = 17143798186130252483;
break;
}
@ -1795,23 +1564,7 @@ unsafe fn yaml_parser_append_tag_directive(
copy.prefix = yaml_strdup(value.prefix);
if copy.handle.is_null() || copy.prefix.is_null() {
(*parser).error = YAML_MEMORY_ERROR;
} else if !(if (*parser).tag_directives.top != (*parser).tag_directives.end
|| yaml_stack_extend(
addr_of_mut!((*parser).tag_directives.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).tag_directives.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).tag_directives.end) as *mut *mut libc::c_void,
) != 0
{
let fresh144 = addr_of_mut!((*parser).tag_directives.top);
let fresh145 = *fresh144;
*fresh144 = (*fresh144).wrapping_offset(1);
*fresh145 = copy;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0)
{
} else if !(PUSH!(parser, (*parser).tag_directives, copy) == 0) {
return 1_i32;
}
yaml_free(copy.handle as *mut libc::c_void);

54
src/scanner.rs
View file

@ -542,23 +542,7 @@ unsafe fn yaml_parser_increase_flow_level(mut parser: *mut yaml_parser_t) -> lib
column: 0_u64,
},
};
if if (*parser).simple_keys.top != (*parser).simple_keys.end
|| yaml_stack_extend(
addr_of_mut!((*parser).simple_keys.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).simple_keys.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).simple_keys.end) as *mut *mut libc::c_void,
) != 0
{
let fresh5 = addr_of_mut!((*parser).simple_keys.top);
let fresh6 = *fresh5;
*fresh5 = (*fresh5).wrapping_offset(1);
*fresh6 = empty_simple_key;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).simple_keys, empty_simple_key) == 0 {
return 0_i32;
}
if (*parser).flow_level == 2147483647_i32 {
@ -593,23 +577,7 @@ unsafe fn yaml_parser_roll_indent(
return 1_i32;
}
if ((*parser).indent as libc::c_long) < column {
if if (*parser).indents.top != (*parser).indents.end
|| yaml_stack_extend(
addr_of_mut!((*parser).indents.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).indents.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).indents.end) as *mut *mut libc::c_void,
) != 0
{
let fresh10 = addr_of_mut!((*parser).indents.top);
let fresh11 = *fresh10;
*fresh10 = (*fresh10).wrapping_offset(1);
*fresh11 = (*parser).indent;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).indents, (*parser).indent) == 0 {
return 0_i32;
}
if column > 2147483647_i64 {
@ -744,23 +712,7 @@ unsafe fn yaml_parser_fetch_stream_start(mut parser: *mut yaml_parser_t) -> libc
let mut token = MaybeUninit::<yaml_token_t>::uninit();
let token = token.as_mut_ptr();
(*parser).indent = -1_i32;
if if (*parser).simple_keys.top != (*parser).simple_keys.end
|| yaml_stack_extend(
addr_of_mut!((*parser).simple_keys.start) as *mut *mut libc::c_void,
addr_of_mut!((*parser).simple_keys.top) as *mut *mut libc::c_void,
addr_of_mut!((*parser).simple_keys.end) as *mut *mut libc::c_void,
) != 0
{
let fresh18 = addr_of_mut!((*parser).simple_keys.top);
let fresh19 = *fresh18;
*fresh18 = (*fresh18).wrapping_offset(1);
*fresh19 = simple_key;
1_i32
} else {
(*parser).error = YAML_MEMORY_ERROR;
0_i32
} == 0
{
if PUSH!(parser, (*parser).simple_keys, simple_key) == 0 {
return 0_i32;
}
(*parser).simple_key_allowed = 1_i32;