chore: checkpoint before Python removal

vendor/unsafe-libyaml/src/bin/cstr/mod.rs

@@ -0,0 +1,47 @@
+use std::fmt::{self, Display, Write as _};
+use std::slice;
+use std::str;
+
+#[allow(non_camel_case_types)]
+type c_char = i8;
+
+pub struct CStr {
+    ptr: *const u8,
+}
+
+impl CStr {
+    pub unsafe fn from_ptr(ptr: *const c_char) -> Self {
+        CStr { ptr: ptr.cast() }
+    }
+}
+
+impl Display for CStr {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let len = unsafe { strlen(self.ptr) };
+        let mut bytes = unsafe { slice::from_raw_parts(self.ptr, len) };
+        loop {
+            match str::from_utf8(bytes) {
+                Ok(valid) => return formatter.write_str(valid),
+                Err(utf8_error) => {
+                    let valid_up_to = utf8_error.valid_up_to();
+                    let valid = unsafe { str::from_utf8_unchecked(&bytes[..valid_up_to]) };
+                    formatter.write_str(valid)?;
+                    formatter.write_char(char::REPLACEMENT_CHARACTER)?;
+                    if let Some(error_len) = utf8_error.error_len() {
+                        bytes = &bytes[valid_up_to + error_len..];
+                    } else {
+                        return Ok(());
+                    }
+                }
+            }
+        }
+    }
+}
+
+unsafe fn strlen(s: *const u8) -> usize {
+    let mut end = s;
+    while *end != 0 {
+        end = end.add(1);
+    }
+    end.offset_from(s) as usize
+}

vendor/unsafe-libyaml/src/bin/run-emitter-test-suite.rs

@@ -0,0 +1,307 @@
+#![warn(clippy::pedantic)]
+#![allow(
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_sign_loss,
+    clippy::items_after_statements,
+    clippy::let_underscore_untyped,
+    clippy::missing_errors_doc,
+    clippy::missing_safety_doc,
+    clippy::ptr_as_ptr,
+    clippy::single_match_else,
+    clippy::too_many_lines,
+    clippy::unreadable_literal
+)]
+
+mod cstr;
+
+use self::cstr::CStr;
+use std::env;
+use std::error::Error;
+use std::ffi::c_void;
+use std::fs::File;
+use std::io::{self, Read, Write};
+use std::mem::MaybeUninit;
+use std::process::{self, ExitCode};
+use std::ptr::{self, addr_of_mut};
+use std::slice;
+use unsafe_libyaml::{
+    yaml_alias_event_initialize, yaml_document_end_event_initialize,
+    yaml_document_start_event_initialize, yaml_emitter_delete, yaml_emitter_emit,
+    yaml_emitter_initialize, yaml_emitter_set_canonical, yaml_emitter_set_output,
+    yaml_emitter_set_unicode, yaml_emitter_t, yaml_event_t, yaml_mapping_end_event_initialize,
+    yaml_mapping_start_event_initialize, yaml_scalar_event_initialize, yaml_scalar_style_t,
+    yaml_sequence_end_event_initialize, yaml_sequence_start_event_initialize,
+    yaml_stream_end_event_initialize, yaml_stream_start_event_initialize, yaml_tag_directive_t,
+    yaml_version_directive_t, YAML_ANY_SCALAR_STYLE, YAML_BLOCK_MAPPING_STYLE,
+    YAML_BLOCK_SEQUENCE_STYLE, YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_EMITTER_ERROR,
+    YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE, YAML_MEMORY_ERROR,
+    YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE, YAML_UTF8_ENCODING,
+    YAML_WRITER_ERROR,
+};
+
+pub(crate) unsafe fn unsafe_main(
+    stdin: &mut dyn Read,
+    mut stdout: &mut dyn Write,
+) -> Result<(), Box<dyn Error>> {
+    let mut emitter = MaybeUninit::<yaml_emitter_t>::uninit();
+    let emitter = emitter.as_mut_ptr();
+    if yaml_emitter_initialize(emitter).fail {
+        return Err("Could not initialize the emitter object".into());
+    }
+
+    unsafe fn write_to_stdio(data: *mut c_void, buffer: *mut u8, size: u64) -> i32 {
+        let stdout: *mut &mut dyn Write = data.cast();
+        let bytes = slice::from_raw_parts(buffer.cast(), size as usize);
+        match (*stdout).write(bytes) {
+            Ok(n) => n as i32,
+            Err(_) => 0,
+        }
+    }
+
+    yaml_emitter_set_output(emitter, write_to_stdio, addr_of_mut!(stdout).cast());
+    yaml_emitter_set_canonical(emitter, false);
+    yaml_emitter_set_unicode(emitter, false);
+
+    let mut buf = ReadBuf::new();
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let result = loop {
+        let line = match buf.get_line(stdin) {
+            Some(line) => line,
+            None => break Ok(()),
+        };
+
+        let mut anchor = [0u8; 256];
+        let mut tag = [0u8; 256];
+        let result = if line.starts_with(b"+STR") {
+            yaml_stream_start_event_initialize(event, YAML_UTF8_ENCODING)
+        } else if line.starts_with(b"-STR") {
+            yaml_stream_end_event_initialize(event)
+        } else if line.starts_with(b"+DOC") {
+            let implicit = !line[4..].starts_with(b" ---");
+            yaml_document_start_event_initialize(
+                event,
+                ptr::null_mut::<yaml_version_directive_t>(),
+                ptr::null_mut::<yaml_tag_directive_t>(),
+                ptr::null_mut::<yaml_tag_directive_t>(),
+                implicit,
+            )
+        } else if line.starts_with(b"-DOC") {
+            let implicit = !line[4..].starts_with(b" ...");
+            yaml_document_end_event_initialize(event, implicit)
+        } else if line.starts_with(b"+MAP") {
+            yaml_mapping_start_event_initialize(
+                event,
+                get_anchor(b'&', line, anchor.as_mut_ptr()),
+                get_tag(line, tag.as_mut_ptr()),
+                false,
+                YAML_BLOCK_MAPPING_STYLE,
+            )
+        } else if line.starts_with(b"-MAP") {
+            yaml_mapping_end_event_initialize(event)
+        } else if line.starts_with(b"+SEQ") {
+            yaml_sequence_start_event_initialize(
+                event,
+                get_anchor(b'&', line, anchor.as_mut_ptr()),
+                get_tag(line, tag.as_mut_ptr()),
+                false,
+                YAML_BLOCK_SEQUENCE_STYLE,
+            )
+        } else if line.starts_with(b"-SEQ") {
+            yaml_sequence_end_event_initialize(event)
+        } else if line.starts_with(b"=VAL") {
+            let mut value = [0i8; 1024];
+            let mut style = YAML_ANY_SCALAR_STYLE;
+            get_value(line, value.as_mut_ptr(), &mut style);
+            let implicit = get_tag(line, tag.as_mut_ptr()).is_null();
+            yaml_scalar_event_initialize(
+                event,
+                get_anchor(b'&', line, anchor.as_mut_ptr()),
+                get_tag(line, tag.as_mut_ptr()),
+                value.as_mut_ptr() as *mut u8,
+                -1,
+                implicit,
+                implicit,
+                style,
+            )
+        } else if line.starts_with(b"=ALI") {
+            yaml_alias_event_initialize(event, get_anchor(b'*', line, anchor.as_mut_ptr()))
+        } else {
+            let line = line as *mut [u8] as *mut i8;
+            break Err(format!("Unknown event: '{}'", CStr::from_ptr(line)).into());
+        };
+
+        if result.fail {
+            break Err("Memory error: Not enough memory for creating an event".into());
+        }
+        if yaml_emitter_emit(emitter, event).fail {
+            break Err(match (*emitter).error {
+                YAML_MEMORY_ERROR => "Memory error: Not enough memory for emitting".into(),
+                YAML_WRITER_ERROR => {
+                    format!("Writer error: {}", CStr::from_ptr((*emitter).problem)).into()
+                }
+                YAML_EMITTER_ERROR => {
+                    format!("Emitter error: {}", CStr::from_ptr((*emitter).problem)).into()
+                }
+                // Couldn't happen.
+                _ => "Internal error".into(),
+            });
+        }
+    };
+
+    yaml_emitter_delete(emitter);
+    result
+}
+
+struct ReadBuf {
+    buf: [u8; 1024],
+    offset: usize,
+    filled: usize,
+}
+
+impl ReadBuf {
+    fn new() -> Self {
+        ReadBuf {
+            buf: [0; 1024],
+            offset: 0,
+            filled: 0,
+        }
+    }
+
+    fn get_line(&mut self, input: &mut dyn Read) -> Option<&mut [u8]> {
+        loop {
+            for i in self.offset..self.offset + self.filled {
+                if self.buf[i] == b'\n' {
+                    self.buf[i] = b'\0';
+                    let line = &mut self.buf[self.offset..=i];
+                    self.offset = i + 1;
+                    self.filled -= line.len();
+                    return Some(line);
+                }
+            }
+            let mut remainder = &mut self.buf[self.offset + self.filled..];
+            if remainder.is_empty() {
+                if self.offset == 0 {
+                    let _ = writeln!(
+                        io::stderr(),
+                        "Line too long: '{}'",
+                        String::from_utf8_lossy(&self.buf),
+                    );
+                    process::abort();
+                }
+                self.buf.copy_within(self.offset.., 0);
+                self.offset = 0;
+                remainder = &mut self.buf;
+            }
+            let n = input.read(remainder).ok()?;
+            self.filled += n;
+            if n == 0 {
+                return None;
+            }
+        }
+    }
+}
+
+unsafe fn get_anchor(sigil: u8, line: &[u8], anchor: *mut u8) -> *mut u8 {
+    let start = match line.iter().position(|ch| *ch == sigil) {
+        Some(offset) => offset + 1,
+        None => return ptr::null_mut::<u8>(),
+    };
+    let end = match line[start..].iter().position(|ch| *ch == b' ') {
+        Some(offset) => start + offset,
+        None => line.len(),
+    };
+    ptr::copy_nonoverlapping(line[start..end].as_ptr(), anchor, end - start);
+    *anchor.add(end - start) = b'\0';
+    anchor
+}
+
+unsafe fn get_tag(line: &[u8], tag: *mut u8) -> *mut u8 {
+    let start = match line.iter().position(|ch| *ch == b'<') {
+        Some(offset) => offset + 1,
+        None => return ptr::null_mut::<u8>(),
+    };
+    let end = match line[start..].iter().position(|ch| *ch == b'>') {
+        Some(offset) => start + offset,
+        None => return ptr::null_mut::<u8>(),
+    };
+    ptr::copy_nonoverlapping(line[start..end].as_ptr(), tag, end - start);
+    *tag.add(end - start) = b'\0';
+    tag
+}
+
+unsafe fn get_value(line: &[u8], value: *mut i8, style: *mut yaml_scalar_style_t) {
+    let line_len = line.len();
+    let line = line as *const [u8] as *mut i8;
+    let mut start = ptr::null_mut::<i8>();
+    let end = line.add(line_len);
+    let mut c = line.offset(4);
+    while c < end {
+        if *c as u8 == b' ' {
+            start = c.offset(1);
+            *style = match *start as u8 {
+                b':' => YAML_PLAIN_SCALAR_STYLE,
+                b'\'' => YAML_SINGLE_QUOTED_SCALAR_STYLE,
+                b'"' => YAML_DOUBLE_QUOTED_SCALAR_STYLE,
+                b'|' => YAML_LITERAL_SCALAR_STYLE,
+                b'>' => YAML_FOLDED_SCALAR_STYLE,
+                _ => {
+                    start = ptr::null_mut::<i8>();
+                    c = c.offset(1);
+                    continue;
+                }
+            };
+            start = start.offset(1);
+            break;
+        }
+        c = c.offset(1);
+    }
+    if start.is_null() {
+        process::abort();
+    }
+
+    let mut i = 0;
+    c = start;
+    while c < end {
+        *value.offset(i) = if *c as u8 == b'\\' {
+            c = c.offset(1);
+            match *c as u8 {
+                b'\\' => b'\\' as i8,
+                b'0' => b'\0' as i8,
+                b'b' => b'\x08' as i8,
+                b'n' => b'\n' as i8,
+                b'r' => b'\r' as i8,
+                b't' => b'\t' as i8,
+                _ => process::abort(),
+            }
+        } else {
+            *c
+        };
+        i += 1;
+        c = c.offset(1);
+    }
+    *value.offset(i) = b'\0' as i8;
+}
+
+fn main() -> ExitCode {
+    let args = env::args_os().skip(1);
+    if args.len() == 0 {
+        let _ = writeln!(
+            io::stderr(),
+            "Usage: run-emitter-test-suite <test.event>...",
+        );
+        return ExitCode::FAILURE;
+    }
+    for arg in args {
+        let mut stdin = File::open(arg).unwrap();
+        let mut stdout = io::stdout();
+        let result = unsafe { unsafe_main(&mut stdin, &mut stdout) };
+        if let Err(err) = result {
+            let _ = writeln!(io::stderr(), "{}", err);
+            return ExitCode::FAILURE;
+        }
+    }
+    ExitCode::SUCCESS
+}

vendor/unsafe-libyaml/src/bin/run-parser-test-suite.rs

@@ -0,0 +1,222 @@
+#![warn(clippy::pedantic)]
+#![allow(
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_sign_loss,
+    clippy::items_after_statements,
+    clippy::let_underscore_untyped,
+    clippy::missing_errors_doc,
+    clippy::missing_safety_doc,
+    clippy::too_many_lines
+)]
+
+mod cstr;
+
+use self::cstr::CStr;
+use std::env;
+use std::error::Error;
+use std::ffi::c_void;
+use std::fmt::Write as _;
+use std::fs::File;
+use std::io::{self, Read, Write};
+use std::mem::MaybeUninit;
+use std::process::{self, ExitCode};
+use std::ptr::addr_of_mut;
+use std::slice;
+use unsafe_libyaml::{
+    yaml_event_delete, yaml_event_t, yaml_event_type_t, yaml_parser_delete, yaml_parser_initialize,
+    yaml_parser_parse, yaml_parser_set_input, yaml_parser_t, YAML_ALIAS_EVENT,
+    YAML_DOCUMENT_END_EVENT, YAML_DOCUMENT_START_EVENT, YAML_DOUBLE_QUOTED_SCALAR_STYLE,
+    YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE, YAML_MAPPING_END_EVENT,
+    YAML_MAPPING_START_EVENT, YAML_NO_EVENT, YAML_PLAIN_SCALAR_STYLE, YAML_SCALAR_EVENT,
+    YAML_SEQUENCE_END_EVENT, YAML_SEQUENCE_START_EVENT, YAML_SINGLE_QUOTED_SCALAR_STYLE,
+    YAML_STREAM_END_EVENT, YAML_STREAM_START_EVENT,
+};
+
+pub(crate) unsafe fn unsafe_main(
+    mut stdin: &mut dyn Read,
+    stdout: &mut dyn Write,
+) -> Result<(), Box<dyn Error>> {
+    let mut parser = MaybeUninit::<yaml_parser_t>::uninit();
+    let parser = parser.as_mut_ptr();
+    if yaml_parser_initialize(parser).fail {
+        return Err("Could not initialize the parser object".into());
+    }
+
+    unsafe fn read_from_stdio(
+        data: *mut c_void,
+        buffer: *mut u8,
+        size: u64,
+        size_read: *mut u64,
+    ) -> i32 {
+        let stdin: *mut &mut dyn Read = data.cast();
+        let slice = slice::from_raw_parts_mut(buffer.cast(), size as usize);
+        match (*stdin).read(slice) {
+            Ok(n) => {
+                *size_read = n as u64;
+                1
+            }
+            Err(_) => 0,
+        }
+    }
+
+    yaml_parser_set_input(parser, read_from_stdio, addr_of_mut!(stdin).cast());
+
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    loop {
+        if yaml_parser_parse(parser, event).fail {
+            let mut error = format!("Parse error: {}", CStr::from_ptr((*parser).problem));
+            if (*parser).problem_mark.line != 0 || (*parser).problem_mark.column != 0 {
+                let _ = write!(
+                    error,
+                    "\nLine: {} Column: {}",
+                    ((*parser).problem_mark.line).wrapping_add(1_u64),
+                    ((*parser).problem_mark.column).wrapping_add(1_u64),
+                );
+            }
+            yaml_parser_delete(parser);
+            return Err(error.into());
+        }
+
+        let type_: yaml_event_type_t = (*event).type_;
+        if type_ == YAML_NO_EVENT {
+            let _ = writeln!(stdout, "???");
+        } else if type_ == YAML_STREAM_START_EVENT {
+            let _ = writeln!(stdout, "+STR");
+        } else if type_ == YAML_STREAM_END_EVENT {
+            let _ = writeln!(stdout, "-STR");
+        } else if type_ == YAML_DOCUMENT_START_EVENT {
+            let _ = write!(stdout, "+DOC");
+            if !(*event).data.document_start.implicit {
+                let _ = write!(stdout, " ---");
+            }
+            let _ = writeln!(stdout);
+        } else if type_ == YAML_DOCUMENT_END_EVENT {
+            let _ = write!(stdout, "-DOC");
+            if !(*event).data.document_end.implicit {
+                let _ = write!(stdout, " ...");
+            }
+            let _ = writeln!(stdout);
+        } else if type_ == YAML_MAPPING_START_EVENT {
+            let _ = write!(stdout, "+MAP");
+            if !(*event).data.mapping_start.anchor.is_null() {
+                let _ = write!(
+                    stdout,
+                    " &{}",
+                    CStr::from_ptr((*event).data.mapping_start.anchor as *const i8),
+                );
+            }
+            if !(*event).data.mapping_start.tag.is_null() {
+                let _ = write!(
+                    stdout,
+                    " <{}>",
+                    CStr::from_ptr((*event).data.mapping_start.tag as *const i8),
+                );
+            }
+            let _ = writeln!(stdout);
+        } else if type_ == YAML_MAPPING_END_EVENT {
+            let _ = writeln!(stdout, "-MAP");
+        } else if type_ == YAML_SEQUENCE_START_EVENT {
+            let _ = write!(stdout, "+SEQ");
+            if !(*event).data.sequence_start.anchor.is_null() {
+                let _ = write!(
+                    stdout,
+                    " &{}",
+                    CStr::from_ptr((*event).data.sequence_start.anchor as *const i8),
+                );
+            }
+            if !(*event).data.sequence_start.tag.is_null() {
+                let _ = write!(
+                    stdout,
+                    " <{}>",
+                    CStr::from_ptr((*event).data.sequence_start.tag as *const i8),
+                );
+            }
+            let _ = writeln!(stdout);
+        } else if type_ == YAML_SEQUENCE_END_EVENT {
+            let _ = writeln!(stdout, "-SEQ");
+        } else if type_ == YAML_SCALAR_EVENT {
+            let _ = write!(stdout, "=VAL");
+            if !(*event).data.scalar.anchor.is_null() {
+                let _ = write!(
+                    stdout,
+                    " &{}",
+                    CStr::from_ptr((*event).data.scalar.anchor as *const i8),
+                );
+            }
+            if !(*event).data.scalar.tag.is_null() {
+                let _ = write!(
+                    stdout,
+                    " <{}>",
+                    CStr::from_ptr((*event).data.scalar.tag as *const i8),
+                );
+            }
+            let _ = stdout.write_all(match (*event).data.scalar.style {
+                YAML_PLAIN_SCALAR_STYLE => b" :",
+                YAML_SINGLE_QUOTED_SCALAR_STYLE => b" '",
+                YAML_DOUBLE_QUOTED_SCALAR_STYLE => b" \"",
+                YAML_LITERAL_SCALAR_STYLE => b" |",
+                YAML_FOLDED_SCALAR_STYLE => b" >",
+                _ => process::abort(),
+            });
+            print_escaped(
+                stdout,
+                (*event).data.scalar.value,
+                (*event).data.scalar.length,
+            );
+            let _ = writeln!(stdout);
+        } else if type_ == YAML_ALIAS_EVENT {
+            let _ = writeln!(
+                stdout,
+                "=ALI *{}",
+                CStr::from_ptr((*event).data.alias.anchor as *const i8),
+            );
+        } else {
+            process::abort();
+        }
+
+        yaml_event_delete(event);
+        if type_ == YAML_STREAM_END_EVENT {
+            break;
+        }
+    }
+    yaml_parser_delete(parser);
+    Ok(())
+}
+
+unsafe fn print_escaped(stdout: &mut dyn Write, mut str: *mut u8, length: u64) {
+    let end = str.offset(length as isize);
+    while str < end {
+        let repr = match &*str {
+            b'\\' => b"\\\\",
+            b'\0' => b"\\0",
+            b'\x08' => b"\\b",
+            b'\n' => b"\\n",
+            b'\r' => b"\\r",
+            b'\t' => b"\\t",
+            c => slice::from_ref(c),
+        };
+        let _ = stdout.write_all(repr);
+        str = str.offset(1);
+    }
+}
+
+fn main() -> ExitCode {
+    let args = env::args_os().skip(1);
+    if args.len() == 0 {
+        let _ = writeln!(io::stderr(), "Usage: run-parser-test-suite <in.yaml>...");
+        return ExitCode::FAILURE;
+    }
+    for arg in args {
+        let mut stdin = File::open(arg).unwrap();
+        let mut stdout = io::stdout();
+        let result = unsafe { unsafe_main(&mut stdin, &mut stdout) };
+        if let Err(err) = result {
+            let _ = writeln!(io::stderr(), "{}", err);
+            return ExitCode::FAILURE;
+        }
+    }
+    ExitCode::SUCCESS
+}

vendor/unsafe-libyaml/src/dumper.rs

@@ -0,0 +1,450 @@
+use crate::api::{yaml_free, yaml_malloc};
+use crate::externs::{memset, strcmp};
+use crate::fmt::WriteToPtr;
+use crate::ops::ForceMul as _;
+use crate::success::{Success, FAIL, OK};
+use crate::yaml::{
+    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_DOCUMENT_END_EVENT, YAML_DOCUMENT_START_EVENT, YAML_MAPPING_END_EVENT, YAML_MAPPING_NODE,
+    YAML_MAPPING_START_EVENT, YAML_SCALAR_EVENT, YAML_SCALAR_NODE, YAML_SEQUENCE_END_EVENT,
+    YAML_SEQUENCE_NODE, YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_START_EVENT,
+};
+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.
+pub unsafe fn yaml_emitter_open(emitter: *mut yaml_emitter_t) -> Success {
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    __assert!(!emitter.is_null());
+    __assert!(!(*emitter).opened);
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_STREAM_START_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    (*event).data.stream_start.encoding = YAML_ANY_ENCODING;
+    if yaml_emitter_emit(emitter, event).fail {
+        return FAIL;
+    }
+    (*emitter).opened = true;
+    OK
+}
+
+/// Finish a YAML stream.
+///
+/// This function should be used after yaml_emitter_dump() is called.
+pub unsafe fn yaml_emitter_close(emitter: *mut yaml_emitter_t) -> Success {
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    __assert!(!emitter.is_null());
+    __assert!((*emitter).opened);
+    if (*emitter).closed {
+        return OK;
+    }
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_STREAM_END_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    if yaml_emitter_emit(emitter, event).fail {
+        return FAIL;
+    }
+    (*emitter).closed = true;
+    OK
+}
+
+/// Emit a YAML document.
+///
+/// The document object may be generated using the yaml_parser_load() function or
+/// the yaml_document_initialize() function. The emitter takes the
+/// responsibility for the document object and destroys its content after it is
+/// emitted. The document object is destroyed even if the function fails.
+pub unsafe fn yaml_emitter_dump(
+    emitter: *mut yaml_emitter_t,
+    document: *mut yaml_document_t,
+) -> Success {
+    let current_block: u64;
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    __assert!(!emitter.is_null());
+    __assert!(!document.is_null());
+    let fresh0 = addr_of_mut!((*emitter).document);
+    *fresh0 = document;
+    if !(*emitter).opened {
+        if yaml_emitter_open(emitter).fail {
+            current_block = 5018439318894558507;
+        } else {
+            current_block = 15619007995458559411;
+        }
+    } else {
+        current_block = 15619007995458559411;
+    }
+    match current_block {
+        15619007995458559411 => {
+            if STACK_EMPTY!((*document).nodes) {
+                if yaml_emitter_close(emitter).ok {
+                    yaml_emitter_delete_document_and_anchors(emitter);
+                    return OK;
+                }
+            } else {
+                __assert!((*emitter).opened);
+                let fresh1 = addr_of_mut!((*emitter).anchors);
+                *fresh1 = yaml_malloc(
+                    (size_of::<yaml_anchors_t>() as libc::c_ulong)
+                        .force_mul((*document).nodes.top.c_offset_from((*document).nodes.start)
+                            as libc::c_ulong),
+                ) as *mut yaml_anchors_t;
+                memset(
+                    (*emitter).anchors as *mut libc::c_void,
+                    0,
+                    (size_of::<yaml_anchors_t>() as libc::c_ulong)
+                        .force_mul((*document).nodes.top.c_offset_from((*document).nodes.start)
+                            as libc::c_ulong),
+                );
+                memset(
+                    event as *mut libc::c_void,
+                    0,
+                    size_of::<yaml_event_t>() as libc::c_ulong,
+                );
+                (*event).type_ = YAML_DOCUMENT_START_EVENT;
+                (*event).start_mark = mark;
+                (*event).end_mark = mark;
+                (*event).data.document_start.version_directive = (*document).version_directive;
+                (*event).data.document_start.tag_directives.start =
+                    (*document).tag_directives.start;
+                (*event).data.document_start.tag_directives.end = (*document).tag_directives.end;
+                (*event).data.document_start.implicit = (*document).start_implicit;
+                if yaml_emitter_emit(emitter, event).ok {
+                    yaml_emitter_anchor_node(emitter, 1);
+                    if yaml_emitter_dump_node(emitter, 1).ok {
+                        memset(
+                            event as *mut libc::c_void,
+                            0,
+                            size_of::<yaml_event_t>() as libc::c_ulong,
+                        );
+                        (*event).type_ = YAML_DOCUMENT_END_EVENT;
+                        (*event).start_mark = mark;
+                        (*event).end_mark = mark;
+                        (*event).data.document_end.implicit = (*document).end_implicit;
+                        if yaml_emitter_emit(emitter, event).ok {
+                            yaml_emitter_delete_document_and_anchors(emitter);
+                            return OK;
+                        }
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    yaml_emitter_delete_document_and_anchors(emitter);
+    FAIL
+}
+
+unsafe fn yaml_emitter_delete_document_and_anchors(emitter: *mut yaml_emitter_t) {
+    let mut index: libc::c_int;
+    if (*emitter).anchors.is_null() {
+        yaml_document_delete((*emitter).document);
+        let fresh2 = addr_of_mut!((*emitter).document);
+        *fresh2 = ptr::null_mut::<yaml_document_t>();
+        return;
+    }
+    index = 0;
+    while (*(*emitter).document)
+        .nodes
+        .start
+        .wrapping_offset(index as isize)
+        < (*(*emitter).document).nodes.top
+    {
+        let mut node: yaml_node_t = *(*(*emitter).document)
+            .nodes
+            .start
+            .wrapping_offset(index as isize);
+        if !(*(*emitter).anchors.wrapping_offset(index as isize)).serialized {
+            yaml_free(node.tag as *mut libc::c_void);
+            if node.type_ == YAML_SCALAR_NODE {
+                yaml_free(node.data.scalar.value as *mut libc::c_void);
+            }
+        }
+        if node.type_ == YAML_SEQUENCE_NODE {
+            STACK_DEL!(node.data.sequence.items);
+        }
+        if node.type_ == YAML_MAPPING_NODE {
+            STACK_DEL!(node.data.mapping.pairs);
+        }
+        index += 1;
+    }
+    STACK_DEL!((*(*emitter).document).nodes);
+    yaml_free((*emitter).anchors as *mut libc::c_void);
+    let fresh6 = addr_of_mut!((*emitter).anchors);
+    *fresh6 = ptr::null_mut::<yaml_anchors_t>();
+    (*emitter).last_anchor_id = 0;
+    let fresh7 = addr_of_mut!((*emitter).document);
+    *fresh7 = ptr::null_mut::<yaml_document_t>();
+}
+
+unsafe fn yaml_emitter_anchor_node_sub(emitter: *mut yaml_emitter_t, index: libc::c_int) {
+    (*((*emitter).anchors).offset((index - 1) as isize)).references += 1;
+    if (*(*emitter).anchors.offset((index - 1) as isize)).references == 2 {
+        (*emitter).last_anchor_id += 1;
+        (*(*emitter).anchors.offset((index - 1) as isize)).anchor = (*emitter).last_anchor_id;
+    }
+}
+
+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)
+        .wrapping_offset(-1_isize);
+    let mut item: *mut yaml_node_item_t;
+    let mut pair: *mut yaml_node_pair_t;
+    let fresh8 =
+        addr_of_mut!((*((*emitter).anchors).wrapping_offset((index - 1) as isize)).references);
+    *fresh8 += 1;
+    if (*(*emitter).anchors.wrapping_offset((index - 1) as isize)).references == 1 {
+        match (*node).type_ {
+            YAML_SEQUENCE_NODE => {
+                item = (*node).data.sequence.items.start;
+                while item < (*node).data.sequence.items.top {
+                    yaml_emitter_anchor_node_sub(emitter, *item);
+                    item = item.wrapping_offset(1);
+                }
+            }
+            YAML_MAPPING_NODE => {
+                pair = (*node).data.mapping.pairs.start;
+                while pair < (*node).data.mapping.pairs.top {
+                    yaml_emitter_anchor_node_sub(emitter, (*pair).key);
+                    yaml_emitter_anchor_node_sub(emitter, (*pair).value);
+                    pair = pair.wrapping_offset(1);
+                }
+            }
+            _ => {}
+        }
+    } else if (*(*emitter).anchors.wrapping_offset((index - 1) as isize)).references == 2 {
+        let fresh9 = addr_of_mut!((*emitter).last_anchor_id);
+        *fresh9 += 1;
+        (*(*emitter).anchors.wrapping_offset((index - 1) as isize)).anchor = *fresh9;
+    }
+}
+
+unsafe fn yaml_emitter_generate_anchor(
+    _emitter: *mut yaml_emitter_t,
+    anchor_id: libc::c_int,
+) -> *mut yaml_char_t {
+    let anchor: *mut yaml_char_t = yaml_malloc(16_u64) as *mut yaml_char_t;
+    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) -> Success {
+    let node: *mut yaml_node_t = (*(*emitter).document)
+        .nodes
+        .start
+        .wrapping_offset(index as isize)
+        .wrapping_offset(-1_isize);
+    let anchor_id: libc::c_int = (*(*emitter).anchors.wrapping_offset((index - 1) as isize)).anchor;
+    let mut anchor: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
+    if anchor_id != 0 {
+        anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
+    }
+    if (*(*emitter).anchors.wrapping_offset((index - 1) as isize)).serialized {
+        return yaml_emitter_dump_alias(emitter, anchor);
+    }
+    (*(*emitter).anchors.wrapping_offset((index - 1) as isize)).serialized = true;
+    match (*node).type_ {
+        YAML_SCALAR_NODE => yaml_emitter_dump_scalar(emitter, node, anchor),
+        YAML_SEQUENCE_NODE => yaml_emitter_dump_sequence(emitter, node, anchor),
+        YAML_MAPPING_NODE => yaml_emitter_dump_mapping(emitter, node, anchor),
+        _ => __assert!(false),
+    }
+}
+
+unsafe fn yaml_emitter_dump_alias(
+    emitter: *mut yaml_emitter_t,
+    anchor: *mut yaml_char_t,
+) -> Success {
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_ALIAS_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    (*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,
+    anchor: *mut yaml_char_t,
+) -> Success {
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    let plain_implicit = strcmp(
+        (*node).tag as *mut libc::c_char,
+        b"tag:yaml.org,2002:str\0" as *const u8 as *const libc::c_char,
+    ) == 0;
+    let quoted_implicit = strcmp(
+        (*node).tag as *mut libc::c_char,
+        b"tag:yaml.org,2002:str\0" as *const u8 as *const libc::c_char,
+    ) == 0;
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_SCALAR_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    (*event).data.scalar.anchor = anchor;
+    (*event).data.scalar.tag = (*node).tag;
+    (*event).data.scalar.value = (*node).data.scalar.value;
+    (*event).data.scalar.length = (*node).data.scalar.length;
+    (*event).data.scalar.plain_implicit = plain_implicit;
+    (*event).data.scalar.quoted_implicit = quoted_implicit;
+    (*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,
+    anchor: *mut yaml_char_t,
+) -> Success {
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    let implicit = strcmp(
+        (*node).tag as *mut libc::c_char,
+        b"tag:yaml.org,2002:seq\0" as *const u8 as *const libc::c_char,
+    ) == 0;
+    let mut item: *mut yaml_node_item_t;
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_SEQUENCE_START_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    (*event).data.sequence_start.anchor = anchor;
+    (*event).data.sequence_start.tag = (*node).tag;
+    (*event).data.sequence_start.implicit = implicit;
+    (*event).data.sequence_start.style = (*node).data.sequence.style;
+    if yaml_emitter_emit(emitter, event).fail {
+        return FAIL;
+    }
+    item = (*node).data.sequence.items.start;
+    while item < (*node).data.sequence.items.top {
+        if yaml_emitter_dump_node(emitter, *item).fail {
+            return FAIL;
+        }
+        item = item.wrapping_offset(1);
+    }
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_SEQUENCE_END_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    yaml_emitter_emit(emitter, event)
+}
+
+unsafe fn yaml_emitter_dump_mapping(
+    emitter: *mut yaml_emitter_t,
+    node: *mut yaml_node_t,
+    anchor: *mut yaml_char_t,
+) -> Success {
+    let mut event = MaybeUninit::<yaml_event_t>::uninit();
+    let event = event.as_mut_ptr();
+    let mark = yaml_mark_t {
+        index: 0_u64,
+        line: 0_u64,
+        column: 0_u64,
+    };
+    let implicit = strcmp(
+        (*node).tag as *mut libc::c_char,
+        b"tag:yaml.org,2002:map\0" as *const u8 as *const libc::c_char,
+    ) == 0;
+    let mut pair: *mut yaml_node_pair_t;
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_MAPPING_START_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    (*event).data.mapping_start.anchor = anchor;
+    (*event).data.mapping_start.tag = (*node).tag;
+    (*event).data.mapping_start.implicit = implicit;
+    (*event).data.mapping_start.style = (*node).data.mapping.style;
+    if yaml_emitter_emit(emitter, event).fail {
+        return FAIL;
+    }
+    pair = (*node).data.mapping.pairs.start;
+    while pair < (*node).data.mapping.pairs.top {
+        if yaml_emitter_dump_node(emitter, (*pair).key).fail {
+            return FAIL;
+        }
+        if yaml_emitter_dump_node(emitter, (*pair).value).fail {
+            return FAIL;
+        }
+        pair = pair.wrapping_offset(1);
+    }
+    memset(
+        event as *mut libc::c_void,
+        0,
+        size_of::<yaml_event_t>() as libc::c_ulong,
+    );
+    (*event).type_ = YAML_MAPPING_END_EVENT;
+    (*event).start_mark = mark;
+    (*event).end_mark = mark;
+    yaml_emitter_emit(emitter, event)
+}

vendor/unsafe-libyaml/src/lib.rs

@@ -0,0 +1,324 @@
+//! [![github]](https://github.com/dtolnay/unsafe-libyaml) [![crates-io]](https://crates.io/crates/unsafe-libyaml) [![docs-rs]](https://docs.rs/unsafe-libyaml)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
+
+#![no_std]
+#![doc(html_root_url = "https://docs.rs/unsafe-libyaml/0.2.11")]
+#![allow(non_camel_case_types, non_snake_case, unsafe_op_in_unsafe_fn)]
+#![warn(clippy::pedantic)]
+#![allow(
+    clippy::bool_to_int_with_if,
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_ptr_alignment,
+    clippy::cast_sign_loss,
+    clippy::collapsible_if,
+    clippy::doc_markdown,
+    clippy::fn_params_excessive_bools,
+    clippy::if_not_else,
+    clippy::items_after_statements,
+    clippy::let_underscore_untyped,
+    clippy::manual_range_contains,
+    clippy::manual_swap,
+    clippy::missing_panics_doc,
+    clippy::missing_safety_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::nonminimal_bool,
+    clippy::ptr_as_ptr,
+    clippy::redundant_else,
+    clippy::similar_names,
+    clippy::single_match,
+    clippy::single_match_else,
+    clippy::too_many_arguments,
+    clippy::too_many_lines,
+    clippy::unnecessary_cast,
+    clippy::unreadable_literal,
+    clippy::while_immutable_condition, // https://github.com/rust-lang/rust-clippy/issues/3548
+)]
+
+extern crate alloc;
+
+use core::mem::size_of;
+
+mod libc {
+    pub use core::ffi::c_void;
+    pub use core::primitive::{
+        i32 as c_int, i64 as c_long, i8 as c_char, u32 as c_uint, u64 as c_ulong, u8 as c_uchar,
+    };
+}
+
+#[macro_use]
+mod externs {
+    use crate::libc;
+    use crate::ops::{die, ForceAdd as _, ForceInto as _};
+    use alloc::alloc::{self as rust, Layout};
+    use core::mem::{self, MaybeUninit};
+    use core::ptr;
+    use core::slice;
+
+    const HEADER: usize = {
+        let need_len = mem::size_of::<usize>();
+        // Round up to multiple of MALLOC_ALIGN.
+        (need_len + MALLOC_ALIGN - 1) & !(MALLOC_ALIGN - 1)
+    };
+
+    // `max_align_t` may be bigger than this, but libyaml does not use `long
+    // double` or u128.
+    const MALLOC_ALIGN: usize = {
+        let int_align = mem::align_of::<libc::c_ulong>();
+        let ptr_align = mem::align_of::<usize>();
+        if int_align >= ptr_align {
+            int_align
+        } else {
+            ptr_align
+        }
+    };
+
+    pub unsafe fn malloc(size: libc::c_ulong) -> *mut libc::c_void {
+        let size = HEADER.force_add(size.force_into());
+        let layout = Layout::from_size_align(size, MALLOC_ALIGN)
+            .ok()
+            .unwrap_or_else(die);
+        let memory = rust::alloc(layout);
+        if memory.is_null() {
+            rust::handle_alloc_error(layout);
+        }
+        memory.cast::<usize>().write(size);
+        memory.add(HEADER).cast()
+    }
+
+    pub unsafe fn realloc(ptr: *mut libc::c_void, new_size: libc::c_ulong) -> *mut libc::c_void {
+        let mut memory = ptr.cast::<u8>().sub(HEADER);
+        let size = memory.cast::<usize>().read();
+        let layout = Layout::from_size_align_unchecked(size, MALLOC_ALIGN);
+        let new_size = HEADER.force_add(new_size.force_into());
+        let new_layout = Layout::from_size_align(new_size, MALLOC_ALIGN)
+            .ok()
+            .unwrap_or_else(die);
+        memory = rust::realloc(memory, layout, new_size);
+        if memory.is_null() {
+            rust::handle_alloc_error(new_layout);
+        }
+        memory.cast::<usize>().write(new_size);
+        memory.add(HEADER).cast()
+    }
+
+    pub unsafe fn free(ptr: *mut libc::c_void) {
+        let memory = ptr.cast::<u8>().sub(HEADER);
+        let size = memory.cast::<usize>().read();
+        let layout = Layout::from_size_align_unchecked(size, MALLOC_ALIGN);
+        rust::dealloc(memory, layout);
+    }
+
+    pub unsafe fn memcmp(
+        lhs: *const libc::c_void,
+        rhs: *const libc::c_void,
+        count: libc::c_ulong,
+    ) -> libc::c_int {
+        let lhs = slice::from_raw_parts(lhs.cast::<u8>(), count as usize);
+        let rhs = slice::from_raw_parts(rhs.cast::<u8>(), count as usize);
+        lhs.cmp(rhs) as libc::c_int
+    }
+
+    pub unsafe fn memcpy(
+        dest: *mut libc::c_void,
+        src: *const libc::c_void,
+        count: libc::c_ulong,
+    ) -> *mut libc::c_void {
+        ptr::copy_nonoverlapping(
+            src.cast::<MaybeUninit<u8>>(),
+            dest.cast::<MaybeUninit<u8>>(),
+            count as usize,
+        );
+        dest
+    }
+
+    pub unsafe fn memmove(
+        dest: *mut libc::c_void,
+        src: *const libc::c_void,
+        count: libc::c_ulong,
+    ) -> *mut libc::c_void {
+        ptr::copy(
+            src.cast::<MaybeUninit<u8>>(),
+            dest.cast::<MaybeUninit<u8>>(),
+            count as usize,
+        );
+        dest
+    }
+
+    pub unsafe fn memset(
+        dest: *mut libc::c_void,
+        ch: libc::c_int,
+        count: libc::c_ulong,
+    ) -> *mut libc::c_void {
+        ptr::write_bytes(dest.cast::<u8>(), ch as u8, count as usize);
+        dest
+    }
+
+    pub unsafe fn strcmp(lhs: *const libc::c_char, rhs: *const libc::c_char) -> libc::c_int {
+        let lhs = slice::from_raw_parts(lhs.cast::<u8>(), strlen(lhs) as usize);
+        let rhs = slice::from_raw_parts(rhs.cast::<u8>(), strlen(rhs) as usize);
+        lhs.cmp(rhs) as libc::c_int
+    }
+
+    pub unsafe fn strdup(src: *const libc::c_char) -> *mut libc::c_char {
+        let len = strlen(src);
+        let dest = malloc(len + 1);
+        memcpy(dest, src.cast(), len + 1);
+        dest.cast()
+    }
+
+    pub unsafe fn strlen(str: *const libc::c_char) -> libc::c_ulong {
+        let mut end = str;
+        while *end != 0 {
+            end = end.add(1);
+        }
+        end.offset_from(str) as libc::c_ulong
+    }
+
+    pub unsafe fn strncmp(
+        lhs: *const libc::c_char,
+        rhs: *const libc::c_char,
+        mut count: libc::c_ulong,
+    ) -> libc::c_int {
+        let mut lhs = lhs.cast::<u8>();
+        let mut rhs = rhs.cast::<u8>();
+        while count > 0 && *lhs != 0 && *lhs == *rhs {
+            lhs = lhs.add(1);
+            rhs = rhs.add(1);
+            count -= 1;
+        }
+        if count == 0 {
+            0
+        } else {
+            (*lhs).cmp(&*rhs) as libc::c_int
+        }
+    }
+
+    macro_rules! __assert {
+        (false $(,)?) => {
+            $crate::externs::__assert_fail(stringify!(false), file!(), line!())
+        };
+        ($assertion:expr $(,)?) => {
+            if !$assertion {
+                $crate::externs::__assert_fail(stringify!($assertion), file!(), line!());
+            }
+        };
+    }
+
+    pub(crate) unsafe fn __assert_fail(
+        __assertion: &'static str,
+        __file: &'static str,
+        __line: u32,
+    ) -> ! {
+        struct Abort;
+        impl Drop for Abort {
+            fn drop(&mut self) {
+                panic!();
+            }
+        }
+        let _abort_on_panic = Abort;
+        panic!("{}:{}: Assertion `{}` failed.", __file, __line, __assertion);
+    }
+}
+
+mod fmt {
+    use crate::yaml::yaml_char_t;
+    use core::fmt::{self, Write};
+    use core::ptr;
+
+    pub struct WriteToPtr {
+        ptr: *mut yaml_char_t,
+    }
+
+    impl WriteToPtr {
+        pub unsafe fn new(ptr: *mut yaml_char_t) -> Self {
+            WriteToPtr { ptr }
+        }
+
+        pub fn write_fmt(&mut self, args: fmt::Arguments) {
+            let _ = Write::write_fmt(self, args);
+        }
+    }
+
+    impl Write for WriteToPtr {
+        fn write_str(&mut self, s: &str) -> fmt::Result {
+            unsafe {
+                ptr::copy_nonoverlapping(s.as_ptr(), self.ptr, s.len());
+                self.ptr = self.ptr.add(s.len());
+            }
+            Ok(())
+        }
+    }
+}
+
+trait PointerExt: Sized {
+    fn c_offset_from(self, origin: Self) -> isize;
+}
+
+impl<T> PointerExt for *const T {
+    fn c_offset_from(self, origin: *const T) -> isize {
+        (self as isize - origin as isize) / size_of::<T>() as isize
+    }
+}
+
+impl<T> PointerExt for *mut T {
+    fn c_offset_from(self, origin: *mut T) -> isize {
+        (self as isize - origin as isize) / size_of::<T>() as isize
+    }
+}
+
+#[macro_use]
+mod macros;
+
+mod api;
+mod dumper;
+mod emitter;
+mod loader;
+mod ops;
+mod parser;
+mod reader;
+mod scanner;
+mod success;
+mod writer;
+mod yaml;
+
+pub use crate::api::{
+    yaml_alias_event_initialize, yaml_document_add_mapping, yaml_document_add_scalar,
+    yaml_document_add_sequence, yaml_document_append_mapping_pair,
+    yaml_document_append_sequence_item, yaml_document_delete, yaml_document_end_event_initialize,
+    yaml_document_get_node, yaml_document_get_root_node, yaml_document_initialize,
+    yaml_document_start_event_initialize, yaml_emitter_delete, yaml_emitter_initialize,
+    yaml_emitter_set_break, yaml_emitter_set_canonical, yaml_emitter_set_encoding,
+    yaml_emitter_set_indent, yaml_emitter_set_output, yaml_emitter_set_output_string,
+    yaml_emitter_set_unicode, yaml_emitter_set_width, yaml_event_delete,
+    yaml_mapping_end_event_initialize, yaml_mapping_start_event_initialize, yaml_parser_delete,
+    yaml_parser_initialize, yaml_parser_set_encoding, yaml_parser_set_input,
+    yaml_parser_set_input_string, yaml_scalar_event_initialize, yaml_sequence_end_event_initialize,
+    yaml_sequence_start_event_initialize, yaml_stream_end_event_initialize,
+    yaml_stream_start_event_initialize, yaml_token_delete,
+};
+pub use crate::dumper::{yaml_emitter_close, yaml_emitter_dump, yaml_emitter_open};
+pub use crate::emitter::yaml_emitter_emit;
+pub use crate::loader::yaml_parser_load;
+pub use crate::parser::yaml_parser_parse;
+pub use crate::scanner::yaml_parser_scan;
+pub use crate::writer::yaml_emitter_flush;
+pub use crate::yaml::{
+    yaml_alias_data_t, yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t,
+    yaml_encoding_t, yaml_error_type_t, yaml_event_t, yaml_event_type_t, yaml_mapping_style_t,
+    yaml_mark_t, yaml_node_item_t, yaml_node_pair_t, yaml_node_t, yaml_node_type_t,
+    yaml_parser_state_t, yaml_parser_t, yaml_read_handler_t, yaml_scalar_style_t,
+    yaml_sequence_style_t, yaml_simple_key_t, yaml_stack_t, yaml_tag_directive_t, yaml_token_t,
+    yaml_token_type_t, yaml_version_directive_t, yaml_write_handler_t,
+};
+#[doc(hidden)]
+pub use crate::yaml::{
+    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::*,
+};

vendor/unsafe-libyaml/src/loader.rs

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

vendor/unsafe-libyaml/src/macros.rs

@@ -0,0 +1,514 @@
+macro_rules! BUFFER_INIT {
+    ($buffer:expr, $size:expr) => {{
+        let start = addr_of_mut!($buffer.start);
+        *start = yaml_malloc($size as size_t) as *mut yaml_char_t;
+        let pointer = addr_of_mut!($buffer.pointer);
+        *pointer = $buffer.start;
+        let last = addr_of_mut!($buffer.last);
+        *last = *pointer;
+        let end = addr_of_mut!($buffer.end);
+        *end = $buffer.start.wrapping_add($size as usize);
+    }};
+}
+
+macro_rules! BUFFER_DEL {
+    ($buffer:expr) => {{
+        yaml_free($buffer.start as *mut libc::c_void);
+        let end = addr_of_mut!($buffer.end);
+        *end = ptr::null_mut::<yaml_char_t>();
+        let pointer = addr_of_mut!($buffer.pointer);
+        *pointer = *end;
+        let start = addr_of_mut!($buffer.start);
+        *start = *pointer;
+    }};
+}
+
+macro_rules! STRING_ASSIGN {
+    ($string:expr, $length:expr) => {
+        yaml_string_t {
+            start: $string,
+            end: $string.wrapping_offset($length as isize),
+            pointer: $string,
+        }
+    };
+}
+
+macro_rules! STRING_INIT {
+    ($string:expr) => {{
+        $string.start = yaml_malloc(16) as *mut yaml_char_t;
+        $string.pointer = $string.start;
+        $string.end = $string.start.wrapping_add(16);
+        memset($string.start as *mut libc::c_void, 0, 16);
+    }};
+}
+
+macro_rules! STRING_DEL {
+    ($string:expr) => {{
+        yaml_free($string.start as *mut libc::c_void);
+        $string.end = ptr::null_mut::<yaml_char_t>();
+        $string.pointer = $string.end;
+        $string.start = $string.pointer;
+    }};
+}
+
+macro_rules! STRING_EXTEND {
+    ($string:expr) => {
+        if $string.pointer.wrapping_add(5) >= $string.end {
+            yaml_string_extend(
+                addr_of_mut!($string.start),
+                addr_of_mut!($string.pointer),
+                addr_of_mut!($string.end),
+            );
+        }
+    };
+}
+
+macro_rules! CLEAR {
+    ($string:expr) => {{
+        $string.pointer = $string.start;
+        memset(
+            $string.start as *mut libc::c_void,
+            0,
+            $string.end.c_offset_from($string.start) as libc::c_ulong,
+        );
+    }};
+}
+
+macro_rules! JOIN {
+    ($string_a:expr, $string_b:expr) => {{
+        yaml_string_join(
+            addr_of_mut!($string_a.start),
+            addr_of_mut!($string_a.pointer),
+            addr_of_mut!($string_a.end),
+            addr_of_mut!($string_b.start),
+            addr_of_mut!($string_b.pointer),
+            addr_of_mut!($string_b.end),
+        );
+        $string_b.pointer = $string_b.start;
+    }};
+}
+
+macro_rules! CHECK_AT {
+    ($string:expr, $octet:expr, $offset:expr) => {
+        *$string.pointer.offset($offset as isize) == $octet
+    };
+}
+
+macro_rules! CHECK {
+    ($string:expr, $octet:expr) => {
+        *$string.pointer == $octet
+    };
+}
+
+macro_rules! IS_ALPHA {
+    ($string:expr) => {
+        *$string.pointer >= b'0' && *$string.pointer <= b'9'
+            || *$string.pointer >= b'A' && *$string.pointer <= b'Z'
+            || *$string.pointer >= b'a' && *$string.pointer <= b'z'
+            || *$string.pointer == b'_'
+            || *$string.pointer == b'-'
+    };
+}
+
+macro_rules! IS_DIGIT {
+    ($string:expr) => {
+        *$string.pointer >= b'0' && *$string.pointer <= b'9'
+    };
+}
+
+macro_rules! AS_DIGIT {
+    ($string:expr) => {
+        (*$string.pointer - b'0') as libc::c_int
+    };
+}
+
+macro_rules! IS_HEX_AT {
+    ($string:expr, $offset:expr) => {
+        *$string.pointer.wrapping_offset($offset) >= b'0'
+            && *$string.pointer.wrapping_offset($offset) <= b'9'
+            || *$string.pointer.wrapping_offset($offset) >= b'A'
+                && *$string.pointer.wrapping_offset($offset) <= b'F'
+            || *$string.pointer.wrapping_offset($offset) >= b'a'
+                && *$string.pointer.wrapping_offset($offset) <= b'f'
+    };
+}
+
+macro_rules! AS_HEX_AT {
+    ($string:expr, $offset:expr) => {
+        if *$string.pointer.wrapping_offset($offset) >= b'A'
+            && *$string.pointer.wrapping_offset($offset) <= b'F'
+        {
+            *$string.pointer.wrapping_offset($offset) - b'A' + 10
+        } else if *$string.pointer.wrapping_offset($offset) >= b'a'
+            && *$string.pointer.wrapping_offset($offset) <= b'f'
+        {
+            *$string.pointer.wrapping_offset($offset) - b'a' + 10
+        } else {
+            *$string.pointer.wrapping_offset($offset) - b'0'
+        } as libc::c_int
+    };
+}
+
+macro_rules! IS_ASCII {
+    ($string:expr) => {
+        *$string.pointer <= b'\x7F'
+    };
+}
+
+macro_rules! IS_PRINTABLE {
+    ($string:expr) => {
+        match *$string.pointer {
+            // ASCII
+            0x0A | 0x20..=0x7E => true,
+            // U+A0 ... U+BF
+            0xC2 => match *$string.pointer.wrapping_offset(1) {
+                0xA0..=0xBF => true,
+                _ => false,
+            },
+            // U+C0 ... U+CFFF
+            0xC3..=0xEC => true,
+            // U+D000 ... U+D7FF
+            0xED => match *$string.pointer.wrapping_offset(1) {
+                0x00..=0x9F => true,
+                _ => false,
+            },
+            // U+E000 ... U+EFFF
+            0xEE => true,
+            // U+F000 ... U+FFFD
+            0xEF => match *$string.pointer.wrapping_offset(1) {
+                0xBB => match *$string.pointer.wrapping_offset(2) {
+                    // except U+FEFF
+                    0xBF => false,
+                    _ => true,
+                },
+                0xBF => match *$string.pointer.wrapping_offset(2) {
+                    0xBE | 0xBF => false,
+                    _ => true,
+                },
+                _ => true,
+            },
+            // U+10000 ... U+10FFFF
+            0xF0..=0xF4 => true,
+            _ => false,
+        }
+    };
+}
+
+macro_rules! IS_Z_AT {
+    ($string:expr, $offset:expr) => {
+        CHECK_AT!($string, b'\0', $offset)
+    };
+}
+
+macro_rules! IS_Z {
+    ($string:expr) => {
+        IS_Z_AT!($string, 0)
+    };
+}
+
+macro_rules! IS_BOM {
+    ($string:expr) => {
+        CHECK_AT!($string, b'\xEF', 0)
+            && CHECK_AT!($string, b'\xBB', 1)
+            && CHECK_AT!($string, b'\xBF', 2)
+    };
+}
+
+macro_rules! IS_SPACE_AT {
+    ($string:expr, $offset:expr) => {
+        CHECK_AT!($string, b' ', $offset)
+    };
+}
+
+macro_rules! IS_SPACE {
+    ($string:expr) => {
+        IS_SPACE_AT!($string, 0)
+    };
+}
+
+macro_rules! IS_TAB_AT {
+    ($string:expr, $offset:expr) => {
+        CHECK_AT!($string, b'\t', $offset)
+    };
+}
+
+macro_rules! IS_TAB {
+    ($string:expr) => {
+        IS_TAB_AT!($string, 0)
+    };
+}
+
+macro_rules! IS_BLANK_AT {
+    ($string:expr, $offset:expr) => {
+        IS_SPACE_AT!($string, $offset) || IS_TAB_AT!($string, $offset)
+    };
+}
+
+macro_rules! IS_BLANK {
+    ($string:expr) => {
+        IS_BLANK_AT!($string, 0)
+    };
+}
+
+macro_rules! IS_BREAK_AT {
+    ($string:expr, $offset:expr) => {
+        CHECK_AT!($string, b'\r', $offset)
+            || CHECK_AT!($string, b'\n', $offset)
+            || CHECK_AT!($string, b'\xC2', $offset) && CHECK_AT!($string, b'\x85', $offset + 1)
+            || CHECK_AT!($string, b'\xE2', $offset)
+                && CHECK_AT!($string, b'\x80', $offset + 1)
+                && CHECK_AT!($string, b'\xA8', $offset + 2)
+            || CHECK_AT!($string, b'\xE2', $offset)
+                && CHECK_AT!($string, b'\x80', $offset + 1)
+                && CHECK_AT!($string, b'\xA9', $offset + 2)
+    };
+}
+
+macro_rules! IS_BREAK {
+    ($string:expr) => {
+        IS_BREAK_AT!($string, 0)
+    };
+}
+
+macro_rules! IS_CRLF {
+    ($string:expr) => {
+        CHECK_AT!($string, b'\r', 0) && CHECK_AT!($string, b'\n', 1)
+    };
+}
+
+macro_rules! IS_BREAKZ_AT {
+    ($string:expr, $offset:expr) => {
+        IS_BREAK_AT!($string, $offset) || IS_Z_AT!($string, $offset)
+    };
+}
+
+macro_rules! IS_BREAKZ {
+    ($string:expr) => {
+        IS_BREAKZ_AT!($string, 0)
+    };
+}
+
+macro_rules! IS_BLANKZ_AT {
+    ($string:expr, $offset:expr) => {
+        IS_BLANK_AT!($string, $offset) || IS_BREAKZ_AT!($string, $offset)
+    };
+}
+
+macro_rules! IS_BLANKZ {
+    ($string:expr) => {
+        IS_BLANKZ_AT!($string, 0)
+    };
+}
+
+macro_rules! WIDTH_AT {
+    ($string:expr, $offset:expr) => {
+        if *$string.pointer.wrapping_offset($offset as isize) & 0x80 == 0x00 {
+            1
+        } else if *$string.pointer.wrapping_offset($offset as isize) & 0xE0 == 0xC0 {
+            2
+        } else if *$string.pointer.wrapping_offset($offset as isize) & 0xF0 == 0xE0 {
+            3
+        } else if *$string.pointer.wrapping_offset($offset as isize) & 0xF8 == 0xF0 {
+            4
+        } else {
+            0
+        }
+    };
+}
+
+macro_rules! WIDTH {
+    ($string:expr) => {
+        WIDTH_AT!($string, 0)
+    };
+}
+
+macro_rules! MOVE {
+    ($string:expr) => {
+        $string.pointer = $string.pointer.wrapping_offset(WIDTH!($string) as isize)
+    };
+}
+
+macro_rules! COPY {
+    ($string_a:expr, $string_b:expr) => {
+        if *$string_b.pointer & 0x80 == 0x00 {
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+        } else if *$string_b.pointer & 0xE0 == 0xC0 {
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+        } else if *$string_b.pointer & 0xF0 == 0xE0 {
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+        } else if *$string_b.pointer & 0xF8 == 0xF0 {
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+            *$string_a.pointer = *$string_b.pointer;
+            $string_a.pointer = $string_a.pointer.wrapping_offset(1);
+            $string_b.pointer = $string_b.pointer.wrapping_offset(1);
+        }
+    };
+}
+
+macro_rules! STACK_INIT {
+    ($stack:expr, $type:ty) => {{
+        $stack.start = yaml_malloc(16 * size_of::<$type>() as libc::c_ulong) as *mut $type;
+        $stack.top = $stack.start;
+        $stack.end = $stack.start.offset(16_isize);
+    }};
+}
+
+macro_rules! STACK_DEL {
+    ($stack:expr) => {
+        yaml_free($stack.start as *mut libc::c_void);
+        $stack.end = ptr::null_mut();
+        $stack.top = ptr::null_mut();
+        $stack.start = ptr::null_mut();
+    };
+}
+
+macro_rules! STACK_EMPTY {
+    ($stack:expr) => {
+        $stack.start == $stack.top
+    };
+}
+
+macro_rules! STACK_LIMIT {
+    ($context:expr, $stack:expr) => {
+        if $stack.top.c_offset_from($stack.start) < libc::c_int::MAX as isize - 1 {
+            OK
+        } else {
+            (*$context).error = YAML_MEMORY_ERROR;
+            FAIL
+        }
+    };
+}
+
+macro_rules! PUSH {
+    (do $stack:expr, $push:expr) => {{
+        if $stack.top == $stack.end {
+            yaml_stack_extend(
+                addr_of_mut!($stack.start) as *mut *mut libc::c_void,
+                addr_of_mut!($stack.top) as *mut *mut libc::c_void,
+                addr_of_mut!($stack.end) as *mut *mut libc::c_void,
+            );
+        }
+        $push;
+        $stack.top = $stack.top.wrapping_offset(1);
+    }};
+    ($stack:expr, *$value:expr) => {
+        PUSH!(do $stack, ptr::copy_nonoverlapping($value, $stack.top, 1))
+    };
+    ($stack:expr, $value:expr) => {
+        PUSH!(do $stack, ptr::write($stack.top, $value))
+    };
+}
+
+macro_rules! POP {
+    ($stack:expr) => {
+        *{
+            $stack.top = $stack.top.offset(-1);
+            $stack.top
+        }
+    };
+}
+
+macro_rules! QUEUE_INIT {
+    ($queue:expr, $type:ty) => {{
+        $queue.start = yaml_malloc(16 * size_of::<$type>() as libc::c_ulong) as *mut $type;
+        $queue.tail = $queue.start;
+        $queue.head = $queue.tail;
+        $queue.end = $queue.start.offset(16_isize);
+    }};
+}
+
+macro_rules! QUEUE_DEL {
+    ($queue:expr) => {
+        yaml_free($queue.start as *mut libc::c_void);
+        $queue.end = ptr::null_mut();
+        $queue.tail = ptr::null_mut();
+        $queue.head = ptr::null_mut();
+        $queue.start = ptr::null_mut();
+    };
+}
+
+macro_rules! QUEUE_EMPTY {
+    ($queue:expr) => {
+        $queue.head == $queue.tail
+    };
+}
+
+macro_rules! ENQUEUE {
+    (do $queue:expr, $enqueue:expr) => {{
+        if $queue.tail == $queue.end {
+            yaml_queue_extend(
+                addr_of_mut!($queue.start) as *mut *mut libc::c_void,
+                addr_of_mut!($queue.head) as *mut *mut libc::c_void,
+                addr_of_mut!($queue.tail) as *mut *mut libc::c_void,
+                addr_of_mut!($queue.end) as *mut *mut libc::c_void,
+            );
+        }
+        $enqueue;
+        $queue.tail = $queue.tail.wrapping_offset(1);
+    }};
+    ($queue:expr, *$value:expr) => {
+        ENQUEUE!(do $queue, ptr::copy_nonoverlapping($value, $queue.tail, 1))
+    };
+    ($queue:expr, $value:expr) => {
+        ENQUEUE!(do $queue, ptr::write($queue.tail, $value))
+    };
+}
+
+macro_rules! DEQUEUE {
+    ($queue:expr) => {
+        *{
+            let head = $queue.head;
+            $queue.head = $queue.head.wrapping_offset(1);
+            head
+        }
+    };
+}
+
+macro_rules! QUEUE_INSERT {
+    ($queue:expr, $index:expr, $value:expr) => {{
+        if $queue.tail == $queue.end {
+            yaml_queue_extend(
+                addr_of_mut!($queue.start) as *mut *mut libc::c_void,
+                addr_of_mut!($queue.head) as *mut *mut libc::c_void,
+                addr_of_mut!($queue.tail) as *mut *mut libc::c_void,
+                addr_of_mut!($queue.end) as *mut *mut libc::c_void,
+            );
+        }
+        memmove(
+            $queue
+                .head
+                .wrapping_offset($index as isize)
+                .wrapping_offset(1_isize) as *mut libc::c_void,
+            $queue.head.wrapping_offset($index as isize) as *const libc::c_void,
+            ($queue.tail.c_offset_from($queue.head) as libc::c_ulong)
+                .wrapping_sub($index)
+                .wrapping_mul(size_of::<yaml_token_t>() as libc::c_ulong),
+        );
+        *$queue.head.wrapping_offset($index as isize) = $value;
+        let fresh14 = addr_of_mut!($queue.tail);
+        *fresh14 = (*fresh14).wrapping_offset(1);
+    }};
+}

vendor/unsafe-libyaml/src/ops.rs

@@ -0,0 +1,111 @@
+pub(crate) trait ForceAdd: Sized {
+    fn force_add(self, rhs: Self) -> Self;
+}
+
+impl ForceAdd for u8 {
+    fn force_add(self, rhs: Self) -> Self {
+        self.checked_add(rhs).unwrap_or_else(die)
+    }
+}
+
+impl ForceAdd for i32 {
+    fn force_add(self, rhs: Self) -> Self {
+        self.checked_add(rhs).unwrap_or_else(die)
+    }
+}
+
+impl ForceAdd for u32 {
+    fn force_add(self, rhs: Self) -> Self {
+        self.checked_add(rhs).unwrap_or_else(die)
+    }
+}
+
+impl ForceAdd for u64 {
+    fn force_add(self, rhs: Self) -> Self {
+        self.checked_add(rhs).unwrap_or_else(die)
+    }
+}
+
+impl ForceAdd for usize {
+    fn force_add(self, rhs: Self) -> Self {
+        self.checked_add(rhs).unwrap_or_else(die)
+    }
+}
+
+pub(crate) trait ForceMul: Sized {
+    fn force_mul(self, rhs: Self) -> Self;
+}
+
+impl ForceMul for i32 {
+    fn force_mul(self, rhs: Self) -> Self {
+        self.checked_mul(rhs).unwrap_or_else(die)
+    }
+}
+
+impl ForceMul for i64 {
+    fn force_mul(self, rhs: Self) -> Self {
+        self.checked_mul(rhs).unwrap_or_else(die)
+    }
+}
+
+impl ForceMul for u64 {
+    fn force_mul(self, rhs: Self) -> Self {
+        self.checked_mul(rhs).unwrap_or_else(die)
+    }
+}
+
+pub(crate) trait ForceInto {
+    fn force_into<U>(self) -> U
+    where
+        Self: TryInto<U>;
+}
+
+impl<T> ForceInto for T {
+    fn force_into<U>(self) -> U
+    where
+        Self: TryInto<U>,
+    {
+        <Self as TryInto<U>>::try_into(self)
+            .ok()
+            .unwrap_or_else(die)
+    }
+}
+
+// Deterministically abort on arithmetic overflow, instead of wrapping and
+// continuing with invalid behavior.
+//
+// This is impossible or nearly impossible to hit as the arithmetic computations
+// in libyaml are all related to either:
+//
+//  - small integer processing (ascii, hex digits)
+//  - allocation sizing
+//
+// and the only allocations in libyaml are for fixed-sized objects and
+// geometrically growing buffers with a growth factor of 2. So in order for an
+// allocation computation to overflow usize, the previous allocation for that
+// container must have been filled to a size of usize::MAX/2, which is an
+// allocation that would have failed in the allocator. But we check for this to
+// be pedantic and to find out if it ever does happen.
+//
+// No-std abort is implemented using a double panic. On most platforms the
+// current mechanism for this is for core::intrinsics::abort to invoke an
+// invalid instruction. On Unix, the process will probably terminate with a
+// signal like SIGABRT, SIGILL, SIGTRAP, SIGSEGV or SIGBUS. The precise
+// behaviour is not guaranteed and not stable, but is safe.
+#[cold]
+pub(crate) fn die<T>() -> T {
+    struct PanicAgain;
+
+    impl Drop for PanicAgain {
+        fn drop(&mut self) {
+            panic!("arithmetic overflow");
+        }
+    }
+
+    fn do_die() -> ! {
+        let _panic_again = PanicAgain;
+        panic!("arithmetic overflow");
+    }
+
+    do_die();
+}

vendor/unsafe-libyaml/src/reader.rs

@@ -0,0 +1,468 @@
+use crate::externs::{memcmp, memmove};
+use crate::ops::ForceAdd as _;
+use crate::success::{Success, FAIL, OK};
+use crate::yaml::{size_t, yaml_char_t};
+use crate::{
+    libc, yaml_parser_t, PointerExt, YAML_ANY_ENCODING, YAML_READER_ERROR, YAML_UTF16BE_ENCODING,
+    YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
+};
+use core::ptr::addr_of_mut;
+
+unsafe fn yaml_parser_set_reader_error(
+    parser: *mut yaml_parser_t,
+    problem: *const libc::c_char,
+    offset: size_t,
+    value: libc::c_int,
+) -> Success {
+    (*parser).error = YAML_READER_ERROR;
+    let fresh0 = addr_of_mut!((*parser).problem);
+    *fresh0 = problem;
+    (*parser).problem_offset = offset;
+    (*parser).problem_value = value;
+    FAIL
+}
+
+const BOM_UTF8: *const libc::c_char = b"\xEF\xBB\xBF\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;
+
+unsafe fn yaml_parser_determine_encoding(parser: *mut yaml_parser_t) -> Success {
+    while !(*parser).eof
+        && ((*parser)
+            .raw_buffer
+            .last
+            .c_offset_from((*parser).raw_buffer.pointer) as libc::c_long)
+            < 3_i64
+    {
+        if yaml_parser_update_raw_buffer(parser).fail {
+            return FAIL;
+        }
+    }
+    if (*parser)
+        .raw_buffer
+        .last
+        .c_offset_from((*parser).raw_buffer.pointer) as libc::c_long
+        >= 2_i64
+        && memcmp(
+            (*parser).raw_buffer.pointer as *const libc::c_void,
+            BOM_UTF16LE as *const libc::c_void,
+            2_u64,
+        ) == 0
+    {
+        (*parser).encoding = YAML_UTF16LE_ENCODING;
+        let fresh1 = addr_of_mut!((*parser).raw_buffer.pointer);
+        *fresh1 = (*fresh1).wrapping_offset(2_isize);
+        let fresh2 = addr_of_mut!((*parser).offset);
+        *fresh2 = (*fresh2 as libc::c_ulong).force_add(2_u64) as size_t;
+    } else if (*parser)
+        .raw_buffer
+        .last
+        .c_offset_from((*parser).raw_buffer.pointer) as libc::c_long
+        >= 2_i64
+        && memcmp(
+            (*parser).raw_buffer.pointer as *const libc::c_void,
+            BOM_UTF16BE as *const libc::c_void,
+            2_u64,
+        ) == 0
+    {
+        (*parser).encoding = YAML_UTF16BE_ENCODING;
+        let fresh3 = addr_of_mut!((*parser).raw_buffer.pointer);
+        *fresh3 = (*fresh3).wrapping_offset(2_isize);
+        let fresh4 = addr_of_mut!((*parser).offset);
+        *fresh4 = (*fresh4 as libc::c_ulong).force_add(2_u64) as size_t;
+    } else if (*parser)
+        .raw_buffer
+        .last
+        .c_offset_from((*parser).raw_buffer.pointer) as libc::c_long
+        >= 3_i64
+        && memcmp(
+            (*parser).raw_buffer.pointer as *const libc::c_void,
+            BOM_UTF8 as *const libc::c_void,
+            3_u64,
+        ) == 0
+    {
+        (*parser).encoding = YAML_UTF8_ENCODING;
+        let fresh5 = addr_of_mut!((*parser).raw_buffer.pointer);
+        *fresh5 = (*fresh5).wrapping_offset(3_isize);
+        let fresh6 = addr_of_mut!((*parser).offset);
+        *fresh6 = (*fresh6 as libc::c_ulong).force_add(3_u64) as size_t;
+    } else {
+        (*parser).encoding = YAML_UTF8_ENCODING;
+    }
+    OK
+}
+
+unsafe fn yaml_parser_update_raw_buffer(parser: *mut yaml_parser_t) -> Success {
+    let mut size_read: size_t = 0_u64;
+    if (*parser).raw_buffer.start == (*parser).raw_buffer.pointer
+        && (*parser).raw_buffer.last == (*parser).raw_buffer.end
+    {
+        return OK;
+    }
+    if (*parser).eof {
+        return OK;
+    }
+    if (*parser).raw_buffer.start < (*parser).raw_buffer.pointer
+        && (*parser).raw_buffer.pointer < (*parser).raw_buffer.last
+    {
+        memmove(
+            (*parser).raw_buffer.start as *mut libc::c_void,
+            (*parser).raw_buffer.pointer as *const libc::c_void,
+            (*parser)
+                .raw_buffer
+                .last
+                .c_offset_from((*parser).raw_buffer.pointer) as libc::c_long
+                as libc::c_ulong,
+        );
+    }
+    let fresh7 = addr_of_mut!((*parser).raw_buffer.last);
+    *fresh7 = (*fresh7).wrapping_offset(
+        -((*parser)
+            .raw_buffer
+            .pointer
+            .c_offset_from((*parser).raw_buffer.start) as libc::c_long as isize),
+    );
+    let fresh8 = addr_of_mut!((*parser).raw_buffer.pointer);
+    *fresh8 = (*parser).raw_buffer.start;
+    if (*parser).read_handler.expect("non-null function pointer")(
+        (*parser).read_handler_data,
+        (*parser).raw_buffer.last,
+        (*parser)
+            .raw_buffer
+            .end
+            .c_offset_from((*parser).raw_buffer.last) as size_t,
+        addr_of_mut!(size_read),
+    ) == 0
+    {
+        return yaml_parser_set_reader_error(
+            parser,
+            b"input error\0" as *const u8 as *const libc::c_char,
+            (*parser).offset,
+            -1,
+        );
+    }
+    let fresh9 = addr_of_mut!((*parser).raw_buffer.last);
+    *fresh9 = (*fresh9).wrapping_offset(size_read as isize);
+    if size_read == 0 {
+        (*parser).eof = true;
+    }
+    OK
+}
+
+pub(crate) unsafe fn yaml_parser_update_buffer(
+    parser: *mut yaml_parser_t,
+    length: size_t,
+) -> Success {
+    let mut first = true;
+    __assert!(((*parser).read_handler).is_some());
+    if (*parser).eof && (*parser).raw_buffer.pointer == (*parser).raw_buffer.last {
+        return OK;
+    }
+    if (*parser).unread >= length {
+        return OK;
+    }
+    if (*parser).encoding == YAML_ANY_ENCODING {
+        if yaml_parser_determine_encoding(parser).fail {
+            return FAIL;
+        }
+    }
+    if (*parser).buffer.start < (*parser).buffer.pointer
+        && (*parser).buffer.pointer < (*parser).buffer.last
+    {
+        let size: size_t = (*parser)
+            .buffer
+            .last
+            .c_offset_from((*parser).buffer.pointer) as size_t;
+        memmove(
+            (*parser).buffer.start as *mut libc::c_void,
+            (*parser).buffer.pointer as *const libc::c_void,
+            size,
+        );
+        let fresh10 = addr_of_mut!((*parser).buffer.pointer);
+        *fresh10 = (*parser).buffer.start;
+        let fresh11 = addr_of_mut!((*parser).buffer.last);
+        *fresh11 = (*parser).buffer.start.wrapping_offset(size as isize);
+    } else if (*parser).buffer.pointer == (*parser).buffer.last {
+        let fresh12 = addr_of_mut!((*parser).buffer.pointer);
+        *fresh12 = (*parser).buffer.start;
+        let fresh13 = addr_of_mut!((*parser).buffer.last);
+        *fresh13 = (*parser).buffer.start;
+    }
+    while (*parser).unread < length {
+        if !first || (*parser).raw_buffer.pointer == (*parser).raw_buffer.last {
+            if yaml_parser_update_raw_buffer(parser).fail {
+                return FAIL;
+            }
+        }
+        first = false;
+        while (*parser).raw_buffer.pointer != (*parser).raw_buffer.last {
+            let mut value: libc::c_uint = 0;
+            let value2: libc::c_uint;
+            let mut incomplete = false;
+            let mut octet: libc::c_uchar;
+            let mut width: libc::c_uint = 0;
+            let low: libc::c_int;
+            let high: libc::c_int;
+            let mut k: size_t;
+            let raw_unread: size_t = (*parser)
+                .raw_buffer
+                .last
+                .c_offset_from((*parser).raw_buffer.pointer)
+                as size_t;
+            match (*parser).encoding {
+                YAML_UTF8_ENCODING => {
+                    octet = *(*parser).raw_buffer.pointer;
+                    width = if octet & 0x80 == 0 {
+                        1
+                    } else if octet & 0xE0 == 0xC0 {
+                        2
+                    } else if octet & 0xF0 == 0xE0 {
+                        3
+                    } else if octet & 0xF8 == 0xF0 {
+                        4
+                    } else {
+                        0
+                    } as libc::c_uint;
+                    if width == 0 {
+                        return yaml_parser_set_reader_error(
+                            parser,
+                            b"invalid leading UTF-8 octet\0" as *const u8 as *const libc::c_char,
+                            (*parser).offset,
+                            octet as libc::c_int,
+                        );
+                    }
+                    if width as libc::c_ulong > raw_unread {
+                        if (*parser).eof {
+                            return yaml_parser_set_reader_error(
+                                parser,
+                                b"incomplete UTF-8 octet sequence\0" as *const u8
+                                    as *const libc::c_char,
+                                (*parser).offset,
+                                -1,
+                            );
+                        }
+                        incomplete = true;
+                    } else {
+                        value = if octet & 0x80 == 0 {
+                            octet & 0x7F
+                        } else if octet & 0xE0 == 0xC0 {
+                            octet & 0x1F
+                        } else if octet & 0xF0 == 0xE0 {
+                            octet & 0xF
+                        } else if octet & 0xF8 == 0xF0 {
+                            octet & 0x7
+                        } else {
+                            0
+                        } as libc::c_uint;
+                        k = 1_u64;
+                        while k < width as libc::c_ulong {
+                            octet = *(*parser).raw_buffer.pointer.wrapping_offset(k as isize);
+                            if octet & 0xC0 != 0x80 {
+                                return yaml_parser_set_reader_error(
+                                    parser,
+                                    b"invalid trailing UTF-8 octet\0" as *const u8
+                                        as *const libc::c_char,
+                                    (*parser).offset.force_add(k),
+                                    octet as libc::c_int,
+                                );
+                            }
+                            value = (value << 6).force_add((octet & 0x3F) as libc::c_uint);
+                            k = k.force_add(1);
+                        }
+                        if !(width == 1
+                            || width == 2 && value >= 0x80
+                            || width == 3 && value >= 0x800
+                            || width == 4 && value >= 0x10000)
+                        {
+                            return yaml_parser_set_reader_error(
+                                parser,
+                                b"invalid length of a UTF-8 sequence\0" as *const u8
+                                    as *const libc::c_char,
+                                (*parser).offset,
+                                -1,
+                            );
+                        }
+                        if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
+                            return yaml_parser_set_reader_error(
+                                parser,
+                                b"invalid Unicode character\0" as *const u8 as *const libc::c_char,
+                                (*parser).offset,
+                                value as libc::c_int,
+                            );
+                        }
+                    }
+                }
+                YAML_UTF16LE_ENCODING | YAML_UTF16BE_ENCODING => {
+                    low = if (*parser).encoding == YAML_UTF16LE_ENCODING {
+                        0
+                    } else {
+                        1
+                    };
+                    high = if (*parser).encoding == YAML_UTF16LE_ENCODING {
+                        1
+                    } else {
+                        0
+                    };
+                    if raw_unread < 2_u64 {
+                        if (*parser).eof {
+                            return yaml_parser_set_reader_error(
+                                parser,
+                                b"incomplete UTF-16 character\0" as *const u8
+                                    as *const libc::c_char,
+                                (*parser).offset,
+                                -1,
+                            );
+                        }
+                        incomplete = true;
+                    } else {
+                        value = (*(*parser).raw_buffer.pointer.wrapping_offset(low as isize)
+                            as libc::c_int
+                            + ((*(*parser).raw_buffer.pointer.wrapping_offset(high as isize)
+                                as libc::c_int)
+                                << 8)) as libc::c_uint;
+                        if value & 0xFC00 == 0xDC00 {
+                            return yaml_parser_set_reader_error(
+                                parser,
+                                b"unexpected low surrogate area\0" as *const u8
+                                    as *const libc::c_char,
+                                (*parser).offset,
+                                value as libc::c_int,
+                            );
+                        }
+                        if value & 0xFC00 == 0xD800 {
+                            width = 4;
+                            if raw_unread < 4_u64 {
+                                if (*parser).eof {
+                                    return yaml_parser_set_reader_error(
+                                        parser,
+                                        b"incomplete UTF-16 surrogate pair\0" as *const u8
+                                            as *const libc::c_char,
+                                        (*parser).offset,
+                                        -1,
+                                    );
+                                }
+                                incomplete = true;
+                            } else {
+                                value2 = (*(*parser)
+                                    .raw_buffer
+                                    .pointer
+                                    .wrapping_offset((low + 2) as isize)
+                                    as libc::c_int
+                                    + ((*(*parser)
+                                        .raw_buffer
+                                        .pointer
+                                        .wrapping_offset((high + 2) as isize)
+                                        as libc::c_int)
+                                        << 8))
+                                    as libc::c_uint;
+                                if value2 & 0xFC00 != 0xDC00 {
+                                    return yaml_parser_set_reader_error(
+                                        parser,
+                                        b"expected low surrogate area\0" as *const u8
+                                            as *const libc::c_char,
+                                        (*parser).offset.force_add(2_u64),
+                                        value2 as libc::c_int,
+                                    );
+                                }
+                                value = 0x10000_u32
+                                    .force_add((value & 0x3FF) << 10)
+                                    .force_add(value2 & 0x3FF);
+                            }
+                        } else {
+                            width = 2;
+                        }
+                    }
+                }
+                _ => {}
+            }
+            if incomplete {
+                break;
+            }
+            if !(value == 0x9
+                || value == 0xA
+                || value == 0xD
+                || value >= 0x20 && value <= 0x7E
+                || value == 0x85
+                || value >= 0xA0 && value <= 0xD7FF
+                || value >= 0xE000 && value <= 0xFFFD
+                || value >= 0x10000 && value <= 0x10FFFF)
+            {
+                return yaml_parser_set_reader_error(
+                    parser,
+                    b"control characters are not allowed\0" as *const u8 as *const libc::c_char,
+                    (*parser).offset,
+                    value as libc::c_int,
+                );
+            }
+            let fresh14 = addr_of_mut!((*parser).raw_buffer.pointer);
+            *fresh14 = (*fresh14).wrapping_offset(width as isize);
+            let fresh15 = addr_of_mut!((*parser).offset);
+            *fresh15 = (*fresh15 as libc::c_ulong).force_add(width as libc::c_ulong) as size_t;
+            if value <= 0x7F {
+                let fresh16 = addr_of_mut!((*parser).buffer.last);
+                let fresh17 = *fresh16;
+                *fresh16 = (*fresh16).wrapping_offset(1);
+                *fresh17 = value as yaml_char_t;
+            } else if value <= 0x7FF {
+                let fresh18 = addr_of_mut!((*parser).buffer.last);
+                let fresh19 = *fresh18;
+                *fresh18 = (*fresh18).wrapping_offset(1);
+                *fresh19 = 0xC0_u32.force_add(value >> 6) as yaml_char_t;
+                let fresh20 = addr_of_mut!((*parser).buffer.last);
+                let fresh21 = *fresh20;
+                *fresh20 = (*fresh20).wrapping_offset(1);
+                *fresh21 = 0x80_u32.force_add(value & 0x3F) as yaml_char_t;
+            } else if value <= 0xFFFF {
+                let fresh22 = addr_of_mut!((*parser).buffer.last);
+                let fresh23 = *fresh22;
+                *fresh22 = (*fresh22).wrapping_offset(1);
+                *fresh23 = 0xE0_u32.force_add(value >> 12) as yaml_char_t;
+                let fresh24 = addr_of_mut!((*parser).buffer.last);
+                let fresh25 = *fresh24;
+                *fresh24 = (*fresh24).wrapping_offset(1);
+                *fresh25 = 0x80_u32.force_add(value >> 6 & 0x3F) as yaml_char_t;
+                let fresh26 = addr_of_mut!((*parser).buffer.last);
+                let fresh27 = *fresh26;
+                *fresh26 = (*fresh26).wrapping_offset(1);
+                *fresh27 = 0x80_u32.force_add(value & 0x3F) as yaml_char_t;
+            } else {
+                let fresh28 = addr_of_mut!((*parser).buffer.last);
+                let fresh29 = *fresh28;
+                *fresh28 = (*fresh28).wrapping_offset(1);
+                *fresh29 = 0xF0_u32.force_add(value >> 18) as yaml_char_t;
+                let fresh30 = addr_of_mut!((*parser).buffer.last);
+                let fresh31 = *fresh30;
+                *fresh30 = (*fresh30).wrapping_offset(1);
+                *fresh31 = 0x80_u32.force_add(value >> 12 & 0x3F) as yaml_char_t;
+                let fresh32 = addr_of_mut!((*parser).buffer.last);
+                let fresh33 = *fresh32;
+                *fresh32 = (*fresh32).wrapping_offset(1);
+                *fresh33 = 0x80_u32.force_add(value >> 6 & 0x3F) as yaml_char_t;
+                let fresh34 = addr_of_mut!((*parser).buffer.last);
+                let fresh35 = *fresh34;
+                *fresh34 = (*fresh34).wrapping_offset(1);
+                *fresh35 = 0x80_u32.force_add(value & 0x3F) as yaml_char_t;
+            }
+            let fresh36 = addr_of_mut!((*parser).unread);
+            *fresh36 = (*fresh36).force_add(1);
+        }
+        if (*parser).eof {
+            let fresh37 = addr_of_mut!((*parser).buffer.last);
+            let fresh38 = *fresh37;
+            *fresh37 = (*fresh37).wrapping_offset(1);
+            *fresh38 = b'\0';
+            let fresh39 = addr_of_mut!((*parser).unread);
+            *fresh39 = (*fresh39).force_add(1);
+            return OK;
+        }
+    }
+    if (*parser).offset >= (!0_u64).wrapping_div(2_u64) {
+        return yaml_parser_set_reader_error(
+            parser,
+            b"input is too long\0" as *const u8 as *const libc::c_char,
+            (*parser).offset,
+            -1,
+        );
+    }
+    OK
+}

vendor/unsafe-libyaml/src/success.rs

@@ -0,0 +1,25 @@
+use core::ops::Deref;
+
+pub const OK: Success = Success { ok: true };
+pub const FAIL: Success = Success { ok: false };
+
+#[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 }
+        }
+    }
+}

vendor/unsafe-libyaml/src/writer.rs

@@ -0,0 +1,149 @@
+use crate::ops::ForceAdd as _;
+use crate::success::{Success, FAIL, OK};
+use crate::yaml::size_t;
+use crate::{
+    libc, yaml_emitter_t, PointerExt, YAML_ANY_ENCODING, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
+    YAML_WRITER_ERROR,
+};
+use core::ptr::addr_of_mut;
+
+unsafe fn yaml_emitter_set_writer_error(
+    emitter: *mut yaml_emitter_t,
+    problem: *const libc::c_char,
+) -> Success {
+    (*emitter).error = YAML_WRITER_ERROR;
+    let fresh0 = addr_of_mut!((*emitter).problem);
+    *fresh0 = problem;
+    FAIL
+}
+
+/// Flush the accumulated characters to the output.
+pub unsafe fn yaml_emitter_flush(emitter: *mut yaml_emitter_t) -> Success {
+    __assert!(!emitter.is_null());
+    __assert!(((*emitter).write_handler).is_some());
+    __assert!((*emitter).encoding != YAML_ANY_ENCODING);
+    let fresh1 = addr_of_mut!((*emitter).buffer.last);
+    *fresh1 = (*emitter).buffer.pointer;
+    let fresh2 = addr_of_mut!((*emitter).buffer.pointer);
+    *fresh2 = (*emitter).buffer.start;
+    if (*emitter).buffer.start == (*emitter).buffer.last {
+        return OK;
+    }
+    if (*emitter).encoding == YAML_UTF8_ENCODING {
+        if (*emitter).write_handler.expect("non-null function pointer")(
+            (*emitter).write_handler_data,
+            (*emitter).buffer.start,
+            (*emitter)
+                .buffer
+                .last
+                .c_offset_from((*emitter).buffer.start) as size_t,
+        ) != 0
+        {
+            let fresh3 = addr_of_mut!((*emitter).buffer.last);
+            *fresh3 = (*emitter).buffer.start;
+            let fresh4 = addr_of_mut!((*emitter).buffer.pointer);
+            *fresh4 = (*emitter).buffer.start;
+            return OK;
+        } else {
+            return yaml_emitter_set_writer_error(
+                emitter,
+                b"write error\0" as *const u8 as *const libc::c_char,
+            );
+        }
+    }
+    let low: libc::c_int = if (*emitter).encoding == YAML_UTF16LE_ENCODING {
+        0
+    } else {
+        1
+    };
+    let high: libc::c_int = if (*emitter).encoding == YAML_UTF16LE_ENCODING {
+        1
+    } else {
+        0
+    };
+    while (*emitter).buffer.pointer != (*emitter).buffer.last {
+        let mut octet: libc::c_uchar;
+        let mut value: libc::c_uint;
+        let mut k: size_t;
+        octet = *(*emitter).buffer.pointer;
+        let width: libc::c_uint = if octet & 0x80 == 0 {
+            1
+        } else if octet & 0xE0 == 0xC0 {
+            2
+        } else if octet & 0xF0 == 0xE0 {
+            3
+        } else if octet & 0xF8 == 0xF0 {
+            4
+        } else {
+            0
+        } as libc::c_uint;
+        value = if octet & 0x80 == 0 {
+            octet & 0x7F
+        } else if octet & 0xE0 == 0xC0 {
+            octet & 0x1F
+        } else if octet & 0xF0 == 0xE0 {
+            octet & 0xF
+        } else if octet & 0xF8 == 0xF0 {
+            octet & 0x7
+        } else {
+            0
+        } as libc::c_uint;
+        k = 1_u64;
+        while k < width as libc::c_ulong {
+            octet = *(*emitter).buffer.pointer.wrapping_offset(k as isize);
+            value = (value << 6).force_add((octet & 0x3F) as libc::c_uint);
+            k = k.force_add(1);
+        }
+        let fresh5 = addr_of_mut!((*emitter).buffer.pointer);
+        *fresh5 = (*fresh5).wrapping_offset(width as isize);
+        if value < 0x10000 {
+            *(*emitter).raw_buffer.last.wrapping_offset(high as isize) =
+                (value >> 8) as libc::c_uchar;
+            *(*emitter).raw_buffer.last.wrapping_offset(low as isize) =
+                (value & 0xFF) as libc::c_uchar;
+            let fresh6 = addr_of_mut!((*emitter).raw_buffer.last);
+            *fresh6 = (*fresh6).wrapping_offset(2_isize);
+        } else {
+            value = value.wrapping_sub(0x10000);
+            *(*emitter).raw_buffer.last.wrapping_offset(high as isize) =
+                0xD8_u32.force_add(value >> 18) as libc::c_uchar;
+            *(*emitter).raw_buffer.last.wrapping_offset(low as isize) =
+                (value >> 10 & 0xFF) as libc::c_uchar;
+            *(*emitter)
+                .raw_buffer
+                .last
+                .wrapping_offset((high + 2) as isize) =
+                0xDC_u32.force_add(value >> 8 & 0xFF) as libc::c_uchar;
+            *(*emitter)
+                .raw_buffer
+                .last
+                .wrapping_offset((low + 2) as isize) = (value & 0xFF) as libc::c_uchar;
+            let fresh7 = addr_of_mut!((*emitter).raw_buffer.last);
+            *fresh7 = (*fresh7).wrapping_offset(4_isize);
+        }
+    }
+    if (*emitter).write_handler.expect("non-null function pointer")(
+        (*emitter).write_handler_data,
+        (*emitter).raw_buffer.start,
+        (*emitter)
+            .raw_buffer
+            .last
+            .c_offset_from((*emitter).raw_buffer.start) as size_t,
+    ) != 0
+    {
+        let fresh8 = addr_of_mut!((*emitter).buffer.last);
+        *fresh8 = (*emitter).buffer.start;
+        let fresh9 = addr_of_mut!((*emitter).buffer.pointer);
+        *fresh9 = (*emitter).buffer.start;
+        let fresh10 = addr_of_mut!((*emitter).raw_buffer.last);
+        *fresh10 = (*emitter).raw_buffer.start;
+        let fresh11 = addr_of_mut!((*emitter).raw_buffer.pointer);
+        *fresh11 = (*emitter).raw_buffer.start;
+        OK
+    } else {
+        yaml_emitter_set_writer_error(
+            emitter,
+            b"write error\0" as *const u8 as *const libc::c_char,
+        )
+    }
+}