/***********************************************************************
* *
* 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
*
* machine independent binary message catalog implementation
*/
#include "sfhdr.h"
#include "lclib.h"
#include <iconv.h>
#define _MC_PRIVATE_ \
size_t nstrs; \
size_t nmsgs; \
iconv_t cvt; \
Sfio_t* tmp; \
Vmalloc_t* vm;
#include <vmalloc.h>
#include <error.h>
#include <mc.h>
#include <nl_types.h>
/*
* find the binary message catalog path for <locale,catalog>
* result placed in path of size PATH_MAX
* pointer to path returned
* catalog==0 tests for category directory or file
* nls!=0 enables NLSPATH+LANG hack (not implemented yet)
*/
char*
mcfind(const char* locale, const char* catalog, int category, int nls, char* path, size_t size)
{
register int c;
register char* s;
register char* e;
register char* p;
register const char* v;
int i;
int first;
int next;
int last;
int oerrno;
Lc_t* lc;
char file[PATH_MAX];
char* paths[5];
static char lc_messages[] = "LC_MESSAGES";
if ((category = lcindex(category, 1)) < 0)
return 0;
if (!(lc = locale ? lcmake(locale) : locales[category]))
return 0;
oerrno = errno;
if (catalog && *catalog == '/')
{
i = eaccess(catalog, R_OK);
errno = oerrno;
if (i)
return 0;
strlcpy(path, catalog, size);
return path;
}
i = 0;
if ((p = getenv("NLSPATH")) && *p)
paths[i++] = p;
paths[i++] = "share/lib/locale/%l/%C/%N";
paths[i++] = "share/locale/%l/%C/%N";
paths[i++] = "lib/locale/%l/%C/%N";
paths[i] = 0;
next = 1;
for (i = 0; p = paths[i]; i += next)
{
first = 1;
last = 0;
e = &file[elementsof(file) - 1];
while (*p)
{
s = file;
for (;;)
{
switch (c = *p++)
{
case 0:
p--;
break;
case ':':
break;
case '%':
if (s < e)
{
switch (c = *p++)
{
case 0:
p--;
continue;
case 'N':
v = catalog;
break;
case 'L':
if (first)
{
first = 0;
if (next)
{
v = lc->code;
if (lc->code != lc->language->code)
next = 0;
}
else
{
next = 1;
v = lc->language->code;
}
}
break;
case 'l':
v = lc->language->code;
break;
case 't':
v = lc->territory->code;
break;
case 'c':
v = lc->charset->code;
break;
case 'C':
case_C:
if (!catalog)
last = 1;
v = lc_categories[category].name;
break;
default:
*s++ = c;
continue;
}
if (v)
while (*v && s < e)
*s++ = *v++;
}
continue;
case '/':
if (last)
break;
if (category != AST_LC_MESSAGES && strneq(p, lc_messages, sizeof(lc_messages) - 1) && p[sizeof(lc_messages)-1] == '/')
{
p += sizeof(lc_messages) - 1;
goto case_C;
}
/*FALLTHROUGH*/
default:
if (s < e)
*s++ = c;
continue;
}
break;
}
if (s > file)
*s = 0;
else if (!catalog)
continue;
else
strlcpy(file, catalog, elementsof(file));
if (ast.locale.set & AST_LC_find)
sfprintf(sfstderr, "locale find %s\n", file);
if (s = pathpath(file, "", (!catalog && category == AST_LC_MESSAGES) ? PATH_READ : (PATH_REGULAR|PATH_READ|PATH_ABSOLUTE), path, size))
{
if (ast.locale.set & (AST_LC_find|AST_LC_setlocale))
sfprintf(sfstderr, "locale path %s\n", s);
errno = oerrno;
return s;
}
}
}
errno = oerrno;
return 0;
}
/*
* allocate and read the binary message catalog ip
* if ip==0 then space is allocated for mcput()
* 0 returned on any error
*/
Mc_t*
mcopen(register Sfio_t* ip)
{
register Mc_t* mc;
register char** mp;
register char* sp;
Vmalloc_t* vm;
char* rp;
int i;
int j;
int oerrno;
size_t n;
char buf[MC_MAGIC_SIZE];
oerrno = errno;
if (ip)
{
/*
* check the magic
*/
if (sfread(ip, buf, MC_MAGIC_SIZE) != MC_MAGIC_SIZE)
{
errno = oerrno;
return 0;
}
if (memcmp(buf, MC_MAGIC, MC_MAGIC_SIZE))
return 0;
}
/*
* allocate the region
*/
if (!(vm = vmopen(Vmdcheap, Vmbest, 0)) || !(mc = vmnewof(vm, 0, Mc_t, 1, 0)))
{
errno = oerrno;
return 0;
}
mc->vm = vm;
mc->cvt = (iconv_t)(-1);
if (ip)
{
/*
* read the translation record
*/
if (!(sp = sfgetr(ip, 0, 0)) || !(mc->translation = vmstrdup(vm, sp)))
goto bad;
/*
* read the optional header records
*/
do
{
if (!(sp = sfgetr(ip, 0, 0)))
goto bad;
} while (*sp);
/*
* get the component dimensions
*/
mc->nstrs = sfgetu(ip);
mc->nmsgs = sfgetu(ip);
mc->num = sfgetu(ip);
if (sfeof(ip))
goto bad;
}
else if (!(mc->translation = vmnewof(vm, 0, char, 1, 0)))
goto bad;
/*
* allocate the remaining space
*/
if (!(mc->set = vmnewof(vm, 0, Mcset_t, mc->num + 1, 0)))
goto bad;
if (!ip)
return mc;
if (!(mp = vmnewof(vm, 0, char*, mc->nmsgs + mc->num + 1, 0)))
goto bad;
if (!(rp = sp = vmalloc(vm, mc->nstrs + 1)))
goto bad;
/*
* get the set dimensions and initialize the msg pointers
*/
while (i = sfgetu(ip))
{
if (i > mc->num)
goto bad;
n = sfgetu(ip);
mc->set[i].num = n;
mc->set[i].msg = mp;
mp += n + 1;
}
/*
* read the msg sizes and set up the msg pointers
*/
for (i = 1; i <= mc->num; i++)
for (j = 1; j <= mc->set[i].num; j++)
if (n = sfgetu(ip))
{
mc->set[i].msg[j] = sp;
sp += n;
}
/*
* read the string table
*/
if (sfread(ip, rp, mc->nstrs) != mc->nstrs || sfgetc(ip) != EOF)
goto bad;
if (!(mc->tmp = sfstropen()))
goto bad;
mc->cvt = iconv_open("", "utf");
errno = oerrno;
return mc;
bad:
vmclose(vm);
errno = oerrno;
return 0;
}
/*
* return the <set,num> message in mc
* msg returned on error
* utf message text converted to ucs
*/
char*
mcget(register Mc_t* mc, int set, int num, const char* msg)
{
char* s;
size_t n;
int p;
if (!mc || set < 0 || set > mc->num || num < 1 || num > mc->set[set].num || !(s = mc->set[set].msg[num]))
return (char*)msg;
if (mc->cvt == (iconv_t)(-1))
return s;
if ((p = sfstrtell(mc->tmp)) > sfstrsize(mc->tmp) / 2)
{
p = 0;
sfstrseek(mc->tmp, p, SEEK_SET);
}
n = strlen(s) + 1;
iconv_write(mc->cvt, mc->tmp, &s, &n, NiL);
return sfstrbase(mc->tmp) + p;
}
/*
* set message <set,num> to msg
* msg==0 deletes the message
* the message and set counts are adjusted
* 0 returned on success, -1 otherwise
*/
int
mcput(register Mc_t* mc, int set, int num, const char* msg)
{
register int i;
register char* s;
register Mcset_t* sp;
register char** mp;
/*
* validate the arguments
*/
if (!mc || set > MC_SET_MAX || num > MC_NUM_MAX)
return -1;
/*
* deletions don't kick in allocations (duh)
*/
if (!msg)
{
if (set <= mc->num && num <= mc->set[set].num && (s = mc->set[set].msg[num]))
{
/*
* decrease the string table size
*/
mc->set[set].msg[num] = 0;
mc->nstrs -= strlen(s) + 1;
if (mc->set[set].num == num)
{
/*
* decrease the max msg num
*/
mp = mc->set[set].msg + num;
while (num && !mp[--num]);
mc->nmsgs -= mc->set[set].num - num;
if (!(mc->set[set].num = num) && mc->num == set)
{
/*
* decrease the max set num
*/
while (num && !mc->set[--num].num);
mc->num = num;
}
}
}
return 0;
}
/*
* keep track of the highest set and allocate if necessary
*/
if (set > mc->num)
{
if (set > mc->gen)
{
i = MC_SET_MAX;
if (!(sp = vmnewof(mc->vm, 0, Mcset_t, i + 1, 0)))
return -1;
mc->gen = i;
for (i = 1; i <= mc->num; i++)
sp[i] = mc->set[i];
mc->set = sp;
}
mc->num = set;
}
sp = mc->set + set;
/*
* keep track of the highest msg and allocate if necessary
*/
if (num > sp->num)
{
if (num > sp->gen)
{
if (!mc->gen)
{
i = (MC_NUM_MAX + 1) / 32;
if (i <= num)
i = 2 * num;
if (i > MC_NUM_MAX)
i = MC_NUM_MAX;
if (!(mp = vmnewof(mc->vm, 0, char*, i + 1, 0)))
return -1;
mc->gen = i;
sp->msg = mp;
for (i = 1; i <= sp->num; i++)
mp[i] = sp->msg[i];
}
else
{
i = 2 * mc->gen;
if (i > MC_NUM_MAX)
i = MC_NUM_MAX;
if (!(mp = vmnewof(mc->vm, sp->msg, char*, i + 1, 0)))
return -1;
sp->gen = i;
sp->msg = mp;
}
}
mc->nmsgs += num - sp->num;
sp->num = num;
}
/*
* decrease the string table size
*/
if (s = sp->msg[num])
{
/*
* no-op if no change
*/
if (streq(s, msg))
return 0;
mc->nstrs -= strlen(s) + 1;
}
/*
* allocate, add and adjust the string table size
*/
if (!(s = vmstrdup(mc->vm, msg)))
return -1;
sp->msg[num] = s;
mc->nstrs += strlen(s) + 1;
return 0;
}
/*
* dump message catalog mc to op
* 0 returned on success, -1 otherwise
*/
int
mcdump(register Mc_t* mc, register Sfio_t* op)
{
register int i;
register int j;
register int n;
register char* s;
register Mcset_t* sp;
/*
* write the magic
*/
if (sfwrite(op, MC_MAGIC, MC_MAGIC_SIZE) != MC_MAGIC_SIZE)
return -1;
/*
* write the translation record
*/
sfputr(op, mc->translation, 0);
/* optional header records here */
/*
* end of optional header records
*/
sfputu(op, 0);
/*
* write the global dimensions
*/
sfputu(op, mc->nstrs);
sfputu(op, mc->nmsgs);
sfputu(op, mc->num);
/*
* write the set dimensions
*/
for (i = 1; i <= mc->num; i++)
if (mc->set[i].num)
{
sfputu(op, i);
sfputu(op, mc->set[i].num);
}
sfputu(op, 0);
/*
* write the message sizes
*/
for (i = 1; i <= mc->num; i++)
if (mc->set[i].num)
{
sp = mc->set + i;
for (j = 1; j <= sp->num; j++)
{
n = (s = sp->msg[j]) ? (strlen(s) + 1) : 0;
sfputu(op, n);
}
}
/*
* write the string table
*/
for (i = 1; i <= mc->num; i++)
if (mc->set[i].num)
{
sp = mc->set + i;
for (j = 1; j <= sp->num; j++)
if (s = sp->msg[j])
sfputr(op, s, 0);
}
/*
* sync and return
*/
return sfsync(op);
}
/*
* parse <set,msg> number from s
* e!=0 is set to the next char after the parse
* set!=0 is set to message set number
* msg!=0 is set to message number
* the message set number is returned
*
* the base 36 hash gives reasonable values for these:
*
* "ast" : ((((36#a^36#s^36#t)-9)&63)+1) = 3
* "gnu" : ((((36#g^36#n^36#u)-9)&63)+1) = 17
* "sgi" : ((((36#s^36#g^36#i)-9)&63)+1) = 22
* "sun" : ((((36#s^36#u^36#n)-9)&63)+1) = 13
*/
int
mcindex(register const char* s, char** e, int* set, int* msg)
{
register int c;
register int m;
register int n;
register int r;
register unsigned char* cv;
char* t;
m = 0;
n = strtol(s, &t, 0);
if (t == (char*)s)
{
SFCVINIT();
cv = _Sfcv36;
for (n = m = 0; (c = cv[*s]) < 36; s++)
{
m++;
n ^= c;
}
m = (m <= 3) ? 63 : ((1 << (m + 3)) - 1);
n = ((n - 9) & m) + 1;
}
else
s = (const char*)t;
r = n;
if (*s)
m = strtol(s + 1, e, 0);
else
{
if (e)
*e = (char*)s;
if (m)
m = 0;
else
{
m = n;
n = 1;
}
}
if (set)
*set = n;
if (msg)
*msg = m;
return r;
}
/*
* close the message catalog mc
*/
int
mcclose(register Mc_t* mc)
{
if (!mc)
return -1;
if (mc->tmp)
sfclose(mc->tmp);
if (mc->cvt != (iconv_t)(-1))
iconv_close(mc->cvt);
vmclose(mc->vm);
return 0;
}