Mirrors/libyaml-safer
2
0
Fork 0
mirror of https://github.com/simonask/libyaml-safer synced 2024-11-22 19:33:03 +00:00
Code Issues Projects Releases Packages Wiki Activity

Replace Success with Result<(), ()>

Browse source
This commit is contained in:
Simon Ask Ulsnes 2024-01-26 11:04:48 +01:00
parent fbdff989b5
commit dc639b92b5
11 changed files with 510 additions and 494 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/api.rs
View file

@ -1,6 +1,6 @@
use crate::externs::{free, malloc, memcpy, memmove, memset, realloc, strdup, strlen}; use crate::externs::{free, malloc, memcpy, memmove, memset, realloc, strdup, strlen};
use crate::ops::{ForceAdd as _, ForceMul as _}; use crate::ops::{ForceAdd as _, ForceMul as _};
use crate::success::{Success, FAIL, OK}; use crate::success::{FAIL, OK};
use crate::yaml::{size_t, yaml_char_t}; use crate::yaml::{size_t, yaml_char_t};
use crate::{ use crate::{
libc, yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t, yaml_encoding_t, libc, yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t, yaml_encoding_t,
@ -164,7 +164,7 @@ pub(crate) unsafe fn yaml_queue_extend(
/// ///
/// This function creates a new parser object. An application is responsible /// This function creates a new parser object. An application is responsible
/// for destroying the object using the yaml_parser_delete() function. /// for destroying the object using the yaml_parser_delete() function.
pub unsafe fn yaml_parser_initialize(parser: *mut yaml_parser_t) -> Success { pub unsafe fn yaml_parser_initialize(parser: *mut yaml_parser_t) -> Result<(), ()> {
__assert!(!parser.is_null()); __assert!(!parser.is_null());
memset( memset(
parser as *mut libc::c_void, parser as *mut libc::c_void,
@ -296,7 +296,7 @@ pub unsafe fn yaml_parser_set_encoding(parser: *mut yaml_parser_t, encoding: yam
/// ///
/// This function creates a new emitter object. An application is responsible /// This function creates a new emitter object. An application is responsible
/// for destroying the object using the yaml_emitter_delete() function. /// for destroying the object using the yaml_emitter_delete() function.
pub unsafe fn yaml_emitter_initialize(emitter: *mut yaml_emitter_t) -> Success { pub unsafe fn yaml_emitter_initialize(emitter: *mut yaml_emitter_t) -> Result<(), ()> {
__assert!(!emitter.is_null()); __assert!(!emitter.is_null());
memset( memset(
emitter as *mut libc::c_void, emitter as *mut libc::c_void,
@ -494,7 +494,7 @@ pub unsafe fn yaml_token_delete(token: *mut yaml_token_t) {
); );
} }
unsafe fn yaml_check_utf8(start: *const yaml_char_t, length: size_t) -> Success { unsafe fn yaml_check_utf8(start: *const yaml_char_t, length: size_t) -> Result<(), ()> {
let end: *const yaml_char_t = start.wrapping_offset(length as isize); let end: *const yaml_char_t = start.wrapping_offset(length as isize);
let mut pointer: *const yaml_char_t = start; let mut pointer: *const yaml_char_t = start;
while pointer < end { while pointer < end {
@ -555,7 +555,7 @@ unsafe fn yaml_check_utf8(start: *const yaml_char_t, length: size_t) -> Success
pub unsafe fn yaml_stream_start_event_initialize( pub unsafe fn yaml_stream_start_event_initialize(
event: *mut yaml_event_t, event: *mut yaml_event_t,
encoding: yaml_encoding_t, encoding: yaml_encoding_t,
) -> Success { ) -> Result<(), ()> {
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
line: 0_u64, line: 0_u64,
@ -575,7 +575,7 @@ pub unsafe fn yaml_stream_start_event_initialize(
} }
/// Create the STREAM-END event. /// Create the STREAM-END event.
pub unsafe fn yaml_stream_end_event_initialize(event: *mut yaml_event_t) -> Success { pub unsafe fn yaml_stream_end_event_initialize(event: *mut yaml_event_t) -> Result<(), ()> {
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
line: 0_u64, line: 0_u64,
@ -603,7 +603,7 @@ pub unsafe fn yaml_document_start_event_initialize(
tag_directives_start: *mut yaml_tag_directive_t, tag_directives_start: *mut yaml_tag_directive_t,
tag_directives_end: *mut yaml_tag_directive_t, tag_directives_end: *mut yaml_tag_directive_t,
implicit: bool, implicit: bool,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
@ -652,7 +652,7 @@ pub unsafe fn yaml_document_start_event_initialize(
(*tag_directive).handle, (*tag_directive).handle,
strlen((*tag_directive).handle as *mut libc::c_char), strlen((*tag_directive).handle as *mut libc::c_char),
) )
.fail .is_err()
{ {
current_block = 14964981520188694172; current_block = 14964981520188694172;
break; break;
@ -661,7 +661,7 @@ pub unsafe fn yaml_document_start_event_initialize(
(*tag_directive).prefix, (*tag_directive).prefix,
strlen((*tag_directive).prefix as *mut libc::c_char), strlen((*tag_directive).prefix as *mut libc::c_char),
) )
.fail .is_err()
{ {
current_block = 14964981520188694172; current_block = 14964981520188694172;
break; break;
@ -717,7 +717,7 @@ pub unsafe fn yaml_document_start_event_initialize(
pub unsafe fn yaml_document_end_event_initialize( pub unsafe fn yaml_document_end_event_initialize(
event: *mut yaml_event_t, event: *mut yaml_event_t,
implicit: bool, implicit: bool,
) -> Success { ) -> Result<(), ()> {
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
line: 0_u64, line: 0_u64,
@ -740,7 +740,7 @@ pub unsafe fn yaml_document_end_event_initialize(
pub unsafe fn yaml_alias_event_initialize( pub unsafe fn yaml_alias_event_initialize(
event: *mut yaml_event_t, event: *mut yaml_event_t,
anchor: *const yaml_char_t, anchor: *const yaml_char_t,
) -> Success { ) -> Result<(), ()> {
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
line: 0_u64, line: 0_u64,
@ -748,7 +748,7 @@ pub unsafe fn yaml_alias_event_initialize(
}; };
__assert!(!event.is_null()); __assert!(!event.is_null());
__assert!(!anchor.is_null()); __assert!(!anchor.is_null());
if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).fail { if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).is_err() {
return FAIL; return FAIL;
} }
let anchor_copy: *mut yaml_char_t = yaml_strdup(anchor); let anchor_copy: *mut yaml_char_t = yaml_strdup(anchor);
@ -784,7 +784,7 @@ pub unsafe fn yaml_scalar_event_initialize(
plain_implicit: bool, plain_implicit: bool,
quoted_implicit: bool, quoted_implicit: bool,
style: yaml_scalar_style_t, style: yaml_scalar_style_t,
) -> Success { ) -> Result<(), ()> {
let mut current_block: u64; let mut current_block: u64;
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
@ -797,7 +797,7 @@ pub unsafe fn yaml_scalar_event_initialize(
__assert!(!event.is_null()); __assert!(!event.is_null());
__assert!(!value.is_null()); __assert!(!value.is_null());
if !anchor.is_null() { if !anchor.is_null() {
if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).fail { if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).is_err() {
current_block = 16285396129609901221; current_block = 16285396129609901221;
} else { } else {
anchor_copy = yaml_strdup(anchor); anchor_copy = yaml_strdup(anchor);
@ -812,7 +812,7 @@ pub unsafe fn yaml_scalar_event_initialize(
} }
if current_block == 8515828400728868193 { if current_block == 8515828400728868193 {
if !tag.is_null() { if !tag.is_null() {
if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).fail { if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).is_err() {
current_block = 16285396129609901221; current_block = 16285396129609901221;
} else { } else {
tag_copy = yaml_strdup(tag); tag_copy = yaml_strdup(tag);
@ -829,7 +829,7 @@ pub unsafe fn yaml_scalar_event_initialize(
if length < 0 { if length < 0 {
length = strlen(value as *mut libc::c_char) as libc::c_int; length = strlen(value as *mut libc::c_char) as libc::c_int;
} }
if yaml_check_utf8(value, length as size_t).ok { if yaml_check_utf8(value, length as size_t).is_ok() {
value_copy = yaml_malloc(length.force_add(1) as size_t) as *mut yaml_char_t; value_copy = yaml_malloc(length.force_add(1) as size_t) as *mut yaml_char_t;
memcpy( memcpy(
value_copy as *mut libc::c_void, value_copy as *mut libc::c_void,
@ -876,7 +876,7 @@ pub unsafe fn yaml_sequence_start_event_initialize(
tag: *const yaml_char_t, tag: *const yaml_char_t,
implicit: bool, implicit: bool,
style: yaml_sequence_style_t, style: yaml_sequence_style_t,
) -> Success { ) -> Result<(), ()> {
let mut current_block: u64; let mut current_block: u64;
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
@ -887,7 +887,7 @@ pub unsafe fn yaml_sequence_start_event_initialize(
let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>(); let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
__assert!(!event.is_null()); __assert!(!event.is_null());
if !anchor.is_null() { if !anchor.is_null() {
if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).fail { if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).is_err() {
current_block = 8817775685815971442; current_block = 8817775685815971442;
} else { } else {
anchor_copy = yaml_strdup(anchor); anchor_copy = yaml_strdup(anchor);
@ -903,7 +903,7 @@ pub unsafe fn yaml_sequence_start_event_initialize(
match current_block { match current_block {
11006700562992250127 => { 11006700562992250127 => {
if !tag.is_null() { if !tag.is_null() {
if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).fail { if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).is_err() {
current_block = 8817775685815971442; current_block = 8817775685815971442;
} else { } else {
tag_copy = yaml_strdup(tag); tag_copy = yaml_strdup(tag);
@ -942,7 +942,7 @@ pub unsafe fn yaml_sequence_start_event_initialize(
} }
/// Create a SEQUENCE-END event. /// Create a SEQUENCE-END event.
pub unsafe fn yaml_sequence_end_event_initialize(event: *mut yaml_event_t) -> Success { pub unsafe fn yaml_sequence_end_event_initialize(event: *mut yaml_event_t) -> Result<(), ()> {
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
line: 0_u64, line: 0_u64,
@ -971,7 +971,7 @@ pub unsafe fn yaml_mapping_start_event_initialize(
tag: *const yaml_char_t, tag: *const yaml_char_t,
implicit: bool, implicit: bool,
style: yaml_mapping_style_t, style: yaml_mapping_style_t,
) -> Success { ) -> Result<(), ()> {
let mut current_block: u64; let mut current_block: u64;
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
@ -982,7 +982,7 @@ pub unsafe fn yaml_mapping_start_event_initialize(
let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>(); let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
__assert!(!event.is_null()); __assert!(!event.is_null());
if !anchor.is_null() { if !anchor.is_null() {
if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).fail { if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).is_err() {
current_block = 14748279734549812740; current_block = 14748279734549812740;
} else { } else {
anchor_copy = yaml_strdup(anchor); anchor_copy = yaml_strdup(anchor);
@ -997,7 +997,7 @@ pub unsafe fn yaml_mapping_start_event_initialize(
} }
if current_block == 11006700562992250127 { if current_block == 11006700562992250127 {
if !tag.is_null() { if !tag.is_null() {
if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).fail { if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).is_err() {
current_block = 14748279734549812740; current_block = 14748279734549812740;
} else { } else {
tag_copy = yaml_strdup(tag); tag_copy = yaml_strdup(tag);
@ -1034,7 +1034,7 @@ pub unsafe fn yaml_mapping_start_event_initialize(
} }
/// Create a MAPPING-END event. /// Create a MAPPING-END event.
pub unsafe fn yaml_mapping_end_event_initialize(event: *mut yaml_event_t) -> Success { pub unsafe fn yaml_mapping_end_event_initialize(event: *mut yaml_event_t) -> Result<(), ()> {
let mark = yaml_mark_t { let mark = yaml_mark_t {
index: 0_u64, index: 0_u64,
line: 0_u64, line: 0_u64,
@ -1100,7 +1100,7 @@ pub unsafe fn yaml_document_initialize(
tag_directives_end: *mut yaml_tag_directive_t, tag_directives_end: *mut yaml_tag_directive_t,
start_implicit: bool, start_implicit: bool,
end_implicit: bool, end_implicit: bool,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
struct Nodes { struct Nodes {
start: *mut yaml_node_t, start: *mut yaml_node_t,
@ -1160,7 +1160,7 @@ pub unsafe fn yaml_document_initialize(
(*tag_directive).handle, (*tag_directive).handle,
strlen((*tag_directive).handle as *mut libc::c_char), strlen((*tag_directive).handle as *mut libc::c_char),
) )
.fail .is_err()
{ {
current_block = 8142820162064489797; current_block = 8142820162064489797;
break; break;
@ -1169,7 +1169,7 @@ pub unsafe fn yaml_document_initialize(
(*tag_directive).prefix, (*tag_directive).prefix,
strlen((*tag_directive).prefix as *mut libc::c_char), strlen((*tag_directive).prefix as *mut libc::c_char),
) )
.fail .is_err()
{ {
current_block = 8142820162064489797; current_block = 8142820162064489797;
break; break;
@ -1330,13 +1330,13 @@ pub unsafe fn yaml_document_add_scalar(
if tag.is_null() { if tag.is_null() {
tag = b"tag:yaml.org,2002:str\0" as *const u8 as *const libc::c_char as *mut yaml_char_t; tag = b"tag:yaml.org,2002:str\0" as *const u8 as *const libc::c_char as *mut yaml_char_t;
} }
if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).ok { if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).is_ok() {
tag_copy = yaml_strdup(tag); tag_copy = yaml_strdup(tag);
if !tag_copy.is_null() { if !tag_copy.is_null() {
if length < 0 { if length < 0 {
length = strlen(value as *mut libc::c_char) as libc::c_int; length = strlen(value as *mut libc::c_char) as libc::c_int;
} }
if yaml_check_utf8(value, length as size_t).ok { if yaml_check_utf8(value, length as size_t).is_ok() {
value_copy = yaml_malloc(length.force_add(1) as size_t) as *mut yaml_char_t; value_copy = yaml_malloc(length.force_add(1) as size_t) as *mut yaml_char_t;
memcpy( memcpy(
value_copy as *mut libc::c_void, value_copy as *mut libc::c_void,
@ -1399,7 +1399,7 @@ pub unsafe fn yaml_document_add_sequence(
if tag.is_null() { if tag.is_null() {
tag = b"tag:yaml.org,2002:seq\0" as *const u8 as *const libc::c_char as *mut yaml_char_t; tag = b"tag:yaml.org,2002:seq\0" as *const u8 as *const libc::c_char as *mut yaml_char_t;
} }
if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).ok { if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).is_ok() {
tag_copy = yaml_strdup(tag); tag_copy = yaml_strdup(tag);
if !tag_copy.is_null() { if !tag_copy.is_null() {
STACK_INIT!(items, yaml_node_item_t); STACK_INIT!(items, yaml_node_item_t);
@ -1458,7 +1458,7 @@ pub unsafe fn yaml_document_add_mapping(
if tag.is_null() { if tag.is_null() {
tag = b"tag:yaml.org,2002:map\0" as *const u8 as *const libc::c_char as *mut yaml_char_t; tag = b"tag:yaml.org,2002:map\0" as *const u8 as *const libc::c_char as *mut yaml_char_t;
} }
if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).ok { if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).is_ok() {
tag_copy = yaml_strdup(tag); tag_copy = yaml_strdup(tag);
if !tag_copy.is_null() { if !tag_copy.is_null() {
STACK_INIT!(pairs, yaml_node_pair_t); STACK_INIT!(pairs, yaml_node_pair_t);
@ -1489,7 +1489,7 @@ pub unsafe fn yaml_document_append_sequence_item(
document: *mut yaml_document_t, document: *mut yaml_document_t,
sequence: libc::c_int, sequence: libc::c_int,
item: libc::c_int, item: libc::c_int,
) -> Success { ) -> Result<(), ()> {
__assert!(!document.is_null()); __assert!(!document.is_null());
__assert!( __assert!(
sequence > 0 sequence > 0
@ -1520,7 +1520,7 @@ pub unsafe fn yaml_document_append_mapping_pair(
mapping: libc::c_int, mapping: libc::c_int,
key: libc::c_int, key: libc::c_int,
value: libc::c_int, value: libc::c_int,
) -> Success { ) -> Result<(), ()> {
__assert!(!document.is_null()); __assert!(!document.is_null());
__assert!( __assert!(
mapping > 0 mapping > 0

6
src/bin/run-emitter-test-suite.rs
View file

@ -47,7 +47,7 @@ pub(crate) unsafe fn unsafe_main(
) -> Result<(), Box<dyn Error>> { ) -> Result<(), Box<dyn Error>> {
let mut emitter = MaybeUninit::<yaml_emitter_t>::uninit(); let mut emitter = MaybeUninit::<yaml_emitter_t>::uninit();
let emitter = emitter.as_mut_ptr(); let emitter = emitter.as_mut_ptr();
if yaml_emitter_initialize(emitter).fail { if yaml_emitter_initialize(emitter).is_err() {
return Err("Could not initalize the emitter object".into()); return Err("Could not initalize the emitter object".into());
} }
@ -133,10 +133,10 @@ pub(crate) unsafe fn unsafe_main(
break Err(format!("Unknown event: '{}'", CStr::from_ptr(line)).into()); break Err(format!("Unknown event: '{}'", CStr::from_ptr(line)).into());
}; };
if result.fail { if result.is_err() {
break Err("Memory error: Not enough memory for creating an event".into()); break Err("Memory error: Not enough memory for creating an event".into());
} }
if yaml_emitter_emit(emitter, event).fail { if yaml_emitter_emit(emitter, event).is_err() {
break Err(match (*emitter).error { break Err(match (*emitter).error {
YAML_MEMORY_ERROR => "Memory error: Not enough memory for emitting".into(), YAML_MEMORY_ERROR => "Memory error: Not enough memory for emitting".into(),
YAML_WRITER_ERROR => { YAML_WRITER_ERROR => {

4
src/bin/run-parser-test-suite.rs
View file

@ -40,7 +40,7 @@ pub(crate) unsafe fn unsafe_main(
) -> Result<(), Box<dyn Error>> { ) -> Result<(), Box<dyn Error>> {
let mut parser = MaybeUninit::<yaml_parser_t>::uninit(); let mut parser = MaybeUninit::<yaml_parser_t>::uninit();
let parser = parser.as_mut_ptr(); let parser = parser.as_mut_ptr();
if yaml_parser_initialize(parser).fail { if yaml_parser_initialize(parser).is_err() {
return Err("Could not initialize the parser object".into()); return Err("Could not initialize the parser object".into());
} }
@ -66,7 +66,7 @@ pub(crate) unsafe fn unsafe_main(
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
loop { loop {
if yaml_parser_parse(parser, event).fail { if yaml_parser_parse(parser, event).is_err() {
let mut error = format!("Parse error: {}", CStr::from_ptr((*parser).problem)); let mut error = format!("Parse error: {}", CStr::from_ptr((*parser).problem));
if (*parser).problem_mark.line != 0 || (*parser).problem_mark.column != 0 { if (*parser).problem_mark.line != 0 || (*parser).problem_mark.column != 0 {
let _ = write!( let _ = write!(

45
src/dumper.rs
View file

@ -2,7 +2,7 @@ use crate::api::{yaml_free, yaml_malloc};
use crate::externs::{memset, strcmp}; use crate::externs::{memset, strcmp};
use crate::fmt::WriteToPtr; use crate::fmt::WriteToPtr;
use crate::ops::ForceMul as _; use crate::ops::ForceMul as _;
use crate::success::{Success, FAIL, OK}; use crate::success::{FAIL, OK};
use crate::yaml::{ use crate::yaml::{
yaml_anchors_t, yaml_char_t, yaml_document_t, yaml_emitter_t, yaml_event_t, yaml_mark_t, yaml_anchors_t, yaml_char_t, yaml_document_t, yaml_emitter_t, yaml_event_t, yaml_mark_t,
yaml_node_item_t, yaml_node_pair_t, yaml_node_t, YAML_ALIAS_EVENT, YAML_ANY_ENCODING, yaml_node_item_t, yaml_node_pair_t, yaml_node_t, YAML_ALIAS_EVENT, YAML_ANY_ENCODING,
@ -17,7 +17,7 @@ use core::ptr::{self, addr_of_mut};
/// Start a YAML stream. /// Start a YAML stream.
/// ///
/// This function should be used before yaml_emitter_dump() is called. /// This function should be used before yaml_emitter_dump() is called.
pub unsafe fn yaml_emitter_open(emitter: *mut yaml_emitter_t) -> Success { pub unsafe fn yaml_emitter_open(emitter: *mut yaml_emitter_t) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
let mark = yaml_mark_t { let mark = yaml_mark_t {
@ -36,7 +36,7 @@ pub unsafe fn yaml_emitter_open(emitter: *mut yaml_emitter_t) -> Success {
(*event).start_mark = mark; (*event).start_mark = mark;
(*event).end_mark = mark; (*event).end_mark = mark;
(*event).data.stream_start.encoding = YAML_ANY_ENCODING; (*event).data.stream_start.encoding = YAML_ANY_ENCODING;
if yaml_emitter_emit(emitter, event).fail { if yaml_emitter_emit(emitter, event).is_err() {
return FAIL; return FAIL;
} }
(*emitter).opened = true; (*emitter).opened = true;
@ -46,7 +46,7 @@ pub unsafe fn yaml_emitter_open(emitter: *mut yaml_emitter_t) -> Success {
/// Finish a YAML stream. /// Finish a YAML stream.
/// ///
/// This function should be used after yaml_emitter_dump() is called. /// This function should be used after yaml_emitter_dump() is called.
pub unsafe fn yaml_emitter_close(emitter: *mut yaml_emitter_t) -> Success { pub unsafe fn yaml_emitter_close(emitter: *mut yaml_emitter_t) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
let mark = yaml_mark_t { let mark = yaml_mark_t {
@ -67,7 +67,7 @@ pub unsafe fn yaml_emitter_close(emitter: *mut yaml_emitter_t) -> Success {
(*event).type_ = YAML_STREAM_END_EVENT; (*event).type_ = YAML_STREAM_END_EVENT;
(*event).start_mark = mark; (*event).start_mark = mark;
(*event).end_mark = mark; (*event).end_mark = mark;
if yaml_emitter_emit(emitter, event).fail { if yaml_emitter_emit(emitter, event).is_err() {
return FAIL; return FAIL;
} }
(*emitter).closed = true; (*emitter).closed = true;
@ -83,7 +83,7 @@ pub unsafe fn yaml_emitter_close(emitter: *mut yaml_emitter_t) -> Success {
pub unsafe fn yaml_emitter_dump( pub unsafe fn yaml_emitter_dump(
emitter: *mut yaml_emitter_t, emitter: *mut yaml_emitter_t,
document: *mut yaml_document_t, document: *mut yaml_document_t,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
@ -97,7 +97,7 @@ pub unsafe fn yaml_emitter_dump(
let fresh0 = addr_of_mut!((*emitter).document); let fresh0 = addr_of_mut!((*emitter).document);
*fresh0 = document; *fresh0 = document;
if !(*emitter).opened { if !(*emitter).opened {
if yaml_emitter_open(emitter).fail { if yaml_emitter_open(emitter).is_err() {
current_block = 5018439318894558507; current_block = 5018439318894558507;
} else { } else {
current_block = 15619007995458559411; current_block = 15619007995458559411;
@ -108,7 +108,7 @@ pub unsafe fn yaml_emitter_dump(
match current_block { match current_block {
15619007995458559411 => { 15619007995458559411 => {
if STACK_EMPTY!((*document).nodes) { if STACK_EMPTY!((*document).nodes) {
if yaml_emitter_close(emitter).ok { if yaml_emitter_close(emitter).is_ok() {
yaml_emitter_delete_document_and_anchors(emitter); yaml_emitter_delete_document_and_anchors(emitter);
return OK; return OK;
} }
@ -140,9 +140,9 @@ pub unsafe fn yaml_emitter_dump(
(*document).tag_directives.start; (*document).tag_directives.start;
(*event).data.document_start.tag_directives.end = (*document).tag_directives.end; (*event).data.document_start.tag_directives.end = (*document).tag_directives.end;
(*event).data.document_start.implicit = (*document).start_implicit; (*event).data.document_start.implicit = (*document).start_implicit;
if yaml_emitter_emit(emitter, event).ok { if yaml_emitter_emit(emitter, event).is_ok() {
yaml_emitter_anchor_node(emitter, 1); yaml_emitter_anchor_node(emitter, 1);
if yaml_emitter_dump_node(emitter, 1).ok { if yaml_emitter_dump_node(emitter, 1).is_ok() {
memset( memset(
event as *mut libc::c_void, event as *mut libc::c_void,
0, 0,
@ -152,7 +152,7 @@ pub unsafe fn yaml_emitter_dump(
(*event).start_mark = mark; (*event).start_mark = mark;
(*event).end_mark = mark; (*event).end_mark = mark;
(*event).data.document_end.implicit = (*document).end_implicit; (*event).data.document_end.implicit = (*document).end_implicit;
if yaml_emitter_emit(emitter, event).ok { if yaml_emitter_emit(emitter, event).is_ok() {
yaml_emitter_delete_document_and_anchors(emitter); yaml_emitter_delete_document_and_anchors(emitter);
return OK; return OK;
} }
@ -262,7 +262,10 @@ unsafe fn yaml_emitter_generate_anchor(
anchor anchor
} }
unsafe fn yaml_emitter_dump_node(emitter: *mut yaml_emitter_t, index: libc::c_int) -> Success { unsafe fn yaml_emitter_dump_node(
emitter: *mut yaml_emitter_t,
index: libc::c_int,
) -> Result<(), ()> {
let node: *mut yaml_node_t = (*(*emitter).document) let node: *mut yaml_node_t = (*(*emitter).document)
.nodes .nodes
.start .start
@ -288,7 +291,7 @@ unsafe fn yaml_emitter_dump_node(emitter: *mut yaml_emitter_t, index: libc::c_in
unsafe fn yaml_emitter_dump_alias( unsafe fn yaml_emitter_dump_alias(
emitter: *mut yaml_emitter_t, emitter: *mut yaml_emitter_t,
anchor: *mut yaml_char_t, anchor: *mut yaml_char_t,
) -> Success { ) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
let mark = yaml_mark_t { let mark = yaml_mark_t {
@ -312,7 +315,7 @@ unsafe fn yaml_emitter_dump_scalar(
emitter: *mut yaml_emitter_t, emitter: *mut yaml_emitter_t,
node: *mut yaml_node_t, node: *mut yaml_node_t,
anchor: *mut yaml_char_t, anchor: *mut yaml_char_t,
) -> Success { ) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
let mark = yaml_mark_t { let mark = yaml_mark_t {
@ -350,7 +353,7 @@ unsafe fn yaml_emitter_dump_sequence(
emitter: *mut yaml_emitter_t, emitter: *mut yaml_emitter_t,
node: *mut yaml_node_t, node: *mut yaml_node_t,
anchor: *mut yaml_char_t, anchor: *mut yaml_char_t,
) -> Success { ) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
let mark = yaml_mark_t { let mark = yaml_mark_t {
@ -375,12 +378,12 @@ unsafe fn yaml_emitter_dump_sequence(
(*event).data.sequence_start.tag = (*node).tag; (*event).data.sequence_start.tag = (*node).tag;
(*event).data.sequence_start.implicit = implicit; (*event).data.sequence_start.implicit = implicit;
(*event).data.sequence_start.style = (*node).data.sequence.style; (*event).data.sequence_start.style = (*node).data.sequence.style;
if yaml_emitter_emit(emitter, event).fail { if yaml_emitter_emit(emitter, event).is_err() {
return FAIL; return FAIL;
} }
item = (*node).data.sequence.items.start; item = (*node).data.sequence.items.start;
while item < (*node).data.sequence.items.top { while item < (*node).data.sequence.items.top {
if yaml_emitter_dump_node(emitter, *item).fail { if yaml_emitter_dump_node(emitter, *item).is_err() {
return FAIL; return FAIL;
} }
item = item.wrapping_offset(1); item = item.wrapping_offset(1);
@ -400,7 +403,7 @@ unsafe fn yaml_emitter_dump_mapping(
emitter: *mut yaml_emitter_t, emitter: *mut yaml_emitter_t,
node: *mut yaml_node_t, node: *mut yaml_node_t,
anchor: *mut yaml_char_t, anchor: *mut yaml_char_t,
) -> Success { ) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
let mark = yaml_mark_t { let mark = yaml_mark_t {
@ -425,15 +428,15 @@ unsafe fn yaml_emitter_dump_mapping(
(*event).data.mapping_start.tag = (*node).tag; (*event).data.mapping_start.tag = (*node).tag;
(*event).data.mapping_start.implicit = implicit; (*event).data.mapping_start.implicit = implicit;
(*event).data.mapping_start.style = (*node).data.mapping.style; (*event).data.mapping_start.style = (*node).data.mapping.style;
if yaml_emitter_emit(emitter, event).fail { if yaml_emitter_emit(emitter, event).is_err() {
return FAIL; return FAIL;
} }
pair = (*node).data.mapping.pairs.start; pair = (*node).data.mapping.pairs.start;
while pair < (*node).data.mapping.pairs.top { while pair < (*node).data.mapping.pairs.top {
if yaml_emitter_dump_node(emitter, (*pair).key).fail { if yaml_emitter_dump_node(emitter, (*pair).key).is_err() {
return FAIL; return FAIL;
} }
if yaml_emitter_dump_node(emitter, (*pair).value).fail { if yaml_emitter_dump_node(emitter, (*pair).value).is_err() {
return FAIL; return FAIL;
} }
pair = pair.wrapping_offset(1); pair = pair.wrapping_offset(1);

402
src/emitter.rs
View file

File diff suppressed because it is too large Load diff

80
src/loader.rs
View file

@ -1,6 +1,6 @@
use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup}; use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
use crate::externs::{memset, strcmp}; use crate::externs::{memset, strcmp};
use crate::success::{Success, FAIL, OK}; use crate::success::{FAIL, OK};
use crate::yaml::yaml_char_t; use crate::yaml::yaml_char_t;
use crate::{ use crate::{
libc, yaml_alias_data_t, yaml_document_delete, yaml_document_t, yaml_event_t, yaml_mark_t, libc, yaml_alias_data_t, yaml_document_delete, yaml_document_t, yaml_event_t, yaml_mark_t,
@ -37,7 +37,7 @@ struct loader_ctx {
pub unsafe fn yaml_parser_load( pub unsafe fn yaml_parser_load(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
document: *mut yaml_document_t, document: *mut yaml_document_t,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
@ -50,7 +50,7 @@ pub unsafe fn yaml_parser_load(
); );
STACK_INIT!((*document).nodes, yaml_node_t); STACK_INIT!((*document).nodes, yaml_node_t);
if !(*parser).stream_start_produced { if !(*parser).stream_start_produced {
if yaml_parser_parse(parser, event).fail { if yaml_parser_parse(parser, event).is_err() {
current_block = 6234624449317607669; current_block = 6234624449317607669;
} else { } else {
__assert!((*event).type_ == YAML_STREAM_START_EVENT); __assert!((*event).type_ == YAML_STREAM_START_EVENT);
@ -63,14 +63,14 @@ pub unsafe fn yaml_parser_load(
if (*parser).stream_end_produced { if (*parser).stream_end_produced {
return OK; return OK;
} }
if yaml_parser_parse(parser, event).ok { if yaml_parser_parse(parser, event).is_ok() {
if (*event).type_ == YAML_STREAM_END_EVENT { if (*event).type_ == YAML_STREAM_END_EVENT {
return OK; return OK;
} }
STACK_INIT!((*parser).aliases, yaml_alias_data_t); STACK_INIT!((*parser).aliases, yaml_alias_data_t);
let fresh6 = addr_of_mut!((*parser).document); let fresh6 = addr_of_mut!((*parser).document);
*fresh6 = document; *fresh6 = document;
if yaml_parser_load_document(parser, event).ok { if yaml_parser_load_document(parser, event).is_ok() {
yaml_parser_delete_aliases(parser); yaml_parser_delete_aliases(parser);
let fresh7 = addr_of_mut!((*parser).document); let fresh7 = addr_of_mut!((*parser).document);
*fresh7 = ptr::null_mut::<yaml_document_t>(); *fresh7 = ptr::null_mut::<yaml_document_t>();
@ -89,7 +89,7 @@ unsafe fn yaml_parser_set_composer_error(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
problem: *const libc::c_char, problem: *const libc::c_char,
problem_mark: yaml_mark_t, problem_mark: yaml_mark_t,
) -> Success { ) -> Result<(), ()> {
(*parser).error = YAML_COMPOSER_ERROR; (*parser).error = YAML_COMPOSER_ERROR;
let fresh9 = addr_of_mut!((*parser).problem); let fresh9 = addr_of_mut!((*parser).problem);
*fresh9 = problem; *fresh9 = problem;
@ -103,7 +103,7 @@ unsafe fn yaml_parser_set_composer_error_context(
context_mark: yaml_mark_t, context_mark: yaml_mark_t,
problem: *const libc::c_char, problem: *const libc::c_char,
problem_mark: yaml_mark_t, problem_mark: yaml_mark_t,
) -> Success { ) -> Result<(), ()> {
(*parser).error = YAML_COMPOSER_ERROR; (*parser).error = YAML_COMPOSER_ERROR;
let fresh10 = addr_of_mut!((*parser).context); let fresh10 = addr_of_mut!((*parser).context);
*fresh10 = context; *fresh10 = context;
@ -124,7 +124,7 @@ unsafe fn yaml_parser_delete_aliases(parser: *mut yaml_parser_t) {
unsafe fn yaml_parser_load_document( unsafe fn yaml_parser_load_document(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let mut ctx = loader_ctx { let mut ctx = loader_ctx {
start: ptr::null_mut::<libc::c_int>(), start: ptr::null_mut::<libc::c_int>(),
end: ptr::null_mut::<libc::c_int>(), end: ptr::null_mut::<libc::c_int>(),
@ -140,7 +140,7 @@ unsafe fn yaml_parser_load_document(
(*(*parser).document).start_implicit = (*event).data.document_start.implicit; (*(*parser).document).start_implicit = (*event).data.document_start.implicit;
(*(*parser).document).start_mark = (*event).start_mark; (*(*parser).document).start_mark = (*event).start_mark;
STACK_INIT!(ctx, libc::c_int); STACK_INIT!(ctx, libc::c_int);
if yaml_parser_load_nodes(parser, addr_of_mut!(ctx)).fail { if yaml_parser_load_nodes(parser, addr_of_mut!(ctx)).is_err() {
STACK_DEL!(ctx); STACK_DEL!(ctx);
return FAIL; return FAIL;
} }
@ -148,41 +148,44 @@ unsafe fn yaml_parser_load_document(
OK OK
} }
unsafe fn yaml_parser_load_nodes(parser: *mut yaml_parser_t, ctx: *mut loader_ctx) -> Success { unsafe fn yaml_parser_load_nodes(
parser: *mut yaml_parser_t,
ctx: *mut loader_ctx,
) -> Result<(), ()> {
let mut event = MaybeUninit::<yaml_event_t>::uninit(); let mut event = MaybeUninit::<yaml_event_t>::uninit();
let event = event.as_mut_ptr(); let event = event.as_mut_ptr();
loop { loop {
if yaml_parser_parse(parser, event).fail { if yaml_parser_parse(parser, event).is_err() {
return FAIL; return FAIL;
} }
match (*event).type_ { match (*event).type_ {
YAML_ALIAS_EVENT => { YAML_ALIAS_EVENT => {
if yaml_parser_load_alias(parser, event, ctx).fail { if yaml_parser_load_alias(parser, event, ctx).is_err() {
return FAIL; return FAIL;
} }
} }
YAML_SCALAR_EVENT => { YAML_SCALAR_EVENT => {
if yaml_parser_load_scalar(parser, event, ctx).fail { if yaml_parser_load_scalar(parser, event, ctx).is_err() {
return FAIL; return FAIL;
} }
} }
YAML_SEQUENCE_START_EVENT => { YAML_SEQUENCE_START_EVENT => {
if yaml_parser_load_sequence(parser, event, ctx).fail { if yaml_parser_load_sequence(parser, event, ctx).is_err() {
return FAIL; return FAIL;
} }
} }
YAML_SEQUENCE_END_EVENT => { YAML_SEQUENCE_END_EVENT => {
if yaml_parser_load_sequence_end(parser, event, ctx).fail { if yaml_parser_load_sequence_end(parser, event, ctx).is_err() {
return FAIL; return FAIL;
} }
} }
YAML_MAPPING_START_EVENT => { YAML_MAPPING_START_EVENT => {
if yaml_parser_load_mapping(parser, event, ctx).fail { if yaml_parser_load_mapping(parser, event, ctx).is_err() {
return FAIL; return FAIL;
} }
} }
YAML_MAPPING_END_EVENT => { YAML_MAPPING_END_EVENT => {
if yaml_parser_load_mapping_end(parser, event, ctx).fail { if yaml_parser_load_mapping_end(parser, event, ctx).is_err() {
return FAIL; return FAIL;
} }
} }
@ -204,7 +207,7 @@ unsafe fn yaml_parser_register_anchor(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
index: libc::c_int, index: libc::c_int,
anchor: *mut yaml_char_t, anchor: *mut yaml_char_t,
) -> Success { ) -> Result<(), ()> {
let mut data = MaybeUninit::<yaml_alias_data_t>::uninit(); let mut data = MaybeUninit::<yaml_alias_data_t>::uninit();
let data = data.as_mut_ptr(); let data = data.as_mut_ptr();
let mut alias_data: *mut yaml_alias_data_t; let mut alias_data: *mut yaml_alias_data_t;
@ -244,7 +247,7 @@ unsafe fn yaml_parser_load_node_add(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
index: libc::c_int, index: libc::c_int,
) -> Success { ) -> Result<(), ()> {
if STACK_EMPTY!(*ctx) { if STACK_EMPTY!(*ctx) {
return OK; return OK;
} }
@ -255,7 +258,7 @@ unsafe fn yaml_parser_load_node_add(
let current_block_17: u64; let current_block_17: u64;
match (*parent).type_ { match (*parent).type_ {
YAML_SEQUENCE_NODE => { YAML_SEQUENCE_NODE => {
if STACK_LIMIT!(parser, (*parent).data.sequence.items).fail { if STACK_LIMIT!(parser, (*parent).data.sequence.items).is_err() {
return FAIL; return FAIL;
} }
PUSH!((*parent).data.sequence.items, index); PUSH!((*parent).data.sequence.items, index);
@ -280,7 +283,7 @@ unsafe fn yaml_parser_load_node_add(
_ => { _ => {
(*pair).key = index; (*pair).key = index;
(*pair).value = 0; (*pair).value = 0;
if STACK_LIMIT!(parser, (*parent).data.mapping.pairs).fail { if STACK_LIMIT!(parser, (*parent).data.mapping.pairs).is_err() {
return FAIL; return FAIL;
} }
PUSH!((*parent).data.mapping.pairs, *pair); PUSH!((*parent).data.mapping.pairs, *pair);
@ -298,7 +301,7 @@ unsafe fn yaml_parser_load_alias(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
) -> Success { ) -> Result<(), ()> {
let anchor: *mut yaml_char_t = (*event).data.alias.anchor; let anchor: *mut yaml_char_t = (*event).data.alias.anchor;
let mut alias_data: *mut yaml_alias_data_t; let mut alias_data: *mut yaml_alias_data_t;
alias_data = (*parser).aliases.start; alias_data = (*parser).aliases.start;
@ -325,13 +328,13 @@ unsafe fn yaml_parser_load_scalar(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
let mut node = MaybeUninit::<yaml_node_t>::uninit(); let mut node = MaybeUninit::<yaml_node_t>::uninit();
let node = node.as_mut_ptr(); let node = node.as_mut_ptr();
let index: libc::c_int; let index: libc::c_int;
let mut tag: *mut yaml_char_t = (*event).data.scalar.tag; let mut tag: *mut yaml_char_t = (*event).data.scalar.tag;
if STACK_LIMIT!(parser, (*(*parser).document).nodes).ok { if STACK_LIMIT!(parser, (*(*parser).document).nodes).is_ok() {
if tag.is_null() if tag.is_null()
|| strcmp( || strcmp(
tag as *mut libc::c_char, tag as *mut libc::c_char,
@ -369,7 +372,7 @@ unsafe fn yaml_parser_load_scalar(
.top .top
.c_offset_from((*(*parser).document).nodes.start) .c_offset_from((*(*parser).document).nodes.start)
as libc::c_int; as libc::c_int;
if yaml_parser_register_anchor(parser, index, (*event).data.scalar.anchor).fail { if yaml_parser_register_anchor(parser, index, (*event).data.scalar.anchor).is_err() {
return FAIL; return FAIL;
} }
return yaml_parser_load_node_add(parser, ctx, index); return yaml_parser_load_node_add(parser, ctx, index);
@ -385,7 +388,7 @@ unsafe fn yaml_parser_load_sequence(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
let mut node = MaybeUninit::<yaml_node_t>::uninit(); let mut node = MaybeUninit::<yaml_node_t>::uninit();
let node = node.as_mut_ptr(); let node = node.as_mut_ptr();
@ -401,7 +404,7 @@ unsafe fn yaml_parser_load_sequence(
}; };
let index: libc::c_int; let index: libc::c_int;
let mut tag: *mut yaml_char_t = (*event).data.sequence_start.tag; let mut tag: *mut yaml_char_t = (*event).data.sequence_start.tag;
if STACK_LIMIT!(parser, (*(*parser).document).nodes).ok { if STACK_LIMIT!(parser, (*(*parser).document).nodes).is_ok() {
if tag.is_null() if tag.is_null()
|| strcmp( || strcmp(
tag as *mut libc::c_char, tag as *mut libc::c_char,
@ -441,14 +444,15 @@ unsafe fn yaml_parser_load_sequence(
.top .top
.c_offset_from((*(*parser).document).nodes.start) .c_offset_from((*(*parser).document).nodes.start)
as libc::c_int; as libc::c_int;
if yaml_parser_register_anchor(parser, index, (*event).data.sequence_start.anchor).fail if yaml_parser_register_anchor(parser, index, (*event).data.sequence_start.anchor)
.is_err()
{ {
return FAIL; return FAIL;
} }
if yaml_parser_load_node_add(parser, ctx, index).fail { if yaml_parser_load_node_add(parser, ctx, index).is_err() {
return FAIL; return FAIL;
} }
if STACK_LIMIT!(parser, *ctx).fail { if STACK_LIMIT!(parser, *ctx).is_err() {
return FAIL; return FAIL;
} }
PUSH!(*ctx, index); PUSH!(*ctx, index);
@ -464,7 +468,7 @@ unsafe fn yaml_parser_load_sequence_end(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
) -> Success { ) -> Result<(), ()> {
__assert!(((*ctx).top).c_offset_from((*ctx).start) as libc::c_long > 0_i64); __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); let index: libc::c_int = *(*ctx).top.wrapping_offset(-1_isize);
__assert!( __assert!(
@ -484,7 +488,7 @@ unsafe fn yaml_parser_load_mapping(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
) -> Success { ) -> Result<(), ()> {
let current_block: u64; let current_block: u64;
let mut node = MaybeUninit::<yaml_node_t>::uninit(); let mut node = MaybeUninit::<yaml_node_t>::uninit();
let node = node.as_mut_ptr(); let node = node.as_mut_ptr();
@ -500,7 +504,7 @@ unsafe fn yaml_parser_load_mapping(
}; };
let index: libc::c_int; let index: libc::c_int;
let mut tag: *mut yaml_char_t = (*event).data.mapping_start.tag; let mut tag: *mut yaml_char_t = (*event).data.mapping_start.tag;
if STACK_LIMIT!(parser, (*(*parser).document).nodes).ok { if STACK_LIMIT!(parser, (*(*parser).document).nodes).is_ok() {
if tag.is_null() if tag.is_null()
|| strcmp( || strcmp(
tag as *mut libc::c_char, tag as *mut libc::c_char,
@ -540,13 +544,15 @@ unsafe fn yaml_parser_load_mapping(
.top .top
.c_offset_from((*(*parser).document).nodes.start) .c_offset_from((*(*parser).document).nodes.start)
as libc::c_int; as libc::c_int;
if yaml_parser_register_anchor(parser, index, (*event).data.mapping_start.anchor).fail { if yaml_parser_register_anchor(parser, index, (*event).data.mapping_start.anchor)
.is_err()
{
return FAIL; return FAIL;
} }
if yaml_parser_load_node_add(parser, ctx, index).fail { if yaml_parser_load_node_add(parser, ctx, index).is_err() {
return FAIL; return FAIL;
} }
if STACK_LIMIT!(parser, *ctx).fail { if STACK_LIMIT!(parser, *ctx).is_err() {
return FAIL; return FAIL;
} }
PUSH!(*ctx, index); PUSH!(*ctx, index);
@ -562,7 +568,7 @@ unsafe fn yaml_parser_load_mapping_end(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
ctx: *mut loader_ctx, ctx: *mut loader_ctx,
) -> Success { ) -> Result<(), ()> {
__assert!(((*ctx).top).c_offset_from((*ctx).start) as libc::c_long > 0_i64); __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); let index: libc::c_int = *(*ctx).top.wrapping_offset(-1_isize);
__assert!( __assert!(

59
src/parser.rs
View file

@ -2,7 +2,7 @@ use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
use crate::externs::{memcpy, memset, strcmp, strlen}; use crate::externs::{memcpy, memset, strcmp, strlen};
use crate::ops::ForceAdd as _; use crate::ops::ForceAdd as _;
use crate::scanner::yaml_parser_fetch_more_tokens; use crate::scanner::yaml_parser_fetch_more_tokens;
use crate::success::{Success, FAIL, OK}; use crate::success::{FAIL, OK};
use crate::yaml::{size_t, yaml_char_t}; use crate::yaml::{size_t, yaml_char_t};
use crate::{ use crate::{
libc, yaml_event_t, yaml_mark_t, yaml_parser_t, yaml_tag_directive_t, yaml_token_t, libc, yaml_event_t, yaml_mark_t, yaml_parser_t, yaml_tag_directive_t, yaml_token_t,
@ -35,7 +35,7 @@ use core::mem::size_of;
use core::ptr::{self, addr_of_mut}; use core::ptr::{self, addr_of_mut};
unsafe fn PEEK_TOKEN(parser: *mut yaml_parser_t) -> *mut yaml_token_t { unsafe fn PEEK_TOKEN(parser: *mut yaml_parser_t) -> *mut yaml_token_t {
if (*parser).token_available || yaml_parser_fetch_more_tokens(parser).ok { if (*parser).token_available || yaml_parser_fetch_more_tokens(parser).is_ok() {
(*parser).tokens.head (*parser).tokens.head
} else { } else {
ptr::null_mut::<yaml_token_t>() ptr::null_mut::<yaml_token_t>()
@ -63,7 +63,10 @@ unsafe fn SKIP_TOKEN(parser: *mut yaml_parser_t) {
/// An application must not alternate the calls of yaml_parser_parse() with the /// 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 /// calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
/// parser. /// parser.
pub unsafe fn yaml_parser_parse(parser: *mut yaml_parser_t, event: *mut yaml_event_t) -> Success { pub unsafe fn yaml_parser_parse(
parser: *mut yaml_parser_t,
event: *mut yaml_event_t,
) -> Result<(), ()> {
__assert!(!parser.is_null()); __assert!(!parser.is_null());
__assert!(!event.is_null()); __assert!(!event.is_null());
memset( memset(
@ -110,7 +113,7 @@ unsafe fn yaml_parser_set_parser_error_context(
unsafe fn yaml_parser_state_machine( unsafe fn yaml_parser_state_machine(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
match (*parser).state { match (*parser).state {
YAML_PARSE_STREAM_START_STATE => yaml_parser_parse_stream_start(parser, event), YAML_PARSE_STREAM_START_STATE => yaml_parser_parse_stream_start(parser, event),
YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => { YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => {
@ -176,7 +179,7 @@ unsafe fn yaml_parser_state_machine(
unsafe fn yaml_parser_parse_stream_start( unsafe fn yaml_parser_parse_stream_start(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let token: *mut yaml_token_t = PEEK_TOKEN(parser); let token: *mut yaml_token_t = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
return FAIL; return FAIL;
@ -207,7 +210,7 @@ unsafe fn yaml_parser_parse_document_start(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
implicit: bool, implicit: bool,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
let mut version_directive: *mut yaml_version_directive_t = let mut version_directive: *mut yaml_version_directive_t =
ptr::null_mut::<yaml_version_directive_t>(); ptr::null_mut::<yaml_version_directive_t>();
@ -244,7 +247,7 @@ unsafe fn yaml_parser_parse_document_start(
ptr::null_mut::<*mut yaml_tag_directive_t>(), ptr::null_mut::<*mut yaml_tag_directive_t>(),
ptr::null_mut::<*mut yaml_tag_directive_t>(), ptr::null_mut::<*mut yaml_tag_directive_t>(),
) )
.fail .is_err()
{ {
return FAIL; return FAIL;
} }
@ -275,7 +278,7 @@ unsafe fn yaml_parser_parse_document_start(
addr_of_mut!(tag_directives.start), addr_of_mut!(tag_directives.start),
addr_of_mut!(tag_directives.end), addr_of_mut!(tag_directives.end),
) )
.fail .is_err()
{ {
return FAIL; return FAIL;
} }
@ -338,7 +341,7 @@ unsafe fn yaml_parser_parse_document_start(
unsafe fn yaml_parser_parse_document_content( unsafe fn yaml_parser_parse_document_content(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let token: *mut yaml_token_t = PEEK_TOKEN(parser); let token: *mut yaml_token_t = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
return FAIL; return FAIL;
@ -359,7 +362,7 @@ unsafe fn yaml_parser_parse_document_content(
unsafe fn yaml_parser_parse_document_end( unsafe fn yaml_parser_parse_document_end(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let mut end_mark: yaml_mark_t; let mut end_mark: yaml_mark_t;
let mut implicit = true; let mut implicit = true;
let token: *mut yaml_token_t = PEEK_TOKEN(parser); let token: *mut yaml_token_t = PEEK_TOKEN(parser);
@ -396,7 +399,7 @@ unsafe fn yaml_parser_parse_node(
event: *mut yaml_event_t, event: *mut yaml_event_t,
block: bool, block: bool,
indentless_sequence: bool, indentless_sequence: bool,
) -> Success { ) -> Result<(), ()> {
let mut current_block: u64; let mut current_block: u64;
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
let mut anchor: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>(); let mut anchor: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
@ -724,7 +727,7 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
first: bool, first: bool,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
if first { if first {
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
@ -777,7 +780,7 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
unsafe fn yaml_parser_parse_indentless_sequence_entry( unsafe fn yaml_parser_parse_indentless_sequence_entry(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
@ -819,7 +822,7 @@ unsafe fn yaml_parser_parse_block_mapping_key(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
first: bool, first: bool,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
if first { if first {
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
@ -875,7 +878,7 @@ unsafe fn yaml_parser_parse_block_mapping_key(
unsafe fn yaml_parser_parse_block_mapping_value( unsafe fn yaml_parser_parse_block_mapping_value(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
@ -908,7 +911,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
first: bool, first: bool,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
if first { if first {
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
@ -978,7 +981,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key( unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let token: *mut yaml_token_t = PEEK_TOKEN(parser); let token: *mut yaml_token_t = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
return FAIL; return FAIL;
@ -1003,7 +1006,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value( unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
@ -1031,7 +1034,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end( unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
) -> Success { ) -> Result<(), ()> {
let token: *mut yaml_token_t = PEEK_TOKEN(parser); let token: *mut yaml_token_t = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
return FAIL; return FAIL;
@ -1052,7 +1055,7 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
first: bool, first: bool,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
if first { if first {
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
@ -1121,7 +1124,7 @@ unsafe fn yaml_parser_parse_flow_mapping_value(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
event: *mut yaml_event_t, event: *mut yaml_event_t,
empty: bool, empty: bool,
) -> Success { ) -> Result<(), ()> {
let mut token: *mut yaml_token_t; let mut token: *mut yaml_token_t;
token = PEEK_TOKEN(parser); token = PEEK_TOKEN(parser);
if token.is_null() { if token.is_null() {
@ -1147,7 +1150,10 @@ unsafe fn yaml_parser_parse_flow_mapping_value(
yaml_parser_process_empty_scalar(event, (*token).start_mark) 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 { unsafe fn yaml_parser_process_empty_scalar(
event: *mut yaml_event_t,
mark: yaml_mark_t,
) -> Result<(), ()> {
let value: *mut yaml_char_t = yaml_malloc(1_u64) as *mut yaml_char_t; let value: *mut yaml_char_t = yaml_malloc(1_u64) as *mut yaml_char_t;
*value = b'\0'; *value = b'\0';
memset( memset(
@ -1176,7 +1182,7 @@ unsafe fn yaml_parser_process_directives(
version_directive_ref: *mut *mut yaml_version_directive_t, version_directive_ref: *mut *mut yaml_version_directive_t,
tag_directives_start_ref: *mut *mut yaml_tag_directive_t, tag_directives_start_ref: *mut *mut yaml_tag_directive_t,
tag_directives_end_ref: *mut *mut yaml_tag_directive_t, tag_directives_end_ref: *mut *mut yaml_tag_directive_t,
) -> Success { ) -> Result<(), ()> {
let mut current_block: u64; let mut current_block: u64;
let mut default_tag_directives: [yaml_tag_directive_t; 3] = [ let mut default_tag_directives: [yaml_tag_directive_t; 3] = [
yaml_tag_directive_t { yaml_tag_directive_t {
@ -1248,7 +1254,8 @@ unsafe fn yaml_parser_process_directives(
handle: (*token).data.tag_directive.handle, handle: (*token).data.tag_directive.handle,
prefix: (*token).data.tag_directive.prefix, prefix: (*token).data.tag_directive.prefix,
}; };
if yaml_parser_append_tag_directive(parser, value, false, (*token).start_mark).fail if yaml_parser_append_tag_directive(parser, value, false, (*token).start_mark)
.is_err()
{ {
current_block = 17143798186130252483; current_block = 17143798186130252483;
break; break;
@ -1275,7 +1282,7 @@ unsafe fn yaml_parser_process_directives(
true, true,
(*token).start_mark, (*token).start_mark,
) )
.fail .is_err()
{ {
current_block = 17143798186130252483; current_block = 17143798186130252483;
break; break;
@ -1320,7 +1327,7 @@ unsafe fn yaml_parser_append_tag_directive(
value: yaml_tag_directive_t, value: yaml_tag_directive_t,
allow_duplicates: bool, allow_duplicates: bool,
mark: yaml_mark_t, mark: yaml_mark_t,
) -> Success { ) -> Result<(), ()> {
let mut tag_directive: *mut yaml_tag_directive_t; let mut tag_directive: *mut yaml_tag_directive_t;
let mut copy = yaml_tag_directive_t { let mut copy = yaml_tag_directive_t {
handle: ptr::null_mut::<yaml_char_t>(), handle: ptr::null_mut::<yaml_char_t>(),

16
src/reader.rs
View file

@ -1,6 +1,6 @@
use crate::externs::{memcmp, memmove}; use crate::externs::{memcmp, memmove};
use crate::ops::ForceAdd as _; use crate::ops::ForceAdd as _;
use crate::success::{Success, FAIL, OK}; use crate::success::{FAIL, OK};
use crate::yaml::{size_t, yaml_char_t}; use crate::yaml::{size_t, yaml_char_t};
use crate::{ use crate::{
libc, yaml_parser_t, PointerExt, YAML_ANY_ENCODING, YAML_READER_ERROR, YAML_UTF16BE_ENCODING, libc, yaml_parser_t, PointerExt, YAML_ANY_ENCODING, YAML_READER_ERROR, YAML_UTF16BE_ENCODING,
@ -13,7 +13,7 @@ unsafe fn yaml_parser_set_reader_error(
problem: *const libc::c_char, problem: *const libc::c_char,
offset: size_t, offset: size_t,
value: libc::c_int, value: libc::c_int,
) -> Success { ) -> Result<(), ()> {
(*parser).error = YAML_READER_ERROR; (*parser).error = YAML_READER_ERROR;
let fresh0 = addr_of_mut!((*parser).problem); let fresh0 = addr_of_mut!((*parser).problem);
*fresh0 = problem; *fresh0 = problem;
@ -26,7 +26,7 @@ const BOM_UTF8: *const libc::c_char = b"\xEF\xBB\xBF\0" as *const u8 as *const l
const BOM_UTF16LE: *const libc::c_char = b"\xFF\xFE\0" as *const u8 as *const libc::c_char; const BOM_UTF16LE: *const libc::c_char = b"\xFF\xFE\0" as *const u8 as *const libc::c_char;
const BOM_UTF16BE: *const libc::c_char = b"\xFE\xFF\0" as *const u8 as *const libc::c_char; const BOM_UTF16BE: *const libc::c_char = b"\xFE\xFF\0" as *const u8 as *const libc::c_char;
unsafe fn yaml_parser_determine_encoding(parser: *mut yaml_parser_t) -> Success { unsafe fn yaml_parser_determine_encoding(parser: *mut yaml_parser_t) -> Result<(), ()> {
while !(*parser).eof while !(*parser).eof
&& ((*parser) && ((*parser)
.raw_buffer .raw_buffer
@ -34,7 +34,7 @@ unsafe fn yaml_parser_determine_encoding(parser: *mut yaml_parser_t) -> Success
.c_offset_from((*parser).raw_buffer.pointer) as libc::c_long) .c_offset_from((*parser).raw_buffer.pointer) as libc::c_long)
< 3_i64 < 3_i64
{ {
if yaml_parser_update_raw_buffer(parser).fail { if yaml_parser_update_raw_buffer(parser).is_err() {
return FAIL; return FAIL;
} }
} }
@ -92,7 +92,7 @@ unsafe fn yaml_parser_determine_encoding(parser: *mut yaml_parser_t) -> Success
OK OK
} }
unsafe fn yaml_parser_update_raw_buffer(parser: *mut yaml_parser_t) -> Success { unsafe fn yaml_parser_update_raw_buffer(parser: *mut yaml_parser_t) -> Result<(), ()> {
let mut size_read: size_t = 0_u64; let mut size_read: size_t = 0_u64;
if (*parser).raw_buffer.start == (*parser).raw_buffer.pointer if (*parser).raw_buffer.start == (*parser).raw_buffer.pointer
&& (*parser).raw_buffer.last == (*parser).raw_buffer.end && (*parser).raw_buffer.last == (*parser).raw_buffer.end
@ -152,7 +152,7 @@ unsafe fn yaml_parser_update_raw_buffer(parser: *mut yaml_parser_t) -> Success {
pub(crate) unsafe fn yaml_parser_update_buffer( pub(crate) unsafe fn yaml_parser_update_buffer(
parser: *mut yaml_parser_t, parser: *mut yaml_parser_t,
length: size_t, length: size_t,
) -> Success { ) -> Result<(), ()> {
let mut first = true; let mut first = true;
__assert!(((*parser).read_handler).is_some()); __assert!(((*parser).read_handler).is_some());
if (*parser).eof && (*parser).raw_buffer.pointer == (*parser).raw_buffer.last { if (*parser).eof && (*parser).raw_buffer.pointer == (*parser).raw_buffer.last {
@ -162,7 +162,7 @@ pub(crate) unsafe fn yaml_parser_update_buffer(
return OK; return OK;
} }
if (*parser).encoding == YAML_ANY_ENCODING { if (*parser).encoding == YAML_ANY_ENCODING {
if yaml_parser_determine_encoding(parser).fail { if yaml_parser_determine_encoding(parser).is_err() {
return FAIL; return FAIL;
} }
} }
@ -190,7 +190,7 @@ pub(crate) unsafe fn yaml_parser_update_buffer(
} }
while (*parser).unread < length { while (*parser).unread < length {
if !first || (*parser).raw_buffer.pointer == (*parser).raw_buffer.last { if !first || (*parser).raw_buffer.pointer == (*parser).raw_buffer.last {
if yaml_parser_update_raw_buffer(parser).fail { if yaml_parser_update_raw_buffer(parser).is_err() {
return FAIL; return FAIL;
} }
} }

295
src/scanner.rs
View file

File diff suppressed because it is too large Load diff

25
src/success.rs
View file

@ -1,25 +1,4 @@
use core::ops::Deref; use core::ops::Deref;
pub const OK: Success = Success { ok: true }; pub const OK: Result<(), ()> = Ok(());
pub const FAIL: Success = Success { ok: false }; pub const FAIL: Result<(), ()> = Err(());
#[must_use]
pub struct Success {
pub ok: bool,
}
pub struct Failure {
pub fail: bool,
}
impl Deref for Success {
type Target = Failure;
fn deref(&self) -> &Self::Target {
if self.ok {
&Failure { fail: false }
} else {
&Failure { fail: true }
}
}
}

6
src/writer.rs
View file

@ -1,5 +1,5 @@
use crate::ops::ForceAdd as _; use crate::ops::ForceAdd as _;
use crate::success::{Success, FAIL, OK}; use crate::success::{FAIL, OK};
use crate::yaml::size_t; use crate::yaml::size_t;
use crate::{ use crate::{
libc, yaml_emitter_t, PointerExt, YAML_ANY_ENCODING, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING, libc, yaml_emitter_t, PointerExt, YAML_ANY_ENCODING, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
@ -10,7 +10,7 @@ use core::ptr::addr_of_mut;
unsafe fn yaml_emitter_set_writer_error( unsafe fn yaml_emitter_set_writer_error(
emitter: *mut yaml_emitter_t, emitter: *mut yaml_emitter_t,
problem: *const libc::c_char, problem: *const libc::c_char,
) -> Success { ) -> Result<(), ()> {
(*emitter).error = YAML_WRITER_ERROR; (*emitter).error = YAML_WRITER_ERROR;
let fresh0 = addr_of_mut!((*emitter).problem); let fresh0 = addr_of_mut!((*emitter).problem);
*fresh0 = problem; *fresh0 = problem;
@ -18,7 +18,7 @@ unsafe fn yaml_emitter_set_writer_error(
} }
/// Flush the accumulated characters to the output. /// Flush the accumulated characters to the output.
pub unsafe fn yaml_emitter_flush(emitter: *mut yaml_emitter_t) -> Success { pub unsafe fn yaml_emitter_flush(emitter: *mut yaml_emitter_t) -> Result<(), ()> {
__assert!(!emitter.is_null()); __assert!(!emitter.is_null());
__assert!(((*emitter).write_handler).is_some()); __assert!(((*emitter).write_handler).is_some());
__assert!((*emitter).encoding != YAML_ANY_ENCODING); __assert!((*emitter).encoding != YAML_ANY_ENCODING);