Build aicasm as host program, not via world's compiler.
[dragonfly.git] / lib / libc / locale / utf8.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 2002 Tim J. Robbins
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
1de703da
MD
25 *
26 * $FreeBSD: src/lib/libc/locale/utf8.c,v 1.1.2.1 2002/10/24 11:00:52 tjr Exp $
27 * $DragonFly: src/lib/libc/locale/Attic/utf8.c,v 1.2 2003/06/17 04:26:44 dillon Exp $
984263bc
MD
28 */
29
984263bc
MD
30#include <rune.h>
31#include <stddef.h>
32#include <stdio.h>
33#include <stdlib.h>
34
35rune_t _UTF8_sgetrune(const char *, size_t, char const **);
36int _UTF8_sputrune(rune_t, char *, size_t, char **);
37
38int
39_UTF8_init(_RuneLocale *rl)
40{
41
42 rl->sgetrune = _UTF8_sgetrune;
43 rl->sputrune = _UTF8_sputrune;
44 _CurrentRuneLocale = rl;
45 __mb_cur_max = 6;
46
47 return (0);
48}
49
50rune_t
51_UTF8_sgetrune(const char *string, size_t n, const char **result)
52{
53 int ch, len, mask, siglen;
54 rune_t lbound, wch;
55
56 if (n < 1) {
57 if (result != NULL)
58 *result = string;
59 return (_INVALID_RUNE);
60 }
61
62 /*
63 * Determine the number of octets that make up this character from
64 * the first octet, and a mask that extracts the interesting bits of
65 * the first octet.
66 *
67 * We also specify a lower bound for the character code to detect
68 * redundant, non-"shortest form" encodings. For example, the
69 * sequence C0 80 is _not_ a legal representation of the null
70 * character. This enforces a 1-to-1 mapping between character
71 * codes and their multibyte representations.
72 */
73 ch = (unsigned char)*string;
74 if ((ch & 0x80) == 0) {
75 mask = 0x7f;
76 len = 1;
77 lbound = 0;
78 } else if ((ch & 0xe0) == 0xc0) {
79 mask = 0x1f;
80 len = 2;
81 lbound = 0x80;
82 } else if ((ch & 0xf0) == 0xe0) {
83 mask = 0x0f;
84 len = 3;
85 lbound = 0x800;
86 } else if ((ch & 0xf8) == 0xf0) {
87 mask = 0x07;
88 len = 4;
89 lbound = 0x10000;
90 } else if ((ch & 0xfc) == 0xf8) {
91 mask = 0x03;
92 len = 5;
93 lbound = 0x200000;
94 } else if ((ch & 0xfc) == 0xfc) {
95 mask = 0x01;
96 len = 6;
97 lbound = 0x4000000;
98 } else {
99 /*
100 * Malformed input; input is not UTF-8.
101 */
102 if (result != NULL)
103 *result = string + 1;
104 return (_INVALID_RUNE);
105 }
106
107 if (n < len) {
108 /*
109 * Truncated or partial input.
110 */
111 if (result != NULL)
112 *result = string;
113 return (_INVALID_RUNE);
114 }
115
116 /*
117 * Decode the octet sequence representing the character in chunks
118 * of 6 bits, most significant first.
119 */
120 wch = (unsigned char)*string++ & mask;
121 while (--len != 0) {
122 if ((*string & 0xc0) != 0x80) {
123 /*
124 * Malformed input; bad characters in the middle
125 * of a character.
126 */
127 wch = _INVALID_RUNE;
128 if (result != NULL)
129 *result = string + 1;
130 return (_INVALID_RUNE);
131 }
132 wch <<= 6;
133 wch |= *string++ & 0x3f;
134 }
135 if (wch != _INVALID_RUNE && wch < lbound)
136 /*
137 * Malformed input; redundant encoding.
138 */
139 wch = _INVALID_RUNE;
140 if (result != NULL)
141 *result = string;
142 return (wch);
143}
144
145int
146_UTF8_sputrune(rune_t c, char *string, size_t n, char **result)
147{
148 unsigned char lead;
149 int i, len;
150
151 /*
152 * Determine the number of octets needed to represent this character.
153 * We always output the shortest sequence possible. Also specify the
154 * first few bits of the first octet, which contains the information
155 * about the sequence length.
156 */
157 if ((c & ~0x7f) == 0) {
158 lead = 0;
159 len = 1;
160 } else if ((c & ~0x7ff) == 0) {
161 lead = 0xc0;
162 len = 2;
163 } else if ((c & ~0xffff) == 0) {
164 lead = 0xe0;
165 len = 3;
166 } else if ((c & ~0x1fffff) == 0) {
167 lead = 0xf0;
168 len = 4;
169 } else if ((c & ~0x3ffffff) == 0) {
170 lead = 0xf8;
171 len = 5;
172 } else if ((c & ~0x7fffffff) == 0) {
173 lead = 0xfc;
174 len = 6;
175 } else {
176 /*
177 * Wide character code is out of range.
178 */
179 if (result != NULL)
180 *result = NULL;
181 return (0);
182 }
183
184 if (n < len) {
185 if (result != NULL)
186 *result = NULL;
187 } else {
188 /*
189 * Output the octets representing the character in chunks
190 * of 6 bits, least significant last. The first octet is
191 * a special case because it contains the sequence length
192 * information.
193 */
194 for (i = len - 1; i > 0; i--) {
195 string[i] = (c & 0x3f) | 0x80;
196 c >>= 6;
197 }
198 *string = (c & 0xff) | lead;
199 if (result != NULL)
200 *result = string + len;
201 }
202
203 return (len);
204}