--- /dev/null	Sat May 28 21:32:38 2011
+++ new/usr/src/cmd/iconv/charmap.c	Sat May 28 21:32:37 2011
@@ -0,0 +1,552 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ */
+
+/*
+ * CHARMAP file handling for iconv.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+#include <unistd.h>
+#include <alloca.h>
+#include <sys/avl.h>
+#include <stddef.h>
+#include <unistd.h>
+#include "charmap.h"
+#include "parser.tab.h"
+#include <assert.h>
+
+enum cmap_pass cmap_pass;
+static avl_tree_t	cmap_sym;
+static avl_tree_t	cmap_mbs;
+
+typedef struct charmap {
+	const char *name;
+	struct charmap *alias_of;
+	avl_node_t avl_sym;
+	avl_node_t avl_mbs;
+	int warned;
+	int mbs_len;
+	int tombs_len;
+	char mbs[MB_LEN_MAX + 1]; /* input */
+	char tombs[MB_LEN_MAX + 1]; /* output */
+} charmap_t;
+
+static void add_charmap_impl_fr(char *sym, char *mbs, int mbs_len, int nodups);
+static void add_charmap_impl_to(char *sym, char *mbs, int mbs_len, int nodups);
+
+/*
+ * Array of POSIX specific portable characters.
+ */
+static const struct {
+	char	*name;
+	int	ch;
+} portable_chars[] = {
+	{ "NUL",		 '\0' },
+	{ "alert",		'\a' },
+	{ "backspace",		'\b' },
+	{ "tab",		'\t' },
+	{ "carriage-return",	'\r' },
+	{ "newline",		'\n' },
+	{ "vertical-tab",	'\v' },
+	{ "form-feed",		'\f' },
+	{ "space",		' ' },
+	{ "exclamation-mark",	'!' },
+	{ "quotation-mark",	'"' },
+	{ "number-sign",	'#' },
+	{ "dollar-sign",	'$' },
+	{ "percent-sign",	'%' },
+	{ "ampersand",		'&' },
+	{ "apostrophe",		'\'' },
+	{ "left-parenthesis",	'(' },
+	{ "right-parenthesis",	'(' },
+	{ "asterisk",		'*' },
+	{ "plus-sign",		'+' },
+	{ "comma",		 ','},
+	{ "hyphen-minus",	'-' },
+	{ "hyphen",		'-' },
+	{ "full-stop",		'.' },
+	{ "period",		'.' },
+	{ "slash",		'/' },
+	{ "solidus",		'/' },
+	{ "zero",		'0' },
+	{ "one",		'1' },
+	{ "two",		'2' },
+	{ "three",		'3' },
+	{ "four",		'4' },
+	{ "five",		'5' },
+	{ "six",		'6' },
+	{ "seven",		'7' },
+	{ "eight",		'8' },
+	{ "nine",		'9' },
+	{ "colon",		':' },
+	{ "semicolon",		';' },
+	{ "less-than-sign",	'<' },
+	{ "equals-sign",	'=' },
+	{ "greater-than-sign",	'>' },
+	{ "question-mark",	'?' },
+	{ "commercial-at",	'@' },
+	{ "left-square-bracket", '[' },
+	{ "backslash",		'\\' },
+	{ "reverse-solidus",	'\\' },
+	{ "right-square-bracket", ']' },
+	{ "circumflex",		'^' },
+	{ "circumflex-accent",	'^' },
+	{ "low-line",		'_' },
+	{ "underscore",		'_' },
+	{ "grave-accent",	'`' },
+	{ "left-brace",		'{' },
+	{ "left-curly-bracket",	'{' },
+	{ "vertical-line",	'|' },
+	{ "right-brace",	'}' },
+	{ "right-curly-bracket", '}' },
+	{ "tilde",		'~' },
+	{ "A", 'A' },
+	{ "B", 'B' },
+	{ "C", 'C' },
+	{ "D", 'D' },
+	{ "E", 'E' },
+	{ "F", 'F' },
+	{ "G", 'G' },
+	{ "H", 'H' },
+	{ "I", 'I' },
+	{ "J", 'J' },
+	{ "K", 'K' },
+	{ "L", 'L' },
+	{ "M", 'M' },
+	{ "N", 'N' },
+	{ "O", 'O' },
+	{ "P", 'P' },
+	{ "Q", 'Q' },
+	{ "R", 'R' },
+	{ "S", 'S' },
+	{ "T", 'T' },
+	{ "U", 'U' },
+	{ "V", 'V' },
+	{ "W", 'W' },
+	{ "X", 'X' },
+	{ "Y", 'Y' },
+	{ "Z", 'Z' },
+	{ "a", 'a' },
+	{ "b", 'b' },
+	{ "c", 'c' },
+	{ "d", 'd' },
+	{ "e", 'e' },
+	{ "f", 'f' },
+	{ "g", 'g' },
+	{ "h", 'h' },
+	{ "i", 'i' },
+	{ "j", 'j' },
+	{ "k", 'k' },
+	{ "l", 'l' },
+	{ "m", 'm' },
+	{ "n", 'n' },
+	{ "o", 'o' },
+	{ "p", 'p' },
+	{ "q", 'q' },
+	{ "r", 'r' },
+	{ "s", 's' },
+	{ "t", 't' },
+	{ "u", 'u' },
+	{ "v", 'v' },
+	{ "w", 'w' },
+	{ "x", 'x' },
+	{ "y", 'y' },
+	{ "z", 'z' },
+	{ NULL, 0 }
+};
+
+static int
+cmap_compare_sym(const void *n1, const void *n2)
+{
+	const charmap_t *c1 = n1;
+	const charmap_t *c2 = n2;
+	int rv;
+
+	rv = strcmp(c1->name, c2->name);
+	return ((rv < 0) ? -1 : (rv > 0) ? 1 : 0);
+}
+
+/*
+ * In order for partial match searches to work,
+ * we need these sorted by mbs contents.
+ */
+static int
+cmap_compare_mbs(const void *n1, const void *n2)
+{
+	const charmap_t *c1 = n1;
+	const charmap_t *c2 = n2;
+	int len, rv;
+
+	len = c1->mbs_len;
+	if (len < c2->mbs_len)
+		len = c2->mbs_len;
+	rv = memcmp(c1->mbs, c2->mbs, len);
+	if (rv < 0)
+		return (-1);
+	if (rv > 0)
+		return (1);
+	/* they match through length */
+	if (c1->mbs_len < c2->mbs_len)
+		return (-1);
+	if (c2->mbs_len < c1->mbs_len)
+		return (1);
+	return (0);
+}
+
+void
+charmap_init(char *to_map, char *from_map)
+{
+	avl_create(&cmap_sym, cmap_compare_sym, sizeof (charmap_t),
+	    offsetof(charmap_t, avl_sym));
+
+	avl_create(&cmap_mbs, cmap_compare_mbs, sizeof (charmap_t),
+	    offsetof(charmap_t, avl_mbs));
+
+	cmap_pass = CMAP_PASS_FROM;
+	reset_scanner(from_map);
+	(void) yyparse();
+	add_charmap_posix();
+
+	cmap_pass = CMAP_PASS_TO;
+	reset_scanner(to_map);
+	(void) yyparse();
+}
+
+void
+charmap_dump()
+{
+	charmap_t *cm;
+	int i;
+
+	cm = avl_first(&cmap_mbs);
+	while (cm != NULL) {
+		(void) printf("name=\"%s\"\n", cm->name);
+
+		(void) printf("\timbs=\"");
+		for (i = 0; i < cm->mbs_len; i++)
+			(void) printf("\\x%02x", cm->mbs[i] & 0xFF);
+		(void) printf("\"\n");
+
+		(void) printf("\tombs=\"");
+		for (i = 0; i < cm->tombs_len; i++)
+			(void) printf("\\x%02x", cm->tombs[i] & 0xFF);
+		(void) printf("\"\n");
+
+		cm = AVL_NEXT(&cmap_mbs, cm);
+	}
+}
+
+/*
+ * We parse two charmap files:  First the "from" map, where we build
+ * cmap_mbs and cmap_sym which we'll later use to translate the input
+ * stream (mbs encodings) to symbols.  Second, we parse the "to" map,
+ * where we fill in the tombs members of entries in cmap_sym, (which
+ * must alread exist) used later to write the output encoding.
+ */
+static void
+add_charmap_impl(char *sym, char *mbs, int mbs_len, int nodups)
+{
+
+	/*
+	 * While parsing both the "from" and "to" cmaps,
+	 * require both the symbol and encoding.
+	 */
+	if (sym == NULL || mbs == NULL) {
+		errf(_("invalid charmap entry"));
+		return;
+	}
+
+	switch (cmap_pass) {
+	case CMAP_PASS_FROM:
+		add_charmap_impl_fr(sym, mbs, mbs_len, nodups);
+		break;
+	case CMAP_PASS_TO:
+		add_charmap_impl_to(sym, mbs, mbs_len, nodups);
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+static void
+add_charmap_impl_fr(char *sym, char *mbs, int mbs_len, int nodups)
+{
+	charmap_t	*m, *n, *s;
+	avl_index_t	where_sym, where_mbs;
+
+	if ((n = calloc(1, sizeof (*n))) == NULL) {
+		errf(_("out of memory"));
+		return;
+	}
+	n->name = sym;
+
+	assert(0 < mbs_len && mbs_len <= MB_LEN_MAX);
+	(void) memcpy(n->mbs, mbs, mbs_len);
+	n->mbs_len = mbs_len;
+
+	m = avl_find(&cmap_mbs, n, &where_mbs);
+	s = avl_find(&cmap_sym, n, &where_sym);
+
+	/*
+	 * If we found the symbol, this is a dup.
+	 */
+	if (s != NULL) {
+		if (nodups) {
+			warn(_("%s: duplicate character symbol"), sym);
+		}
+		free(n);
+		return;
+	}
+
+	/*
+	 * If we found the mbs, the new one is an alias,
+	 * which we'll add _only_ to the symbol AVL.
+	 */
+	if (m != NULL) {
+		/* The new one is an alias of the original. */
+		n->alias_of = m;
+		avl_insert(&cmap_sym, n, where_sym);
+		return;
+	}
+
+	avl_insert(&cmap_sym, n, where_sym);
+	avl_insert(&cmap_mbs, n, where_mbs);
+}
+
+static void
+add_charmap_impl_to(char *sym, char *mbs, int mbs_len, int nodups)
+{
+	charmap_t	srch = {0};
+	charmap_t	*m;
+	avl_index_t	where;
+
+	assert(0 < mbs_len && mbs_len <= MB_LEN_MAX);
+
+	srch.name = sym;
+
+	m = avl_find(&cmap_sym, &srch, &where);
+	if (m == NULL) {
+		if (sflag == 0)
+			warn(_("%s: symbol not found"), sym);
+		return;
+	}
+	if (m->alias_of != NULL) {
+		m = m->alias_of;
+
+		/* don't warn for dups with aliases */
+		if (m->tombs_len != 0)
+			return;
+	}
+
+	if (m->tombs_len != 0) {
+		if (nodups) {
+			warn(_("%s: duplicate encoding for"), sym);
+		}
+		return;
+	}
+
+	(void) memcpy(m->tombs, mbs, mbs_len);
+	m->tombs_len = mbs_len;
+}
+
+void
+add_charmap(char *sym, char *mbs)
+{
+	/* mbs[0] is the length */
+	int mbs_len = *mbs++;
+	assert(0 < mbs_len && mbs_len <= MB_LEN_MAX);
+	add_charmap_impl(sym, mbs, mbs_len, 1);
+}
+
+
+void
+add_charmap_range(char *ssym, char *esym, char *mbs)
+{
+	int	ls, le;
+	int	si;
+	int	sn, en;
+	int	i;
+	int	mbs_len;
+	char	tmbs[MB_LEN_MAX+1];
+	char	*mb_last;
+
+	static const char *digits = "0123456789";
+
+	/* mbs[0] is the length */
+	mbs_len = *mbs++;
+	assert(0 < mbs_len && mbs_len <= MB_LEN_MAX);
+	(void) memcpy(tmbs, mbs, mbs_len);
+	mb_last = tmbs + mbs_len - 1;
+
+	ls = strlen(ssym);
+	le = strlen(esym);
+
+	if (((si = strcspn(ssym, digits)) == 0) || (si == ls) ||
+	    (strncmp(ssym, esym, si) != 0) ||
+	    (strspn(ssym + si, digits) != (ls - si)) ||
+	    (strspn(esym + si, digits) != (le - si)) ||
+	    ((sn = atoi(ssym + si)) > ((en = atoi(esym + si))))) {
+		errf(_("malformed charmap range"));
+		return;
+	}
+
+	ssym[si] = 0;
+	for (i = sn; i <= en; i++) {
+		char *nn;
+		(void) asprintf(&nn, "%s%0*u", ssym, ls - si, i);
+		if (nn == NULL) {
+			errf(_("out of memory"));
+			return;
+		}
+
+		add_charmap_impl(nn, tmbs, mbs_len, 1);
+		(*mb_last)++;
+	}
+	free(ssym);
+	free(esym);
+}
+
+void
+add_charmap_char(char *name, int c)
+{
+	char mbs[MB_LEN_MAX+1];
+
+	mbs[0] = c;
+	mbs[1] = '\0';
+	add_charmap_impl(name, mbs, 1, 0);
+}
+
+/*
+ * POSIX insists that certain entries be present, even when not in the
+ * orginal charmap file.
+ */
+void
+add_charmap_posix(void)
+{
+	char	i;
+
+	for (i = 0; portable_chars[i].name; i++) {
+		add_charmap_char(portable_chars[i].name, portable_chars[i].ch);
+	}
+}
+
+static charmap_t *
+find_mbs(const char *mbs, int len)
+{
+	charmap_t srch = {0};
+	charmap_t *cm;
+
+	while (len > 0) {
+		(void) memcpy(srch.mbs, mbs, len);
+		srch.mbs_len = len;
+		cm = avl_find(&cmap_mbs, &srch, NULL);
+		if (cm != NULL)
+			break;
+		len--;
+	}
+
+	return (cm);
+}
+
+/*
+ * Return true if this sequence matches the initial part
+ * of any sequence known in this charmap.
+ */
+static boolean_t
+find_mbs_partial(const char *mbs, int len)
+{
+	charmap_t srch = {0};
+	charmap_t *cm;
+	avl_index_t where;
+
+	(void) memcpy(srch.mbs, mbs, len);
+	srch.mbs_len = len;
+	cm = avl_find(&cmap_mbs, &srch, &where);
+	if (cm != NULL) {
+		/* full match - not expected, but OK */
+		return (B_TRUE);
+	}
+	cm = avl_nearest(&cmap_mbs, where, AVL_AFTER);
+	if (cm != NULL && 0 == memcmp(cm->mbs, mbs, len))
+		return (B_TRUE);
+
+	return (B_FALSE);
+}
+
+/*
+ * Do like iconv(3), but with charmaps.
+ */
+size_t
+cm_iconv(const char **iptr, size_t *ileft, char **optr, size_t *oleft)
+{
+	charmap_t *cm;
+	int mbs_len;
+
+	/* Ignore state reset requests. */
+	if (iptr == NULL || *iptr == NULL)
+		return (0);
+
+	if (*oleft < MB_LEN_MAX) {
+		errno = E2BIG;
+		return ((size_t)-1);
+	}
+
+	while (*ileft > 0 && *oleft >= MB_LEN_MAX) {
+		mbs_len = MB_LEN_MAX;
+		if (mbs_len > *ileft)
+			mbs_len = *ileft;
+		cm = find_mbs(*iptr, mbs_len);
+		if (cm == NULL) {
+			if (mbs_len < MB_LEN_MAX &&
+			    find_mbs_partial(*iptr, mbs_len)) {
+				/* incomplete sequence */
+				errno = EINVAL;
+			} else {
+				errno = EILSEQ;
+			}
+			return ((size_t)-1);
+		}
+		assert(cm->mbs_len > 0);
+		if (cm->tombs_len == 0) {
+			if (sflag == 0 && cm->warned == 0) {
+				cm->warned = 1;
+				fprintf(stderr, gettext(
+				    "To-map does not encode <%s>\n"),
+				    cm->name);
+			}
+			if (cflag == 0) {
+				errno = EILSEQ;
+				return ((size_t)-1);
+			}
+			/* just skip this input seq. */
+			*iptr  += cm->mbs_len;
+			*ileft -= cm->mbs_len;
+			continue;
+		}
+
+		*iptr  += cm->mbs_len;
+		*ileft -= cm->mbs_len;
+		(void) memcpy(*optr, cm->tombs, cm->tombs_len);
+		*optr  += cm->tombs_len;
+		*oleft -= cm->tombs_len;
+	}
+
+	return (0);
+}
