1 /*-
2 * Copyright 2010 Nexenta Systems, Inc. All rights reserved.
3 * Copyright 2015 John Marino <draco@marino.st>
4 *
5 * This source code is derived from the illumos localedef command, and
6 * provided under BSD-style license terms by Nexenta Systems, Inc.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 /*
32 * CHARMAP file handling for localedef.
33 */
34
35 #include <sys/types.h>
36 #include <sys/tree.h>
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <limits.h>
42 #include <stddef.h>
43 #include <unistd.h>
44 #include "localedef.h"
45 #include "parser.h"
46
47
48 typedef struct charmap {
49 const char *name;
50 wchar_t wc;
51 RB_ENTRY(charmap) rb_sym;
52 RB_ENTRY(charmap) rb_wc;
53 } charmap_t;
54
55 static int cmap_compare_sym(const void *n1, const void *n2);
56 static int cmap_compare_wc(const void *n1, const void *n2);
57
58 static RB_HEAD(cmap_sym, charmap) cmap_sym;
59 static RB_HEAD(cmap_wc, charmap) cmap_wc;
60
61 RB_GENERATE_STATIC(cmap_sym, charmap, rb_sym, cmap_compare_sym);
62 RB_GENERATE_STATIC(cmap_wc, charmap, rb_wc, cmap_compare_wc);
63
64 /*
65 * Array of POSIX specific portable characters.
66 */
67
68 static const struct {
69 const char *name;
70 int ch;
71 } portable_chars[] = {
72 { "NUL", '\0' },
73 { "SOH", '\x01' },
74 { "STX", '\x02' },
75 { "ETX", '\x03' },
76 { "EOT", '\x04' },
77 { "ENQ", '\x05' },
78 { "ACK", '\x06' },
79 { "BEL", '\a' },
80 { "alert", '\a' },
81 { "BS", '\b' },
82 { "backspace", '\b' },
83 { "HT", '\t' },
84 { "tab", '\t' },
85 { "LF", '\n' },
86 { "newline", '\n' },
87 { "VT", '\v' },
88 { "vertical-tab", '\v' },
89 { "FF", '\f' },
90 { "form-feed", '\f' },
91 { "CR", '\r' },
92 { "carriage-return", '\r' },
93 { "SO", '\x0e' },
94 { "SI", '\x0f' },
95 { "DLE", '\x10' },
96 { "DC1", '\x11' },
97 { "DC2", '\x12' },
98 { "DC3", '\x13' },
99 { "DC4", '\x14' },
100 { "NAK", '\x15' },
101 { "SYN", '\x16' },
102 { "ETB", '\x17' },
103 { "CAN", '\x18' },
104 { "EM", '\x19' },
105 { "SUB", '\x1a' },
106 { "ESC", '\x1b' },
107 { "FS", '\x1c' },
108 { "IS4", '\x1c' },
109 { "GS", '\x1d' },
110 { "IS3", '\x1d' },
111 { "RS", '\x1e' },
112 { "IS2", '\x1e' },
113 { "US", '\x1f' },
114 { "IS1", '\x1f' },
115 { "DEL", '\x7f' },
116 { "space", ' ' },
117 { "exclamation-mark", '!' },
118 { "quotation-mark", '"' },
119 { "number-sign", '#' },
120 { "dollar-sign", '$' },
121 { "percent-sign", '%' },
122 { "ampersand", '&' },
123 { "apostrophe", '\'' },
124 { "left-parenthesis", '(' },
125 { "right-parenthesis", ')' },
126 { "asterisk", '*' },
127 { "plus-sign", '+' },
128 { "comma", ','},
129 { "hyphen-minus", '-' },
130 { "hyphen", '-' },
131 { "full-stop", '.' },
132 { "period", '.' },
133 { "slash", '/' },
134 { "solidus", '/' },
135 { "zero", '0' },
136 { "one", '1' },
137 { "two", '2' },
138 { "three", '3' },
139 { "four", '4' },
140 { "five", '5' },
141 { "six", '6' },
142 { "seven", '7' },
143 { "eight", '8' },
144 { "nine", '9' },
145 { "colon", ':' },
146 { "semicolon", ';' },
147 { "less-than-sign", '<' },
148 { "equals-sign", '=' },
149 { "greater-than-sign", '>' },
150 { "question-mark", '?' },
151 { "commercial-at", '@' },
152 { "left-square-bracket", '[' },
153 { "backslash", '\\' },
154 { "reverse-solidus", '\\' },
155 { "right-square-bracket", ']' },
156 { "circumflex", '^' },
157 { "circumflex-accent", '^' },
158 { "low-line", '_' },
159 { "underscore", '_' },
160 { "grave-accent", '`' },
161 { "left-brace", '{' },
162 { "left-curly-bracket", '{' },
163 { "vertical-line", '|' },
164 { "right-brace", '}' },
165 { "right-curly-bracket", '}' },
166 { "tilde", '~' },
167 { "A", 'A' },
168 { "B", 'B' },
169 { "C", 'C' },
170 { "D", 'D' },
171 { "E", 'E' },
172 { "F", 'F' },
173 { "G", 'G' },
174 { "H", 'H' },
175 { "I", 'I' },
176 { "J", 'J' },
177 { "K", 'K' },
178 { "L", 'L' },
179 { "M", 'M' },
180 { "N", 'N' },
181 { "O", 'O' },
182 { "P", 'P' },
183 { "Q", 'Q' },
184 { "R", 'R' },
185 { "S", 'S' },
186 { "T", 'T' },
187 { "U", 'U' },
188 { "V", 'V' },
189 { "W", 'W' },
190 { "X", 'X' },
191 { "Y", 'Y' },
192 { "Z", 'Z' },
193 { "a", 'a' },
194 { "b", 'b' },
195 { "c", 'c' },
196 { "d", 'd' },
197 { "e", 'e' },
198 { "f", 'f' },
199 { "g", 'g' },
200 { "h", 'h' },
201 { "i", 'i' },
202 { "j", 'j' },
203 { "k", 'k' },
204 { "l", 'l' },
205 { "m", 'm' },
206 { "n", 'n' },
207 { "o", 'o' },
208 { "p", 'p' },
209 { "q", 'q' },
210 { "r", 'r' },
211 { "s", 's' },
212 { "t", 't' },
213 { "u", 'u' },
214 { "v", 'v' },
215 { "w", 'w' },
216 { "x", 'x' },
217 { "y", 'y' },
218 { "z", 'z' },
219 { NULL, 0 }
220 };
221
222 static int
cmap_compare_sym(const void * n1,const void * n2)223 cmap_compare_sym(const void *n1, const void *n2)
224 {
225 const charmap_t *c1 = n1;
226 const charmap_t *c2 = n2;
227 int rv;
228
229 rv = strcmp(c1->name, c2->name);
230 return ((rv < 0) ? -1 : (rv > 0) ? 1 : 0);
231 }
232
233 static int
cmap_compare_wc(const void * n1,const void * n2)234 cmap_compare_wc(const void *n1, const void *n2)
235 {
236 const charmap_t *c1 = n1;
237 const charmap_t *c2 = n2;
238
239 return ((c1->wc < c2->wc) ? -1 : (c1->wc > c2->wc) ? 1 : 0);
240 }
241
242 void
init_charmap(void)243 init_charmap(void)
244 {
245 RB_INIT(&cmap_sym);
246
247 RB_INIT(&cmap_wc);
248 }
249
250 static void
add_charmap_impl(const char * sym,wchar_t wc,int nodups)251 add_charmap_impl(const char *sym, wchar_t wc, int nodups)
252 {
253 charmap_t srch;
254 charmap_t *n = NULL;
255
256 srch.wc = wc;
257 srch.name = sym;
258
259 /*
260 * also possibly insert the wide mapping, although note that there
261 * can only be one of these per wide character code.
262 */
263 if ((wc != (wchar_t)-1) && ((RB_FIND(cmap_wc, &cmap_wc, &srch)) == NULL)) {
264 if ((n = calloc(1, sizeof (*n))) == NULL) {
265 errf("out of memory");
266 return;
267 }
268 n->wc = wc;
269 RB_INSERT(cmap_wc, &cmap_wc, n);
270 }
271
272 if (sym) {
273 if (RB_FIND(cmap_sym, &cmap_sym, &srch) != NULL) {
274 if (nodups) {
275 errf("duplicate character definition");
276 }
277 return;
278 }
279 if ((n == NULL) && ((n = calloc(1, sizeof (*n))) == NULL)) {
280 errf("out of memory");
281 return;
282 }
283 n->wc = wc;
284 n->name = sym;
285
286 RB_INSERT(cmap_sym, &cmap_sym, n);
287 }
288 }
289
290 void
add_charmap(const char * sym,int c)291 add_charmap(const char *sym, int c)
292 {
293 add_charmap_impl(sym, c, 1);
294 }
295
296 void
add_charmap_undefined(char * sym)297 add_charmap_undefined(char *sym)
298 {
299 charmap_t srch;
300 charmap_t *cm = NULL;
301
302 srch.name = sym;
303 cm = RB_FIND(cmap_sym, &cmap_sym, &srch);
304
305 if ((undefok == 0) && ((cm == NULL) || (cm->wc == (wchar_t)-1))) {
306 warn("undefined symbol <%s>", sym);
307 add_charmap_impl(sym, -1, 0);
308 } else {
309 free(sym);
310 }
311 }
312
313 void
add_charmap_range(char * s,char * e,int wc)314 add_charmap_range(char *s, char *e, int wc)
315 {
316 int ls, le;
317 int si;
318 int sn, en;
319 int i;
320
321 static const char *digits = "0123456789";
322
323 ls = strlen(s);
324 le = strlen(e);
325
326 if (((si = strcspn(s, digits)) == 0) || (si == ls) ||
327 (strncmp(s, e, si) != 0) ||
328 ((int)strspn(s + si, digits) != (ls - si)) ||
329 ((int)strspn(e + si, digits) != (le - si)) ||
330 ((sn = atoi(s + si)) > ((en = atoi(e + si))))) {
331 errf("malformed charmap range");
332 return;
333 }
334
335 s[si] = 0;
336
337 for (i = sn; i <= en; i++) {
338 char *nn;
339 (void) asprintf(&nn, "%s%0*u", s, ls - si, i);
340 if (nn == NULL) {
341 errf("out of memory");
342 return;
343 }
344
345 add_charmap_impl(nn, wc, 1);
346 wc++;
347 }
348 free(s);
349 free(e);
350 }
351
352 void
add_charmap_char(const char * name,int val)353 add_charmap_char(const char *name, int val)
354 {
355 add_charmap_impl(name, val, 0);
356 }
357
358 /*
359 * POSIX insists that certain entries be present, even when not in the
360 * original charmap file.
361 */
362 void
add_charmap_posix(void)363 add_charmap_posix(void)
364 {
365 int i;
366
367 for (i = 0; portable_chars[i].name; i++) {
368 add_charmap_char(portable_chars[i].name, portable_chars[i].ch);
369 }
370 }
371
372 int
lookup_charmap(const char * sym,wchar_t * wc)373 lookup_charmap(const char *sym, wchar_t *wc)
374 {
375 charmap_t srch;
376 charmap_t *n;
377
378 srch.name = sym;
379 n = RB_FIND(cmap_sym, &cmap_sym, &srch);
380 if (n && n->wc != (wchar_t)-1) {
381 if (wc)
382 *wc = n->wc;
383 return (0);
384 }
385 return (-1);
386 }
387
388 int
check_charmap(wchar_t wc)389 check_charmap(wchar_t wc)
390 {
391 charmap_t srch;
392
393 srch.wc = wc;
394 return (RB_FIND(cmap_wc, &cmap_wc, &srch) ? 0 : -1);
395 }
396