/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * locale -- get current locale information
 *
 * Copyright 1991, 1993 by Mortice Kern Systems Inc.  All rights reserved.
 *
 */

/*
 * locale: get locale-specific information
 * usage:  locale [-a|-m]
 *         locale [-ck] name ...
 */

/*
 * New members added in the struct lconv by IEEE Std 1003.1-2001
 * are always activated in the locale object.
 * See <iso/locale_iso.h>.
 */
#define	_LCONV_C99

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <dirent.h>
#include <ctype.h>
#include <stddef.h>
#include <nl_types.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/types.h>
#include <sys/stat.h>

#define	LC_LOCDEF	999	/* Random number! */

#define	LOCALE_DIR		"/usr/lib/locale/"
#define	CHARMAP_DIR		"/usr/lib/localedef/src/"
#define	CHARMAP_NAME	"charmap.src"

#define	GET_LOCALE	0
#define	GET_CHARMAP	1
#define	CSSIZE	128

#ifndef isblank
#define	isblank(c)	((__ctype + 1)[c] & _B)
#endif

enum types {
	TYPE_STR,	/* char * */
	TYPE_GROUP,	/* char *, for mon_grouping, and grouping */
	TYPE_INT,	/* int */
	TYPE_CHR,	/* char, printed as signed integer */
	TYPE_PCHR,	/* char, printed as printable character */
	TYPE_CTP,	/* ctype entry */
	TYPE_CNVL,	/* convert to lower */
	TYPE_CNVU,	/* convert to upper */
	TYPE_COLLEL	/* print the multi-character collating elements */
};

static int	print_locale_info(char *keyword, int cflag, int kflag);
static int	print_category(int category, int cflag, int kflag);
static int	print_keyword(char *name, int cflag, int kflag);
static void	usage(void);
static void	print_all_info(int);
static void	print_cur_locale(void);
static void	outstr(char *s);
static void	outchar(int);
static void	prt_ctp(char *);
static void	prt_cnv(char *);
static void	prt_collel(char *);
static char	get_escapechar(void);
static char	get_commentchar(void);

static char	*save_loc;

/*
 * yes/no is not in the localeconv structure for xpg style.
 * We dummy up a new structure for purposes of the code below.
 * If YESEXPR is available per XPG4, we use it.
 * Otherwise, use YESSTR, the old method with less functionality from XPG3.
 */
struct yesno {
	char	*yes_expr;
	char	*no_expr;
	char	*yes_str;
	char	*no_str;
};

struct dtconv {
	char	*date_time_format;
	char	*date_format;
	char	*time_format;
	char	*time_format_ampm;
	char	*am_string;
	char	*pm_string;
	char	*abbrev_day_names[7];
	char	*day_names[7];
	char	*abbrev_month_names[12];
	char	*month_names[12];
	char	*era;
	char	*era_d_fmt;
	char	*era_d_t_fmt;
	char	*era_t_fmt;
	char	*alt_digits;
};

struct localedef {
	char	*charmap;
	char	*code_set_name;
	char	escape_char;
	char	comment_char;
	int		mb_cur_max;
	int		mb_cur_min;
};

static struct yesno *
getyesno(void)
{
	static struct yesno	yn;
	static int	loaded = 0;

	if (loaded) {
		return (&yn);
		/* NOTREACHED */
	}

	yn.yes_expr = strdup(nl_langinfo(YESEXPR));
	yn.no_expr = strdup(nl_langinfo(NOEXPR));
	yn.yes_str = strdup(nl_langinfo(YESSTR));
	yn.no_str = strdup(nl_langinfo(NOSTR));

	loaded = 1;
	return (&yn);
}

static struct dtconv *
localedtconv(void)
{
	static struct dtconv	_dtconv;
	static int				loaded = 0;

	if (loaded) {
		return (&_dtconv);
		/* NOTREACHED */
	}

	_dtconv.date_time_format = strdup(nl_langinfo(D_T_FMT));
	_dtconv.date_format = strdup(nl_langinfo(D_FMT));
	_dtconv.time_format = strdup(nl_langinfo(T_FMT));
	_dtconv.time_format_ampm = strdup(nl_langinfo(T_FMT_AMPM));
	_dtconv.am_string = strdup(nl_langinfo(AM_STR));
	_dtconv.pm_string = strdup(nl_langinfo(PM_STR));
	_dtconv.abbrev_day_names[0] = strdup(nl_langinfo(ABDAY_1));
	_dtconv.abbrev_day_names[1] = strdup(nl_langinfo(ABDAY_2));
	_dtconv.abbrev_day_names[2] = strdup(nl_langinfo(ABDAY_3));
	_dtconv.abbrev_day_names[3] = strdup(nl_langinfo(ABDAY_4));
	_dtconv.abbrev_day_names[4] = strdup(nl_langinfo(ABDAY_5));
	_dtconv.abbrev_day_names[5] = strdup(nl_langinfo(ABDAY_6));
	_dtconv.abbrev_day_names[6] = strdup(nl_langinfo(ABDAY_7));
	_dtconv.day_names[0] = strdup(nl_langinfo(DAY_1));
	_dtconv.day_names[1] = strdup(nl_langinfo(DAY_2));
	_dtconv.day_names[2] = strdup(nl_langinfo(DAY_3));
	_dtconv.day_names[3] = strdup(nl_langinfo(DAY_4));
	_dtconv.day_names[4] = strdup(nl_langinfo(DAY_5));
	_dtconv.day_names[5] = strdup(nl_langinfo(DAY_6));
	_dtconv.day_names[6] = strdup(nl_langinfo(DAY_7));
	_dtconv.abbrev_month_names[0] = strdup(nl_langinfo(ABMON_1));
	_dtconv.abbrev_month_names[1] = strdup(nl_langinfo(ABMON_2));
	_dtconv.abbrev_month_names[2] = strdup(nl_langinfo(ABMON_3));
	_dtconv.abbrev_month_names[3] = strdup(nl_langinfo(ABMON_4));
	_dtconv.abbrev_month_names[4] = strdup(nl_langinfo(ABMON_5));
	_dtconv.abbrev_month_names[5] = strdup(nl_langinfo(ABMON_6));
	_dtconv.abbrev_month_names[6] = strdup(nl_langinfo(ABMON_7));
	_dtconv.abbrev_month_names[7] = strdup(nl_langinfo(ABMON_8));
	_dtconv.abbrev_month_names[8] = strdup(nl_langinfo(ABMON_9));
	_dtconv.abbrev_month_names[9] = strdup(nl_langinfo(ABMON_10));
	_dtconv.abbrev_month_names[10] = strdup(nl_langinfo(ABMON_11));
	_dtconv.abbrev_month_names[11] = strdup(nl_langinfo(ABMON_12));
	_dtconv.month_names[0] = strdup(nl_langinfo(MON_1));
	_dtconv.month_names[1] = strdup(nl_langinfo(MON_2));
	_dtconv.month_names[2] = strdup(nl_langinfo(MON_3));
	_dtconv.month_names[3] = strdup(nl_langinfo(MON_4));
	_dtconv.month_names[4] = strdup(nl_langinfo(MON_5));
	_dtconv.month_names[5] = strdup(nl_langinfo(MON_6));
	_dtconv.month_names[6] = strdup(nl_langinfo(MON_7));
	_dtconv.month_names[7] = strdup(nl_langinfo(MON_8));
	_dtconv.month_names[8] = strdup(nl_langinfo(MON_9));
	_dtconv.month_names[9] = strdup(nl_langinfo(MON_10));
	_dtconv.month_names[10] = strdup(nl_langinfo(MON_11));
	_dtconv.month_names[11] = strdup(nl_langinfo(MON_12));
	_dtconv.era = strdup(nl_langinfo(ERA));
	_dtconv.era_d_fmt = strdup(nl_langinfo(ERA_D_FMT));
	_dtconv.era_d_t_fmt = strdup(nl_langinfo(ERA_D_T_FMT));
	_dtconv.era_t_fmt = strdup(nl_langinfo(ERA_T_FMT));
	_dtconv.alt_digits = strdup(nl_langinfo(ALT_DIGITS));

	loaded = 1;
	return (&_dtconv);
}

static struct localedef *
localeldconv(void)
{
	static struct localedef	_locdef;
	static int	loaded = 0;

	if (loaded) {
		return (&_locdef);
		/* NOTREACHED */
	}

	_locdef.charmap = strdup(nl_langinfo(CODESET));
	_locdef.code_set_name = strdup(nl_langinfo(CODESET));
	_locdef.mb_cur_max = MB_CUR_MAX;
	_locdef.mb_cur_min = 1;
	_locdef.escape_char = get_escapechar();
	_locdef.comment_char = get_commentchar();

	loaded = 1;
	return (&_locdef);
}

/*
 * The locale_name array also defines a canonical ordering for the categories.
 * The function tocanon() translates the LC_* manifests to their canonical
 * values.
 */
static struct locale_name {
	char	*name;
	int 	category;
} locale_name[] = {
	{"LC_CTYPE",	LC_CTYPE},
	{"LC_NUMERIC",	LC_NUMERIC},
	{"LC_TIME",		LC_TIME},
	{"LC_COLLATE",	LC_COLLATE},
	{"LC_MONETARY",	LC_MONETARY},
	{"LC_MESSAGES",	LC_MESSAGES},
	{"LC_ALL",		LC_ALL},
	NULL
};

/*
 * The structure key contains all keywords string name,
 * symbolic name, category, and type (STR INT ...)
 * the type will decide the way the value of the item be printed out
 */
static struct key {
	char		*name;
	void		*(*structure)(void);
	int			offset;
	int			count;
	int			category;
	enum types	type;
} key[] = {

#define	SPECIAL		0, 0, 0,
	{"lower",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"upper",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"alpha",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"digit",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"space",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"cntrl",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"punct",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"graph",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"print",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"xdigit",	SPECIAL	LC_CTYPE,	TYPE_CTP},
	{"blank",	SPECIAL	LC_CTYPE,	TYPE_CTP},

	{"tolower",	SPECIAL	LC_CTYPE,	TYPE_CNVL},
	{"toupper",	SPECIAL	LC_CTYPE,	TYPE_CNVU},

	{"collating-element",	0, 0, 0, LC_COLLATE,	TYPE_COLLEL},
	{"character-collation",	0, 1, 0, LC_COLLATE,	TYPE_COLLEL},

#define	dt(member, count) \
		(void *(*)(void))localedtconv, \
		offsetof(struct dtconv, member), \
		count, \
		LC_TIME, \
		TYPE_STR
	{"d_t_fmt",	dt(date_time_format, 1)},
	{"d_fmt",	dt(date_format, 1)},
	{"t_fmt",	dt(time_format, 1)},
	{"t_fmt_ampm",	dt(time_format_ampm, 1)},
	{"am_pm",	dt(am_string, 2)},
	{"day",		dt(day_names, 7)},
	{"abday",	dt(abbrev_day_names, 7)},
	{"mon",		dt(month_names, 12)},
	{"abmon",	dt(abbrev_month_names, 12)},
	{"era",		dt(era, 1)},
	{"era_d_fmt",	dt(era_d_fmt, 1)},
	{"era_d_t_fmt",	dt(era_d_t_fmt, 1)},
	{"era_t_fmt",	dt(era_t_fmt, 1)},
	{"alt_digits",	dt(alt_digits, 1)},

#undef dt

#define	lc(member, locale, type) \
		(void *(*)(void))localeconv, \
		offsetof(struct lconv, member), \
		1, \
		locale, \
		type
{"decimal_point",	lc(decimal_point, 	LC_NUMERIC, TYPE_STR) },
{"thousands_sep",	lc(thousands_sep, 	LC_NUMERIC, TYPE_STR) },
{"grouping",		lc(grouping,		LC_NUMERIC, TYPE_GROUP)},
{"int_curr_symbol",	lc(int_curr_symbol,	LC_MONETARY, TYPE_STR)},
{"currency_symbol",	lc(currency_symbol,	LC_MONETARY, TYPE_STR)},
{"mon_decimal_point",	lc(mon_decimal_point,	LC_MONETARY, TYPE_STR)},
{"mon_thousands_sep",	lc(mon_thousands_sep,	LC_MONETARY, TYPE_STR)},
{"mon_grouping",	lc(mon_grouping,	LC_MONETARY, TYPE_GROUP)},
{"positive_sign",	lc(positive_sign,	LC_MONETARY, TYPE_STR)},
{"negative_sign",	lc(negative_sign,	LC_MONETARY, TYPE_STR)},

{"int_frac_digits",	lc(int_frac_digits,	LC_MONETARY, TYPE_CHR)},
{"frac_digits",		lc(frac_digits,		LC_MONETARY, TYPE_CHR)},
{"p_cs_precedes",	lc(p_cs_precedes,	LC_MONETARY, TYPE_CHR)},
{"p_sep_by_space",	lc(p_sep_by_space,	LC_MONETARY, TYPE_CHR)},
{"n_cs_precedes",	lc(n_cs_precedes,	LC_MONETARY, TYPE_CHR)},
{"n_sep_by_space",	lc(n_sep_by_space,	LC_MONETARY, TYPE_CHR)},
{"p_sign_posn",		lc(p_sign_posn,		LC_MONETARY, TYPE_CHR)},
{"n_sign_posn",		lc(n_sign_posn,		LC_MONETARY, TYPE_CHR)},
{"int_p_cs_precedes",	lc(int_p_cs_precedes,	LC_MONETARY, TYPE_CHR)},
{"int_p_sep_by_space",	lc(int_p_sep_by_space,	LC_MONETARY, TYPE_CHR)},
{"int_n_cs_precedes",	lc(int_n_cs_precedes,	LC_MONETARY, TYPE_CHR)},
{"int_n_sep_by_space",	lc(int_n_sep_by_space,	LC_MONETARY, TYPE_CHR)},
{"int_p_sign_posn",	lc(int_p_sign_posn,	LC_MONETARY, TYPE_CHR)},
{"int_n_sign_posn",	lc(int_n_sign_posn,	LC_MONETARY, TYPE_CHR)},

#undef lc
#define	lc(member) \
		(void *(*)(void))getyesno, \
		offsetof(struct yesno, member), \
		1, \
		LC_MESSAGES, \
		TYPE_STR
	{"yesexpr",		lc(yes_expr)},
	{"noexpr",		lc(no_expr)},
	{"yesstr",		lc(yes_str)},
	{"nostr",		lc(no_str)},
#undef lc

	/*
	 * Following keywords have no official method of obtaining them
	 */
#define	ld(member, locale, type) \
		(void *(*)(void))localeldconv, \
		offsetof(struct localedef, member), \
		1, \
		locale, \
		type
	{"charmap",		ld(charmap,		LC_LOCDEF, TYPE_STR)},
	{"code_set_name",	ld(code_set_name,	LC_LOCDEF, TYPE_STR)},
	{"escape_char",		ld(escape_char,		LC_LOCDEF, TYPE_PCHR)},
	{"comment_char",	ld(comment_char,	LC_LOCDEF, TYPE_PCHR)},
	{"mb_cur_max",		ld(mb_cur_max,		LC_LOCDEF, TYPE_INT)},
	{"mb_cur_min",		ld(mb_cur_min,		LC_LOCDEF, TYPE_INT)},
#undef ld

	{NULL,			NULL,			0, 0}
};

static char escapec;

int
main(int argc, char **argv)
{
	int		c;
	int		retval = 0;
	int		cflag, kflag, aflag, mflag;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN	"SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	cflag = kflag = aflag = mflag = 0;

	while ((c = getopt(argc, argv, "amck")) != EOF) {
		switch (c) {
		case 'a':
			aflag = 1;
			break;
		case 'm':
			mflag = 1;
			break;
		case 'c':
			cflag = 1;
			break;
		case 'k':
			kflag = 1;
			break;
		default:
			usage();
			/* NOTREACHED */
			break;
		}
	}

	/* -a OR -m OR (-c and/or -k) */
	if ((aflag && mflag) || ((aflag || mflag) && (cflag || kflag))) {
		usage();
		/* NOTREACHED */
	}

	escapec = get_escapechar();

	if (aflag) {
		print_all_info(GET_LOCALE);
		/* NOTREACHED */
	}

	if (mflag) {
		print_all_info(GET_CHARMAP);
		/* NOTREACHED */
	}

	if (optind == argc && !cflag && !kflag) {
		print_cur_locale();
		/* NOTREACHED */
	}
	if (optind == argc) {
		usage();
		/* NOTREACHED */
	}

	for (; optind < argc; optind++) {
		retval += print_locale_info(argv[optind], cflag, kflag);
	}
	return (retval);
}

/*
 * No options or operands.
 * Print out the current locale names from the environment, or implied.
 * Variables directly set in the environment are printed as-is, those
 * implied are printed in quotes.
 * The strings are printed ``appropriately quoted for possible later re-entry
 * to the shell''.  We use the routine outstr to do this -- however we
 * want the shell escape character, the backslash, not the locale escape
 * character, so we quietly save and restore the locale escape character.
 */
static void
print_cur_locale(void)
{
	char	*lc_allp;
	char	*env, *eff;
	int		i;

	if ((env = getenv("LANG")) != NULL) {
		(void) printf("LANG=%s\n", env);
	} else {
		(void) printf("LANG=\n");
	}

	lc_allp = getenv("LC_ALL");

	for (i = 0; i < LC_ALL; i++) {
		(void) printf("%s=", locale_name[i].name);
		eff = setlocale(i, NULL);
		if (eff == NULL) {
			eff = "";
		}
		env = getenv(locale_name[i].name);

		if (env == NULL) {
			(void) putchar('"');
			outstr(eff);
			(void) putchar('"');
		} else {
			if (strcmp(env, eff) != 0) {
				(void) putchar('"');
				outstr(eff);
				(void) putchar('"');
			} else {
				outstr(eff);
			}
		}
		(void) putchar('\n');
	}

	(void) printf("LC_ALL=");
	if (lc_allp != NULL) {
		outstr(lc_allp);
	}
	(void) putchar('\n');
	exit(0);
}

static int	num_of_loc = 0;
static int	num_of_entries = 0;
static char	**entries = NULL;

static void
add_loc_entry(char *loc)
{
#define	_INC_NUM	10
	char	*s;

	if (num_of_loc >= num_of_entries) {
		char	**tmp;
		num_of_entries += _INC_NUM;
		tmp = realloc(entries, sizeof (char *) * num_of_entries);
		if (tmp == NULL) {
			/* restoring original locale */
			(void) setlocale(LC_ALL, save_loc);
			(void) fprintf(stderr,
			    gettext("locale: cannot allocate buffer"));
			exit(1);
		}
		entries = tmp;
	}
	s = strdup(loc);
	if (s == NULL) {
		/* restoring original locale */
		(void) setlocale(LC_ALL, save_loc);
		(void) fprintf(stderr,
		    gettext("locale: cannot allocate buffer"));
		exit(1);
	}
	entries[num_of_loc] = s;

	num_of_loc++;
}

static int
loccmp(const char **str1, const char **str2)
{
	return (strcmp(*str1, *str2));
}

static void
show_loc_entry(void)
{
	int	i;

	qsort(entries, num_of_loc, sizeof (char *),
	    (int (*)(const void *, const void *))loccmp);
	for (i = 0; i < num_of_loc; i++) {
		(void) printf("%s\n", entries[i]);
	}
}

static void
check_loc(char *loc)
{
	int	cat;

	/* first, try LC_ALL */
	if (setlocale(LC_ALL, loc) != NULL) {
		/* succeeded */
		add_loc_entry(loc);
		return;
	}

	/*
	 * LC_ALL failed.
	 * try each category.
	 */
	for (cat = 0; cat <= _LastCategory; cat++) {
		if (setlocale(cat, loc) != NULL) {
			/* succeeded */
			add_loc_entry(loc);
			return;
		}
	}

	/* loc is not a valid locale */
}

/*
 * print_all_info(): Print out all the locales and
 *                   charmaps supported by the system
 */
static void
print_all_info(int flag)
{
	struct dirent	*direntp;
	DIR				*dirp;
	char			*filename;		/* filename[PATH_MAX] */
	char			*p;

	if ((filename = malloc(PATH_MAX)) == NULL) {
		(void) fprintf(stderr,
		    gettext("locale: cannot allocate buffer"));
		exit(1);
	}

	(void) memset(filename, 0, PATH_MAX);

	if (flag == GET_LOCALE) {
		/* save the current locale */
		save_loc = setlocale(LC_ALL, NULL);

		(void) strcpy(filename, LOCALE_DIR);
		add_loc_entry("POSIX");
	} else {						/* CHARMAP */
		(void) strcpy(filename, CHARMAP_DIR);
	}

	if ((dirp = opendir(filename)) == NULL) {
		if (flag == GET_LOCALE)
			exit(0);
		else {					/* CHARMAP */
			(void) fprintf(stderr, gettext(
			    "locale: charmap information not available.\n"));
			exit(2);
		}
	}

	p = filename + strlen(filename);
	while ((direntp = readdir(dirp)) != NULL) {
		struct stat stbuf;

		(void) strcpy(p, direntp->d_name);
		if (stat(filename, &stbuf) < 0) {
			continue;
		}

		if (flag == GET_LOCALE) {
			if (S_ISDIR(stbuf.st_mode) &&
			    (direntp->d_name[0] != '.') &&
			    /* "POSIX" has already been printed out */
			    strcmp(direntp->d_name, "POSIX") != 0) {
				check_loc(direntp->d_name);
			}
		} else {			/* CHARMAP */
			if (S_ISDIR(stbuf.st_mode) &&
			    direntp->d_name[0] != '.') {
				struct dirent	*direntc;
				DIR		*dirc;
				char		*charmap;
				char		*c;

				if ((charmap = malloc(PATH_MAX)) == NULL) {
					(void) fprintf(stderr,
				    gettext("locale: cannot allocate buffer"));
					exit(1);
				}

				(void) memset(charmap, 0, PATH_MAX);

				(void) strcpy(charmap, filename);

				if ((dirc = opendir(charmap)) == NULL) {
					exit(0);
				}

				c = charmap + strlen(charmap);
				*c++ = '/';
				while ((direntc = readdir(dirc)) != NULL) {
					struct stat stbuf;

					(void) strcpy(c, direntc->d_name);
					if (stat(charmap, &stbuf) < 0) {
						continue;
					}

					if (S_ISREG(stbuf.st_mode) &&
						(strcmp(direntc->d_name,
							CHARMAP_NAME) == 0) &&
						(direntc->d_name[0] != '.')) {
						(void) printf("%s/%s\n",
							p, direntc->d_name);
					}
				}
				(void) closedir(dirc);
				free(charmap);
			}
		}
	}
	if (flag == GET_LOCALE) {
		/* restore the saved loc */
		(void) setlocale(LC_ALL, save_loc);
		show_loc_entry();
	}
	(void) closedir(dirp);
	free(filename);
	exit(0);
}

/*
 * Print out the keyword value or category info.
 * Call print_category() to print the entire locale category, if the name
 * given is recognized as a category.
 * Otherwise, assume that it is a keyword, and call print_keyword().
 */
static int
print_locale_info(char *name, int cflag, int kflag)
{
	int i;

	for (i = 0; locale_name[i].name != NULL; i++) {
		if (strcmp(locale_name[i].name, name) == 0) {
			/*
			 * name is a category name
			 * print out all keywords in this category
			 */
			return (print_category(locale_name[i].category,
				cflag, kflag));
		}
	}

	/* The name is a keyword name */
	return (print_keyword(name, cflag, kflag));
}

/*
 * Print out the value of the keyword
 */
static int
print_keyword(char *name, int cflag, int kflag)
{
	int		i, j;
	int		first_flag = 1;
	int		found = 0;

	for (i = 0; key[i].name != NULL; i++) {
		if (strcmp(key[i].name, name) != 0) {
			continue;
		}

		found = 1;
		if (first_flag && cflag && key[i].category != LC_LOCDEF) {
			/* print out this category's name */
			(void) printf("%s\n",
				locale_name[key[i].category].name);
		}
		if (kflag) {
			(void) printf("%s=", name);
		}
		switch (key[i].type) {

		/*
		 * The grouping fields are a set of bytes, each of which
		 * is the numeric value of the next group size, terminated
		 * by a \0, or by CHAR_MAX
		 */
		case TYPE_GROUP:
			{
				void	*s;
				char	*q;
				int		first = 1;

				s = (*key[i].structure)();
				/* LINTED */
				q = *(char **)((char *)s + key[i].offset);
				if (*q == '\0') {
					(void) printf("-1");
					break;
				}
				while (*q != '\0' && *q != CHAR_MAX) {
					if (!first) {
						(void) putchar(';');
					}
					first = 0;
					(void) printf("%u",
					    *(unsigned char *)q++);
				}
				/* CHAR_MAX: no further grouping performed. */
				if (!first) {
					(void) putchar(';');
				}
				if (*q == CHAR_MAX) {
					(void) printf("-1");
				} else {
					(void) putchar('0');
				}
			}
			break;

		/*
		 * Entries like decimal_point states ``the decimal-point
		 * character...'' not string.  However, it is a char *.
		 * This assumes single, narrow, character.
		 * Should it permit multibyte characters?
		 * Should it permit a whole string, in that case?
		 */
		case TYPE_STR:
			{
				void	*s;
				char	**q;

				s = (*key[i].structure)();
				/* LINTED */
				q = (char **)((char *)s + key[i].offset);
				for (j = 0; j < key[i].count; j++) {
					if (j != 0) {
						(void) printf(";");
					}
					if (kflag) {
						(void) printf("\"");
						outstr(q[j]);
						(void) printf("\"");
					} else {
						(void) printf("%s", q[j]);
					}
				}
			}
			break;

		case TYPE_INT:
			{
				void	*s;
				int		*q;

				s = (*key[i].structure)();
				/* LINTED */
				q = (int *)((char *)s + key[i].offset);
				(void) printf("%d", *q);
			}
			break;

		/*
		 * TYPE_CHR: Single byte integer.
		 */
		case TYPE_CHR:
			{
				void	*s;
				char	*q;

				s = (*key[i].structure)();
				q = (char *)((char *)s + key[i].offset);
				if (*q == CHAR_MAX) {
					(void) printf("-1");
				} else {
					(void) printf("%u",
					    *(unsigned char *)q);
				}
			}
			break;

		/*
		 * TYPE_PCHR: Single byte, printed as a character if printable
		 */
		case TYPE_PCHR:
			{
				void	*s;
				char	*q;

				s = (*key[i].structure)();
				q = (char *)((char *)s + key[i].offset);
				if (isprint(*(unsigned char *)q)) {
					if (kflag) {
						(void) printf("\"");
						if ((*q == '\\') ||
							(*q == ';') ||
							(*q == '"')) {
							(void) putchar(escapec);
							(void) printf("%c",
							*(unsigned char *)q);
						} else {
							(void) printf("%c",
							*(unsigned char *)q);
						}
						(void) printf("\"");
					} else {
						(void) printf("%c",
						    *(unsigned char *)q);
					}
				} else if (*q == (char)-1) {
					/* In case no signed chars */
					(void) printf("-1");
				} else {
					(void) printf("%u",
					    *(unsigned char *)q);
				}
			}
			break;

		case TYPE_CTP:
			{
				prt_ctp(key[i].name);
			}
			break;

		case TYPE_CNVU:
			{
				prt_cnv(key[i].name);
			}
			break;

		case TYPE_CNVL:
			{
				prt_cnv(key[i].name);
			}
			break;

		case TYPE_COLLEL:
			{
				prt_collel(key[i].name);
			}
			break;
		}
	}
	if (found) {
		(void) printf("\n");
		return (0);
	} else {
		(void) fprintf(stderr,
		    gettext("Unknown keyword name '%s'.\n"), name);
		return (1);
	}
}

/*
 * Strings being outputed have to use an unambiguous format --  escape
 * any potentially bad output characters.
 * The standard says that any control character shall be preceeded by
 * the escape character.  But it doesn't say that you can format that
 * character at all.
 * Question: If the multibyte character contains a quoting character,
 * should that *byte* be escaped?
 */
static void
outstr(char *s)
{
	wchar_t	ws;
	int		c;
	size_t	mbcurmax = MB_CUR_MAX;

	while (*s != '\0') {
		c = mbtowc(&ws, s, mbcurmax);
		if (c < 0) {
			s++;
		} else if (c == 1) {
			outchar(*s++);
		} else {
			for (; c > 0; c--) {
				(void) putchar(*s++);
			}
		}
	}
}

static void
outchar(int c)
{
	unsigned char	uc;

	uc = (unsigned char) c;

	if ((uc == '\\') || (uc == ';') || (uc == '"')) {
		(void) putchar(escapec);
		(void) putchar(uc);
	} else if (iscntrl(uc)) {
		(void) printf("%cx%02x", escapec, uc);
	} else {
		(void) putchar(uc);
	}
}

/*
 * print_category(): Print out all the keyword's value
 *                  in the given category
 */
static int
print_category(int category, int cflag, int kflag)
{
	int		i;
	int		retval = 0;

	if (category == LC_ALL) {
		retval += print_category(LC_CTYPE, cflag, kflag);
		retval += print_category(LC_NUMERIC, cflag, kflag);
		retval += print_category(LC_TIME, cflag, kflag);
		retval += print_category(LC_COLLATE, cflag, kflag);
		retval += print_category(LC_MONETARY, cflag, kflag);
		retval += print_category(LC_MESSAGES, cflag, kflag);
	} else {
		if (cflag) {
			(void) printf("%s\n",
			    locale_name[category].name);
		}

		for (i = 0; key[i].name != NULL; i++) {
			if (key[i].category == category) {
				retval += print_keyword(key[i].name, 0, kflag);
			}
		}
	}
	return (retval);
}

/*
 * usage message for locale
 */
static void
usage(void)
{
	(void) fprintf(stderr, gettext(
	    "Usage: locale [-a|-m]\n"
	    "       locale [-ck] name ...\n"));
	exit(2);
}

static void
prt_ctp(char *name)
{
	int		idx, i, mem;
	int		first = 1;

	static const char	*reg_names[] = {
		"upper", "lower", "alpha", "digit", "space", "cntrl",
		"punct", "graph", "print", "xdigit", "blank", NULL
	};
	for (idx = 0; reg_names[idx] != NULL; idx++) {
		if (strcmp(name, reg_names[idx]) == 0) {
			break;
		}
	}
	if (reg_names[idx] == NULL) {
		return;
	}

	for (i = 0; i < CSSIZE; i++) {
		mem = 0;
		switch (idx) {
		case 0:
			mem = isupper(i);
			break;
		case 1:
			mem = islower(i);
			break;
		case 2:
			mem = isalpha(i);
			break;
		case 3:
			mem = isdigit(i);
			break;
		case 4:
			mem = isspace(i);
			break;
		case 5:
			mem = iscntrl(i);
			break;
		case 6:
			mem = ispunct(i);
			break;
		case 7:
			mem = isgraph(i);
			break;
		case 8:
			mem = isprint(i);
			break;
		case 9:
			mem = isxdigit(i);
			break;
		case 10:
			mem = isblank(i);
			break;
		}
		if (mem) {
			if (!first) {
				(void) putchar(';');
			}
			first = 0;
			(void) printf("\"");
			outchar(i);
			(void) printf("\"");
		}
	}
}

static void
prt_cnv(char *name)
{
	int		idx, i, q;
	int		first = 1;

	static const char	*reg_names[] = {
		"toupper", "tolower", NULL
	};
	for (idx = 0; reg_names[idx] != NULL; idx++) {
		if (strcmp(name, reg_names[idx]) == 0) {
			break;
		}
	}
	if (reg_names[idx] == NULL) {
		return;
	}

	for (i = 0; i < CSSIZE; i++) {
		switch (idx) {
		case 0:
			q = toupper(i);
			if (q == i) {
				continue;
			}
			if (!first) {
				(void) putchar(';');
			}
			first = 0;
			/* BEGIN CSTYLED */
			(void) printf("\"<'");
			/* END CSTYLED */
			outchar(i);
			(void) printf("','");
			outchar(q);
			(void) printf("'>\"");
			break;
		case 1:
			q = tolower(i);
			if (q == i) {
				continue;
			}
			if (!first) {
				(void) putchar(';');
			}
			first = 0;
			/* BEGIN CSTYLED */
			(void) printf("\"<'");
			/* END CSTYLED */
			outchar(i);
			(void) printf("','");
			outchar(q);
			(void) printf("'>\"");
			break;
		}
	}
}

/*
 * prt_collel(): Stub for the collate class which does nothing.
 */
/* ARGSUSED */
static void
prt_collel(char *name)
{
}

static char
get_escapechar(void)
{
	return ('\\');
}

static char
get_commentchar(void)
{
	return ('#');
}