Add space between items

src/api.rs

@@ -13,9 +13,11 @@ use crate::{
 };
 use core::mem::{size_of, MaybeUninit};
 use core::ptr::{self, addr_of_mut};
+
 struct api_context {
     error: yaml_error_type_t,
 }
+
 /// Get the libyaml version as a string.
 ///
 /// Returns the pointer to a static string of the form `"X.Y.Z"`, where `X` is
@@ -24,6 +26,7 @@ struct api_context {
 pub unsafe fn yaml_get_version_string() -> *const libc::c_char {
     b"0.2.5\0" as *const u8 as *const libc::c_char
 }
+
 /// Get the libyaml version numbers.
 pub unsafe fn yaml_get_version(
     major: *mut libc::c_int,
@@ -34,9 +37,11 @@ pub unsafe fn yaml_get_version(
     *minor = 2_i32;
     *patch = 5_i32;
 }
+
 pub(crate) unsafe fn yaml_malloc(size: size_t) -> *mut libc::c_void {
     malloc(size)
 }
+
 pub(crate) unsafe fn yaml_realloc(ptr: *mut libc::c_void, size: size_t) -> *mut libc::c_void {
     if !ptr.is_null() {
         realloc(ptr, size)
@@ -44,17 +49,20 @@ pub(crate) unsafe fn yaml_realloc(ptr: *mut libc::c_void, size: size_t) -> *mut
         malloc(size)
     }
 }
+
 pub(crate) unsafe fn yaml_free(ptr: *mut libc::c_void) {
     if !ptr.is_null() {
         free(ptr);
     }
 }
+
 pub(crate) unsafe fn yaml_strdup(str: *const yaml_char_t) -> *mut yaml_char_t {
     if str.is_null() {
         return ptr::null_mut::<yaml_char_t>();
     }
     strdup(str as *mut libc::c_char) as *mut yaml_char_t
 }
+
 pub(crate) unsafe fn yaml_string_extend(
     start: *mut *mut yaml_char_t,
     pointer: *mut *mut yaml_char_t,
@@ -79,6 +87,7 @@ pub(crate) unsafe fn yaml_string_extend(
     *start = new_start;
     1_i32
 }
+
 pub(crate) unsafe fn yaml_string_join(
     a_start: *mut *mut yaml_char_t,
     a_pointer: *mut *mut yaml_char_t,
@@ -106,6 +115,7 @@ pub(crate) unsafe fn yaml_string_join(
         (*a_pointer).wrapping_offset((*b_pointer).c_offset_from(*b_start) as libc::c_long as isize);
     1_i32
 }
+
 pub(crate) unsafe fn yaml_stack_extend(
     start: *mut *mut libc::c_void,
     top: *mut *mut libc::c_void,
@@ -135,6 +145,7 @@ pub(crate) unsafe fn yaml_stack_extend(
     *start = new_start;
     1_i32
 }
+
 pub(crate) unsafe fn yaml_queue_extend(
     start: *mut *mut libc::c_void,
     head: *mut *mut libc::c_void,
@@ -181,6 +192,7 @@ pub(crate) unsafe fn yaml_queue_extend(
     }
     1_i32
 }
+
 /// Initialize a parser.
 ///
 /// This function creates a new parser object. An application is responsible
@@ -388,6 +400,7 @@ pub unsafe fn yaml_parser_initialize(parser: *mut yaml_parser_t) -> libc::c_int
     *fresh51 = *fresh50;
     0_i32
 }
+
 /// Destroy a parser.
 pub unsafe fn yaml_parser_delete(parser: *mut yaml_parser_t) {
     __assert!(!parser.is_null());
@@ -468,6 +481,7 @@ pub unsafe fn yaml_parser_delete(parser: *mut yaml_parser_t) {
         size_of::<yaml_parser_t>() as libc::c_ulong,
     );
 }
+
 unsafe fn yaml_string_read_handler(
     data: *mut libc::c_void,
     buffer: *mut libc::c_uchar,
@@ -496,6 +510,7 @@ unsafe fn yaml_string_read_handler(
     *size_read = size;
     1_i32
 }
+
 /// Set a string input.
 ///
 /// Note that the `input` pointer must be valid while the `parser` object
@@ -523,6 +538,7 @@ pub unsafe fn yaml_parser_set_input_string(
     let fresh85 = addr_of_mut!((*parser).input.string.end);
     *fresh85 = input.wrapping_offset(size as isize);
 }
+
 /// Set a generic input handler.
 pub unsafe fn yaml_parser_set_input(
     parser: *mut yaml_parser_t,
@@ -537,12 +553,14 @@ pub unsafe fn yaml_parser_set_input(
     let fresh90 = addr_of_mut!((*parser).read_handler_data);
     *fresh90 = data;
 }
+
 /// Set the source encoding.
 pub unsafe fn yaml_parser_set_encoding(mut parser: *mut yaml_parser_t, encoding: yaml_encoding_t) {
     __assert!(!parser.is_null());
     __assert!((*parser).encoding as u64 == 0);
     (*parser).encoding = encoding;
 }
+
 /// Initialize an emitter.
 ///
 /// This function creates a new emitter object. An application is responsible
@@ -703,6 +721,7 @@ pub unsafe fn yaml_emitter_initialize(mut emitter: *mut yaml_emitter_t) -> libc:
     *fresh130 = *fresh129;
     0_i32
 }
+
 /// Destroy an emitter.
 pub unsafe fn yaml_emitter_delete(emitter: *mut yaml_emitter_t) {
     __assert!(!emitter.is_null());
@@ -770,6 +789,7 @@ pub unsafe fn yaml_emitter_delete(emitter: *mut yaml_emitter_t) {
         size_of::<yaml_emitter_t>() as libc::c_ulong,
     );
 }
+
 unsafe fn yaml_string_write_handler(
     data: *mut libc::c_void,
     buffer: *mut libc::c_uchar,
@@ -798,6 +818,7 @@ unsafe fn yaml_string_write_handler(
     *fresh153 = (*fresh153 as libc::c_ulong).wrapping_add(size) as size_t as size_t;
     1_i32
 }
+
 /// Set a string output.
 ///
 /// The emitter will write the output characters to the `output` buffer of the
@@ -827,6 +848,7 @@ pub unsafe fn yaml_emitter_set_output_string(
     *fresh157 = size_written;
     *size_written = 0_u64;
 }
+
 /// Set a generic output handler.
 pub unsafe fn yaml_emitter_set_output(
     emitter: *mut yaml_emitter_t,
@@ -841,6 +863,7 @@ pub unsafe fn yaml_emitter_set_output(
     let fresh162 = addr_of_mut!((*emitter).write_handler_data);
     *fresh162 = data;
 }
+
 /// Set the output encoding.
 pub unsafe fn yaml_emitter_set_encoding(
     mut emitter: *mut yaml_emitter_t,
@@ -850,12 +873,14 @@ pub unsafe fn yaml_emitter_set_encoding(
     __assert!((*emitter).encoding as u64 == 0);
     (*emitter).encoding = encoding;
 }
+
 /// Set if the output should be in the "canonical" format as in the YAML
 /// specification.
 pub unsafe fn yaml_emitter_set_canonical(mut emitter: *mut yaml_emitter_t, canonical: libc::c_int) {
     __assert!(!emitter.is_null());
     (*emitter).canonical = (canonical != 0_i32) as libc::c_int;
 }
+
 /// Set the indentation increment.
 pub unsafe fn yaml_emitter_set_indent(mut emitter: *mut yaml_emitter_t, indent: libc::c_int) {
     __assert!(!emitter.is_null());
@@ -865,21 +890,25 @@ pub unsafe fn yaml_emitter_set_indent(mut emitter: *mut yaml_emitter_t, indent:
         2_i32
     };
 }
+
 /// Set the preferred line width. -1 means unlimited.
 pub unsafe fn yaml_emitter_set_width(mut emitter: *mut yaml_emitter_t, width: libc::c_int) {
     __assert!(!emitter.is_null());
     (*emitter).best_width = if width >= 0_i32 { width } else { -1_i32 };
 }
+
 /// Set if unescaped non-ASCII characters are allowed.
 pub unsafe fn yaml_emitter_set_unicode(mut emitter: *mut yaml_emitter_t, unicode: libc::c_int) {
     __assert!(!emitter.is_null());
     (*emitter).unicode = (unicode != 0_i32) as libc::c_int;
 }
+
 /// Set the preferred line break.
 pub unsafe fn yaml_emitter_set_break(mut emitter: *mut yaml_emitter_t, line_break: yaml_break_t) {
     __assert!(!emitter.is_null());
     (*emitter).line_break = line_break;
 }
+
 /// Free any memory allocated for a token object.
 pub unsafe fn yaml_token_delete(token: *mut yaml_token_t) {
     __assert!(!token.is_null());
@@ -909,6 +938,7 @@ pub unsafe fn yaml_token_delete(token: *mut yaml_token_t) {
         size_of::<yaml_token_t>() as libc::c_ulong,
     );
 }
+
 unsafe fn yaml_check_utf8(start: *const yaml_char_t, length: size_t) -> libc::c_int {
     let end: *const yaml_char_t = start.wrapping_offset(length as isize);
     let mut pointer: *const yaml_char_t = start;
@@ -966,6 +996,7 @@ unsafe fn yaml_check_utf8(start: *const yaml_char_t, length: size_t) -> libc::c_
     }
     1_i32
 }
+
 /// Create the STREAM-START event.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -990,6 +1021,7 @@ pub unsafe fn yaml_stream_start_event_initialize(
     (*event).data.stream_start.encoding = encoding;
     1_i32
 }
+
 /// Create the STREAM-END event.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -1010,6 +1042,7 @@ pub unsafe fn yaml_stream_end_event_initialize(mut event: *mut yaml_event_t) ->
     (*event).end_mark = mark;
     1_i32
 }
+
 /// Create the DOCUMENT-START event.
 ///
 /// The `implicit` argument is considered as a stylistic parameter and may be
@@ -1180,6 +1213,7 @@ pub unsafe fn yaml_document_start_event_initialize(
     yaml_free(value.prefix as *mut libc::c_void);
     0_i32
 }
+
 /// Create the DOCUMENT-END event.
 ///
 /// The `implicit` argument is considered as a stylistic parameter and may be
@@ -1207,6 +1241,7 @@ pub unsafe fn yaml_document_end_event_initialize(
     (*event).data.document_end.implicit = implicit;
     1_i32
 }
+
 /// Create an ALIAS event.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -1240,6 +1275,7 @@ pub unsafe fn yaml_alias_event_initialize(
     *fresh167 = anchor_copy;
     1_i32
 }
+
 /// Create a SCALAR event.
 ///
 /// The `style` argument may be ignored by the emitter.
@@ -1346,6 +1382,7 @@ pub unsafe fn yaml_scalar_event_initialize(
     yaml_free(value_copy as *mut libc::c_void);
     0_i32
 }
+
 /// Create a SEQUENCE-START event.
 ///
 /// The `style` argument may be ignored by the emitter.
@@ -1426,6 +1463,7 @@ pub unsafe fn yaml_sequence_start_event_initialize(
     yaml_free(tag_copy as *mut libc::c_void);
     0_i32
 }
+
 /// Create a SEQUENCE-END event.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -1446,6 +1484,7 @@ pub unsafe fn yaml_sequence_end_event_initialize(mut event: *mut yaml_event_t) -
     (*event).end_mark = mark;
     1_i32
 }
+
 /// Create a MAPPING-START event.
 ///
 /// The `style` argument may be ignored by the emitter.
@@ -1526,6 +1565,7 @@ pub unsafe fn yaml_mapping_start_event_initialize(
     yaml_free(tag_copy as *mut libc::c_void);
     0_i32
 }
+
 /// Create a MAPPING-END event.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -1546,6 +1586,7 @@ pub unsafe fn yaml_mapping_end_event_initialize(mut event: *mut yaml_event_t) ->
     (*event).end_mark = mark;
     1_i32
 }
+
 /// Free any memory allocated for an event object.
 pub unsafe fn yaml_event_delete(event: *mut yaml_event_t) {
     let mut tag_directive: *mut yaml_tag_directive_t;
@@ -1585,6 +1626,7 @@ pub unsafe fn yaml_event_delete(event: *mut yaml_event_t) {
         size_of::<yaml_event_t>() as libc::c_ulong,
     );
 }
+
 /// Create a YAML document.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -1791,6 +1833,7 @@ pub unsafe fn yaml_document_initialize(
     yaml_free(value.prefix as *mut libc::c_void);
     0_i32
 }
+
 /// Delete a YAML document and all its nodes.
 pub unsafe fn yaml_document_delete(document: *mut yaml_document_t) {
     let mut tag_directive: *mut yaml_tag_directive_t;
@@ -1842,6 +1885,7 @@ pub unsafe fn yaml_document_delete(document: *mut yaml_document_t) {
         size_of::<yaml_document_t>() as libc::c_ulong,
     );
 }
+
 /// Get a node of a YAML document.
 ///
 /// The pointer returned by this function is valid until any of the functions
@@ -1862,6 +1906,7 @@ pub unsafe fn yaml_document_get_node(
     }
     ptr::null_mut::<yaml_node_t>()
 }
+
 /// Get the root of a YAML document node.
 ///
 /// The root object is the first object added to the document.
@@ -1879,6 +1924,7 @@ pub unsafe fn yaml_document_get_root_node(document: *mut yaml_document_t) -> *mu
     }
     ptr::null_mut::<yaml_node_t>()
 }
+
 /// Create a SCALAR node and attach it to the document.
 ///
 /// The `style` argument may be ignored by the emitter.
@@ -1963,6 +2009,7 @@ pub unsafe fn yaml_document_add_scalar(
     yaml_free(value_copy as *mut libc::c_void);
     0_i32
 }
+
 /// Create a SEQUENCE node and attach it to the document.
 ///
 /// The `style` argument may be ignored by the emitter.
@@ -2056,6 +2103,7 @@ pub unsafe fn yaml_document_add_sequence(
     yaml_free(tag_copy as *mut libc::c_void);
     0_i32
 }
+
 /// Create a MAPPING node and attach it to the document.
 ///
 /// The `style` argument may be ignored by the emitter.
@@ -2149,6 +2197,7 @@ pub unsafe fn yaml_document_add_mapping(
     yaml_free(tag_copy as *mut libc::c_void);
     0_i32
 }
+
 /// Add an item to a SEQUENCE node.
 ///
 /// Returns 1 if the function succeeded, 0 on error.
@@ -2229,6 +2278,7 @@ pub unsafe fn yaml_document_append_sequence_item(
     }
     1_i32
 }
+
 /// Add a pair of a key and a value to a MAPPING node.
 ///
 /// Returns 1 if the function succeeded, 0 on error.

src/bin/run-emitter-test-suite.rs

@@ -36,6 +36,7 @@ use unsafe_libyaml::{
     YAML_LITERAL_SCALAR_STYLE, YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE,
     YAML_UTF8_ENCODING,
 };
+
 pub(crate) unsafe fn unsafe_main(
     stdin: &mut dyn Read,
     mut stdout: &mut dyn Write,
@@ -180,11 +181,13 @@ pub(crate) unsafe fn unsafe_main(
     yaml_emitter_delete(emitter);
     result
 }
+
 struct ReadBuf {
     buf: [u8; 1024],
     offset: usize,
     filled: usize,
 }
+
 impl ReadBuf {
     fn new() -> Self {
         ReadBuf {
@@ -193,6 +196,7 @@ impl ReadBuf {
             filled: 0,
         }
     }
+
     fn get_line(&mut self, input: &mut dyn Read) -> Option<&mut [u8]> {
         loop {
             for i in self.offset..self.offset + self.filled {
@@ -226,6 +230,7 @@ impl ReadBuf {
         }
     }
 }
+
 unsafe fn get_anchor(sigil: i8, line: *mut i8, anchor: *mut i8) -> *mut i8 {
     let mut start: *mut i8;
     let mut end: *mut i8;
@@ -246,6 +251,7 @@ unsafe fn get_anchor(sigil: i8, line: *mut i8, anchor: *mut i8) -> *mut i8 {
     *anchor.offset(end.offset_from(start) as i64 as isize) = '\0' as i32 as i8;
     anchor
 }
+
 unsafe fn get_tag(line: *mut i8, tag: *mut i8) -> *mut i8 {
     let start: *mut i8 = strchr(line, '<' as i32);
     if start.is_null() {
@@ -263,6 +269,7 @@ unsafe fn get_tag(line: *mut i8, tag: *mut i8) -> *mut i8 {
     *tag.offset((end.offset_from(start) as i64 - 1_i64) as isize) = '\0' as i32 as i8;
     tag
 }
+
 unsafe fn get_value(line: *mut i8, value: *mut i8, style: *mut yaml_scalar_style_t) {
     let mut i: i32 = 0_i32;
     let mut c: *mut i8;
@@ -345,6 +352,7 @@ unsafe fn get_value(line: *mut i8, value: *mut i8, style: *mut yaml_scalar_style
     }
     *value.offset(i as isize) = '\0' as i32 as i8;
 }
+
 unsafe fn memcpy(dest: *mut c_void, src: *const c_void, count: u64) -> *mut c_void {
     ptr::copy_nonoverlapping(
         src.cast::<MaybeUninit<u8>>(),
@@ -353,6 +361,7 @@ unsafe fn memcpy(dest: *mut c_void, src: *const c_void, count: u64) -> *mut c_vo
     );
     dest
 }
+
 unsafe fn strchr(mut str: *const i8, c: i32) -> *mut i8 {
     loop {
         match *str {
@@ -362,6 +371,7 @@ unsafe fn strchr(mut str: *const i8, c: i32) -> *mut i8 {
         }
     }
 }
+
 unsafe fn strlen(str: *const i8) -> u64 {
     let mut end = str;
     while *end != 0 {
@@ -369,6 +379,7 @@ unsafe fn strlen(str: *const i8) -> u64 {
     }
     end.offset_from(str) as u64
 }
+
 unsafe fn strncmp(lhs: *const i8, rhs: *const i8, mut count: u64) -> i32 {
     let mut lhs = lhs.cast::<u8>();
     let mut rhs = rhs.cast::<u8>();
@@ -383,6 +394,7 @@ unsafe fn strncmp(lhs: *const i8, rhs: *const i8, mut count: u64) -> i32 {
         (*lhs).cmp(&*rhs) as i32
     }
 }
+
 fn main() -> ExitCode {
     let args = env::args_os().skip(1);
     if args.len() == 0 {

src/bin/run-parser-test-suite.rs

@@ -28,6 +28,7 @@ use unsafe_libyaml::{
     YAML_MAPPING_START_EVENT, YAML_NO_EVENT, YAML_SCALAR_EVENT, YAML_SEQUENCE_END_EVENT,
     YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_START_EVENT,
 };
+
 pub(crate) unsafe fn unsafe_main(
     mut stdin: &mut dyn Read,
     stdout: &mut dyn Write,
@@ -192,6 +193,7 @@ pub(crate) unsafe fn unsafe_main(
     yaml_parser_delete(parser);
     Ok(())
 }
+
 unsafe fn print_escaped(stdout: &mut dyn Write, str: *mut u8, length: u64) {
     let mut i: i32;
     let mut c: i8;
@@ -216,6 +218,7 @@ unsafe fn print_escaped(stdout: &mut dyn Write, str: *mut u8, length: u64) {
         i += 1;
     }
 }
+
 fn main() -> ExitCode {
     let args = env::args_os().skip(1);
     if args.len() == 0 {

src/dumper.rs

@@ -11,6 +11,7 @@ use crate::yaml::{
 use crate::{libc, yaml_document_delete, yaml_emitter_emit, PointerExt};
 use core::mem::{size_of, MaybeUninit};
 use core::ptr::{self, addr_of_mut};
+
 /// Start a YAML stream.
 ///
 /// This function should be used before yaml_emitter_dump() is called.
@@ -41,6 +42,7 @@ pub unsafe fn yaml_emitter_open(mut emitter: *mut yaml_emitter_t) -> libc::c_int
     (*emitter).opened = 1_i32;
     1_i32
 }
+
 /// Finish a YAML stream.
 ///
 /// This function should be used after yaml_emitter_dump() is called.
@@ -73,6 +75,7 @@ pub unsafe fn yaml_emitter_close(mut emitter: *mut yaml_emitter_t) -> libc::c_in
     (*emitter).closed = 1_i32;
     1_i32
 }
+
 /// Emit a YAML document.
 ///
 /// The documen object may be generated using the yaml_parser_load() function or
@@ -169,6 +172,7 @@ pub unsafe fn yaml_emitter_dump(
     yaml_emitter_delete_document_and_anchors(emitter);
     0_i32
 }
+
 unsafe fn yaml_emitter_delete_document_and_anchors(mut emitter: *mut yaml_emitter_t) {
     let mut index: libc::c_int;
     if ((*emitter).anchors).is_null() {
@@ -217,6 +221,7 @@ unsafe fn yaml_emitter_delete_document_and_anchors(mut emitter: *mut yaml_emitte
     let fresh7 = addr_of_mut!((*emitter).document);
     *fresh7 = ptr::null_mut::<yaml_document_t>();
 }
+
 unsafe fn yaml_emitter_anchor_node(emitter: *mut yaml_emitter_t, index: libc::c_int) {
     let node: *mut yaml_node_t = ((*(*emitter).document).nodes.start)
         .wrapping_offset(index as isize)
@@ -252,6 +257,7 @@ unsafe fn yaml_emitter_anchor_node(emitter: *mut yaml_emitter_t, index: libc::c_
         (*((*emitter).anchors).wrapping_offset((index - 1_i32) as isize)).anchor = *fresh9;
     }
 }
+
 unsafe fn yaml_emitter_generate_anchor(
     _emitter: *mut yaml_emitter_t,
     anchor_id: libc::c_int,
@@ -263,6 +269,7 @@ unsafe fn yaml_emitter_generate_anchor(
     write!(WriteToPtr::new(anchor), "id{:03}\0", anchor_id);
     anchor
 }
+
 unsafe fn yaml_emitter_dump_node(emitter: *mut yaml_emitter_t, index: libc::c_int) -> libc::c_int {
     let node: *mut yaml_node_t = ((*(*emitter).document).nodes.start)
         .wrapping_offset(index as isize)
@@ -287,6 +294,7 @@ unsafe fn yaml_emitter_dump_node(emitter: *mut yaml_emitter_t, index: libc::c_in
         _ => __assert!(false),
     }
 }
+
 unsafe fn yaml_emitter_dump_alias(
     emitter: *mut yaml_emitter_t,
     anchor: *mut yaml_char_t,
@@ -309,6 +317,7 @@ unsafe fn yaml_emitter_dump_alias(
     (*event).data.alias.anchor = anchor;
     yaml_emitter_emit(emitter, event)
 }
+
 unsafe fn yaml_emitter_dump_scalar(
     emitter: *mut yaml_emitter_t,
     node: *mut yaml_node_t,
@@ -346,6 +355,7 @@ unsafe fn yaml_emitter_dump_scalar(
     (*event).data.scalar.style = (*node).data.scalar.style;
     yaml_emitter_emit(emitter, event)
 }
+
 unsafe fn yaml_emitter_dump_sequence(
     emitter: *mut yaml_emitter_t,
     node: *mut yaml_node_t,
@@ -398,6 +408,7 @@ unsafe fn yaml_emitter_dump_sequence(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_dump_mapping(
     emitter: *mut yaml_emitter_t,
     node: *mut yaml_node_t,

src/emitter.rs

@@ -20,6 +20,7 @@ use crate::{
     YAML_STREAM_START_EVENT, YAML_UTF8_ENCODING,
 };
 use core::ptr::{self, addr_of_mut};
+
 unsafe fn yaml_emitter_set_emitter_error(
     mut emitter: *mut yaml_emitter_t,
     problem: *const libc::c_char,
@@ -29,6 +30,7 @@ unsafe fn yaml_emitter_set_emitter_error(
     *fresh0 = problem;
     0_i32
 }
+
 /// Emit an event.
 ///
 /// The event object may be generated using the yaml_parser_parse() function.
@@ -76,6 +78,7 @@ pub unsafe fn yaml_emitter_emit(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_need_more_events(emitter: *mut yaml_emitter_t) -> libc::c_int {
     let mut level: libc::c_int = 0_i32;
     let mut event: *mut yaml_event_t;
@@ -111,6 +114,7 @@ unsafe fn yaml_emitter_need_more_events(emitter: *mut yaml_emitter_t) -> libc::c
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_append_tag_directive(
     mut emitter: *mut yaml_emitter_t,
     value: yaml_tag_directive_t,
@@ -165,6 +169,7 @@ unsafe fn yaml_emitter_append_tag_directive(
     yaml_free(copy.prefix as *mut libc::c_void);
     0_i32
 }
+
 unsafe fn yaml_emitter_increase_indent(
     mut emitter: *mut yaml_emitter_t,
     flow: libc::c_int,
@@ -200,6 +205,7 @@ unsafe fn yaml_emitter_increase_indent(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_state_machine(
     emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -252,6 +258,7 @@ unsafe fn yaml_emitter_state_machine(
     }
     0_i32
 }
+
 unsafe fn yaml_emitter_emit_stream_start(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -296,6 +303,7 @@ unsafe fn yaml_emitter_emit_stream_start(
         b"expected STREAM-START\0" as *const u8 as *const libc::c_char,
     )
 }
+
 unsafe fn yaml_emitter_emit_document_start(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -500,6 +508,7 @@ unsafe fn yaml_emitter_emit_document_start(
         b"expected DOCUMENT-START or STREAM-END\0" as *const u8 as *const libc::c_char,
     )
 }
+
 unsafe fn yaml_emitter_emit_document_content(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -525,6 +534,7 @@ unsafe fn yaml_emitter_emit_document_content(
     }
     yaml_emitter_emit_node(emitter, event, 1_i32, 0_i32, 0_i32, 0_i32)
 }
+
 unsafe fn yaml_emitter_emit_document_end(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -569,6 +579,7 @@ unsafe fn yaml_emitter_emit_document_end(
         b"expected DOCUMENT-END\0" as *const u8 as *const libc::c_char,
     )
 }
+
 unsafe fn yaml_emitter_emit_flow_sequence_item(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -665,6 +676,7 @@ unsafe fn yaml_emitter_emit_flow_sequence_item(
     }
     yaml_emitter_emit_node(emitter, event, 0_i32, 1_i32, 0_i32, 0_i32)
 }
+
 unsafe fn yaml_emitter_emit_flow_mapping_key(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -794,6 +806,7 @@ unsafe fn yaml_emitter_emit_flow_mapping_key(
         yaml_emitter_emit_node(emitter, event, 0_i32, 0_i32, 1_i32, 0_i32)
     }
 }
+
 unsafe fn yaml_emitter_emit_flow_mapping_value(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -848,6 +861,7 @@ unsafe fn yaml_emitter_emit_flow_mapping_value(
     }
     yaml_emitter_emit_node(emitter, event, 0_i32, 0_i32, 1_i32, 0_i32)
 }
+
 unsafe fn yaml_emitter_emit_block_sequence_item(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -906,6 +920,7 @@ unsafe fn yaml_emitter_emit_block_sequence_item(
     }
     yaml_emitter_emit_node(emitter, event, 0_i32, 1_i32, 0_i32, 0_i32)
 }
+
 unsafe fn yaml_emitter_emit_block_mapping_key(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -982,6 +997,7 @@ unsafe fn yaml_emitter_emit_block_mapping_key(
         yaml_emitter_emit_node(emitter, event, 0_i32, 0_i32, 1_i32, 0_i32)
     }
 }
+
 unsafe fn yaml_emitter_emit_block_mapping_value(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -1034,6 +1050,7 @@ unsafe fn yaml_emitter_emit_block_mapping_value(
     }
     yaml_emitter_emit_node(emitter, event, 0_i32, 0_i32, 1_i32, 0_i32)
 }
+
 unsafe fn yaml_emitter_emit_node(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -1058,6 +1075,7 @@ unsafe fn yaml_emitter_emit_node(
         ),
     }
 }
+
 unsafe fn yaml_emitter_emit_alias(
     mut emitter: *mut yaml_emitter_t,
     _event: *mut yaml_event_t,
@@ -1086,6 +1104,7 @@ unsafe fn yaml_emitter_emit_alias(
     (*emitter).state = **fresh43;
     1_i32
 }
+
 unsafe fn yaml_emitter_emit_scalar(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -1113,6 +1132,7 @@ unsafe fn yaml_emitter_emit_scalar(
     (*emitter).state = **fresh45;
     1_i32
 }
+
 unsafe fn yaml_emitter_emit_sequence_start(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -1135,6 +1155,7 @@ unsafe fn yaml_emitter_emit_sequence_start(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_emit_mapping_start(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -1157,9 +1178,11 @@ unsafe fn yaml_emitter_emit_mapping_start(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_check_empty_document(_emitter: *mut yaml_emitter_t) -> libc::c_int {
     0_i32
 }
+
 unsafe fn yaml_emitter_check_empty_sequence(emitter: *mut yaml_emitter_t) -> libc::c_int {
     if (((*emitter).events.tail).c_offset_from((*emitter).events.head) as libc::c_long) < 2_i64 {
         return 0_i32;
@@ -1169,6 +1192,7 @@ unsafe fn yaml_emitter_check_empty_sequence(emitter: *mut yaml_emitter_t) -> lib
         && (*((*emitter).events.head).wrapping_offset(1_isize)).type_ as libc::c_uint
             == YAML_SEQUENCE_END_EVENT as libc::c_int as libc::c_uint) as libc::c_int
 }
+
 unsafe fn yaml_emitter_check_empty_mapping(emitter: *mut yaml_emitter_t) -> libc::c_int {
     if (((*emitter).events.tail).c_offset_from((*emitter).events.head) as libc::c_long) < 2_i64 {
         return 0_i32;
@@ -1178,6 +1202,7 @@ unsafe fn yaml_emitter_check_empty_mapping(emitter: *mut yaml_emitter_t) -> libc
         && (*((*emitter).events.head).wrapping_offset(1_isize)).type_ as libc::c_uint
             == YAML_MAPPING_END_EVENT as libc::c_int as libc::c_uint) as libc::c_int
 }
+
 unsafe fn yaml_emitter_check_simple_key(emitter: *mut yaml_emitter_t) -> libc::c_int {
     let event: *mut yaml_event_t = (*emitter).events.head;
     let mut length: size_t = 0_u64;
@@ -1224,6 +1249,7 @@ unsafe fn yaml_emitter_check_simple_key(emitter: *mut yaml_emitter_t) -> libc::c
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_select_scalar_style(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -1290,6 +1316,7 @@ unsafe fn yaml_emitter_select_scalar_style(
     (*emitter).scalar_data.style = style;
     1_i32
 }
+
 unsafe fn yaml_emitter_process_anchor(emitter: *mut yaml_emitter_t) -> libc::c_int {
     if ((*emitter).anchor_data.anchor).is_null() {
         return 1_i32;
@@ -1314,6 +1341,7 @@ unsafe fn yaml_emitter_process_anchor(emitter: *mut yaml_emitter_t) -> libc::c_i
         (*emitter).anchor_data.anchor_length,
     )
 }
+
 unsafe fn yaml_emitter_process_tag(emitter: *mut yaml_emitter_t) -> libc::c_int {
     if ((*emitter).tag_data.handle).is_null() && ((*emitter).tag_data.suffix).is_null() {
         return 1_i32;
@@ -1371,6 +1399,7 @@ unsafe fn yaml_emitter_process_tag(emitter: *mut yaml_emitter_t) -> libc::c_int
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_process_scalar(emitter: *mut yaml_emitter_t) -> libc::c_int {
     match (*emitter).scalar_data.style as libc::c_uint {
         1 => {
@@ -1415,6 +1444,7 @@ unsafe fn yaml_emitter_process_scalar(emitter: *mut yaml_emitter_t) -> libc::c_i
     }
     0_i32
 }
+
 unsafe fn yaml_emitter_analyze_version_directive(
     emitter: *mut yaml_emitter_t,
     version_directive: yaml_version_directive_t,
@@ -1429,6 +1459,7 @@ unsafe fn yaml_emitter_analyze_version_directive(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_analyze_tag_directive(
     emitter: *mut yaml_emitter_t,
     tag_directive: yaml_tag_directive_t,
@@ -1511,6 +1542,7 @@ unsafe fn yaml_emitter_analyze_tag_directive(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_analyze_anchor(
     mut emitter: *mut yaml_emitter_t,
     anchor: *mut yaml_char_t,
@@ -1583,6 +1615,7 @@ unsafe fn yaml_emitter_analyze_anchor(
     (*emitter).anchor_data.alias = alias;
     1_i32
 }
+
 unsafe fn yaml_emitter_analyze_tag(
     mut emitter: *mut yaml_emitter_t,
     tag: *mut yaml_char_t,
@@ -1629,6 +1662,7 @@ unsafe fn yaml_emitter_analyze_tag(
         string.end.c_offset_from(string.start) as libc::c_long as size_t;
     1_i32
 }
+
 unsafe fn yaml_emitter_analyze_scalar(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -2534,6 +2568,7 @@ unsafe fn yaml_emitter_analyze_scalar(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_analyze_event(
     mut emitter: *mut yaml_emitter_t,
     event: *mut yaml_event_t,
@@ -2619,6 +2654,7 @@ unsafe fn yaml_emitter_analyze_event(
         _ => 1_i32,
     }
 }
+
 unsafe fn yaml_emitter_write_bom(emitter: *mut yaml_emitter_t) -> libc::c_int {
     if !(((*emitter).buffer.pointer).wrapping_offset(5_isize) < (*emitter).buffer.end
         || yaml_emitter_flush(emitter) != 0)
@@ -2639,6 +2675,7 @@ unsafe fn yaml_emitter_write_bom(emitter: *mut yaml_emitter_t) -> libc::c_int {
     *fresh61 = -65i32 as yaml_char_t;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_indent(mut emitter: *mut yaml_emitter_t) -> libc::c_int {
     let indent: libc::c_int = if (*emitter).indent >= 0_i32 {
         (*emitter).indent
@@ -2707,6 +2744,7 @@ unsafe fn yaml_emitter_write_indent(mut emitter: *mut yaml_emitter_t) -> libc::c
     (*emitter).indention = 1_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_indicator(
     mut emitter: *mut yaml_emitter_t,
     indicator: *const libc::c_char,
@@ -2817,6 +2855,7 @@ unsafe fn yaml_emitter_write_indicator(
     (*emitter).indention = ((*emitter).indention != 0 && is_indention != 0) as libc::c_int;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_anchor(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -2908,6 +2947,7 @@ unsafe fn yaml_emitter_write_anchor(
     (*emitter).indention = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_tag_handle(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -3015,6 +3055,7 @@ unsafe fn yaml_emitter_write_tag_handle(
     (*emitter).indention = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_tag_content(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -3260,6 +3301,7 @@ unsafe fn yaml_emitter_write_tag_content(
     (*emitter).indention = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_plain_scalar(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -3671,6 +3713,7 @@ unsafe fn yaml_emitter_write_plain_scalar(
     (*emitter).indention = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_single_quoted_scalar(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -4111,6 +4154,7 @@ unsafe fn yaml_emitter_write_single_quoted_scalar(
     (*emitter).indention = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_double_quoted_scalar(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -4792,6 +4836,7 @@ unsafe fn yaml_emitter_write_double_quoted_scalar(
     (*emitter).indention = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_emitter_write_block_scalar_hints(
     mut emitter: *mut yaml_emitter_t,
     mut string: yaml_string_t,
@@ -4905,6 +4950,7 @@ unsafe fn yaml_emitter_write_block_scalar_hints(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_write_literal_scalar(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,
@@ -5195,6 +5241,7 @@ unsafe fn yaml_emitter_write_literal_scalar(
     }
     1_i32
 }
+
 unsafe fn yaml_emitter_write_folded_scalar(
     mut emitter: *mut yaml_emitter_t,
     value: *mut yaml_char_t,

src/loader.rs

@@ -10,12 +10,14 @@ use crate::{
 };
 use core::mem::{size_of, MaybeUninit};
 use core::ptr::{self, addr_of_mut};
+
 #[repr(C)]
 struct loader_ctx {
     start: *mut libc::c_int,
     end: *mut libc::c_int,
     top: *mut libc::c_int,
 }
+
 /// Parse the input stream and produce the next YAML document.
 ///
 /// Call this function subsequently to produce a sequence of documents
@@ -119,6 +121,7 @@ pub unsafe fn yaml_parser_load(
     *fresh8 = ptr::null_mut::<yaml_document_t>();
     0_i32
 }
+
 unsafe fn yaml_parser_set_composer_error(
     mut parser: *mut yaml_parser_t,
     problem: *const libc::c_char,
@@ -130,6 +133,7 @@ unsafe fn yaml_parser_set_composer_error(
     (*parser).problem_mark = problem_mark;
     0_i32
 }
+
 unsafe fn yaml_parser_set_composer_error_context(
     mut parser: *mut yaml_parser_t,
     context: *const libc::c_char,
@@ -146,6 +150,7 @@ unsafe fn yaml_parser_set_composer_error_context(
     (*parser).problem_mark = problem_mark;
     0_i32
 }
+
 unsafe fn yaml_parser_delete_aliases(parser: *mut yaml_parser_t) {
     while !((*parser).aliases.start == (*parser).aliases.top) {
         let fresh12 = addr_of_mut!((*parser).aliases.top);
@@ -160,6 +165,7 @@ unsafe fn yaml_parser_delete_aliases(parser: *mut yaml_parser_t) {
     let fresh15 = addr_of_mut!((*parser).aliases.start);
     *fresh15 = *fresh14;
 }
+
 unsafe fn yaml_parser_load_document(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -206,6 +212,7 @@ unsafe fn yaml_parser_load_document(
     ctx.start = ctx.top;
     1_i32
 }
+
 unsafe fn yaml_parser_load_nodes(
     mut parser: *mut yaml_parser_t,
     ctx: *mut loader_ctx,
@@ -262,6 +269,7 @@ unsafe fn yaml_parser_load_nodes(
     (*(*parser).document).end_mark = (*event).end_mark;
     1_i32
 }
+
 unsafe fn yaml_parser_register_anchor(
     mut parser: *mut yaml_parser_t,
     index: libc::c_int,
@@ -317,6 +325,7 @@ unsafe fn yaml_parser_register_anchor(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_load_node_add(
     mut parser: *mut yaml_parser_t,
     ctx: *mut loader_ctx,
@@ -429,6 +438,7 @@ unsafe fn yaml_parser_load_node_add(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_load_alias(
     parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -455,6 +465,7 @@ unsafe fn yaml_parser_load_alias(
         (*event).start_mark,
     )
 }
+
 unsafe fn yaml_parser_load_scalar(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -542,6 +553,7 @@ unsafe fn yaml_parser_load_scalar(
     yaml_free((*event).data.scalar.value as *mut libc::c_void);
     0_i32
 }
+
 unsafe fn yaml_parser_load_sequence(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -690,6 +702,7 @@ unsafe fn yaml_parser_load_sequence(
     yaml_free((*event).data.sequence_start.anchor as *mut libc::c_void);
     0_i32
 }
+
 unsafe fn yaml_parser_load_sequence_end(
     parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -708,6 +721,7 @@ unsafe fn yaml_parser_load_sequence_end(
     *fresh31 = (*fresh31).wrapping_offset(-1);
     1_i32
 }
+
 unsafe fn yaml_parser_load_mapping(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -856,6 +870,7 @@ unsafe fn yaml_parser_load_mapping(
     yaml_free((*event).data.mapping_start.anchor as *mut libc::c_void);
     0_i32
 }
+
 unsafe fn yaml_parser_load_mapping_end(
     parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,

src/parser.rs

@@ -30,6 +30,7 @@ use crate::{
 };
 use core::mem::size_of;
 use core::ptr::{self, addr_of_mut};
+
 /// Parse the input stream and produce the next parsing event.
 ///
 /// Call the function subsequently to produce a sequence of events corresponding
@@ -63,6 +64,7 @@ pub unsafe fn yaml_parser_parse(
     }
     yaml_parser_state_machine(parser, event)
 }
+
 unsafe fn yaml_parser_set_parser_error(
     mut parser: *mut yaml_parser_t,
     problem: *const libc::c_char,
@@ -74,6 +76,7 @@ unsafe fn yaml_parser_set_parser_error(
     (*parser).problem_mark = problem_mark;
     0_i32
 }
+
 unsafe fn yaml_parser_set_parser_error_context(
     mut parser: *mut yaml_parser_t,
     context: *const libc::c_char,
@@ -90,6 +93,7 @@ unsafe fn yaml_parser_set_parser_error_context(
     (*parser).problem_mark = problem_mark;
     0_i32
 }
+
 unsafe fn yaml_parser_state_machine(
     parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -140,6 +144,7 @@ unsafe fn yaml_parser_state_machine(
     }
     0_i32
 }
+
 unsafe fn yaml_parser_parse_stream_start(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -180,6 +185,7 @@ unsafe fn yaml_parser_parse_stream_start(
     *fresh4 = (*fresh4).wrapping_offset(1);
     1_i32
 }
+
 unsafe fn yaml_parser_parse_document_start(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -383,6 +389,7 @@ unsafe fn yaml_parser_parse_document_start(
         1_i32
     }
 }
+
 unsafe fn yaml_parser_parse_document_content(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -411,6 +418,7 @@ unsafe fn yaml_parser_parse_document_content(
         yaml_parser_parse_node(parser, event, 1_i32, 0_i32)
     }
 }
+
 unsafe fn yaml_parser_parse_document_end(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -459,6 +467,7 @@ unsafe fn yaml_parser_parse_document_end(
     (*event).data.document_end.implicit = implicit;
     1_i32
 }
+
 unsafe fn yaml_parser_parse_node(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -911,6 +920,7 @@ unsafe fn yaml_parser_parse_node(
         0_i32
     }
 }
+
 unsafe fn yaml_parser_parse_block_sequence_entry(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1040,6 +1050,7 @@ unsafe fn yaml_parser_parse_block_sequence_entry(
         )
     }
 }
+
 unsafe fn yaml_parser_parse_indentless_sequence_entry(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1115,6 +1126,7 @@ unsafe fn yaml_parser_parse_indentless_sequence_entry(
         1_i32
     }
 }
+
 unsafe fn yaml_parser_parse_block_mapping_key(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1245,6 +1257,7 @@ unsafe fn yaml_parser_parse_block_mapping_key(
         )
     }
 }
+
 unsafe fn yaml_parser_parse_block_mapping_value(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -1309,6 +1322,7 @@ unsafe fn yaml_parser_parse_block_mapping_value(
         yaml_parser_process_empty_scalar(parser, event, (*token).start_mark)
     }
 }
+
 unsafe fn yaml_parser_parse_flow_sequence_entry(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1466,6 +1480,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry(
     *fresh108 = (*fresh108).wrapping_offset(1);
     1_i32
 }
+
 unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -1518,6 +1533,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
         yaml_parser_process_empty_scalar(parser, event, mark)
     }
 }
+
 unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -1577,6 +1593,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
     (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
     yaml_parser_process_empty_scalar(parser, event, (*token).start_mark)
 }
+
 unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1601,6 +1618,7 @@ unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end(
     (*event).end_mark = (*token).start_mark;
     1_i32
 }
+
 unsafe fn yaml_parser_parse_flow_mapping_key(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1781,6 +1799,7 @@ unsafe fn yaml_parser_parse_flow_mapping_key(
     *fresh133 = (*fresh133).wrapping_offset(1);
     1_i32
 }
+
 unsafe fn yaml_parser_parse_flow_mapping_value(
     mut parser: *mut yaml_parser_t,
     event: *mut yaml_event_t,
@@ -1845,6 +1864,7 @@ unsafe fn yaml_parser_parse_flow_mapping_value(
     (*parser).state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
     yaml_parser_process_empty_scalar(parser, event, (*token).start_mark)
 }
+
 unsafe fn yaml_parser_process_empty_scalar(
     mut parser: *mut yaml_parser_t,
     mut event: *mut yaml_event_t,
@@ -1876,6 +1896,7 @@ unsafe fn yaml_parser_process_empty_scalar(
     (*event).data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
     1_i32
 }
+
 unsafe fn yaml_parser_process_directives(
     mut parser: *mut yaml_parser_t,
     version_directive_ref: *mut *mut yaml_version_directive_t,
@@ -2097,6 +2118,7 @@ unsafe fn yaml_parser_process_directives(
     tag_directives.start = tag_directives.top;
     0_i32
 }
+
 unsafe fn yaml_parser_append_tag_directive(
     mut parser: *mut yaml_parser_t,
     value: yaml_tag_directive_t,

src/reader.rs

@@ -5,6 +5,7 @@ use crate::{
     YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
 };
 use core::ptr::addr_of_mut;
+
 unsafe fn yaml_parser_set_reader_error(
     mut parser: *mut yaml_parser_t,
     problem: *const libc::c_char,
@@ -18,6 +19,7 @@ unsafe fn yaml_parser_set_reader_error(
     (*parser).problem_value = value;
     0_i32
 }
+
 unsafe fn yaml_parser_determine_encoding(mut parser: *mut yaml_parser_t) -> libc::c_int {
     while (*parser).eof == 0
         && (((*parser).raw_buffer.last).c_offset_from((*parser).raw_buffer.pointer) as libc::c_long)
@@ -73,6 +75,7 @@ unsafe fn yaml_parser_determine_encoding(mut parser: *mut yaml_parser_t) -> libc
     }
     1_i32
 }
+
 unsafe fn yaml_parser_update_raw_buffer(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut size_read: size_t = 0_u64;
     if (*parser).raw_buffer.start == (*parser).raw_buffer.pointer
@@ -122,6 +125,7 @@ unsafe fn yaml_parser_update_raw_buffer(mut parser: *mut yaml_parser_t) -> libc:
     }
     1_i32
 }
+
 pub(crate) unsafe fn yaml_parser_update_buffer(
     parser: *mut yaml_parser_t,
     length: size_t,

src/scanner.rs

@@ -19,6 +19,7 @@ use crate::{
 };
 use core::mem::{size_of, MaybeUninit};
 use core::ptr::{self, addr_of_mut};
+
 /// Scan the input stream and produce the next token.
 ///
 /// Call the function subsequently to produce a sequence of tokens corresponding
@@ -64,6 +65,7 @@ pub unsafe fn yaml_parser_scan(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_set_scanner_error(
     mut parser: *mut yaml_parser_t,
     context: *const libc::c_char,
@@ -79,6 +81,7 @@ unsafe fn yaml_parser_set_scanner_error(
     (*parser).problem_mark = (*parser).mark;
     0_i32
 }
+
 pub(crate) unsafe fn yaml_parser_fetch_more_tokens(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut need_more_tokens: libc::c_int;
     loop {
@@ -112,6 +115,7 @@ pub(crate) unsafe fn yaml_parser_fetch_more_tokens(mut parser: *mut yaml_parser_
     (*parser).token_available = 1_i32;
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_next_token(parser: *mut yaml_parser_t) -> libc::c_int {
     if if (*parser).unread >= 1_u64 {
         1_i32
@@ -522,6 +526,7 @@ unsafe fn yaml_parser_fetch_next_token(parser: *mut yaml_parser_t) -> libc::c_in
         b"found character that cannot start any token\0" as *const u8 as *const libc::c_char,
     )
 }
+
 unsafe fn yaml_parser_stale_simple_keys(parser: *mut yaml_parser_t) -> libc::c_int {
     let mut simple_key: *mut yaml_simple_key_t;
     simple_key = (*parser).simple_keys.start;
@@ -544,6 +549,7 @@ unsafe fn yaml_parser_stale_simple_keys(parser: *mut yaml_parser_t) -> libc::c_i
     }
     1_i32
 }
+
 unsafe fn yaml_parser_save_simple_key(parser: *mut yaml_parser_t) -> libc::c_int {
     let required: libc::c_int = ((*parser).flow_level == 0
         && (*parser).indent as libc::c_long == (*parser).mark.column as ptrdiff_t)
@@ -564,6 +570,7 @@ unsafe fn yaml_parser_save_simple_key(parser: *mut yaml_parser_t) -> libc::c_int
     }
     1_i32
 }
+
 unsafe fn yaml_parser_remove_simple_key(parser: *mut yaml_parser_t) -> libc::c_int {
     let mut simple_key: *mut yaml_simple_key_t =
         ((*parser).simple_keys.top).wrapping_offset(-(1_isize));
@@ -580,6 +587,7 @@ unsafe fn yaml_parser_remove_simple_key(parser: *mut yaml_parser_t) -> libc::c_i
     (*simple_key).possible = 0_i32;
     1_i32
 }
+
 unsafe fn yaml_parser_increase_flow_level(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let empty_simple_key = yaml_simple_key_t {
         possible: 0_i32,
@@ -618,6 +626,7 @@ unsafe fn yaml_parser_increase_flow_level(mut parser: *mut yaml_parser_t) -> lib
     *fresh7 += 1;
     1_i32
 }
+
 unsafe fn yaml_parser_decrease_flow_level(parser: *mut yaml_parser_t) -> libc::c_int {
     if (*parser).flow_level != 0 {
         let fresh8 = addr_of_mut!((*parser).flow_level);
@@ -627,6 +636,7 @@ unsafe fn yaml_parser_decrease_flow_level(parser: *mut yaml_parser_t) -> libc::c
     }
     1_i32
 }
+
 unsafe fn yaml_parser_roll_indent(
     mut parser: *mut yaml_parser_t,
     column: ptrdiff_t,
@@ -731,6 +741,7 @@ unsafe fn yaml_parser_roll_indent(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_unroll_indent(
     mut parser: *mut yaml_parser_t,
     column: ptrdiff_t,
@@ -775,6 +786,7 @@ unsafe fn yaml_parser_unroll_indent(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_stream_start(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let simple_key = yaml_simple_key_t {
         possible: 0_i32,
@@ -841,6 +853,7 @@ unsafe fn yaml_parser_fetch_stream_start(mut parser: *mut yaml_parser_t) -> libc
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_stream_end(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -886,6 +899,7 @@ unsafe fn yaml_parser_fetch_stream_end(mut parser: *mut yaml_parser_t) -> libc::
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_directive(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -922,6 +936,7 @@ unsafe fn yaml_parser_fetch_directive(mut parser: *mut yaml_parser_t) -> libc::c
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_document_indicator(
     mut parser: *mut yaml_parser_t,
     type_: yaml_token_type_t,
@@ -1048,6 +1063,7 @@ unsafe fn yaml_parser_fetch_document_indicator(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_flow_collection_start(
     mut parser: *mut yaml_parser_t,
     type_: yaml_token_type_t,
@@ -1120,6 +1136,7 @@ unsafe fn yaml_parser_fetch_flow_collection_start(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_flow_collection_end(
     mut parser: *mut yaml_parser_t,
     type_: yaml_token_type_t,
@@ -1192,6 +1209,7 @@ unsafe fn yaml_parser_fetch_flow_collection_end(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_flow_entry(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -1258,6 +1276,7 @@ unsafe fn yaml_parser_fetch_flow_entry(mut parser: *mut yaml_parser_t) -> libc::
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_block_entry(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -1345,6 +1364,7 @@ unsafe fn yaml_parser_fetch_block_entry(mut parser: *mut yaml_parser_t) -> libc:
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_key(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -1432,6 +1452,7 @@ unsafe fn yaml_parser_fetch_key(mut parser: *mut yaml_parser_t) -> libc::c_int {
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_value(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -1578,6 +1599,7 @@ unsafe fn yaml_parser_fetch_value(mut parser: *mut yaml_parser_t) -> libc::c_int
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_anchor(
     mut parser: *mut yaml_parser_t,
     type_: yaml_token_type_t,
@@ -1614,6 +1636,7 @@ unsafe fn yaml_parser_fetch_anchor(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_tag(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -1647,6 +1670,7 @@ unsafe fn yaml_parser_fetch_tag(mut parser: *mut yaml_parser_t) -> libc::c_int {
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_block_scalar(
     mut parser: *mut yaml_parser_t,
     literal: libc::c_int,
@@ -1683,6 +1707,7 @@ unsafe fn yaml_parser_fetch_block_scalar(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_flow_scalar(
     mut parser: *mut yaml_parser_t,
     single: libc::c_int,
@@ -1719,6 +1744,7 @@ unsafe fn yaml_parser_fetch_flow_scalar(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_fetch_plain_scalar(mut parser: *mut yaml_parser_t) -> libc::c_int {
     let mut token = MaybeUninit::<yaml_token_t>::uninit();
     let token = token.as_mut_ptr();
@@ -1752,6 +1778,7 @@ unsafe fn yaml_parser_fetch_plain_scalar(mut parser: *mut yaml_parser_t) -> libc
     }
     1_i32
 }
+
 unsafe fn yaml_parser_scan_to_next_token(mut parser: *mut yaml_parser_t) -> libc::c_int {
     loop {
         if if (*parser).unread >= 1_u64 {
@@ -2029,6 +2056,7 @@ unsafe fn yaml_parser_scan_to_next_token(mut parser: *mut yaml_parser_t) -> libc
     }
     1_i32
 }
+
 unsafe fn yaml_parser_scan_directive(
     mut parser: *mut yaml_parser_t,
     mut token: *mut yaml_token_t,
@@ -2525,6 +2553,7 @@ unsafe fn yaml_parser_scan_directive(
     yaml_free(name as *mut libc::c_void);
     0_i32
 }
+
 unsafe fn yaml_parser_scan_directive_name(
     mut parser: *mut yaml_parser_t,
     start_mark: yaml_mark_t,
@@ -2740,6 +2769,7 @@ unsafe fn yaml_parser_scan_directive_name(
     string.start = string.pointer;
     0_i32
 }
+
 unsafe fn yaml_parser_scan_version_directive_value(
     parser: *mut yaml_parser_t,
     start_mark: yaml_mark_t,
@@ -2841,6 +2871,7 @@ unsafe fn yaml_parser_scan_version_directive_value(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_scan_version_directive_number(
     parser: *mut yaml_parser_t,
     start_mark: yaml_mark_t,
@@ -2921,6 +2952,7 @@ unsafe fn yaml_parser_scan_version_directive_number(
     *number = value;
     1_i32
 }
+
 unsafe fn yaml_parser_scan_tag_directive_value(
     parser: *mut yaml_parser_t,
     start_mark: yaml_mark_t,
@@ -3163,6 +3195,7 @@ unsafe fn yaml_parser_scan_tag_directive_value(
         }
     }
 }
+
 unsafe fn yaml_parser_scan_anchor(
     mut parser: *mut yaml_parser_t,
     mut token: *mut yaml_token_t,
@@ -3456,6 +3489,7 @@ unsafe fn yaml_parser_scan_anchor(
     string.start = string.pointer;
     0_i32
 }
+
 unsafe fn yaml_parser_scan_tag(
     parser: *mut yaml_parser_t,
     mut token: *mut yaml_token_t,
@@ -3738,6 +3772,7 @@ unsafe fn yaml_parser_scan_tag(
     yaml_free(suffix as *mut libc::c_void);
     0_i32
 }
+
 unsafe fn yaml_parser_scan_tag_handle(
     mut parser: *mut yaml_parser_t,
     directive: libc::c_int,
@@ -4149,6 +4184,7 @@ unsafe fn yaml_parser_scan_tag_handle(
     string.start = string.pointer;
     0_i32
 }
+
 unsafe fn yaml_parser_scan_tag_uri(
     mut parser: *mut yaml_parser_t,
     uri_char: libc::c_int,
@@ -4461,6 +4497,7 @@ unsafe fn yaml_parser_scan_tag_uri(
         }
     }
 }
+
 unsafe fn yaml_parser_scan_uri_escapes(
     parser: *mut yaml_parser_t,
     directive: libc::c_int,
@@ -4687,6 +4724,7 @@ unsafe fn yaml_parser_scan_uri_escapes(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_scan_block_scalar(
     mut parser: *mut yaml_parser_t,
     mut token: *mut yaml_token_t,
@@ -6054,6 +6092,7 @@ unsafe fn yaml_parser_scan_block_scalar(
     trailing_breaks.start = trailing_breaks.pointer;
     0_i32
 }
+
 unsafe fn yaml_parser_scan_block_scalar_breaks(
     mut parser: *mut yaml_parser_t,
     indent: *mut libc::c_int,
@@ -6287,6 +6326,7 @@ unsafe fn yaml_parser_scan_block_scalar_breaks(
     }
     1_i32
 }
+
 unsafe fn yaml_parser_scan_flow_scalar(
     mut parser: *mut yaml_parser_t,
     mut token: *mut yaml_token_t,
@@ -8229,6 +8269,7 @@ unsafe fn yaml_parser_scan_flow_scalar(
     whitespaces.start = whitespaces.pointer;
     0_i32
 }
+
 unsafe fn yaml_parser_scan_plain_scalar(
     mut parser: *mut yaml_parser_t,
     mut token: *mut yaml_token_t,

src/writer.rs

@@ -3,6 +3,7 @@ use crate::{
     libc, yaml_emitter_t, PointerExt, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING, YAML_WRITER_ERROR,
 };
 use core::ptr::addr_of_mut;
+
 unsafe fn yaml_emitter_set_writer_error(
     mut emitter: *mut yaml_emitter_t,
     problem: *const libc::c_char,
@@ -12,6 +13,7 @@ unsafe fn yaml_emitter_set_writer_error(
     *fresh0 = problem;
     0_i32
 }
+
 /// Flush the accumulated characters to the output.
 ///
 /// Returns 1 if the function succeeded, 0 on error.

src/yaml.rs

@@ -1,10 +1,12 @@
+use crate::libc;
+
 pub use self::{
     yaml_break_t::*, yaml_emitter_state_t::*, yaml_encoding_t::*, yaml_error_type_t::*,
     yaml_event_type_t::*, yaml_mapping_style_t::*, yaml_node_type_t::*, yaml_parser_state_t::*,
     yaml_scalar_style_t::*, yaml_sequence_style_t::*, yaml_token_type_t::*,
 };
-use crate::libc;
 pub use core::primitive::{i64 as ptrdiff_t, u64 as size_t, u8 as yaml_char_t};
+
 /// The version directive data.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -15,6 +17,7 @@ pub struct yaml_version_directive_t {
     /// The minor version number.
     pub minor: libc::c_int,
 }
+
 /// The tag directive data.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -25,6 +28,7 @@ pub struct yaml_tag_directive_t {
     /// The tag prefix.
     pub prefix: *mut yaml_char_t,
 }
+
 /// The stream encoding.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -39,6 +43,7 @@ pub enum yaml_encoding_t {
     /// The UTF-16-BE encoding with BOM.
     YAML_UTF16BE_ENCODING = 3,
 }
+
 /// Line break type.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -53,6 +58,7 @@ pub enum yaml_break_t {
     /// Use CR LN for line breaks (DOS style).
     YAML_CRLN_BREAK = 3,
 }
+
 /// Many bad things could happen with the parser and emitter.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -75,6 +81,7 @@ pub enum yaml_error_type_t {
     /// Cannot emit a YAML stream.
     YAML_EMITTER_ERROR = 7,
 }
+
 /// The pointer position.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -87,6 +94,7 @@ pub struct yaml_mark_t {
     /// The position column.
     pub column: size_t,
 }
+
 /// Scalar styles.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -105,6 +113,7 @@ pub enum yaml_scalar_style_t {
     /// The folded scalar style.
     YAML_FOLDED_SCALAR_STYLE = 5,
 }
+
 /// Sequence styles.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -117,6 +126,7 @@ pub enum yaml_sequence_style_t {
     /// The flow sequence style.
     YAML_FLOW_SEQUENCE_STYLE = 2,
 }
+
 /// Mapping styles.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -129,6 +139,7 @@ pub enum yaml_mapping_style_t {
     /// The flow mapping style.
     YAML_FLOW_MAPPING_STYLE = 2,
 }
+
 /// Token types.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -179,6 +190,7 @@ pub enum yaml_token_type_t {
     /// A SCALAR token.
     YAML_SCALAR_TOKEN = 21,
 }
+
 /// The token structure.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -193,6 +205,7 @@ pub struct yaml_token_t {
     /// The end of the token.
     pub end_mark: yaml_mark_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub union unnamed_yaml_token_t_data {
@@ -211,6 +224,7 @@ pub union unnamed_yaml_token_t_data {
     /// The tag directive (for YAML_TAG_DIRECTIVE_TOKEN).
     pub tag_directive: unnamed_yaml_token_t_data_tag_directive,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -218,6 +232,7 @@ pub struct unnamed_yaml_token_t_data_stream_start {
     /// The stream encoding.
     pub encoding: yaml_encoding_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -225,6 +240,7 @@ pub struct unnamed_yaml_token_t_data_alias {
     /// The alias value.
     pub value: *mut yaml_char_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -232,6 +248,7 @@ pub struct unnamed_yaml_token_t_data_anchor {
     /// The anchor value.
     pub value: *mut yaml_char_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -241,6 +258,7 @@ pub struct unnamed_yaml_token_t_data_tag {
     /// The tag suffix.
     pub suffix: *mut yaml_char_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -252,6 +270,7 @@ pub struct unnamed_yaml_token_t_data_scalar {
     /// The scalar style.
     pub style: yaml_scalar_style_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -261,6 +280,7 @@ pub struct unnamed_yaml_token_t_data_version_directive {
     /// The minor version number.
     pub minor: libc::c_int,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -270,6 +290,7 @@ pub struct unnamed_yaml_token_t_data_tag_directive {
     /// The tag prefix.
     pub prefix: *mut yaml_char_t,
 }
+
 /// Event types.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -298,6 +319,7 @@ pub enum yaml_event_type_t {
     /// A MAPPING-END event.
     YAML_MAPPING_END_EVENT = 10,
 }
+
 /// The event structure.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -312,6 +334,7 @@ pub struct yaml_event_t {
     /// The end of the event.
     pub end_mark: yaml_mark_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub union unnamed_yaml_event_t_data {
@@ -330,6 +353,7 @@ pub union unnamed_yaml_event_t_data {
     /// The mapping parameters (for YAML_MAPPING_START_EVENT).
     pub mapping_start: unnamed_yaml_event_t_data_mapping_start,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -337,6 +361,7 @@ pub struct unnamed_yaml_event_t_data_stream_start {
     /// The document encoding.
     pub encoding: yaml_encoding_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -348,6 +373,7 @@ pub struct unnamed_yaml_event_t_data_document_start {
     /// Is the document indicator implicit?
     pub implicit: libc::c_int,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -357,6 +383,7 @@ pub struct unnamed_yaml_event_t_data_document_start_tag_directives {
     /// The end of the tag directives list.
     pub end: *mut yaml_tag_directive_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -364,6 +391,7 @@ pub struct unnamed_yaml_event_t_data_document_end {
     /// Is the document end indicator implicit?
     pub implicit: libc::c_int,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -371,6 +399,7 @@ pub struct unnamed_yaml_event_t_data_alias {
     /// The anchor.
     pub anchor: *mut yaml_char_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -390,6 +419,7 @@ pub struct unnamed_yaml_event_t_data_scalar {
     /// The scalar style.
     pub style: yaml_scalar_style_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -403,6 +433,7 @@ pub struct unnamed_yaml_event_t_data_sequence_start {
     /// The sequence style.
     pub style: yaml_sequence_style_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -416,6 +447,7 @@ pub struct unnamed_yaml_event_t_data_mapping_start {
     /// The mapping style.
     pub style: yaml_mapping_style_t,
 }
+
 /// Node types.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -430,6 +462,7 @@ pub enum yaml_node_type_t {
     /// A mapping node.
     YAML_MAPPING_NODE = 3,
 }
+
 /// The node structure.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -446,6 +479,7 @@ pub struct yaml_node_t {
     /// The end of the node.
     pub end_mark: yaml_mark_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub union unnamed_yaml_node_t_data {
@@ -456,6 +490,7 @@ pub union unnamed_yaml_node_t_data {
     /// The mapping parameters (for YAML_MAPPING_NODE).
     pub mapping: unnamed_yaml_node_t_data_mapping,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -467,8 +502,10 @@ pub struct unnamed_yaml_node_t_data_scalar {
     /// The scalar style.
     pub style: yaml_scalar_style_t,
 }
+
 /// An element of a sequence node.
 pub type yaml_node_item_t = libc::c_int;
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -478,6 +515,7 @@ pub struct unnamed_yaml_node_t_data_sequence {
     /// The sequence style.
     pub style: yaml_sequence_style_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -489,6 +527,7 @@ pub struct unnamed_yaml_node_t_data_sequence_items {
     /// The top of the stack.
     pub top: *mut yaml_node_item_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -498,6 +537,7 @@ pub struct unnamed_yaml_node_t_data_mapping {
     /// The mapping style.
     pub style: yaml_mapping_style_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -509,6 +549,7 @@ pub struct unnamed_yaml_node_t_data_mapping_pairs {
     /// The top of the stack.
     pub top: *mut yaml_node_pair_t,
 }
+
 /// An element of a mapping node.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -519,6 +560,7 @@ pub struct yaml_node_pair_t {
     /// The value of the element.
     pub value: libc::c_int,
 }
+
 /// The document structure.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -539,6 +581,7 @@ pub struct yaml_document_t {
     /// The end of the document.
     pub end_mark: yaml_mark_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -550,6 +593,7 @@ pub struct unnamed_yaml_document_t_nodes {
     /// The top of the stack.
     pub top: *mut yaml_node_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -559,6 +603,7 @@ pub struct unnamed_yaml_document_t_tag_directives {
     /// The end of the tag directives list.
     pub end: *mut yaml_tag_directive_t,
 }
+
 /// The prototype of a read handler.
 ///
 /// The read handler is called when the parser needs to read more bytes from the
@@ -574,6 +619,7 @@ pub type yaml_read_handler_t = unsafe fn(
     size: size_t,
     size_read: *mut size_t,
 ) -> libc::c_int;
+
 /// This structure holds information about a potential simple key.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -588,6 +634,7 @@ pub struct yaml_simple_key_t {
     /// The position mark.
     pub mark: yaml_mark_t,
 }
+
 /// The states of the parser.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -642,6 +689,7 @@ pub enum yaml_parser_state_t {
     /// Expect nothing.
     YAML_PARSE_END_STATE = 23,
 }
+
 /// This structure holds aliases data.
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -654,6 +702,7 @@ pub struct yaml_alias_data_t {
     /// The anchor mark.
     pub mark: yaml_mark_t,
 }
+
 /// The parser structure.
 ///
 /// All members are internal. Manage the structure using the `yaml_parser_`
@@ -731,12 +780,14 @@ pub struct yaml_parser_t {
     /// The currently parsed document.
     pub(crate) document: *mut yaml_document_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub(crate) union unnamed_yaml_parser_t_input {
     /// String input data.
     pub string: unnamed_yaml_parser_t_input_string,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -748,6 +799,7 @@ pub(crate) struct unnamed_yaml_parser_t_input_string {
     /// The string current position.
     pub current: *const libc::c_uchar,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -761,6 +813,7 @@ pub(crate) struct unnamed_yaml_parser_t_buffer {
     /// The last filled position of the buffer.
     pub last: *mut yaml_char_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -774,6 +827,7 @@ pub(crate) struct unnamed_yaml_parser_t_raw_buffer {
     /// The last filled position of the buffer.
     pub last: *mut libc::c_uchar,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -787,6 +841,7 @@ pub(crate) struct unnamed_yaml_parser_t_tokens {
     /// The tail of the tokens queue.
     pub tail: *mut yaml_token_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -798,6 +853,7 @@ pub(crate) struct unnamed_yaml_parser_t_indents {
     /// The top of the stack.
     pub top: *mut libc::c_int,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -809,6 +865,7 @@ pub(crate) struct unnamed_yaml_parser_t_simple_keys {
     /// The top of the stack.
     pub top: *mut yaml_simple_key_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -820,6 +877,7 @@ pub(crate) struct unnamed_yaml_parser_t_states {
     /// The top of the stack.
     pub top: *mut yaml_parser_state_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -831,6 +889,7 @@ pub(crate) struct unnamed_yaml_parser_t_marks {
     /// The top of the stack.
     pub top: *mut yaml_mark_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -842,6 +901,7 @@ pub(crate) struct unnamed_yaml_parser_t_tag_directives {
     /// The top of the list.
     pub top: *mut yaml_tag_directive_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -853,6 +913,7 @@ pub(crate) struct unnamed_yaml_parser_t_aliases {
     /// The top of the list.
     pub top: *mut yaml_alias_data_t,
 }
+
 /// The prototype of a write handler.
 ///
 /// The write handler is called when the emitter needs to flush the accumulated
@@ -863,6 +924,7 @@ pub(crate) struct unnamed_yaml_parser_t_aliases {
 /// value should be 0.
 pub type yaml_write_handler_t =
     unsafe fn(data: *mut libc::c_void, buffer: *mut libc::c_uchar, size: size_t) -> libc::c_int;
+
 /// The emitter states.
 #[derive(Copy, Clone)]
 #[repr(u32)]
@@ -905,6 +967,7 @@ pub enum yaml_emitter_state_t {
     /// Expect nothing.
     YAML_EMIT_END_STATE = 17,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -916,6 +979,7 @@ pub(crate) struct yaml_anchors_t {
     /// If the node has been emitted?
     pub serialized: libc::c_int,
 }
+
 /// The emitter structure.
 ///
 /// All members are internal. Manage the structure using the `yaml_emitter_`
@@ -1001,12 +1065,14 @@ pub struct yaml_emitter_t {
     /// The currently emitted document.
     pub(crate) document: *mut yaml_document_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub(crate) union unnamed_yaml_emitter_t_output {
     /// String output data.
     pub string: unnamed_yaml_emitter_t_output_string,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1018,6 +1084,7 @@ pub(crate) struct unnamed_yaml_emitter_t_output_string {
     /// The number of written bytes.
     pub size_written: *mut size_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1031,6 +1098,7 @@ pub(crate) struct unnamed_yaml_emitter_t_buffer {
     /// The last filled position of the buffer.
     pub last: *mut yaml_char_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1044,6 +1112,7 @@ pub(crate) struct unnamed_yaml_emitter_t_raw_buffer {
     /// The last filled position of the buffer.
     pub last: *mut libc::c_uchar,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1055,6 +1124,7 @@ pub(crate) struct unnamed_yaml_emitter_t_states {
     /// The top of the stack.
     pub top: *mut yaml_emitter_state_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1068,6 +1138,7 @@ pub(crate) struct unnamed_yaml_emitter_t_events {
     /// The tail of the event queue.
     pub tail: *mut yaml_event_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1079,6 +1150,7 @@ pub(crate) struct unnamed_yaml_emitter_t_indents {
     /// The top of the stack.
     pub top: *mut libc::c_int,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1090,6 +1162,7 @@ pub(crate) struct unnamed_yaml_emitter_t_tag_directives {
     /// The top of the list.
     pub top: *mut yaml_tag_directive_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1101,6 +1174,7 @@ pub(crate) struct unnamed_yaml_emitter_t_anchor_data {
     /// Is it an alias?
     pub alias: libc::c_int,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1114,6 +1188,7 @@ pub(crate) struct unnamed_yaml_emitter_t_tag_data {
     /// The tag suffix length.
     pub suffix_length: size_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]
@@ -1135,6 +1210,7 @@ pub(crate) struct unnamed_yaml_emitter_t_scalar_data {
     /// The output style.
     pub style: yaml_scalar_style_t,
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 #[non_exhaustive]