Mirrors/libyaml-safer
2
0
Fork 0
mirror of https://github.com/simonask/libyaml-safer synced 2024-11-26 05:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

Eliminate return value of stack push

Browse source
This commit is contained in:
David Tolnay 2022-07-30 02:00:06 -07:00
parent 560f7b2032
commit 44b9e9795a
No known key found for this signature in database
GPG key ID: F9BA143B95FF6D82
6 changed files with 126 additions and 289 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

93
src/api.rs
View file

@ -3,23 +3,19 @@ use crate::success::{Success, FAIL, OK};
use crate::yaml::{size_t, yaml_char_t};
use crate::{
libc, yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t, yaml_encoding_t,
yaml_error_type_t, yaml_event_t, yaml_mapping_style_t, yaml_mark_t, yaml_node_item_t,
yaml_node_pair_t, yaml_node_t, yaml_parser_state_t, yaml_parser_t, yaml_read_handler_t,
yaml_scalar_style_t, yaml_sequence_style_t, yaml_simple_key_t, yaml_tag_directive_t,
yaml_token_t, yaml_version_directive_t, yaml_write_handler_t, PointerExt, YAML_ALIAS_EVENT,
YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN, YAML_ANY_ENCODING, YAML_DOCUMENT_END_EVENT,
YAML_DOCUMENT_START_EVENT, YAML_MAPPING_END_EVENT, YAML_MAPPING_NODE, YAML_MAPPING_START_EVENT,
YAML_MEMORY_ERROR, YAML_NO_ERROR, YAML_SCALAR_EVENT, YAML_SCALAR_NODE, YAML_SCALAR_TOKEN,
YAML_SEQUENCE_END_EVENT, YAML_SEQUENCE_NODE, YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT,
YAML_STREAM_START_EVENT, YAML_TAG_DIRECTIVE_TOKEN, YAML_TAG_TOKEN,
yaml_event_t, yaml_mapping_style_t, yaml_mark_t, yaml_node_item_t, yaml_node_pair_t,
yaml_node_t, yaml_parser_state_t, yaml_parser_t, yaml_read_handler_t, yaml_scalar_style_t,
yaml_sequence_style_t, yaml_simple_key_t, yaml_tag_directive_t, yaml_token_t,
yaml_version_directive_t, yaml_write_handler_t, PointerExt, YAML_ALIAS_EVENT, YAML_ALIAS_TOKEN,
YAML_ANCHOR_TOKEN, YAML_ANY_ENCODING, YAML_DOCUMENT_END_EVENT, YAML_DOCUMENT_START_EVENT,
YAML_MAPPING_END_EVENT, YAML_MAPPING_NODE, YAML_MAPPING_START_EVENT, YAML_SCALAR_EVENT,
YAML_SCALAR_NODE, YAML_SCALAR_TOKEN, YAML_SEQUENCE_END_EVENT, YAML_SEQUENCE_NODE,
YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_START_EVENT,
YAML_TAG_DIRECTIVE_TOKEN, YAML_TAG_TOKEN,
};
use core::mem::{size_of, MaybeUninit};
use core::ptr::{self, addr_of_mut};
struct api_context {
error: yaml_error_type_t,
}
const INPUT_RAW_BUFFER_SIZE: usize = 16384;
const INPUT_BUFFER_SIZE: usize = INPUT_RAW_BUFFER_SIZE * 3;
const OUTPUT_BUFFER_SIZE: usize = 16384;
@ -100,12 +96,7 @@ pub(crate) unsafe fn yaml_stack_extend(
start: *mut *mut libc::c_void,
top: *mut *mut libc::c_void,
end: *mut *mut libc::c_void,
) -> Success {
if (*end as *mut libc::c_char).c_offset_from(*start as *mut libc::c_char) as libc::c_long
>= (2147483647 / 2) as libc::c_long
{
return FAIL;
}
) {
let new_start: *mut libc::c_void = yaml_realloc(
*start,
((*end as *mut libc::c_char).c_offset_from(*start as *mut libc::c_char) as libc::c_long
@ -120,7 +111,6 @@ pub(crate) unsafe fn yaml_stack_extend(
* 2_i64) as isize,
) as *mut libc::c_void;
*start = new_start;
OK
}
pub(crate) unsafe fn yaml_queue_extend(
@ -614,9 +604,6 @@ pub unsafe fn yaml_document_start_event_initialize(
implicit: bool,
) -> Success {
let mut current_block: u64;
let mut context = api_context {
error: YAML_NO_ERROR,
};
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -693,10 +680,7 @@ pub unsafe fn yaml_document_start_event_initialize(
current_block = 14964981520188694172;
break;
}
if PUSH!(addr_of_mut!(context), tag_directives_copy, value).fail {
current_block = 14964981520188694172;
break;
}
PUSH!(addr_of_mut!(context), tag_directives_copy, value);
value.handle = ptr::null_mut::<yaml_char_t>();
value.prefix = ptr::null_mut::<yaml_char_t>();
tag_directive = tag_directive.wrapping_offset(1);
@ -1147,9 +1131,6 @@ pub unsafe fn yaml_document_initialize(
end_implicit: bool,
) -> Success {
let mut current_block: u64;
let mut context = api_context {
error: YAML_NO_ERROR,
};
struct Nodes {
start: *mut yaml_node_t,
end: *mut yaml_node_t,
@ -1238,10 +1219,7 @@ pub unsafe fn yaml_document_initialize(
current_block = 8142820162064489797;
break;
}
if PUSH!(addr_of_mut!(context), tag_directives_copy, value).fail {
current_block = 8142820162064489797;
break;
}
PUSH!(addr_of_mut!(context), tag_directives_copy, value);
value.handle = ptr::null_mut::<yaml_char_t>();
value.prefix = ptr::null_mut::<yaml_char_t>();
tag_directive = tag_directive.wrapping_offset(1);
@ -1382,9 +1360,6 @@ pub unsafe fn yaml_document_add_scalar(
mut length: libc::c_int,
style: yaml_scalar_style_t,
) -> libc::c_int {
let mut context = api_context {
error: YAML_NO_ERROR,
};
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -1425,10 +1400,8 @@ 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 PUSH!(addr_of_mut!(context), (*document).nodes, *node).ok {
return (*document).nodes.top.c_offset_from((*document).nodes.start)
as libc::c_int;
}
PUSH!(addr_of_mut!(context), (*document).nodes, *node);
return (*document).nodes.top.c_offset_from((*document).nodes.start) as libc::c_int;
}
}
}
@ -1448,9 +1421,6 @@ pub unsafe fn yaml_document_add_sequence(
mut tag: *const yaml_char_t,
style: yaml_sequence_style_t,
) -> libc::c_int {
let mut context = api_context {
error: YAML_NO_ERROR,
};
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -1490,9 +1460,8 @@ 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 PUSH!(addr_of_mut!(context), (*document).nodes, *node).ok {
return (*document).nodes.top.c_offset_from((*document).nodes.start) as libc::c_int;
}
PUSH!(addr_of_mut!(context), (*document).nodes, *node);
return (*document).nodes.top.c_offset_from((*document).nodes.start) as libc::c_int;
}
}
STACK_DEL!(items);
@ -1511,9 +1480,6 @@ pub unsafe fn yaml_document_add_mapping(
mut tag: *const yaml_char_t,
style: yaml_mapping_style_t,
) -> libc::c_int {
let mut context = api_context {
error: YAML_NO_ERROR,
};
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -1553,9 +1519,8 @@ 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 PUSH!(addr_of_mut!(context), (*document).nodes, *node).ok {
return (*document).nodes.top.c_offset_from((*document).nodes.start) as libc::c_int;
}
PUSH!(addr_of_mut!(context), (*document).nodes, *node);
return (*document).nodes.top.c_offset_from((*document).nodes.start) as libc::c_int;
}
}
STACK_DEL!(pairs);
@ -1569,9 +1534,6 @@ pub unsafe fn yaml_document_append_sequence_item(
sequence: libc::c_int,
item: libc::c_int,
) -> Success {
let mut context = api_context {
error: YAML_NO_ERROR,
};
__assert!(!document.is_null());
__assert!(
sequence > 0
@ -1586,18 +1548,14 @@ pub unsafe fn yaml_document_append_sequence_item(
item > 0
&& ((*document).nodes.start).wrapping_offset(item as isize) <= (*document).nodes.top
);
if PUSH!(
PUSH!(
addr_of_mut!(context),
(*((*document).nodes.start).wrapping_offset((sequence - 1) as isize))
.data
.sequence
.items,
item
)
.fail
{
return FAIL;
}
);
OK
}
@ -1608,9 +1566,6 @@ pub unsafe fn yaml_document_append_mapping_pair(
key: libc::c_int,
value: libc::c_int,
) -> Success {
let mut context = api_context {
error: YAML_NO_ERROR,
};
__assert!(!document.is_null());
__assert!(
mapping > 0
@ -1628,17 +1583,13 @@ 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 PUSH!(
PUSH!(
addr_of_mut!(context),
(*((*document).nodes.start).wrapping_offset((mapping - 1) as isize))
.data
.mapping
.pairs,
pair
)
.fail
{
return FAIL;
}
);
OK
}

71
src/emitter.rs
View file

@ -218,7 +218,8 @@ 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 PUSH!(emitter, (*emitter).tag_directives, copy).ok {
} else {
PUSH!(emitter, (*emitter).tag_directives, copy);
return OK;
}
yaml_free(copy.handle as *mut libc::c_void);
@ -231,9 +232,7 @@ unsafe fn yaml_emitter_increase_indent(
flow: bool,
indentless: bool,
) -> Success {
if PUSH!(emitter, (*emitter).indents, (*emitter).indent).fail {
return FAIL;
}
PUSH!(emitter, (*emitter).indents, (*emitter).indent);
if (*emitter).indent < 0 {
(*emitter).indent = if flow { (*emitter).best_indent } else { 0 };
} else if !indentless {
@ -558,9 +557,7 @@ unsafe fn yaml_emitter_emit_document_content(
mut emitter: *mut yaml_emitter_t,
event: *mut yaml_event_t,
) -> Success {
if PUSH!(emitter, (*emitter).states, YAML_EMIT_DOCUMENT_END_STATE).fail {
return FAIL;
}
PUSH!(emitter, (*emitter).states, YAML_EMIT_DOCUMENT_END_STATE);
yaml_emitter_emit_node(emitter, event, true, false, false, false)
}
@ -683,15 +680,11 @@ unsafe fn yaml_emitter_emit_flow_sequence_item(
return FAIL;
}
}
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, true, false, false)
}
@ -774,15 +767,11 @@ unsafe fn yaml_emitter_emit_flow_mapping_key(
}
}
if !(*emitter).canonical && yaml_emitter_check_simple_key(emitter) {
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, false, true, true)
} else {
if yaml_emitter_write_indicator(
@ -796,15 +785,11 @@ unsafe fn yaml_emitter_emit_flow_mapping_key(
{
return FAIL;
}
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_FLOW_MAPPING_VALUE_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, false, true, false)
}
}
@ -844,9 +829,7 @@ unsafe fn yaml_emitter_emit_flow_mapping_value(
return FAIL;
}
}
if PUSH!(emitter, (*emitter).states, YAML_EMIT_FLOW_MAPPING_KEY_STATE).fail {
return FAIL;
}
PUSH!(emitter, (*emitter).states, YAML_EMIT_FLOW_MAPPING_KEY_STATE);
yaml_emitter_emit_node(emitter, event, false, false, true, false)
}
@ -885,15 +868,11 @@ unsafe fn yaml_emitter_emit_block_sequence_item(
{
return FAIL;
}
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, true, false, false)
}
@ -916,15 +895,11 @@ unsafe fn yaml_emitter_emit_block_mapping_key(
return FAIL;
}
if yaml_emitter_check_simple_key(emitter) {
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, false, true, true)
} else {
if yaml_emitter_write_indicator(
@ -938,15 +913,11 @@ unsafe fn yaml_emitter_emit_block_mapping_key(
{
return FAIL;
}
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_MAPPING_VALUE_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, false, true, false)
}
}
@ -984,15 +955,11 @@ unsafe fn yaml_emitter_emit_block_mapping_value(
return FAIL;
}
}
if PUSH!(
PUSH!(
emitter,
(*emitter).states,
YAML_EMIT_BLOCK_MAPPING_KEY_STATE
)
.fail
{
return FAIL;
}
);
yaml_emitter_emit_node(emitter, event, false, false, true, false)
}

115
src/loader.rs
View file

@ -239,10 +239,7 @@ unsafe fn yaml_parser_register_anchor(
}
alias_data = alias_data.wrapping_offset(1);
}
if PUSH!(parser, (*parser).aliases, *data).fail {
yaml_free(anchor as *mut libc::c_void);
return FAIL;
}
PUSH!(parser, (*parser).aliases, *data);
OK
}
@ -264,9 +261,7 @@ unsafe fn yaml_parser_load_node_add(
if STACK_LIMIT!(parser, (*parent).data.sequence.items).fail {
return FAIL;
}
if PUSH!(parser, (*parent).data.sequence.items, index).fail {
return FAIL;
}
PUSH!(parser, (*parent).data.sequence.items, index);
}
YAML_MAPPING_NODE => {
let mut pair = MaybeUninit::<yaml_node_pair_t>::uninit();
@ -291,9 +286,7 @@ unsafe fn yaml_parser_load_node_add(
if STACK_LIMIT!(parser, (*parent).data.mapping.pairs).fail {
return FAIL;
}
if PUSH!(parser, (*parent).data.mapping.pairs, *pair).fail {
return FAIL;
}
PUSH!(parser, (*parent).data.mapping.pairs, *pair);
}
}
}
@ -375,18 +368,16 @@ 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 PUSH!(parser, (*(*parser).document).nodes, *node).ok {
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);
PUSH!(parser, (*(*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);
}
}
}
@ -452,32 +443,25 @@ 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 PUSH!(parser, (*(*parser).document).nodes, *node).ok {
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,
)
PUSH!(parser, (*(*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;
}
if PUSH!(parser, *ctx, index).fail {
return FAIL;
}
return OK;
{
return FAIL;
}
if yaml_parser_load_node_add(parser, ctx, index).fail {
return FAIL;
}
if STACK_LIMIT!(parser, *ctx).fail {
return FAIL;
}
PUSH!(parser, *ctx, index);
return OK;
}
}
}
@ -562,32 +546,25 @@ 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 PUSH!(parser, (*(*parser).document).nodes, *node).ok {
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,
)
PUSH!(parser, (*(*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;
}
if PUSH!(parser, *ctx, index).fail {
return FAIL;
}
return OK;
{
return FAIL;
}
if yaml_parser_load_node_add(parser, ctx, index).fail {
return FAIL;
}
if STACK_LIMIT!(parser, *ctx).fail {
return FAIL;
}
PUSH!(parser, *ctx, index);
return OK;
}
}
}

19
src/macros.rs
View file

@ -381,22 +381,17 @@ macro_rules! STACK_LIMIT {
}
macro_rules! PUSH {
(do $context:expr, $stack:expr, $push:expr) => {
if $stack.top != $stack.end
|| yaml_stack_extend(
(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,
).ok
{
$push;
$stack.top = $stack.top.wrapping_offset(1);
OK
} else {
(*$context).error = YAML_MEMORY_ERROR;
FAIL
);
}
};
$push;
$stack.top = $stack.top.wrapping_offset(1);
}};
($context:expr, $stack:expr, *$value:expr) => {
PUSH!(do $context, $stack, ptr::copy_nonoverlapping($value, $stack.top, 1))
};

105
src/parser.rs
View file

@ -257,9 +257,7 @@ unsafe fn yaml_parser_parse_document_start(
{
return FAIL;
}
if PUSH!(parser, (*parser).states, YAML_PARSE_DOCUMENT_END_STATE).fail {
return FAIL;
}
PUSH!(parser, (*parser).states, YAML_PARSE_DOCUMENT_END_STATE);
(*parser).state = YAML_PARSE_BLOCK_NODE_STATE;
memset(
event as *mut libc::c_void,
@ -298,7 +296,8 @@ 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 PUSH!(parser, (*parser).states, YAML_PARSE_DOCUMENT_END_STATE).ok {
} else {
PUSH!(parser, (*parser).states, YAML_PARSE_DOCUMENT_END_STATE);
(*parser).state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
end_mark = (*token).end_mark;
memset(
@ -756,9 +755,7 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
let mut token: *mut yaml_token_t;
if first {
token = PEEK_TOKEN(parser);
if PUSH!(parser, (*parser).marks, (*token).start_mark).fail {
return FAIL;
}
PUSH!(parser, (*parser).marks, (*token).start_mark);
SKIP_TOKEN(parser);
}
token = PEEK_TOKEN(parser);
@ -773,15 +770,11 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
return FAIL;
}
if (*token).type_ != YAML_BLOCK_ENTRY_TOKEN && (*token).type_ != YAML_BLOCK_END_TOKEN {
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
)
.fail
{
return FAIL;
}
);
yaml_parser_parse_node(parser, event, true, false)
} else {
(*parser).state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
@ -833,15 +826,11 @@ unsafe fn yaml_parser_parse_indentless_sequence_entry(
&& (*token).type_ != YAML_VALUE_TOKEN
&& (*token).type_ != YAML_BLOCK_END_TOKEN
{
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
)
.fail
{
return FAIL;
}
);
yaml_parser_parse_node(parser, event, true, false)
} else {
(*parser).state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
@ -869,9 +858,7 @@ unsafe fn yaml_parser_parse_block_mapping_key(
let mut token: *mut yaml_token_t;
if first {
token = PEEK_TOKEN(parser);
if PUSH!(parser, (*parser).marks, (*token).start_mark).fail {
return FAIL;
}
PUSH!(parser, (*parser).marks, (*token).start_mark);
SKIP_TOKEN(parser);
}
token = PEEK_TOKEN(parser);
@ -889,15 +876,11 @@ unsafe fn yaml_parser_parse_block_mapping_key(
&& (*token).type_ != YAML_VALUE_TOKEN
&& (*token).type_ != YAML_BLOCK_END_TOKEN
{
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_BLOCK_MAPPING_VALUE_STATE
)
.fail
{
return FAIL;
}
);
yaml_parser_parse_node(parser, event, true, true)
} else {
(*parser).state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
@ -948,9 +931,7 @@ unsafe fn yaml_parser_parse_block_mapping_value(
&& (*token).type_ != YAML_VALUE_TOKEN
&& (*token).type_ != YAML_BLOCK_END_TOKEN
{
if PUSH!(parser, (*parser).states, YAML_PARSE_BLOCK_MAPPING_KEY_STATE).fail {
return FAIL;
}
PUSH!(parser, (*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;
@ -970,9 +951,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
let mut token: *mut yaml_token_t;
if first {
token = PEEK_TOKEN(parser);
if PUSH!(parser, (*parser).marks, (*token).start_mark).fail {
return FAIL;
}
PUSH!(parser, (*parser).marks, (*token).start_mark);
SKIP_TOKEN(parser);
}
token = PEEK_TOKEN(parser);
@ -1017,15 +996,11 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
SKIP_TOKEN(parser);
return OK;
} else if (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN {
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE
)
.fail
{
return FAIL;
}
);
return yaml_parser_parse_node(parser, event, false, false);
}
}
@ -1055,15 +1030,11 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
&& (*token).type_ != YAML_FLOW_ENTRY_TOKEN
&& (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN
{
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
)
.fail
{
return FAIL;
}
);
yaml_parser_parse_node(parser, event, false, false)
} else {
let mark: yaml_mark_t = (*token).end_mark;
@ -1090,15 +1061,11 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
}
if (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN
{
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
)
.fail
{
return FAIL;
}
);
return yaml_parser_parse_node(parser, event, false, false);
}
}
@ -1134,9 +1101,7 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
let mut token: *mut yaml_token_t;
if first {
token = PEEK_TOKEN(parser);
if PUSH!(parser, (*parser).marks, (*token).start_mark).fail {
return FAIL;
}
PUSH!(parser, (*parser).marks, (*token).start_mark);
SKIP_TOKEN(parser);
}
token = PEEK_TOKEN(parser);
@ -1172,30 +1137,22 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
&& (*token).type_ != YAML_FLOW_ENTRY_TOKEN
&& (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN
{
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_MAPPING_VALUE_STATE
)
.fail
{
return FAIL;
}
);
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 {
if PUSH!(
PUSH!(
parser,
(*parser).states,
YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE
)
.fail
{
return FAIL;
}
);
return yaml_parser_parse_node(parser, event, false, false);
}
}
@ -1235,9 +1192,7 @@ unsafe fn yaml_parser_parse_flow_mapping_value(
}
if (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN
{
if PUSH!(parser, (*parser).states, YAML_PARSE_FLOW_MAPPING_KEY_STATE).fail {
return FAIL;
}
PUSH!(parser, (*parser).states, YAML_PARSE_FLOW_MAPPING_KEY_STATE);
return yaml_parser_parse_node(parser, event, false, false);
}
}
@ -1273,7 +1228,7 @@ unsafe fn yaml_parser_process_empty_scalar(
}
unsafe fn yaml_parser_process_directives(
mut parser: *mut yaml_parser_t,
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,
@ -1354,10 +1309,7 @@ unsafe fn yaml_parser_process_directives(
current_block = 17143798186130252483;
break;
}
if PUSH!(parser, tag_directives, value).fail {
current_block = 17143798186130252483;
break;
}
PUSH!(parser, tag_directives, value);
}
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser);
@ -1459,7 +1411,8 @@ 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 PUSH!(parser, (*parser).tag_directives, copy).ok {
} else {
PUSH!(parser, (*parser).tag_directives, copy);
return OK;
}
yaml_free(copy.handle as *mut libc::c_void);

12
src/scanner.rs
View file

@ -409,9 +409,7 @@ unsafe fn yaml_parser_increase_flow_level(mut parser: *mut yaml_parser_t) -> Suc
column: 0_u64,
},
};
if PUSH!(parser, (*parser).simple_keys, empty_simple_key).fail {
return FAIL;
}
PUSH!(parser, (*parser).simple_keys, empty_simple_key);
if (*parser).flow_level == 2147483647 {
(*parser).error = YAML_MEMORY_ERROR;
return FAIL;
@ -443,9 +441,7 @@ unsafe fn yaml_parser_roll_indent(
return OK;
}
if ((*parser).indent as libc::c_long) < column {
if PUSH!(parser, (*parser).indents, (*parser).indent).fail {
return FAIL;
}
PUSH!(parser, (*parser).indents, (*parser).indent);
if column > 2147483647_i64 {
(*parser).error = YAML_MEMORY_ERROR;
return FAIL;
@ -508,9 +504,7 @@ unsafe fn yaml_parser_fetch_stream_start(mut parser: *mut yaml_parser_t) -> Succ
let mut token = MaybeUninit::<yaml_token_t>::uninit();
let token = token.as_mut_ptr();
(*parser).indent = -1;
if PUSH!(parser, (*parser).simple_keys, simple_key).fail {
return FAIL;
}
PUSH!(parser, (*parser).simple_keys, simple_key);
(*parser).simple_key_allowed = true;
(*parser).stream_start_produced = true;
memset(