/***********************************************************************
* *
* This software is part of the ast package *
* Copyright (c) 1985-2011 AT&T Intellectual Property *
* and is licensed under the *
* Eclipse Public License, Version 1.0 *
* by AT&T Intellectual Property *
* *
* A copy of the License is available at *
* http://www.eclipse.org/org/documents/epl-v10.html *
* (with md5 checksum b35adb5213ca9657e911e9befb180842) *
* *
* Information and Software Systems Research *
* AT&T Research *
* Florham Park NJ *
* *
* Glenn Fowler <gsf@research.att.com> *
* David Korn <dgk@research.att.com> *
* Phong Vo <kpv@research.att.com> *
* *
***********************************************************************/
#pragma prototyped
/*
* Glenn Fowler
* AT&T Research
*
* time conversion translation support
*/
#include <ast.h>
#include <cdt.h>
#include <iconv.h>
#include <mc.h>
#include <tm.h>
#include <ast_nl_types.h>
#include "lclib.h"
static struct
{
char* format;
Lc_info_t* locale;
char null[1];
} state;
/*
* this is unix dadgummit
*/
static int
standardized(Lc_info_t* li, register char** b)
{
if ((li->lc->language->flags & (LC_debug|LC_default)) || streq(li->lc->language->code, "en"))
{
b[TM_TIME] = "%H:%M:%S";
b[TM_DATE] = "%m/%d/%y";
b[TM_DEFAULT] = "%a %b %e %T %Z %Y";
return 1;
}
return 0;
}
/*
* fix up LC_TIME data after loading
*/
static void
fixup(Lc_info_t* li, register char** b)
{
register char** v;
register char** e;
register int n;
static int must[] =
{
TM_TIME,
TM_DATE,
TM_DEFAULT,
TM_MERIDIAN,
TM_UT,
TM_DT,
TM_SUFFIXES,
TM_PARTS,
TM_HOURS,
TM_DAYS,
TM_LAST,
TM_THIS,
TM_NEXT,
TM_EXACT,
TM_NOISE,
TM_ORDINAL,
TM_CTIME,
TM_DATE_1,
TM_INTERNATIONAL,
TM_RECENT,
TM_DISTANT,
TM_MERIDIAN_TIME,
TM_ORDINALS,
TM_FINAL,
TM_WORK,
};
standardized(li, b);
for (v = b, e = b + TM_NFORM; v < e; v++)
if (!*v)
*v = state.null;
for (n = 0; n < elementsof(must); n++)
if (!*b[must[n]])
b[must[n]] = tm_data.format[must[n]];
if (li->lc->flags & LC_default)
for (n = 0; n < TM_NFORM; n++)
if (!*b[n])
b[n] = tm_data.format[n];
if (strchr(b[TM_UT], '%'))
{
tm_info.deformat = b[TM_UT];
for (n = TM_UT; n < TM_DT; n++)
b[n] = state.null;
}
else
tm_info.deformat = b[TM_DEFAULT];
tm_info.format = b;
if (!(tm_info.deformat = state.format))
tm_info.deformat = tm_info.format[TM_DEFAULT];
li->data = (void*)b;
}
#if _WINIX
#include <ast_windows.h>
typedef struct Map_s
{
LCID native;
int local;
} Map_t;
static const Map_t map[] =
{
LOCALE_S1159, (TM_MERIDIAN+0),
LOCALE_S2359, (TM_MERIDIAN+1),
LOCALE_SABBREVDAYNAME1, (TM_DAY_ABBREV+1),
LOCALE_SABBREVDAYNAME2, (TM_DAY_ABBREV+2),
LOCALE_SABBREVDAYNAME3, (TM_DAY_ABBREV+3),
LOCALE_SABBREVDAYNAME4, (TM_DAY_ABBREV+4),
LOCALE_SABBREVDAYNAME5, (TM_DAY_ABBREV+5),
LOCALE_SABBREVDAYNAME6, (TM_DAY_ABBREV+6),
LOCALE_SABBREVDAYNAME7, (TM_DAY_ABBREV+0),
LOCALE_SABBREVMONTHNAME1, (TM_MONTH_ABBREV+0),
LOCALE_SABBREVMONTHNAME2, (TM_MONTH_ABBREV+1),
LOCALE_SABBREVMONTHNAME3, (TM_MONTH_ABBREV+2),
LOCALE_SABBREVMONTHNAME4, (TM_MONTH_ABBREV+3),
LOCALE_SABBREVMONTHNAME5, (TM_MONTH_ABBREV+4),
LOCALE_SABBREVMONTHNAME6, (TM_MONTH_ABBREV+5),
LOCALE_SABBREVMONTHNAME7, (TM_MONTH_ABBREV+6),
LOCALE_SABBREVMONTHNAME8, (TM_MONTH_ABBREV+7),
LOCALE_SABBREVMONTHNAME9, (TM_MONTH_ABBREV+8),
LOCALE_SABBREVMONTHNAME10, (TM_MONTH_ABBREV+9),
LOCALE_SABBREVMONTHNAME11, (TM_MONTH_ABBREV+10),
LOCALE_SABBREVMONTHNAME12, (TM_MONTH_ABBREV+11),
LOCALE_SDAYNAME1, (TM_DAY+1),
LOCALE_SDAYNAME2, (TM_DAY+2),
LOCALE_SDAYNAME3, (TM_DAY+3),
LOCALE_SDAYNAME4, (TM_DAY+4),
LOCALE_SDAYNAME5, (TM_DAY+5),
LOCALE_SDAYNAME6, (TM_DAY+6),
LOCALE_SDAYNAME7, (TM_DAY+0),
LOCALE_SMONTHNAME1, (TM_MONTH+0),
LOCALE_SMONTHNAME2, (TM_MONTH+1),
LOCALE_SMONTHNAME3, (TM_MONTH+2),
LOCALE_SMONTHNAME4, (TM_MONTH+3),
LOCALE_SMONTHNAME5, (TM_MONTH+4),
LOCALE_SMONTHNAME6, (TM_MONTH+5),
LOCALE_SMONTHNAME7, (TM_MONTH+6),
LOCALE_SMONTHNAME8, (TM_MONTH+7),
LOCALE_SMONTHNAME9, (TM_MONTH+8),
LOCALE_SMONTHNAME10, (TM_MONTH+9),
LOCALE_SMONTHNAME11, (TM_MONTH+10),
LOCALE_SMONTHNAME12, (TM_MONTH+11),
};
#undef extern
/*
* convert ms word date spec w to posix strftime format f
* next char after f returned
* the caller already made sure f is big enough
*/
static char*
word2posix(register char* f, register char* w, int alternate)
{
register char* r;
register int c;
register int p;
register int n;
while (*w)
{
p = 0;
r = w;
while (*++w == *r);
if ((n = w - r) > 3 && alternate)
n--;
switch (*r)
{
case 'a':
case 'A':
if (!strncasecmp(w, "am/pm", 5))
w += 5;
else if (!strncasecmp(w, "a/p", 3))
w += 3;
c = 'p';
break;
case 'd':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
case 2:
c = 'd';
break;
case 3:
c = 'a';
break;
default:
c = 'A';
break;
}
break;
case 'h':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
default:
c = 'I';
break;
}
break;
case 'H':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
default:
c = 'H';
break;
}
break;
case 'M':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
case 2:
c = 'm';
break;
case 3:
c = 'b';
break;
default:
c = 'B';
break;
}
break;
case 'm':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
default:
c = 'M';
break;
}
break;
case 's':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
default:
c = 'S';
break;
}
break;
case 'y':
switch (n)
{
case 1:
p = '-';
/*FALLTHROUGH*/
case 2:
c = 'y';
break;
default:
c = 'Y';
break;
}
break;
case '\'':
if (n & 1)
for (w = r + 1; *w; *f++ = *w++)
if (*w == '\'')
{
w++;
break;
}
continue;
case '%':
while (r < w)
{
*f++ = *r++;
*f++ = *r++;
}
continue;
default:
while (r < w)
*f++ = *r++;
continue;
}
*f++ = '%';
if (p)
*f++ = '-';
*f++ = c;
}
*f++ = 0;
return f;
}
/*
* load the native LC_TIME data for the current locale
*/
static void
native_lc_time(Lc_info_t* li)
{
register char* s;
register char* t;
register char** b;
register int n;
register int m;
register int i;
LCID lcid;
int nt;
int ns;
int nl;
int clock_24;
int leading_0;
char buf[256];
lcid = li->lc->index;
nt = 2 * GetLocaleInfo(lcid, LOCALE_STIME, 0, 0) + 7; /* HH:MM:SS */
ns = 3 * GetLocaleInfo(lcid, LOCALE_SSHORTDATE, 0, 0);
nl = 3 * GetLocaleInfo(lcid, LOCALE_SLONGDATE, 0, 0);
n = nt + ns + nl;
for (i = 0; i < elementsof(map); i++)
n += GetLocaleInfo(lcid, map[i].native, 0, 0);
if (!(b = newof(0, char*, TM_NFORM, n)))
return;
s = (char*)(b + TM_NFORM);
for (i = 0; i < elementsof(map); i++)
{
if (!(m = GetLocaleInfo(lcid, map[i].native, s, n)))
goto bad;
b[map[i].local] = s;
s += m;
}
if (!standardized(li, b))
{
/*
* synthesize TM_TIME format from the ms word template
*/
if (!GetLocaleInfo(lcid, LOCALE_ITIME, buf, sizeof(buf)))
goto bad;
clock_24 = atoi(buf);
if (!GetLocaleInfo(lcid, LOCALE_ITLZERO, buf, sizeof(buf)))
goto bad;
leading_0 = atoi(buf);
if (!GetLocaleInfo(lcid, LOCALE_STIME, buf, sizeof(buf)))
goto bad;
b[TM_TIME] = s;
*s++ = '%';
if (!leading_0)
*s++ = '-';
*s++ = clock_24 ? 'H' : 'I';
for (t = buf; *s = *t++; s++);
*s++ = '%';
if (!leading_0)
*s++ = '-';
*s++ = 'M';
for (t = buf; *s = *t++; s++);
*s++ = '%';
if (!leading_0)
*s++ = '-';
*s++ = 'S';
*s++ = 0;
/*
* synthesize TM_DATE format
*/
if (!GetLocaleInfo(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf)))
goto bad;
b[TM_DATE] = s;
s = word2posix(s, buf, 1);
/*
* synthesize TM_DEFAULT format
*/
if (!GetLocaleInfo(lcid, LOCALE_SLONGDATE, buf, sizeof(buf)))
goto bad;
b[TM_DEFAULT] = s;
s = word2posix(s, buf, 1);
strcpy(s - 1, " %X");
}
/*
* done
*/
fixup(li, b);
return;
bad:
free(b);
}
#else
#if _lib_nl_langinfo && _hdr_langinfo
#if _hdr_nl_types
#include <nl_types.h>
#endif
#include <langinfo.h>
typedef struct Map_s
{
int native;
int local;
} Map_t;
static const Map_t map[] =
{
AM_STR, (TM_MERIDIAN+0),
PM_STR, (TM_MERIDIAN+1),
ABDAY_1, (TM_DAY_ABBREV+0),
ABDAY_2, (TM_DAY_ABBREV+1),
ABDAY_3, (TM_DAY_ABBREV+2),
ABDAY_4, (TM_DAY_ABBREV+3),
ABDAY_5, (TM_DAY_ABBREV+4),
ABDAY_6, (TM_DAY_ABBREV+5),
ABDAY_7, (TM_DAY_ABBREV+6),
ABMON_1, (TM_MONTH_ABBREV+0),
ABMON_2, (TM_MONTH_ABBREV+1),
ABMON_3, (TM_MONTH_ABBREV+2),
ABMON_4, (TM_MONTH_ABBREV+3),
ABMON_5, (TM_MONTH_ABBREV+4),
ABMON_6, (TM_MONTH_ABBREV+5),
ABMON_7, (TM_MONTH_ABBREV+6),
ABMON_8, (TM_MONTH_ABBREV+7),
ABMON_9, (TM_MONTH_ABBREV+8),
ABMON_10, (TM_MONTH_ABBREV+9),
ABMON_11, (TM_MONTH_ABBREV+10),
ABMON_12, (TM_MONTH_ABBREV+11),
DAY_1, (TM_DAY+0),
DAY_2, (TM_DAY+1),
DAY_3, (TM_DAY+2),
DAY_4, (TM_DAY+3),
DAY_5, (TM_DAY+4),
DAY_6, (TM_DAY+5),
DAY_7, (TM_DAY+6),
MON_1, (TM_MONTH+0),
MON_2, (TM_MONTH+1),
MON_3, (TM_MONTH+2),
MON_4, (TM_MONTH+3),
MON_5, (TM_MONTH+4),
MON_6, (TM_MONTH+5),
MON_7, (TM_MONTH+6),
MON_8, (TM_MONTH+7),
MON_9, (TM_MONTH+8),
MON_10, (TM_MONTH+9),
MON_11, (TM_MONTH+10),
MON_12, (TM_MONTH+11),
#ifdef _DATE_FMT
_DATE_FMT, TM_DEFAULT,
#else
D_T_FMT, TM_DEFAULT,
#endif
D_FMT, TM_DATE,
T_FMT, TM_TIME,
#ifdef ERA
ERA, TM_ERA,
ERA_D_T_FMT, TM_ERA_DEFAULT,
ERA_D_FMT, TM_ERA_DATE,
ERA_T_FMT, TM_ERA_TIME,
#endif
#ifdef ALT_DIGITS
ALT_DIGITS, TM_DIGITS,
#endif
};
static void
native_lc_time(Lc_info_t* li)
{
register char* s;
register char* t;
register char** b;
register int n;
register int i;
n = 0;
for (i = 0; i < elementsof(map); i++)
{
if (!(t = nl_langinfo(map[i].native)))
t = tm_data.format[map[i].local];
n += strlen(t) + 1;
}
if (!(b = newof(0, char*, TM_NFORM, n)))
return;
s = (char*)(b + TM_NFORM);
for (i = 0; i < elementsof(map); i++)
{
b[map[i].local] = s;
if (!(t = nl_langinfo(map[i].native)))
t = tm_data.format[map[i].local];
while (*s++ = *t++);
}
fixup(li, b);
}
#else
#define native_lc_time(li) ((li->data=(void*)(tm_info.format=tm_data.format)),(tm_info.deformat=tm_info.format[TM_DEFAULT]))
#endif
#endif
/*
* load the LC_TIME data for the current locale
*/
static void
load(Lc_info_t* li)
{
register char* s;
register char** b;
register char** v;
register char** e;
unsigned char* u;
ssize_t n;
iconv_t cvt;
Sfio_t* sp;
Sfio_t* tp;
char path[PATH_MAX];
if (b = (char**)li->data)
{
tm_info.format = b;
if (!(tm_info.deformat = state.format))
tm_info.deformat = tm_info.format[TM_DEFAULT];
return;
}
tm_info.format = tm_data.format;
if (!(tm_info.deformat = state.format))
tm_info.deformat = tm_info.format[TM_DEFAULT];
if (mcfind(NiL, NiL, LC_TIME, 0, path, sizeof(path)) && (sp = sfopen(NiL, path, "r")))
{
n = sfsize(sp);
tp = 0;
if (u = (unsigned char*)sfreserve(sp, 3, 1))
{
if (u[0] == 0xef && u[1] == 0xbb && u[2] == 0xbf && (cvt = iconv_open("", "utf")) != (iconv_t)(-1))
{
if (tp = sfstropen())
{
sfread(sp, u, 3);
n = iconv_move(cvt, sp, tp, SF_UNBOUND, NiL);
}
iconv_close(cvt);
}
if (!tp)
sfread(sp, u, 0);
}
if (b = newof(0, char*, TM_NFORM, n + 2))
{
v = b;
e = b + TM_NFORM;
s = (char*)e;
if (tp && memcpy(s, sfstrbase(tp), n) || !tp && sfread(sp, s, n) == n)
{
s[n] = '\n';
while (v < e)
{
*v++ = s;
if (!(s = strchr(s, '\n')))
break;
*s++ = 0;
}
fixup(li, b);
}
else
free(b);
}
if (tp)
sfclose(tp);
sfclose(sp);
}
else
native_lc_time(li);
}
/*
* check that tm_info.format matches the current locale
*/
char**
tmlocale(void)
{
Lc_info_t* li;
if (!tm_info.format)
{
tm_info.format = tm_data.format;
if (!tm_info.deformat)
tm_info.deformat = tm_info.format[TM_DEFAULT];
else if (tm_info.deformat != tm_info.format[TM_DEFAULT])
state.format = tm_info.deformat;
}
li = LCINFO(AST_LC_TIME);
if (!li->data)
load(li);
return tm_info.format;
}