/src/libyaml/src/writer.c

Source (jump to first uncovered line)

#include "yaml_private.h"

/*
 * Declarations.
 */

static int
yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem);

YAML_DECLARE(int)
yaml_emitter_flush(yaml_emitter_t *emitter);

/*
 * Set the writer error and return 0.
 */

static int
yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem)
{
    emitter->error = YAML_WRITER_ERROR;
    emitter->problem = problem;

    return 0;
}

/*
 * Flush the output buffer.
 */

YAML_DECLARE(int)
yaml_emitter_flush(yaml_emitter_t *emitter)
{
    int low, high;

    assert(emitter);    /* Non-NULL emitter object is expected. */
    assert(emitter->write_handler); /* Write handler must be set. */
    assert(emitter->encoding);  /* Output encoding must be set. */

    emitter->buffer.last = emitter->buffer.pointer;
    emitter->buffer.pointer = emitter->buffer.start;

    /* Check if the buffer is empty. */

    if (emitter->buffer.start == emitter->buffer.last) {
        return 1;
    }

    /* If the output encoding is UTF-8, we don't need to recode the buffer. */

    if (emitter->encoding == YAML_UTF8_ENCODING)
    {
        if (emitter->write_handler(emitter->write_handler_data,
                    emitter->buffer.start,
                    emitter->buffer.last - emitter->buffer.start)) {
            emitter->buffer.last = emitter->buffer.start;
            emitter->buffer.pointer = emitter->buffer.start;
            return 1;
        }
        else {
            return yaml_emitter_set_writer_error(emitter, "write error");
        }
    }

    /* Recode the buffer into the raw buffer. */

    low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
    high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);

    while (emitter->buffer.pointer != emitter->buffer.last)
    {
        unsigned char octet;
        unsigned int width;
        unsigned int value;
        size_t k;

        /*
         * See the "reader.c" code for more details on UTF-8 encoding.  Note
         * that we assume that the buffer contains a valid UTF-8 sequence.
         */

        /* Read the next UTF-8 character. */

        octet = emitter->buffer.pointer[0];

        width = (octet & 0x80) == 0x00 ? 1 :
                (octet & 0xE0) == 0xC0 ? 2 :
                (octet & 0xF0) == 0xE0 ? 3 :
                (octet & 0xF8) == 0xF0 ? 4 : 0;

        value = (octet & 0x80) == 0x00 ? octet & 0x7F :
                (octet & 0xE0) == 0xC0 ? octet & 0x1F :
                (octet & 0xF0) == 0xE0 ? octet & 0x0F :
                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;

        for (k = 1; k < width; k ++) {
            octet = emitter->buffer.pointer[k];
            value = (value << 6) + (octet & 0x3F);
        }

        emitter->buffer.pointer += width;

        /* Write the character. */

        if (value < 0x10000)
        {
            emitter->raw_buffer.last[high] = value >> 8;
            emitter->raw_buffer.last[low] = value & 0xFF;

            emitter->raw_buffer.last += 2;
        }
        else
        {
            /* Write the character using a surrogate pair (check "reader.c"). */

            value -= 0x10000;
            emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
            emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
            emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
            emitter->raw_buffer.last[low+2] = value & 0xFF;

            emitter->raw_buffer.last += 4;
        }
    }

    /* Write the raw buffer. */

    if (emitter->write_handler(emitter->write_handler_data,
                emitter->raw_buffer.start,
                emitter->raw_buffer.last - emitter->raw_buffer.start)) {
        emitter->buffer.last = emitter->buffer.start;
        emitter->buffer.pointer = emitter->buffer.start;
        emitter->raw_buffer.last = emitter->raw_buffer.start;
        emitter->raw_buffer.pointer = emitter->raw_buffer.start;
        return 1;
    }
    else {
        return yaml_emitter_set_writer_error(emitter, "write error");
    }
}


Line	Count	Source (jump to first uncovered line)
1
2		#include "yaml_private.h"
3
4		/*
5		* Declarations.
6		*/
7
8		static int
9		yaml_emitter_set_writer_error(yaml_emitter_t emitter, const char problem);
10
11		YAML_DECLARE(int)
12		yaml_emitter_flush(yaml_emitter_t *emitter);
13
14		/*
15		* Set the writer error and return 0.
16		*/
17
18		static int
19		yaml_emitter_set_writer_error(yaml_emitter_t emitter, const char problem)
20	4.24k	{
21	4.24k	emitter->error = YAML_WRITER_ERROR;
22	4.24k	emitter->problem = problem;
23
24	4.24k	return 0;
25	4.24k	}
26
27		/*
28		* Flush the output buffer.
29		*/
30
31		YAML_DECLARE(int)
32		yaml_emitter_flush(yaml_emitter_t *emitter)
33	256k	{
34	256k	int low, high;
35
36	256k	assert(emitter); /* Non-NULL emitter object is expected. */
37	256k	assert(emitter->write_handler); /* Write handler must be set. */
38	256k	assert(emitter->encoding); /* Output encoding must be set. */
39
40	256k	emitter->buffer.last = emitter->buffer.pointer;
41	256k	emitter->buffer.pointer = emitter->buffer.start;
42
43		/* Check if the buffer is empty. */
44
45	256k	if (emitter->buffer.start == emitter->buffer.last) {
46	1.16k	return 1;
47	1.16k	}
48
49		/* If the output encoding is UTF-8, we don't need to recode the buffer. */
50
51	255k	if (emitter->encoding == YAML_UTF8_ENCODING)
52	251k	{
53	251k	if (emitter->write_handler(emitter->write_handler_data,
54	251k	emitter->buffer.start,
55	251k	emitter->buffer.last - emitter->buffer.start)) {
56	247k	emitter->buffer.last = emitter->buffer.start;
57	247k	emitter->buffer.pointer = emitter->buffer.start;
58	247k	return 1;
59	247k	}
60	3.95k	else {
61	3.95k	return yaml_emitter_set_writer_error(emitter, "write error");
62	3.95k	}
63	251k	}
64
65		/* Recode the buffer into the raw buffer. */
66
67	3.62k	low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
68	3.62k	high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
69
70	42.8M	while (emitter->buffer.pointer != emitter->buffer.last)
71	42.8M	{
72	42.8M	unsigned char octet;
73	42.8M	unsigned int width;
74	42.8M	unsigned int value;
75	42.8M	size_t k;
76
77		/*
78		* See the "reader.c" code for more details on UTF-8 encoding. Note
79		* that we assume that the buffer contains a valid UTF-8 sequence.
80		*/
81
82		/* Read the next UTF-8 character. */
83
84	42.8M	octet = emitter->buffer.pointer[0];
85
86	42.8M	width = (octet & 0x80) == 0x00 ? 1 :
87	42.8M	(octet & 0xE0) == 0xC0 ? 2 :
88	2.45M	(octet & 0xF0) == 0xE0 ? 3 :
89	2.45M	(octet & 0xF8) == 0xF0 ? 4 : 0;
90
91	42.8M	value = (octet & 0x80) == 0x00 ? octet & 0x7F :
92	42.8M	(octet & 0xE0) == 0xC0 ? octet & 0x1F :
93	2.45M	(octet & 0xF0) == 0xE0 ? octet & 0x0F :
94	2.45M	(octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
95
96	47.7M	for (k = 1; k < width; k ++) {
97	4.91M	octet = emitter->buffer.pointer[k];
98	4.91M	value = (value << 6) + (octet & 0x3F);
99	4.91M	}
100
101	42.8M	emitter->buffer.pointer += width;
102
103		/* Write the character. */
104
105	42.8M	if (value < 0x10000)
106	42.8M	{
107	42.8M	emitter->raw_buffer.last[high] = value >> 8;
108	42.8M	emitter->raw_buffer.last[low] = value & 0xFF;
109
110	42.8M	emitter->raw_buffer.last += 2;
111	42.8M	}
112	0	else
113	0	{
114		/* Write the character using a surrogate pair (check "reader.c"). */
115
116	0	value -= 0x10000;
117	0	emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
118	0	emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
119	0	emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
120	0	emitter->raw_buffer.last[low+2] = value & 0xFF;
121
122	0	emitter->raw_buffer.last += 4;
123	0	}
124	42.8M	}
125
126		/* Write the raw buffer. */
127
128	3.62k	if (emitter->write_handler(emitter->write_handler_data,
129	3.62k	emitter->raw_buffer.start,
130	3.62k	emitter->raw_buffer.last - emitter->raw_buffer.start)) {
131	3.33k	emitter->buffer.last = emitter->buffer.start;
132	3.33k	emitter->buffer.pointer = emitter->buffer.start;
133	3.33k	emitter->raw_buffer.last = emitter->raw_buffer.start;
134	3.33k	emitter->raw_buffer.pointer = emitter->raw_buffer.start;
135	3.33k	return 1;
136	3.33k	}
137	293	else {
138	293	return yaml_emitter_set_writer_error(emitter, "write error");
139	293	}
140	3.62k	}
141

Coverage Report

Created: 2025-07-11 06:35