#pragma prototyped

static const char usage[] =

;

#include <ast.h>

#include <cdt.h>

#include <ctype.h>

#include <error.h>

#include <lc.h>

#include <tm.h>

#include <regex.h>

#include <proc.h>

#include "FEATURE/locales"

#define TEST (AST_LC_COUNT+1)

#if _hdr_nl_types && _hdr_langinfo

#include <nl_types.h>

#include <langinfo.h>

#else

#undef _hdr_nl_types

#undef _hdr_langinfo

#endif

typedef struct Keyword_s

{

const char* name;

int index;

int type;

int elements;

long offset;

Dtlink_t link;

} Keyword_t;

#define LC_category (LC_user<<1)

#define LC_indent (LC_user<<2)

#define LC_keyword (LC_user<<3)

#define LC_proper (LC_user<<4)

#define LC_quote (LC_user<<5)

#define LC_recursive (LC_user<<6)

#define LC_upper (LC_user<<7)

#define C 1

#define I 4

#define N 3

#define S 0

#define X 5

#define CV_collate 1

#define CV_charset 1

#define CV_mb_cur_max 2

#define CV_mb_cur_min 3

#ifdef NOEXPR

#define CV_noexpr NOEXPR

#else

#define CV_noexpr (-1)

#endif

#ifdef NOSTR

#define CV_nostr NOSTR

#else

#define CV_nostr (-1)

#endif

#ifdef YESEXPR

#define CV_yesexpr YESEXPR

#else

#define CV_yesexpr (-1)

#endif

#ifdef YESSTR

#define CV_yesstr YESSTR

#else

#define CV_yesstr (-1)

#endif

#if _mem_credit_sign_lconv

#define CV_credit_sign offsetof(struct lconv,credit_sign)

#else

#define CV_credit_sign (-1)

#endif

#if _mem_currency_symbol_lconv

#define CV_currency_symbol offsetof(struct lconv,currency_symbol)

#else

#define CV_currency_symbol (-1)

#endif

#if _mem_debit_sign_lconv

#define CV_debit_sign offsetof(struct lconv,debit_sign)

#else

#define CV_debit_sign (-1)

#endif

#if _mem_frac_digits_lconv

#define CV_frac_digits offsetof(struct lconv,frac_digits)

#else

#define CV_frac_digits (-1)

#endif

#if _mem_int_curr_symbol_lconv

#define CV_int_curr_symbol offsetof(struct lconv,int_curr_symbol)

#else

#define CV_int_curr_symbol (-1)

#endif

#if _mem_int_frac_digits_lconv

#define CV_int_frac_digits offsetof(struct lconv,int_frac_digits)

#else

#define CV_int_frac_digits (-1)

#endif

#if _mem_left_parenthesis_lconv

#define CV_left_parenthesis offsetof(struct lconv,left_parenthesis)

#else

#define CV_left_parenthesis (-1)

#endif

#if _mem_mon_decimal_point_lconv

#define CV_mon_decimal_point offsetof(struct lconv,mon_decimal_point)

#else

#define CV_mon_decimal_point (-1)

#endif

#if _mem_mon_grouping_lconv

#define CV_mon_grouping offsetof(struct lconv,mon_grouping)

#else

#define CV_mon_grouping (-1)

#endif

#if _mem_mon_thousands_sep_lconv

#define CV_mon_thousands_sep offsetof(struct lconv,mon_thousands_sep)

#else

#define CV_mon_thousands_sep (-1)

#endif

#if _mem_n_cs_precedes_lconv

#define CV_n_cs_precedes offsetof(struct lconv,n_cs_precedes)

#else

#define CV_n_cs_precedes (-1)

#endif

#if _mem_n_sep_by_space_lconv

#define CV_n_sep_by_space offsetof(struct lconv,n_sep_by_space)

#else

#define CV_n_sep_by_space (-1)

#endif

#if _mem_n_sign_posn_lconv

#define CV_n_sign_posn offsetof(struct lconv,n_sign_posn)

#else

#define CV_n_sign_posn (-1)

#endif

#if _mem_negative_sign_lconv

#define CV_negative_sign offsetof(struct lconv,negative_sign)

#else

#define CV_negative_sign (-1)

#endif

#if _mem_p_cs_precedes_lconv

#define CV_p_cs_precedes offsetof(struct lconv,p_cs_precedes)

#else

#define CV_p_cs_precedes (-1)

#endif

#if _mem_p_sep_by_space_lconv

#define CV_p_sep_by_space offsetof(struct lconv,p_sep_by_space)

#else

#define CV_p_sep_by_space (-1)

#endif

#if _mem_p_sign_posn_lconv

#define CV_p_sign_posn offsetof(struct lconv,p_sign_posn)

#else

#define CV_p_sign_posn (-1)

#endif

#if _mem_positive_sign_lconv

#define CV_positive_sign offsetof(struct lconv,positive_sign)

#else

#define CV_positive_sign (-1)

#endif

#if _mem_right_parenthesis_lconv

#define CV_right_parenthesis offsetof(struct lconv,right_parenthesis)

#else

#define CV_right_parenthesis (-1)

#endif

#if _mem_decimal_point_lconv

#define CV_decimal_point offsetof(struct lconv,decimal_point)

#else

#define CV_decimal_point (-1)

#endif

#if _mem_grouping_lconv

#define CV_grouping offsetof(struct lconv,grouping)

#else

#define CV_grouping (-1)

#endif

#if _mem_thousands_sep_lconv

#define CV_thousands_sep offsetof(struct lconv,thousands_sep)

#else

#define CV_thousands_sep (-1)

#endif

#if _num__NL_ADDRESS_POSTAL_FMT

#define CV_postal_fmt _NL_ADDRESS_POSTAL_FMT

#else

#define CV_postal_fmt (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_NAME

#define CV_country_name _NL_ADDRESS_COUNTRY_NAME

#else

#define CV_country_name (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_POST

#define CV_country_post _NL_ADDRESS_COUNTRY_POST

#else

#define CV_country_post (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_AB2

#define CV_country_ab2 _NL_ADDRESS_COUNTRY_AB2

#else

#define CV_country_ab2 (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_AB3

#define CV_country_ab3 _NL_ADDRESS_COUNTRY_AB3

#else

#define CV_country_ab3 (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_NUM

#define CV_country_num _NL_ADDRESS_COUNTRY_NUM

#else

#define CV_country_num (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_CAR

#define CV_country_car _NL_ADDRESS_COUNTRY_CAR

#else

#define CV_country_car (-1)

#endif

#if _num__NL_ADDRESS_COUNTRY_ISBN

#define CV_country_isbn _NL_ADDRESS_COUNTRY_ISBN

#else

#define CV_country_isbn (-1)

#endif

#if _num__NL_ADDRESS_LANG_NAME

#define CV_lang_name _NL_ADDRESS_LANG_NAME

#else

#define CV_lang_name (-1)

#endif

#if _num__NL_ADDRESS_LANG_AB

#define CV_lang_ab _NL_ADDRESS_LANG_AB

#else

#define CV_lang_ab (-1)

#endif

#if _num__NL_ADDRESS_LANG_TERM

#define CV_lang_term _NL_ADDRESS_LANG_TERM

#else

#define CV_lang_term (-1)

#endif

#if _num__NL_ADDRESS_LANG_LIB

#define CV_lang_lib _NL_ADDRESS_LANG_LIB

#else

#define CV_lang_lib (-1)

#endif

#if _num__NL_IDENTIFICATION_TITLE

#define CV_title _NL_IDENTIFICATION_TITLE

#else

#define CV_title (-1)

#endif

#if _num__NL_IDENTIFICATION_SOURCE

#define CV_source _NL_IDENTIFICATION_SOURCE

#else

#define CV_source (-1)

#endif

#if _num__NL_IDENTIFICATION_ADDRESS

#define CV_address _NL_IDENTIFICATION_ADDRESS

#else

#define CV_address (-1)

#endif

#if _num__NL_IDENTIFICATION_CONTACT

#define CV_contact _NL_IDENTIFICATION_CONTACT

#else

#define CV_contact (-1)

#endif

#if _num__NL_IDENTIFICATION_EMAIL

#define CV_email _NL_IDENTIFICATION_EMAIL

#else

#define CV_email (-1)

#endif

#if _num__NL_IDENTIFICATION_TEL

#define CV_tel _NL_IDENTIFICATION_TEL

#else

#define CV_tel (-1)

#endif

#if _num__NL_IDENTIFICATION_FAX

#define CV_fax _NL_IDENTIFICATION_FAX

#else

#define CV_fax (-1)

#endif

#if _num__NL_IDENTIFICATION_LANGUAGE

#define CV_language _NL_IDENTIFICATION_LANGUAGE

#define T_language N

#else

#define CV_language (-2)

#define T_language X

#endif

#if _num__NL_IDENTIFICATION_TERRITORY

#define CV_territory _NL_IDENTIFICATION_TERRITORY

#define T_territory N

#else

#define CV_territory (-3)

#define T_territory X

#endif

#if _num__NL_IDENTIFICATION_ATTRIBUTES

#define CV_attributes _NL_IDENTIFICATION_ATTRIBUTES

#define T_attributes N

#else

#define CV_attributes (-4)

#define T_attributes X

#endif

#if _num__NL_IDENTIFICATION_REVISION

#define CV_revision _NL_IDENTIFICATION_REVISION

#else

#define CV_revision (-1)

#endif

#if _num__NL_IDENTIFICATION_DATE

#define CV_date _NL_IDENTIFICATION_DATE

#else

#define CV_date (-1)

#endif

#if _num__NL_MEASUREMENT_MEASUREMENT

#define CV_measurement _NL_MEASUREMENT_MEASUREMENT

#else

#define CV_measurement (-1)

#endif

#if _num__NL_NAME_NAME_FMT

#define CV_name_fmt _NL_NAME_NAME_FMT

#else

#define CV_name_fmt (-1)

#endif

#if _num__NL_NAME_NAME_MISS

#define CV_name_miss _NL_NAME_NAME_MISS

#else

#define CV_name_miss (-1)

#endif

#if _num__NL_NAME_NAME_MR

#define CV_name_mr _NL_NAME_NAME_MR

#else

#define CV_name_mr (-1)

#endif

#if _num__NL_NAME_NAME_MRS

#define CV_name_mrs _NL_NAME_NAME_MRS

#else

#define CV_name_mrs (-1)

#endif

#if _num__NL_NAME_NAME_MS

#define CV_name_ms _NL_NAME_NAME_MS

#else

#define CV_name_ms (-1)

#endif

#if _num__NL_PAPER_HEIGHT

#define CV_height _NL_PAPER_HEIGHT

#else

#define CV_height (-1)

#endif

#if _num__NL_PAPER_WIDTH

#define CV_width _NL_PAPER_WIDTH

#else

#define CV_width (-1)

#endif

#if _num__NL_TELEPHONE_TEL_INT_FMT

#define CV_tel_int_fmt _NL_TELEPHONE_TEL_INT_FMT

#else

#define CV_tel_int_fmt (-1)

#endif

#if _num__NL_TELEPHONE_TEL_DOM_FMT

#define CV_tel_dom_fmt _NL_TELEPHONE_TEL_DOM_FMT

#else

#define CV_tel_dom_fmt (-1)

#endif

#if _num__NL_TELEPHONE_INT_SELECT

#define CV_int_select _NL_TELEPHONE_INT_SELECT

#else

#define CV_int_select (-1)

#endif

#if _num__NL_TELEPHONE_INT_PREFIX

#define CV_int_prefix _NL_TELEPHONE_INT_PREFIX

#else

#define CV_int_prefix (-1)

#endif

#ifndef MB_CUR_MIN

#define MB_CUR_MIN 1

#endif

static const char defer[] = "/usr/bin/locale";

static Keyword_t keywords[] =

{

{"TEST", TEST, S,1,0},

{"postal_fmt", AST_LC_ADDRESS, N,1,CV_postal_fmt},

{"country_name", AST_LC_ADDRESS, N,1,CV_country_name},

{"country_post", AST_LC_ADDRESS, N,1,CV_country_post},

{"country_ab2", AST_LC_ADDRESS, N,1,CV_country_ab2},

{"country_ab3", AST_LC_ADDRESS, N,1,CV_country_ab3},

{"country_num", AST_LC_ADDRESS, N,1,CV_country_num},

{"country_car", AST_LC_ADDRESS, N,1,CV_country_car},

{"country_isbn", AST_LC_ADDRESS, N,1,CV_country_isbn},

{"lang_name", AST_LC_ADDRESS, N,1,CV_lang_name},

{"lang_ab", AST_LC_ADDRESS, N,1,CV_lang_ab},

{"lang_term", AST_LC_ADDRESS, N,1,CV_lang_term},

{"lang_lib", AST_LC_ADDRESS, N,1,CV_lang_lib},

{"collate", AST_LC_COLLATE, S,1,CV_collate},

{"charset", AST_LC_CTYPE, S,1,CV_charset},

{"mb_cur_max", AST_LC_CTYPE, I,1,CV_mb_cur_max},

{"mb_cur_min", AST_LC_CTYPE, I,1,CV_mb_cur_min},

{"title", AST_LC_IDENTIFICATION,N,1,CV_title},

{"source", AST_LC_IDENTIFICATION,N,1,CV_source},

{"address", AST_LC_IDENTIFICATION,N,1,CV_address},

{"contact", AST_LC_IDENTIFICATION,N,1,CV_contact},

{"email", AST_LC_IDENTIFICATION,N,1,CV_email},

{"tel", AST_LC_IDENTIFICATION,N,1,CV_tel},

{"fax", AST_LC_IDENTIFICATION,N,1,CV_fax},

{"language", AST_LC_IDENTIFICATION,T_language,1,CV_language},

{"territory", AST_LC_IDENTIFICATION,T_territory,1,CV_territory},

{"attributes", AST_LC_IDENTIFICATION,T_attributes,1,CV_attributes},

{"revision", AST_LC_IDENTIFICATION,N,1,CV_revision},

{"date", AST_LC_IDENTIFICATION,N,1,CV_date},

{"measurement", AST_LC_MEASUREMENT,N,1,CV_measurement},

{"yesexpr", AST_LC_MESSAGES, N,1,CV_yesexpr},

{"noexpr", AST_LC_MESSAGES, N,1,CV_noexpr},

{"yesstr", AST_LC_MESSAGES, N,1,CV_yesstr},

{"nostr", AST_LC_MESSAGES, N,1,CV_nostr},

{"credit_sign", AST_LC_MONETARY, S,1,CV_credit_sign},

{"currency_symbol", AST_LC_MONETARY, S,1,CV_currency_symbol},

{"debit_sign", AST_LC_MONETARY, S,1,CV_debit_sign},

{"frac_digits", AST_LC_MONETARY, C,1,CV_frac_digits},

{"int_curr_symbol", AST_LC_MONETARY, S,1,CV_int_curr_symbol},

{"int_frac_digits", AST_LC_MONETARY, C,1,CV_int_frac_digits},

{"left_parenthesis", AST_LC_MONETARY, S,1,CV_left_parenthesis},

{"mon_decimal_point", AST_LC_MONETARY, S,1,CV_mon_decimal_point},

{"mon_grouping", AST_LC_MONETARY, S,1,CV_mon_grouping},

{"mon_thousands_sep", AST_LC_MONETARY, S,1,CV_mon_thousands_sep},

{"n_cs_precedes", AST_LC_MONETARY, C,1,CV_n_cs_precedes},

{"n_sep_by_space", AST_LC_MONETARY, C,1,CV_n_sep_by_space},

{"n_sign_posn", AST_LC_MONETARY, C,1,CV_n_sign_posn},

{"negative_sign", AST_LC_MONETARY, S,1,CV_negative_sign},

{"p_cs_precedes", AST_LC_MONETARY, C,1,CV_p_cs_precedes},

{"p_sep_by_space", AST_LC_MONETARY, C,1,CV_p_sep_by_space},

{"p_sign_posn", AST_LC_MONETARY, C,1,CV_p_sign_posn},

{"positive_sign", AST_LC_MONETARY, S,1,CV_positive_sign},

{"right_parenthesis", AST_LC_MONETARY, S,1,CV_right_parenthesis},

{"name_fmt", AST_LC_NAME, N,1,CV_name_fmt},

{"name_miss", AST_LC_NAME, N,1,CV_name_miss},

{"name_mr", AST_LC_NAME, N,1,CV_name_mr},

{"name_mrs", AST_LC_NAME, N,1,CV_name_mrs},

{"name_ms", AST_LC_NAME, N,1,CV_name_ms},

{"decimal_point", AST_LC_NUMERIC, S,1,CV_decimal_point},

{"grouping", AST_LC_NUMERIC, S,1,CV_grouping},

{"thousands_sep", AST_LC_NUMERIC, S,1,CV_thousands_sep},

{"height", AST_LC_PAPER, N,1,CV_height},

{"width", AST_LC_PAPER, N,1,CV_width},

{"tel_int_fmt", AST_LC_TELEPHONE, N,1,CV_tel_int_fmt},

{"tel_dom_fmt", AST_LC_TELEPHONE, N,1,CV_tel_dom_fmt},

{"int_select", AST_LC_TELEPHONE, N,1,CV_int_select},

{"int_prefix", AST_LC_TELEPHONE, N,1,CV_int_prefix},

{"abday", AST_LC_TIME, S,7,TM_DAY_ABBREV*sizeof(char*)},

{"abmon", AST_LC_TIME, S,12,TM_MONTH_ABBREV*sizeof(char*)},

{"alt_digits", AST_LC_TIME, S,10,TM_DIGITS*sizeof(char*)},

{"am_pm", AST_LC_TIME, S,2,TM_MERIDIAN*sizeof(char*)},

{"d_fmt", AST_LC_TIME, S,1,TM_DATE*sizeof(char*)},

{"d_t_fmt", AST_LC_TIME, S,1,TM_DEFAULT*sizeof(char*)},

{"day", AST_LC_TIME, S,7,TM_DAY*sizeof(char*)},

{"era", AST_LC_TIME, S,1,TM_ERA*sizeof(char*)},

{"era_d_fmt", AST_LC_TIME, S,1,TM_ERA_DATE*sizeof(char*)},

{"era_d_t_fmt", AST_LC_TIME, S,1,TM_ERA_DEFAULT*sizeof(char*)},

{"era_t_fmt", AST_LC_TIME, S,1,TM_ERA_TIME*sizeof(char*)},

{"era_year", AST_LC_TIME, S,1,TM_ERA_YEAR*sizeof(char*)},

{"m_d_old", AST_LC_TIME, S,1,TM_DISTANT*sizeof(char*)},

{"m_d_recent", AST_LC_TIME, S,1,TM_RECENT*sizeof(char*)},

{"mon", AST_LC_TIME, S,12,TM_MONTH*sizeof(char*)},

{"t_fmt", AST_LC_TIME, S,1,TM_TIME*sizeof(char*)},

{"t_fmt_ampm", AST_LC_TIME, S,1,TM_MERIDIAN_TIME*sizeof(char*)},

};

static struct State_s

{

Lc_category_t* categories;

struct lconv* conv;

Dt_t* dict;

Dtdisc_t disc;

int all;

int output;

int sep;

} state;

static void

list_locale(Sfio_t* sp, Keyword_t* key, Lc_t* lc, unsigned int flags)

{

register int i;

int n;

char* fmt;

char* sep;

char buf[256];

static unsigned long types[] = { LC_abbreviated, LC_qualified, LC_verbose, LC_local };

n = 0;

for (i = 0; i < elementsof(types); i++)

if (flags & types[i])

n++;

if (!n)

{

n++;

flags |= LC_abbreviated;

}

n = n == 1;

if (key)

{

if (flags & LC_indent)

{

sfputc(sp, '\t');

n = 0;

}

if (flags & (LC_category|LC_keyword))

{

sfprintf(sp, "%s=", key->name);

n = 0;

}

}

fmt = n ? "%s%s" : "%s\"%s\"";

sep = "";

for (i = 0; i < elementsof(types); i++)

if (flags & types[i])

{

lccanon(lc, types[i], buf, sizeof(buf));

if (n && streq(buf, "-"))

return;

sfprintf(sp, fmt, sep, buf);

sep = ";";

}

sfputc(sp, '\n');

}

static void

number(Sfio_t* sp, register Keyword_t* key, int i, unsigned int flags)

{

state.output = 1;

if (flags & LC_indent)

sfputc(sp, '\t');

if (flags & LC_keyword)

sfprintf(sp, "%s=%d\n", key->name, i);

else

sfprintf(sp, "%d\n", i);

}

static void

value(Sfio_t* sp, register const char* s, register unsigned int flags)

{

register int c;

register int u;

state.output = 1;

if ((flags & (LC_quote|LC_proper|LC_upper)) == LC_quote)

{

sfprintf(sp, "%s", fmtquote(s, "\"", "\"", strlen(s), FMT_ALWAYS));

return;

}

if (flags & LC_quote)

sfputc(sp, '"');

if (flags & LC_upper)

while (c = *s++)

{

if (islower(c))

c = toupper(c);

sfputc(sp, c);

}

else if (flags & LC_proper)

{

u = 1;

while (c = *s++)

{

if (!isalnum(c))

u = 1;

else

{

if (u && islower(c))

c = toupper(c);

u = 0;

}

sfputc(sp, c);

}

}

else

sfprintf(sp, "%s", s);

if (flags & LC_quote)

sfputc(sp, '"');

}

static void

string(Sfio_t* sp, register Keyword_t* key, char** v, int n, unsigned int flags)

{

char** e;

register const Lc_attribute_list_t* a;

if (flags & LC_indent)

sfputc(sp, '\t');

if (flags & LC_keyword)

sfprintf(sp, "%s=", key->name);

if ((flags & LC_keyword) || n != 1)

flags |= LC_quote;

if (n)

{

value(sp, *v, flags);

flags |= LC_quote;

e = v + n - 1;

while (v++ < e)

{

sfputc(sp, ';');

value(sp, *v, flags);

}

}

else if (v && (a = *((Lc_attribute_list_t**)v)))

{

value(sp, a->attribute->name, flags);

while (a = a->next)

{

sfputc(sp, ';');

value(sp, a->attribute->name, flags);

}

}

sfputc(sp, '\n');

}

static void

extract(Sfio_t* sp, register Keyword_t* key, void* data, unsigned int flags)

{

register int i;

char* s;

char** v;

Lc_t* lc;

switch (key->type)

{

case C:

if (key->offset >= 0)

i = *((char*)data + key->offset);

else

i = CHAR_MAX;

if (i == CHAR_MAX)

i = -1;

number(sp, key, i, flags);

break;

case I:

if (key->offset >= 0)

i = *(int*)((char*)data + key->offset);

else

i = -1;

number(sp, key, i, flags);

break;

case N:

#if _lib_nl_langinfo

if (key->offset >= 0)

{

s = nl_langinfo(key->offset);

#if _num__NL_PAPER_HEIGHT

/*

if (((unsigned int)s) < 8196)

{

static char xxx[32];

sfsprintf(xxx, sizeof(xxx), "%d", (unsigned int)s);

s = xxx;

}

#endif

}

else

#endif

s = "";

string(sp, key, &s, 1, flags);

break;

case S:

if (key->offset >= 0)

{

v = (char**)((char*)data + key->offset);

i = key->elements;

}

else

{

s = "";

v = &s;

i = 1;

}

string(sp, key, v, i, flags);

break;

case X:

lc = (Lc_t*)lcinfo(state.categories[key->index].external)->lc;

i = 1;

if (key->offset == CV_language && lc->language)

{

s = (char*)lc->language->name;

flags |= LC_proper;

}

else if (key->offset == CV_territory && lc->territory)

{

s = (char*)lc->territory->name;

flags |= LC_proper;

}

else if (key->offset == CV_attributes && lc->attributes)

{

s = (char*)lc->attributes;

i = 0;

}

else

s = "";

string(sp, key, &s, i, flags);

break;

}

}

static void

list_all(Sfio_t* sp, register Lc_t* lc, unsigned long flags)

{

if (!lc)

lc = (Lc_t*)lcinfo(LC_CTYPE)->lc;

if (!state.sep)

state.sep = 1;

else

sfputc(sp, '\n');

if (flags & LC_category)

sfprintf(sp, "LC_ALL\n");

if (flags & LC_indent)

sfputc(sp, '\t');

if (flags & LC_keyword)

{

flags |= LC_quote;

sfprintf(sp, "locale=");

}

value(sp, lc->name, flags);

sfputc(sp, '\n');

}

static int scan(Sfio_t*, Keyword_t*, unsigned long);

static void

list_keyword(Sfio_t* sp, register Keyword_t* key, char* value, unsigned int flags)

{

register int i;

register int j;

register int n;

register unsigned int f;

char* s;

if ((flags & LC_category) && key->index != AST_LC_ALL)

sfprintf(sp, "%s\n", state.categories[key->index].name);

switch (key->index)

{

case AST_LC_COLLATE:

s = mbcoll() ? "strcoll" : "strcmp";

string(sp, key, &s, 1, flags);

break;

case AST_LC_CTYPE:

switch (key->offset)

{

case CV_charset:

s = (char*)lcinfo(LC_CTYPE)->lc->charset->code;

string(sp, key, &s, 1, flags|LC_upper);

break;

case CV_mb_cur_max:

number(sp, key, ast.mb_cur_max, flags);

break;

case CV_mb_cur_min:

number(sp, key, MB_CUR_MIN, flags);

break;

}

break;

case AST_LC_MONETARY:

case AST_LC_NUMERIC:

if (!state.conv)

state.conv = localeconv();

extract(sp, key, state.conv, flags);

break;

case AST_LC_ADDRESS:

case AST_LC_IDENTIFICATION:

case AST_LC_MEASUREMENT:

case AST_LC_MESSAGES:

case AST_LC_NAME:

case AST_LC_PAPER:

case AST_LC_TELEPHONE:

case AST_LC_TIME:

extract(sp, key, tmlocale(), flags);

break;

case AST_LC_ALL:

if (value)

{

if (streq(value, "-"))

value = 0;

if (!setlocale(key->offset, value))

error(1, "%s: invalid locale", value);

state.conv = 0;

}

else

{

if (key->type == AST_LC_ALL)

{

state.all = 1;

if ((flags & (LC_defined|LC_recursive)) == LC_defined)

{

scan(sp, key, flags|LC_recursive);

break;

}

i = 1;

n = AST_LC_COUNT - 1;

}

else

i = n = key->type;

if (state.all)

list_all(sp, NiL, flags);

for (; i <= n; i++)

{

f = flags;

for (j = 0; j < elementsof(keywords); j++)

if (keywords[j].index == i)

{

list_keyword(sp, &keywords[j], NiL, f);

f &= ~LC_category;

}

}

}

break;

case TEST:

state.output = 1;

if (!value)

error(2, "%s: value expected", key->name);

else

{

if (streq(value, "-"))

value = 0;

list_locale(sfstdout, key, lcmake(value), flags);

}

break;

}

}

static int

scan(Sfio_t* sp, Keyword_t* key, unsigned long flags)

{

register Lc_t* lc = 0;

while (lc = lcscan(lc))

{

switch (flags & (LC_defined|LC_undefined))

{

case LC_defined:

if (!lc->index && !setlocale(LC_MONETARY, lc->name))

continue;

break;

case LC_undefined:

if (lc->index || setlocale(LC_MONETARY, lc->name))

continue;

break;

}

if (!key)

list_locale(sp, NiL, lc, flags);

else if (setlocale(LC_ALL, lc->name))

list_keyword(sp, key, NiL, flags&~LC_quote);

}

return 0;

}

main(int argc, char** argv)

{

register char* name;

register char* s;

register int i;

register unsigned int flags;

int collate;

int composite;

int transform;

int j;

char* value;

char** oargv;

Keyword_t* key;

char buf[64];

char col[1024];

char dip[64];

error_info.id = "locale";

oargv = argv;

flags = 0;

collate = 0;

composite = 0;

transform = 0;

for (;;)

{

switch (optget(argv, usage))

{

case 'a':

flags |= LC_defined;

continue;

case 'b':

flags |= LC_abbreviated;

continue;

case 'c':

flags |= LC_category;

continue;

case 'e':

collate = 1;

continue;

case 'i':

flags |= LC_indent;

continue;

case 'k':

flags |= LC_keyword;

continue;

case 'l':

flags |= LC_local;

continue;

case 'm':

return execv(defer, argv);

case 'q':

flags |= LC_qualified;

continue;

case 't':

composite = 1;

continue;

case 'u':

flags |= LC_undefined;

continue;

case 'v':

flags |= LC_verbose;

continue;

case 'x':

transform = 1;

continue;

case '?':

error(ERROR_USAGE|4, "%s", opt_info.arg);

break;

case ':':

error(2, "%s", opt_info.arg);

break;

}

break;

}

if (error_info.errors)

error(ERROR_USAGE|4, "%s", optusage(NiL));

argv += opt_info.index;

if (collate)

{

while (name = *argv++)

{

sfprintf(sfstdout, "%s", name);

sfsprintf(col, sizeof(col), ".%s.]", name);

if ((i = regcollate(col, NiL, buf, sizeof(buf), NiL)) < 0)

{

sfprintf(sfstdout, "\tERROR\n");

continue;

}

if (!(collate = mbxfrm(col, buf, sizeof(col))))

{

if (i > 1)

{

sfprintf(sfstdout, "\tINVALID\n");

continue;

}

collate = i;

memcpy(col, buf, i);

}

else if (i > 1)

{

buf[1] = 0;

if (mbxfrm(dip, buf, sizeof(dip)) < collate)

{

sfprintf(sfstdout, "\tUNDEFINED\n");

continue;

}

}

for (i = 0, j = '\t'; i < collate; i++, j = ' ')

sfprintf(sfstdout, "%c%02x", j, ((unsigned char*)col)[i]);

sfputc(sfstdout, '\n');

}

return error_info.errors != 0;

}

if (composite)

{

sfprintf(sfstdout, "%s\n", setlocale(LC_ALL, NiL));

return error_info.errors != 0;

}

if (transform)

{

while (name = *argv++)

{

sfprintf(sfstdout, "%s", name);

collate = mbxfrm(col, name, sizeof(col));

for (i = 0, j = '\t'; i < collate; i++, j = ' ')

sfprintf(sfstdout, "%c%02x", j, ((unsigned char*)col)[i]);

sfputc(sfstdout, '\n');

}

return error_info.errors != 0;

}

state.categories = lccategories();

if (!*argv)

{

if (flags & (LC_undefined|LC_defined))

{

if (!(flags & (LC_abbreviated|LC_qualified|LC_local|LC_verbose)))

flags |= LC_abbreviated;

return scan(sfstdout, NiL, flags);

}

if (!flags)

{

name = "LANG";

sfprintf(sfstdout, "%s=", name);

if (!(s = getenv("LANG")))

s = "POSIX";

sfprintf(sfstdout, "%s\n", fmtquote(s, "'", NiL, strlen(s), 0));

value = getenv(state.categories[AST_LC_ALL].name);

for (i = 1; i < AST_LC_COUNT; i++)

{

s = setlocale(state.categories[i].external, NiL);

sfprintf(sfstdout, "%s=%s\n", state.categories[i].name, fmtquote(s, "\"", "\"", strlen(s), (value || !getenv(state.categories[i].name)) ? FMT_ALWAYS : 0));

}

sfprintf(sfstdout, "%s=", state.categories[0].name);

if (value)

{

s = setlocale(state.categories[0].external, NiL);

sfprintf(sfstdout, "%s", fmtquote(s, "\"", "\"", strlen(s), 0));

}

sfputc(sfstdout, '\n');

return 0;

}

}

state.disc.key = offsetof(Keyword_t, name);

state.disc.size = -1;

state.disc.link = offsetof(Keyword_t, link);

if (!(state.dict = dtopen(&state.disc, Dtoset)))

error(3, "out of space [dictionary]");

for (i = 0; i < elementsof(keywords); i++)

dtinsert(state.dict, keywords + i);

for (i = 0; i < AST_LC_COUNT; i++)

{

if (!(key = newof(0, Keyword_t, 1, 0)))

error(3, "out of space [keyword]");

key->name = state.categories[i].name;

key->index = AST_LC_ALL;

key->type = state.categories[i].internal;

key->offset = state.categories[i].external;

dtinsert(state.dict, key);

}

while (name = *argv++)

{

if (value = strchr(name, '='))

*value++ = 0;

if (!(key = (Keyword_t*)dtmatch(state.dict, name)))

{

if (name[0] == 'L' && name[1] == 'C' && name[2] == '_')

error(2, "%s: unknown category", name);

else if (oargv[0][0] != '/')

{

char* cmd[3];

cmd[0] = (char*)defer;

cmd[1] = name;

cmd[2] = 0;

procrun(defer, cmd, 0);

state.output = 1;

}

else

error(2, "%s: unknown keyword", name);

}

else

list_keyword(sfstdout, key, value, flags);

}

if (!error_info.errors && !state.output)

list_keyword(sfstdout, (Keyword_t*)dtmatch(state.dict, state.categories[0].name), NiL, flags);

return error_info.errors != 0;

}