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
48typedef 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
55static int cmap_compare_sym(const void *n1, const void *n2);
56static int cmap_compare_wc(const void *n1, const void *n2);
57
58static RB_HEAD(cmap_sym, charmap) cmap_sym;
59static RB_HEAD(cmap_wc, charmap) cmap_wc;
60
61RB_GENERATE_STATIC(cmap_sym, charmap, rb_sym, cmap_compare_sym);
62RB_GENERATE_STATIC(cmap_wc, charmap, rb_wc, cmap_compare_wc);
63
64/*
65 * Array of POSIX specific portable characters.
66 */
67
68static 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
222static int
223cmap_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
233static int
234cmap_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
242void
243init_charmap(void)
244{
245	RB_INIT(&cmap_sym);
246
247	RB_INIT(&cmap_wc);
248}
249
250static void
251add_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
290void
291add_charmap(const char *sym, int c)
292{
293	add_charmap_impl(sym, c, 1);
294}
295
296void
297add_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
313void
314add_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
352void
353add_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 */
362void
363add_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
372int
373lookup_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
388int
389check_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