xlcload.c

早期freebsd实现

    sscanf(str, "%x", &woffset);
    if (!(str = nstr))
        return False;
    str++;
    if (nstr = index(str, ':')) *nstr = '\0';
    cset->cs_des = escape(str);
    cset->cs_woff = woffset;
    if (cset->cs_des[1] == 0x25)
	cset->cs_len = cset->cs_des[3] - '0';
    else
	cset->cs_len = (cset->cs_des[1] == '$') ? 2 : 1;
    return _XRegisterCharSet(cset->cs_name, cset->cs_des, cset->cs_woff,
			     cset->cs_GLorGR, cset->cs_len);
}

static Fontset *
LoadFontList(fp)
    FILE       *fp;
{
    Fontset    *flist;
    Charset    *csets[MAXCHARSETS];
    char        buf[MAXLINEBUF];
    char       *s;
    int         cnt, i;

    cnt = 0;
    while ((s = fgetline(buf, MAXLINEBUF, fp)) != NULL) {
        if (!strncmp(s, END_LINE, 3))
            break;
        csets[cnt] = (Charset *) Xmalloc(sizeof(Charset));
	if (!csets[cnt]) {
	    for (cnt--; cnt >= 0; cnt--)
		Xfree((char *)csets[cnt]);
	    return ((Fontset *)NULL);
	}
        if (LoadOneCharset(buf, csets[cnt]) == True)
            cnt++;
        else {
            /* should return error. */  
	    for (cnt--; cnt >= 0; cnt--)
		Xfree((char *)csets[cnt]);
	    return ((Fontset *)NULL);
	}
    }               /* end of while */
    flist = (Fontset *) Xmalloc(sizeof(Fontset));
    if (!flist) {
	for (cnt--; cnt >= 0; cnt--)
	    Xfree((char *)csets[cnt]);
	return ((Fontset *)NULL);
    }
    flist->fs_num = cnt;
    flist->fs_cset = (Charset **) Xmalloc((unsigned)cnt * sizeof(Charset *));
    if (!flist->fs_cset) {
	Xfree((char *)flist);
	for (cnt--; cnt >= 0; cnt--)
	    Xfree((char *)csets[cnt]);
	return ((Fontset *)NULL);
    }
    for (i = 0; i < cnt; i++) {
      /* To avoid the bug of gcc 1.37 optimization,
       * temporary variable `temp' was introduced
       * by demizu on Feb 19, 1991 */
      register Charset *temp;
	temp = csets[i];
	flist->fs_cset[i] = temp;

    }
    return (flist);
}

static void
GetCTidToCSid(fontset)
    Fontset	*fontset;
{
    int i;
    for (i = 0; i < fontset->fs_num; i++) {
	fontset->fs_cset[i]->cs_id =
		_XcwNameGetGLorGRId(fontset->fs_cset[i]->cs_name,
				    fontset->fs_cset[i]->cs_GLorGR);
    }
}

/* Read/Load locale file */
struct _NLSAlias {
    char *lc_alias;
    char *lc_name;
};

static struct _NLSAlias *NLSAlias = NULL;

struct _NLSDir {
    char *dir;
    char *lc_name;
    char *fn;
};

static struct _NLSDir *NLSDir = NULL;

#ifndef lint
static int lock;
#endif

#define XREALLOC(p, size) ((p) ? Xrealloc(p, size) : Xmalloc(size))
static void
ReadNLSAlias(dir)
    char       	       *dir;
{
    char 		fname[PATH_MAX];
    char 		alias[PATH_MAX];
    char 		lang_name[PATH_MAX];
    char 		str[PATH_MAX];
    int 		count, i;
    struct _NLSAlias   *p, *ptr = NULL;
    static 		size = 0;
    FILE       	       *fp;


    sprintf(fname, "%s/nls.alias", dir);
    if ((fp = fopen(fname, "r")) == NULL)
	return;

    if (fgetline(str, PATH_MAX, fp) == NULL) {
	fclose(fp);
	return;
    }
    count = sscanf(str, "%d", &i);
    if (i < 1) {
	fclose(fp);
	return;
    }

    NLSAlias = (struct _NLSAlias *) XREALLOC((char *)NLSAlias,
			(unsigned)sizeof(struct _NLSAlias) * (size + i + 1));

    if (!NLSAlias) {
	fclose(fp);
	return;
    }

    ptr = NLSAlias + size;
    for (;;) {
	if (fgetline(str, PATH_MAX, fp) == NULL)
	    break;
	count = sscanf(str, "%s %s", alias, lang_name);
	if (count != 2)
	    break;
	for (p = NLSAlias; p != ptr; p++)
	    if (strcmp(alias, p->lc_alias) == 0)
		break;
	if (p != ptr)
	    continue;
	ptr->lc_alias = Xmalloc((unsigned)strlen(alias)+1);
	if (!ptr->lc_alias)
	    break;
	strcpy(ptr->lc_alias, alias);
	ptr->lc_name = Xmalloc((unsigned)strlen(lang_name)+1);
	if (!ptr->lc_name)
	    break;
	strcpy(ptr->lc_name, lang_name);
	ptr++;
	size++;
    }
    ptr->lc_alias = NULL;
    fclose(fp);
}

static void
ReadNLSDir(dir)
    char       	       *dir;
{
    char 		fname[PATH_MAX];
    char 		file_name[PATH_MAX];
    char 		lang_name[PATH_MAX];
    char 		str[PATH_MAX];
    char       	       *tmp;
    int 		count, i;
    struct _NLSDir     *p, *ptr = NULL;
    static 		size = 0;
    FILE	       *fp;

    sprintf(fname, "%s/nls.dir", dir);
    if ((fp = fopen(fname, "r")) == NULL)
	return;

    if (fgetline(str, PATH_MAX, fp) == NULL) {
	fclose(fp);
	return;
    }
    /* read number of locales */
    count = sscanf(str, "%d", &i);
    if (i < 1) {
	fclose(fp);
	return;
    }

    NLSDir = (struct _NLSDir *) XREALLOC((char *)NLSDir,
			(unsigned)sizeof(struct _NLSDir) * (size + i + 1));

    if (!NLSDir) {
	fclose(fp);
	return;
    }

    ptr = NLSDir + size;
    tmp = ptr->dir = Xmalloc((unsigned)strlen(dir) + 1);
    if (!ptr->dir) {
	fclose(fp);
	return;
    }
    strcpy(ptr->dir, dir);
    for (;;) {
	if (fgetline(str, PATH_MAX, fp) == NULL)
	    break;
	count = sscanf(str, "%s %s", file_name, lang_name);
	if(count == 1)
	    strcpy(lang_name, file_name);
	else if (count < 1)
	    break;
	for (p = NLSDir; p != ptr; p++)
	    if (strcmp(lang_name, p->lc_name) == 0)
		break;
	if (p != ptr)
	    continue;
	ptr->fn = Xmalloc((unsigned)strlen(file_name)+1);
	if (!ptr->fn)
	    break;
	strcpy(ptr->fn, file_name);
	ptr->lc_name = Xmalloc((unsigned)strlen(lang_name)+1);
	if (!ptr->lc_name)
	    break;
	strcpy(ptr->lc_name, lang_name);
	ptr->dir = tmp;
	ptr++;
	size++;
    }
    ptr->dir = NULL;
    fclose(fp);
    fp = NULL;
}


static void
ReadNLS()
{
    char 		nlspath[PATH_MAX];
    char 	       *path;
    char	       *dir;
    char 	       *env;

    LockMutex(&lock);
    if (NLSDir != NULL) {
	UnlockMutex(&lock);
	return;
    }
    if ((env = getenv("XNLSPATH")) == NULL) {
	env = XNLSPATHDEFAULT;
    }
    path = nlspath;
    strcpy(path, env);

    while (1) {
	if (path == NULL) {
	    UnlockMutex(&lock);
	    return;
	}
	dir = path;
	if ((path = index(dir, ':')) != NULL) {
	    *path++ = '\0';
	}

	ReadNLSDir(dir);
	ReadNLSAlias(dir);
    }
    UnlockMutex(&lock);
}

static void
_XlcFindNLSDir(lc_name, fname)
    char       	       *lc_name;
    char       	       *fname;
{
    struct _NLSDir     *ptr;

    ReadNLS();
    ptr = NLSDir;
    if (!ptr) {
	*fname = 0;
	return;
    }
    while (1) {
	if (ptr->dir == NULL) {
	    *fname = 0;
	    break;
	}
	if (strcmp(lc_name, ptr->lc_name) == 0) {
	   sprintf(fname, "%s/%s", ptr->dir, ptr->fn);
	   break;
	}
	ptr++;
    }
}

static char *lastBadLCName;

static XLocaleDB *
_XlcGetLocaleDB(lc_name)
    char	*lc_name;	/* locale name */
{
    XLocaleDB	  *xlc_db;
    char	  fn[PATH_MAX];
    int		  err;

    LockMutex(&lock_tbl);
    for (xlc_db = _Xlctbl_; xlc_db; xlc_db = xlc_db->next) {
	if (!strcmp(lc_name, xlc_db->lc_name)) {
	    UnlockMutex(&lock_tbl);
	    return xlc_db;
	}
    }
    _XlcFindNLSDir(lc_name, fn);
    if (*fn) {
	xlc_db = _XlcLoadLocale(fn, &err);
	if (xlc_db) {
	    xlc_db->next = _Xlctbl_;
	    _Xlctbl_ = xlc_db;
	} else if ((err != BadAccess || strcmp(lc_name, "C")) &&
		   (!lastBadLCName || strcmp(lc_name, lastBadLCName))) {
	    if (err == BadAccess)
		fprintf(stderr, "Xlib: missing locale file: %s\n", fn);
	    else if (err == BadAlloc)
		fprintf(stderr, "Xlib: failed to load locale file: %s\n", fn);
	    else
		fprintf(stderr, "Xlib: bad format locale file: %s\n", fn);
	    if (lastBadLCName)
		Xfree(lastBadLCName);
	    if (lastBadLCName = Xmalloc(strlen(lc_name) + 1))
		strcpy(lastBadLCName, lc_name);
	}
    }
    UnlockMutex(&lock_tbl);
    return (xlc_db);
}

static char *
_XlcResolveName(lc_name)
    char	        *lc_name;
{
    struct _NLSAlias    *ptr;

    ReadNLS();
    if (NLSAlias)
	for (ptr = NLSAlias; ptr->lc_alias != NULL ; ptr++) {
	    if (!strcmp(lc_name, ptr->lc_alias)) {
		return (ptr->lc_name);
	    }
	}
    return(lc_name);
}

/* list up supported locale name */
/* need to call Xfree(list) by caller */
int
_XlcListLocale(list)
    char 	      **list[];
{
    struct _NLSDir     *ptr;
    char 	      **p;
    int			i;

    ReadNLS();
    for (i = 0, ptr = NLSDir; ptr->dir != NULL ; ptr++, i++) ;
    p = *list = (char **) Xmalloc((unsigned)sizeof(char *) * (i + 1));
    if (!p)
	return (0);
    for (ptr = NLSDir; ptr->dir != NULL ; ptr++)
	*p++ = ptr->lc_name;
    *p = NULL;
    return(i);
}

XLocale
_XlcMakeLocale(lc_name)
    char       *lc_name;	/* locale name */
{
    char       *p;
    char       *lc_alias;
    char	lang[256];
    XLocaleDB  *xlc_db;
    XLocale	xlc;

    /* extract locale name */
    lc_alias = _XlcResolveName(lc_name);

    p = index(lc_alias, '@');
    if (p) {
	strncpy(lang, lc_alias, p - lc_alias);
	lang[p - lc_alias] = '\0';
	lc_alias = lang;
    }

    xlc_db = _XlcGetLocaleDB(lc_alias);
    if (!xlc_db)
	return NULL;
    xlc = (XLocale)Xmalloc(sizeof(XLocaleRec));
    if (!xlc)
	return NULL;

    xlc->xlc_db = xlc_db;
    xlc->lc_lang = xlc_db->lc_name;
    _Xctinit(xlc);
    _Xmbinit(xlc);

    return xlc;
}

XLocale
_XlcDupLocale(xlocale)
    XLocale	xlocale;
{
    XLocale	new;

    if ((new = (XLocale) Xmalloc(sizeof(XLocaleRec))) == NULL) {
	return ((XLocale)NULL);
    }
    new->xlc_db = xlocale->xlc_db;
    new->lc_lang = xlocale->lc_lang;
    _Xctinit(new);
    _Xmbinit(new);

    return new;
}

XLocale
_XFallBackConvert()
{
    static XLocale xlc_xlc;
    char *osname = setlocale(LC_CTYPE, (char *)NULL);
    char *name;
    XLocale xlc;
#if !defined(X_NOT_STDC_ENV) && !defined(X_LOCALE)
    char siname[256];
    char *_XlcMapOSLocaleName();
#endif

    if (xlc_xlc && !strcmp(xlc_xlc->lc_lang, osname))
	return xlc_xlc;
#if !defined(X_NOT_STDC_ENV) && !defined(X_LOCALE)
    name = _XlcMapOSLocaleName(osname, siname);
#else
    name = osname;
#endif
    xlc = _XlcMakeLocale(name);
    if (!xlc)
	return NULL;
    name = Xmalloc(strlen(osname) + 1);
    if (!name) {
	_XlcFreeLocale(xlc);
	return NULL;
    }
    strcpy(name, osname);
    xlc->lc_lang = name;
    if (xlc_xlc)
	_XlcFreeLocale(xlc_xlc);
    xlc_xlc = xlc;
    return xlc;
}

static void
_Xsimbinit(state)
    XPointer state;
{
    XLocale xlc = (XLocale)state;

    _Xmbinit(xlc);
}

/*ARGSUSED*/
static void
_Xsimbfinish(state)
    XPointer state;
{
}

static char
_Xsimbchar(state, str, lenp)
    XPointer state;
    char *str;
    int *lenp;
{
    _CSID csid;
    char ret = 'a';
    int cscode;
    int dlen;

    csid = _Xmbcsid((XLocale)state, str);
    dlen = _Xmbdlen((XLocale)state, str);
    if (dlen > 0) {
	for (*lenp = 0; ; ) {
	    str += dlen;
	    *lenp += dlen;
	    dlen = _Xmbdlen((XLocale)state, str);
	    if (dlen == 0)  return (ret);
	}
    }
    csid = _Xmbcsid((XLocale)state, str);
    if (csid == C0) {
	ret = *str;
    } else if (csid == CODESET0) {
	_Xmbctocsc((XLocale)state, str, &cscode);
	if (cscode < 0x7f)
	    ret = (char)cscode;
    }
    *lenp = _Xmblen((XLocale)state);
    return (ret);
}

static char *
_Xsilcname(state)
    XPointer state;
{
    return ((XLocale)state)->lc_lang;
}

static void _Xsidestroy(state)
    XPointer state;
{
    _XlcFreeLocale((XLocale)state);
}

static RConst XrmMethodsRec mb_methods = {
    _Xsimbinit,
    _Xsimbchar,
    _Xsimbfinish,
    _Xsilcname,
    _Xsidestroy
};

XrmMethods
_XrmInitParseInfo(state)
    XPointer *state;
{
    XLocale xlc = _XFallBackConvert();

    if (xlc)
	xlc = _XlcDupLocale(xlc);
    if (!xlc)
	return NULL;
    *state = (XPointer)xlc;
    return (XrmMethods)&mb_methods;
}