Coverage Report

Created: 2025-07-12 06:26

/rust/registry/src/index.crates.io-6f17d22bba15001f/unsafe-libyaml-0.2.11/src/writer.rs
Line
Count
Source (jump to first uncovered line)
1
use crate::ops::ForceAdd as _;
2
use crate::success::{Success, FAIL, OK};
3
use crate::yaml::size_t;
4
use crate::{
5
    libc, yaml_emitter_t, PointerExt, YAML_ANY_ENCODING, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
6
    YAML_WRITER_ERROR,
7
};
8
use core::ptr::addr_of_mut;
9
10
0
unsafe fn yaml_emitter_set_writer_error(
11
0
    emitter: *mut yaml_emitter_t,
12
0
    problem: *const libc::c_char,
13
0
) -> Success {
14
0
    (*emitter).error = YAML_WRITER_ERROR;
15
0
    let fresh0 = addr_of_mut!((*emitter).problem);
16
0
    *fresh0 = problem;
17
0
    FAIL
18
0
}
19
20
/// Flush the accumulated characters to the output.
21
0
pub unsafe fn yaml_emitter_flush(emitter: *mut yaml_emitter_t) -> Success {
22
0
    __assert!(!emitter.is_null());
23
0
    __assert!(((*emitter).write_handler).is_some());
24
0
    __assert!((*emitter).encoding != YAML_ANY_ENCODING);
25
0
    let fresh1 = addr_of_mut!((*emitter).buffer.last);
26
0
    *fresh1 = (*emitter).buffer.pointer;
27
0
    let fresh2 = addr_of_mut!((*emitter).buffer.pointer);
28
0
    *fresh2 = (*emitter).buffer.start;
29
0
    if (*emitter).buffer.start == (*emitter).buffer.last {
30
0
        return OK;
31
0
    }
32
0
    if (*emitter).encoding == YAML_UTF8_ENCODING {
33
0
        if (*emitter).write_handler.expect("non-null function pointer")(
34
0
            (*emitter).write_handler_data,
35
0
            (*emitter).buffer.start,
36
0
            (*emitter)
37
0
                .buffer
38
0
                .last
39
0
                .c_offset_from((*emitter).buffer.start) as size_t,
40
0
        ) != 0
41
        {
42
0
            let fresh3 = addr_of_mut!((*emitter).buffer.last);
43
0
            *fresh3 = (*emitter).buffer.start;
44
0
            let fresh4 = addr_of_mut!((*emitter).buffer.pointer);
45
0
            *fresh4 = (*emitter).buffer.start;
46
0
            return OK;
47
        } else {
48
0
            return yaml_emitter_set_writer_error(
49
0
                emitter,
50
0
                b"write error\0" as *const u8 as *const libc::c_char,
51
0
            );
52
        }
53
0
    }
54
0
    let low: libc::c_int = if (*emitter).encoding == YAML_UTF16LE_ENCODING {
55
0
        0
56
    } else {
57
0
        1
58
    };
59
0
    let high: libc::c_int = if (*emitter).encoding == YAML_UTF16LE_ENCODING {
60
0
        1
61
    } else {
62
0
        0
63
    };
64
0
    while (*emitter).buffer.pointer != (*emitter).buffer.last {
65
        let mut octet: libc::c_uchar;
66
        let mut value: libc::c_uint;
67
        let mut k: size_t;
68
0
        octet = *(*emitter).buffer.pointer;
69
0
        let width: libc::c_uint = if octet & 0x80 == 0 {
70
0
            1
71
0
        } else if octet & 0xE0 == 0xC0 {
72
0
            2
73
0
        } else if octet & 0xF0 == 0xE0 {
74
0
            3
75
0
        } else if octet & 0xF8 == 0xF0 {
76
0
            4
77
        } else {
78
0
            0
79
        } as libc::c_uint;
80
0
        value = if octet & 0x80 == 0 {
81
0
            octet & 0x7F
82
0
        } else if octet & 0xE0 == 0xC0 {
83
0
            octet & 0x1F
84
0
        } else if octet & 0xF0 == 0xE0 {
85
0
            octet & 0xF
86
0
        } else if octet & 0xF8 == 0xF0 {
87
0
            octet & 0x7
88
        } else {
89
0
            0
90
        } as libc::c_uint;
91
0
        k = 1_u64;
92
0
        while k < width as libc::c_ulong {
93
0
            octet = *(*emitter).buffer.pointer.wrapping_offset(k as isize);
94
0
            value = (value << 6).force_add((octet & 0x3F) as libc::c_uint);
95
0
            k = k.force_add(1);
96
0
        }
97
0
        let fresh5 = addr_of_mut!((*emitter).buffer.pointer);
98
0
        *fresh5 = (*fresh5).wrapping_offset(width as isize);
99
0
        if value < 0x10000 {
100
0
            *(*emitter).raw_buffer.last.wrapping_offset(high as isize) =
101
0
                (value >> 8) as libc::c_uchar;
102
0
            *(*emitter).raw_buffer.last.wrapping_offset(low as isize) =
103
0
                (value & 0xFF) as libc::c_uchar;
104
0
            let fresh6 = addr_of_mut!((*emitter).raw_buffer.last);
105
0
            *fresh6 = (*fresh6).wrapping_offset(2_isize);
106
0
        } else {
107
0
            value = value.wrapping_sub(0x10000);
108
0
            *(*emitter).raw_buffer.last.wrapping_offset(high as isize) =
109
0
                0xD8_u32.force_add(value >> 18) as libc::c_uchar;
110
0
            *(*emitter).raw_buffer.last.wrapping_offset(low as isize) =
111
0
                (value >> 10 & 0xFF) as libc::c_uchar;
112
0
            *(*emitter)
113
0
                .raw_buffer
114
0
                .last
115
0
                .wrapping_offset((high + 2) as isize) =
116
0
                0xDC_u32.force_add(value >> 8 & 0xFF) as libc::c_uchar;
117
0
            *(*emitter)
118
0
                .raw_buffer
119
0
                .last
120
0
                .wrapping_offset((low + 2) as isize) = (value & 0xFF) as libc::c_uchar;
121
0
            let fresh7 = addr_of_mut!((*emitter).raw_buffer.last);
122
0
            *fresh7 = (*fresh7).wrapping_offset(4_isize);
123
0
        }
124
    }
125
0
    if (*emitter).write_handler.expect("non-null function pointer")(
126
0
        (*emitter).write_handler_data,
127
0
        (*emitter).raw_buffer.start,
128
0
        (*emitter)
129
0
            .raw_buffer
130
0
            .last
131
0
            .c_offset_from((*emitter).raw_buffer.start) as size_t,
132
0
    ) != 0
133
    {
134
0
        let fresh8 = addr_of_mut!((*emitter).buffer.last);
135
0
        *fresh8 = (*emitter).buffer.start;
136
0
        let fresh9 = addr_of_mut!((*emitter).buffer.pointer);
137
0
        *fresh9 = (*emitter).buffer.start;
138
0
        let fresh10 = addr_of_mut!((*emitter).raw_buffer.last);
139
0
        *fresh10 = (*emitter).raw_buffer.start;
140
0
        let fresh11 = addr_of_mut!((*emitter).raw_buffer.pointer);
141
0
        *fresh11 = (*emitter).raw_buffer.start;
142
0
        OK
143
    } else {
144
0
        yaml_emitter_set_writer_error(
145
0
            emitter,
146
0
            b"write error\0" as *const u8 as *const libc::c_char,
147
0
        )
148
    }
149
0
}