1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2010 Nexenta Systems, Inc. All rights reserved.
14 */
15
16 /*
17 * CHARMAP file handling for localedef.
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <limits.h>
24 #include <unistd.h>
25 #include <alloca.h>
26 #include <sys/avl.h>
27 #include <stddef.h>
28 #include <unistd.h>
29 #include "localedef.h"
30 #include "parser.tab.h"
31
32 static avl_tree_t cmap_sym;
33 static avl_tree_t cmap_wc;
34
35 typedef struct charmap {
36 const char *name;
37 wchar_t wc;
38 avl_node_t avl_sym;
39 avl_node_t avl_wc;
40 } charmap_t;
41
42 /*
43 * Array of POSIX specific portable characters.
44 */
45 static const struct {
46 const char *name;
47 int ch;
48 } portable_chars[] = {
49 { "NUL", '\0' },
50 { "alert", '\a' },
51 { "backspace", '\b' },
52 { "tab", '\t' },
53 { "carriage-return", '\r' },
54 { "newline", '\n' },
55 { "vertical-tab", '\v' },
56 { "form-feed", '\f' },
57 { "space", ' ' },
58 { "exclamation-mark", '!' },
59 { "quotation-mark", '"' },
60 { "number-sign", '#' },
61 { "dollar-sign", '$' },
62 { "percent-sign", '%' },
63 { "ampersand", '&' },
64 { "apostrophe", '\'' },
65 { "left-parenthesis", '(' },
66 { "right-parenthesis", '(' },
67 { "asterisk", '*' },
68 { "plus-sign", '+' },
69 { "comma", ','},
70 { "hyphen-minus", '-' },
71 { "hyphen", '-' },
72 { "full-stop", '.' },
73 { "period", '.' },
74 { "slash", '/' },
75 { "solidus", '/' },
76 { "zero", '0' },
77 { "one", '1' },
78 { "two", '2' },
79 { "three", '3' },
80 { "four", '4' },
81 { "five", '5' },
82 { "six", '6' },
83 { "seven", '7' },
84 { "eight", '8' },
85 { "nine", '9' },
86 { "colon", ':' },
87 { "semicolon", ';' },
88 { "less-than-sign", '<' },
89 { "equals-sign", '=' },
90 { "greater-than-sign", '>' },
91 { "question-mark", '?' },
92 { "commercial-at", '@' },
93 { "left-square-bracket", '[' },
94 { "backslash", '\\' },
95 { "reverse-solidus", '\\' },
96 { "right-square-bracket", ']' },
97 { "circumflex", '^' },
98 { "circumflex-accent", '^' },
99 { "low-line", '_' },
100 { "underscore", '_' },
101 { "grave-accent", '`' },
102 { "left-brace", '{' },
103 { "left-curly-bracket", '{' },
104 { "vertical-line", '|' },
105 { "right-brace", '}' },
106 { "right-curly-bracket", '}' },
107 { "tilde", '~' },
108 { "A", 'A' },
109 { "B", 'B' },
110 { "C", 'C' },
111 { "D", 'D' },
112 { "E", 'E' },
113 { "F", 'F' },
114 { "G", 'G' },
115 { "H", 'H' },
116 { "I", 'I' },
117 { "J", 'J' },
118 { "K", 'K' },
119 { "L", 'L' },
120 { "M", 'M' },
121 { "N", 'N' },
122 { "O", 'O' },
123 { "P", 'P' },
124 { "Q", 'Q' },
125 { "R", 'R' },
126 { "S", 'S' },
127 { "T", 'T' },
128 { "U", 'U' },
129 { "V", 'V' },
130 { "W", 'W' },
131 { "X", 'X' },
132 { "Y", 'Y' },
133 { "Z", 'Z' },
134 { "a", 'a' },
135 { "b", 'b' },
136 { "c", 'c' },
137 { "d", 'd' },
138 { "e", 'e' },
139 { "f", 'f' },
140 { "g", 'g' },
141 { "h", 'h' },
142 { "i", 'i' },
143 { "j", 'j' },
144 { "k", 'k' },
145 { "l", 'l' },
146 { "m", 'm' },
147 { "n", 'n' },
148 { "o", 'o' },
149 { "p", 'p' },
150 { "q", 'q' },
151 { "r", 'r' },
152 { "s", 's' },
153 { "t", 't' },
154 { "u", 'u' },
155 { "v", 'v' },
156 { "w", 'w' },
157 { "x", 'x' },
158 { "y", 'y' },
159 { "z", 'z' },
160 { NULL, 0 }
161 };
162
163 static int
cmap_compare_sym(const void * n1,const void * n2)164 cmap_compare_sym(const void *n1, const void *n2)
165 {
166 const charmap_t *c1 = n1;
167 const charmap_t *c2 = n2;
168 int rv;
169
170 rv = strcmp(c1->name, c2->name);
171 return ((rv < 0) ? -1 : (rv > 0) ? 1 : 0);
172 }
173
174 static int
cmap_compare_wc(const void * n1,const void * n2)175 cmap_compare_wc(const void *n1, const void *n2)
176 {
177 const charmap_t *c1 = n1;
178 const charmap_t *c2 = n2;
179
180 return ((c1->wc < c2->wc) ? -1 : (c1->wc > c2->wc) ? 1 : 0);
181 }
182
183 void
init_charmap(void)184 init_charmap(void)
185 {
186 avl_create(&cmap_sym, cmap_compare_sym, sizeof (charmap_t),
187 offsetof(charmap_t, avl_sym));
188
189 avl_create(&cmap_wc, cmap_compare_wc, sizeof (charmap_t),
190 offsetof(charmap_t, avl_wc));
191 }
192
193 static void
add_charmap_impl(const char * sym,wchar_t wc,int nodups)194 add_charmap_impl(const char *sym, wchar_t wc, int nodups)
195 {
196 charmap_t srch;
197 charmap_t *n = NULL;
198 avl_index_t where;
199
200 srch.wc = wc;
201 srch.name = sym;
202
203 /*
204 * also possibly insert the wide mapping, although note that there
205 * can only be one of these per wide character code.
206 */
207 if ((wc != (wchar_t)-1) &&
208 ((avl_find(&cmap_wc, &srch, &where)) == NULL)) {
209 if ((n = calloc(1, sizeof (*n))) == NULL) {
210 errf(_("out of memory"));
211 return;
212 }
213 n->wc = wc;
214 avl_insert(&cmap_wc, n, where);
215 }
216
217 if (sym) {
218 if (avl_find(&cmap_sym, &srch, &where) != NULL) {
219 if (nodups) {
220 errf(_("duplicate character definition"));
221 }
222 return;
223 }
224 if ((n == NULL) && ((n = calloc(1, sizeof (*n))) == NULL)) {
225 errf(_("out of memory"));
226 return;
227 }
228 n->wc = wc;
229 n->name = sym;
230
231 avl_insert(&cmap_sym, n, where);
232 }
233 }
234
235 void
add_charmap(const char * sym,int c)236 add_charmap(const char *sym, int c)
237 {
238 add_charmap_impl(sym, c, 1);
239 }
240
241 void
add_charmap_undefined(char * sym)242 add_charmap_undefined(char *sym)
243 {
244 charmap_t srch;
245 charmap_t *cm = NULL;
246
247 srch.name = sym;
248 cm = avl_find(&cmap_sym, &srch, NULL);
249
250 if ((undefok == 0) && ((cm == NULL) || (cm->wc == (wchar_t)-1))) {
251 warn(_("undefined symbol <%s>"), sym);
252 add_charmap_impl(sym, -1, 0);
253 } else {
254 free(sym);
255 }
256 }
257
258 void
add_charmap_range(char * s,char * e,int wc)259 add_charmap_range(char *s, char *e, int wc)
260 {
261 int ls, le;
262 int si;
263 int sn, en;
264 int i;
265
266 static const char *digits = "0123456789";
267
268 ls = strlen(s);
269 le = strlen(e);
270
271 if (((si = strcspn(s, digits)) == 0) || (si == ls) ||
272 (strncmp(s, e, si) != 0) ||
273 (strspn(s + si, digits) != (ls - si)) ||
274 (strspn(e + si, digits) != (le - si)) ||
275 ((sn = atoi(s + si)) > ((en = atoi(e + si))))) {
276 errf(_("malformed charmap range"));
277 return;
278 }
279
280 s[si] = 0;
281
282 for (i = sn; i <= en; i++) {
283 char *nn;
284 (void) asprintf(&nn, "%s%0*u", s, ls - si, i);
285 if (nn == NULL) {
286 errf(_("out of memory"));
287 return;
288 }
289
290 add_charmap_impl(nn, wc, 1);
291 wc++;
292 }
293 free(s);
294 free(e);
295 }
296
297 void
add_charmap_char(const char * name,int val)298 add_charmap_char(const char *name, int val)
299 {
300 add_charmap_impl(name, val, 0);
301 }
302
303 /*
304 * POSIX insists that certain entries be present, even when not in the
305 * original charmap file.
306 */
307 void
add_charmap_posix(void)308 add_charmap_posix(void)
309 {
310 int i;
311
312 for (i = 0; portable_chars[i].name; i++) {
313 add_charmap_char(portable_chars[i].name, portable_chars[i].ch);
314 }
315 }
316
317 int
lookup_charmap(const char * sym,wchar_t * wc)318 lookup_charmap(const char *sym, wchar_t *wc)
319 {
320 charmap_t srch;
321 charmap_t *n;
322
323 srch.name = sym;
324 n = avl_find(&cmap_sym, &srch, NULL);
325 if (n && n->wc != (wchar_t)-1) {
326 if (wc)
327 *wc = n->wc;
328 return (0);
329 }
330 return (-1);
331 }
332
333 int
check_charmap(wchar_t wc)334 check_charmap(wchar_t wc)
335 {
336 charmap_t srch;
337
338 srch.wc = wc;
339 return (avl_find(&cmap_wc, &srch, NULL) ? 0 : -1);
340 }
341