/src/jansson/src/utf.c

Source
/*
 * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
 *
 * Jansson is free software; you can redistribute it and/or modify
 * it under the terms of the MIT license. See LICENSE for details.
 */

#include "utf.h"
#include <string.h>

int utf8_encode(int32_t codepoint, char *buffer, size_t *size) {
    if (codepoint < 0)
        return -1;
    else if (codepoint < 0x80) {
        buffer[0] = (char)codepoint;
        *size = 1;
    } else if (codepoint < 0x800) {
        buffer[0] = 0xC0 + ((codepoint & 0x7C0) >> 6);
        buffer[1] = 0x80 + ((codepoint & 0x03F));
        *size = 2;
    } else if (codepoint < 0x10000) {
        buffer[0] = 0xE0 + ((codepoint & 0xF000) >> 12);
        buffer[1] = 0x80 + ((codepoint & 0x0FC0) >> 6);
        buffer[2] = 0x80 + ((codepoint & 0x003F));
        *size = 3;
    } else if (codepoint <= 0x10FFFF) {
        buffer[0] = 0xF0 + ((codepoint & 0x1C0000) >> 18);
        buffer[1] = 0x80 + ((codepoint & 0x03F000) >> 12);
        buffer[2] = 0x80 + ((codepoint & 0x000FC0) >> 6);
        buffer[3] = 0x80 + ((codepoint & 0x00003F));
        *size = 4;
    } else
        return -1;

    return 0;
}

size_t utf8_check_first(char byte) {
    unsigned char u = (unsigned char)byte;

    if (u < 0x80)
        return 1;

    if (0x80 <= u && u <= 0xBF) {
        /* second, third or fourth byte of a multi-byte
           sequence, i.e. a "continuation byte" */
        return 0;
    } else if (u == 0xC0 || u == 0xC1) {
        /* overlong encoding of an ASCII byte */
        return 0;
    } else if (0xC2 <= u && u <= 0xDF) {
        /* 2-byte sequence */
        return 2;
    }

    else if (0xE0 <= u && u <= 0xEF) {
        /* 3-byte sequence */
        return 3;
    } else if (0xF0 <= u && u <= 0xF4) {
        /* 4-byte sequence */
        return 4;
    } else { /* u >= 0xF5 */
        /* Restricted (start of 4-, 5- or 6-byte sequence) or invalid
           UTF-8 */
        return 0;
    }
}

size_t utf8_check_full(const char *buffer, size_t size, int32_t *codepoint) {
    size_t i;
    int32_t value = 0;
    unsigned char u = (unsigned char)buffer[0];

    if (size == 2) {
        value = u & 0x1F;
    } else if (size == 3) {
        value = u & 0xF;
    } else if (size == 4) {
        value = u & 0x7;
    } else
        return 0;

    for (i = 1; i < size; i++) {
        u = (unsigned char)buffer[i];

        if (u < 0x80 || u > 0xBF) {
            /* not a continuation byte */
            return 0;
        }

        value = (value << 6) + (u & 0x3F);
    }

    if (value > 0x10FFFF) {
        /* not in Unicode range */
        return 0;
    }

    else if (0xD800 <= value && value <= 0xDFFF) {
        /* invalid code point (UTF-16 surrogate halves) */
        return 0;
    }

    else if ((size == 2 && value < 0x80) || (size == 3 && value < 0x800) ||
             (size == 4 && value < 0x10000)) {
        /* overlong encoding */
        return 0;
    }

    if (codepoint)
        *codepoint = value;

    return 1;
}

const char *utf8_iterate(const char *buffer, size_t bufsize, int32_t *codepoint) {
    size_t count;
    int32_t value;

    if (!bufsize)
        return buffer;

    count = utf8_check_first(buffer[0]);
    if (count <= 0)
        return NULL;

    if (count == 1)
        value = (unsigned char)buffer[0];
    else {
        if (count > bufsize || !utf8_check_full(buffer, count, &value))
            return NULL;
    }

    if (codepoint)
        *codepoint = value;

    return buffer + count;
}

int utf8_check_string(const char *string, size_t length) {
    size_t i;

    for (i = 0; i < length; i++) {
        size_t count = utf8_check_first(string[i]);
        if (count == 0)
            return 0;
        else if (count > 1) {
            if (count > length - i)
                return 0;

            if (!utf8_check_full(&string[i], count, NULL))
                return 0;

            i += count - 1;
        }
    }

    return 1;
}

Line	Count	Source
1		/*
2		* Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
3		*
4		* Jansson is free software; you can redistribute it and/or modify
5		* it under the terms of the MIT license. See LICENSE for details.
6		*/
7
8		#include "utf.h"
9		#include <string.h>
10
11	3.25k	int utf8_encode(int32_t codepoint, char buffer, size_t size) {
12	3.25k	if (codepoint < 0)
13	0	return -1;
14	3.25k	else if (codepoint < 0x80) {
15	859	buffer[0] = (char)codepoint;
16	859	*size = 1;
17	2.39k	} else if (codepoint < 0x800) {
18	325	buffer[0] = 0xC0 + ((codepoint & 0x7C0) >> 6);
19	325	buffer[1] = 0x80 + ((codepoint & 0x03F));
20	325	*size = 2;
21	2.07k	} else if (codepoint < 0x10000) {
22	1.29k	buffer[0] = 0xE0 + ((codepoint & 0xF000) >> 12);
23	1.29k	buffer[1] = 0x80 + ((codepoint & 0x0FC0) >> 6);
24	1.29k	buffer[2] = 0x80 + ((codepoint & 0x003F));
25	1.29k	*size = 3;
26	1.29k	} else if (codepoint <= 0x10FFFF) {
27	773	buffer[0] = 0xF0 + ((codepoint & 0x1C0000) >> 18);
28	773	buffer[1] = 0x80 + ((codepoint & 0x03F000) >> 12);
29	773	buffer[2] = 0x80 + ((codepoint & 0x000FC0) >> 6);
30	773	buffer[3] = 0x80 + ((codepoint & 0x00003F));
31	773	*size = 4;
32	773	} else
33	0	return -1;
34
35	3.25k	return 0;
36	3.25k	}
37
38	4.87M	size_t utf8_check_first(char byte) {
39	4.87M	unsigned char u = (unsigned char)byte;
40
41	4.87M	if (u < 0x80)
42	3.63M	return 1;
43
44	1.23M	if (0x80 <= u && u <= 0xBF) {
45		/* second, third or fourth byte of a multi-byte
46		sequence, i.e. a "continuation byte" */
47	611k	return 0;
48	623k	} else if (u == 0xC0 \|\| u == 0xC1) {
49		/* overlong encoding of an ASCII byte */
50	544	return 0;
51	623k	} else if (0xC2 <= u && u <= 0xDF) {
52		/* 2-byte sequence */
53	7.85k	return 2;
54	7.85k	}
55
56	615k	else if (0xE0 <= u && u <= 0xEF) {
57		/* 3-byte sequence */
58	610k	return 3;
59	610k	} else if (0xF0 <= u && u <= 0xF4) {
60		/* 4-byte sequence */
61	3.94k	return 4;
62	3.94k	} else { /* u >= 0xF5 */
63		/* Restricted (start of 4-, 5- or 6-byte sequence) or invalid
64		UTF-8 */
65	892	return 0;
66	892	}
67	1.23M	}
68
69	314k	size_t utf8_check_full(const char buffer, size_t size, int32_t codepoint) {
70	314k	size_t i;
71	314k	int32_t value = 0;
72	314k	unsigned char u = (unsigned char)buffer[0];
73
74	314k	if (size == 2) {
75	4.77k	value = u & 0x1F;
76	310k	} else if (size == 3) {
77	306k	value = u & 0xF;
78	306k	} else if (size == 4) {
79	3.21k	value = u & 0x7;
80	3.21k	} else
81	0	return 0;
82
83	936k	for (i = 1; i < size; i++) {
84	625k	u = (unsigned char)buffer[i];
85
86	625k	if (u < 0x80 \|\| u > 0xBF) {
87		/* not a continuation byte */
88	3.74k	return 0;
89	3.74k	}
90
91	621k	value = (value << 6) + (u & 0x3F);
92	621k	}
93
94	311k	if (value > 0x10FFFF) {
95		/* not in Unicode range */
96	197	return 0;
97	197	}
98
99	310k	else if (0xD800 <= value && value <= 0xDFFF) {
100		/* invalid code point (UTF-16 surrogate halves) */
101	211	return 0;
102	211	}
103
104	310k	else if ((size == 2 && value < 0x80) \|\| (size == 3 && value < 0x800) \|\|
105	310k	(size == 4 && value < 0x10000)) {
106		/* overlong encoding */
107	461	return 0;
108	461	}
109
110	310k	if (codepoint)
111	1.86k	*codepoint = value;
112
113	310k	return 1;
114	311k	}
115
116	957k	const char utf8_iterate(const char buffer, size_t bufsize, int32_t *codepoint) {
117	957k	size_t count;
118	957k	int32_t value;
119
120	957k	if (!bufsize)
121	0	return buffer;
122
123	957k	count = utf8_check_first(buffer[0]);
124	957k	if (count <= 0)
125	0	return NULL;
126
127	957k	if (count == 1)
128	955k	value = (unsigned char)buffer[0];
129	1.86k	else {
130	1.86k	if (count > bufsize \|\| !utf8_check_full(buffer, count, &value))
131	0	return NULL;
132	1.86k	}
133
134	957k	if (codepoint)
135	957k	*codepoint = value;
136
137	957k	return buffer + count;
138	957k	}
139
140	65.0k	int utf8_check_string(const char *string, size_t length) {
141	65.0k	size_t i;
142
143	1.04M	for (i = 0; i < length; i++) {
144	979k	size_t count = utf8_check_first(string[i]);
145	979k	if (count == 0)
146	39	return 0;
147	979k	else if (count > 1) {
148	2.40k	if (count > length - i)
149	12	return 0;
150
151	2.39k	if (!utf8_check_full(&string[i], count, NULL))
152	79	return 0;
153
154	2.31k	i += count - 1;
155	2.31k	}
156	979k	}
157
158	64.9k	return 1;
159	65.0k	}

Coverage Report

Created: 2026-09-03 06:52