[fontconfig.git] / src / fclang.c

/*
 * fontconfig/src/fclang.c
 *
 * Copyright © 2002 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "fcint.h"
#include "fcftint.h"

typedef struct {
    const FcChar8    	lang[8];
    const FcCharSet	charset;
} FcLangCharSet;

typedef struct {
    int begin;
    int end;
} FcLangCharSetRange;

#include "../fc-lang/fclang.h"

struct _FcLangSet {
    FcStrSet	*extra;
    FcChar32    map_size;
    FcChar32	map[NUM_LANG_SET_MAP];
};

static void
FcLangSetBitSet (FcLangSet    *ls,
		 unsigned int  id)
{
  int bucket;

  id = fcLangCharSetIndices[id];
  bucket = id >> 5;
  if (bucket >= ls->map_size)
    return; /* shouldn't happen really */

  ls->map[bucket] |= ((FcChar32) 1 << (id & 0x1f));
}

static FcBool
FcLangSetBitGet (const FcLangSet *ls,
		 unsigned int     id)
{
  int bucket;

  id = fcLangCharSetIndices[id];
  bucket = id >> 5;
  if (bucket >= ls->map_size)
    return FcFalse;

  return ((ls->map[bucket] >> (id & 0x1f)) & 1) ? FcTrue : FcFalse;
}

FcLangSet *
FcFreeTypeLangSet (const FcCharSet  *charset, 
		   const FcChar8    *exclusiveLang)
{
    int		    i, j;
    FcChar32	    missing;
    const FcCharSet *exclusiveCharset = 0;
    FcLangSet	    *ls;

    if (exclusiveLang)
	exclusiveCharset = FcLangGetCharSet (exclusiveLang);
    ls = FcLangSetCreate ();
    if (!ls)
	return 0;
    if (FcDebug() & FC_DBG_LANGSET) 
    {
	printf ("font charset");
	FcCharSetPrint (charset);
	printf ("\n");
    }
    for (i = 0; i < NUM_LANG_CHAR_SET; i++)
    {
	if (FcDebug() & FC_DBG_LANGSET) 
	{
	    printf ("%s charset", fcLangCharSets[i].lang);
	    FcCharSetPrint (&fcLangCharSets[i].charset);
	    printf ("\n");
	}
	
	/*
	 * Check for Han charsets to make fonts
	 * which advertise support for a single language
	 * not support other Han languages
	 */
	if (exclusiveCharset &&
	    FcFreeTypeIsExclusiveLang (fcLangCharSets[i].lang))
	{
	    if (fcLangCharSets[i].charset.num != exclusiveCharset->num)
		continue;

	    for (j = 0; j < fcLangCharSets[i].charset.num; j++)
		if (FcCharSetLeaf(&fcLangCharSets[i].charset, j) != 
		    FcCharSetLeaf(exclusiveCharset, j))
		    continue;
	}
	missing = FcCharSetSubtractCount (&fcLangCharSets[i].charset, charset);
        if (FcDebug() & FC_DBG_SCANV)
	{
	    if (missing && missing < 10)
	    {
		FcCharSet   *missed = FcCharSetSubtract (&fcLangCharSets[i].charset, 
							 charset);
		FcChar32    ucs4;
		FcChar32    map[FC_CHARSET_MAP_SIZE];
		FcChar32    next;

		printf ("\n%s(%u) ", fcLangCharSets[i].lang, missing);
		printf ("{");
		for (ucs4 = FcCharSetFirstPage (missed, map, &next);
		     ucs4 != FC_CHARSET_DONE;
		     ucs4 = FcCharSetNextPage (missed, map, &next))
		{
		    int	    i, j;
		    for (i = 0; i < FC_CHARSET_MAP_SIZE; i++)
			if (map[i])
			{
			    for (j = 0; j < 32; j++)
				if (map[i] & (1 << j))
				    printf (" %04x", ucs4 + i * 32 + j);
			}
		}
		printf (" }\n\t");
		FcCharSetDestroy (missed);
	    }
	    else
		printf ("%s(%u) ", fcLangCharSets[i].lang, missing);
	}
	if (!missing)
	    FcLangSetBitSet (ls, i);
    }

    if (FcDebug() & FC_DBG_SCANV)
	printf ("\n");
    
    
    return ls;
}

#define FcLangEnd(c)	((c) == '-' || (c) == '\0')

FcLangResult
FcLangCompare (const FcChar8 *s1, const FcChar8 *s2)
{
    FcChar8	    c1, c2;
    FcLangResult    result = FcLangDifferentLang;

    for (;;)
    {
	c1 = *s1++;
	c2 = *s2++;
	
	c1 = FcToLower (c1);
	c2 = FcToLower (c2);
	if (c1 != c2)
	{
	    if (FcLangEnd (c1) && FcLangEnd (c2))
		result = FcLangDifferentTerritory;
	    return result;
	}
	else if (!c1)
	    return FcLangEqual;
	else if (c1 == '-')
	    result = FcLangDifferentTerritory;
    }
}

/*
 * Return FcTrue when super contains sub. 
 *
 * super contains sub if super and sub have the same
 * language and either the same country or one
 * is missing the country
 */

static FcBool
FcLangContains (const FcChar8 *super, const FcChar8 *sub)
{
    FcChar8	    c1, c2;

    for (;;)
    {
	c1 = *super++;
	c2 = *sub++;
	
	c1 = FcToLower (c1);
	c2 = FcToLower (c2);
	if (c1 != c2)
	{
	    /* see if super has a country while sub is mising one */
	    if (c1 == '-' && c2 == '\0')
		return FcTrue;
	    /* see if sub has a country while super is mising one */
	    if (c1 == '\0' && c2 == '-')
		return FcTrue;
	    return FcFalse;
	}
	else if (!c1)
	    return FcTrue;
    }
}

const FcCharSet *
FcLangGetCharSet (const FcChar8 *lang)
{
    int		i;
    int		country = -1;

    for (i = 0; i < NUM_LANG_CHAR_SET; i++)
    {
	switch (FcLangCompare (lang, fcLangCharSets[i].lang)) {
	case FcLangEqual:
	    return &fcLangCharSets[i].charset;
	case FcLangDifferentTerritory:
	    if (country == -1)
		country = i;
	case FcLangDifferentLang:
	default:
	    break;
	}
    }
    if (country == -1)
	return 0;
    return &fcLangCharSets[country].charset;
}

FcStrSet *
FcGetLangs (void)
{
    FcStrSet *langs;
    int	i;

    langs = FcStrSetCreate();
    if (!langs)
	return 0;

    for (i = 0; i < NUM_LANG_CHAR_SET; i++)
	FcStrSetAdd (langs, fcLangCharSets[i].lang);

    return langs;
}

FcLangSet *
FcLangSetCreate (void)
{
    FcLangSet	*ls;

    ls = malloc (sizeof (FcLangSet));
    if (!ls)
	return 0;
    FcMemAlloc (FC_MEM_LANGSET, sizeof (FcLangSet));
    memset (ls->map, '\0', sizeof (ls->map));
    ls->map_size = NUM_LANG_SET_MAP;
    ls->extra = 0;
    return ls;
}

void
FcLangSetDestroy (FcLangSet *ls)
{
    if (ls->extra)
	FcStrSetDestroy (ls->extra);
    FcMemFree (FC_MEM_LANGSET, sizeof (FcLangSet));
    free (ls);
}

FcLangSet *
FcLangSetCopy (const FcLangSet *ls)
{
    FcLangSet	*new;

    new = FcLangSetCreate ();
    if (!new)
	goto bail0;
    memset (new->map, '\0', sizeof (new->map));
    memcpy (new->map, ls->map, FC_MIN (sizeof (new->map), ls->map_size * sizeof (ls->map[0])));
    if (ls->extra)
    {
	FcStrList	*list;
	FcChar8		*extra;
	
	new->extra = FcStrSetCreate ();
	if (!new->extra)
	    goto bail1;

	list = FcStrListCreate (ls->extra);	
	if (!list)
	    goto bail1;
	
	while ((extra = FcStrListNext (list)))
	    if (!FcStrSetAdd (new->extra, extra))
	    {
		FcStrListDone (list);
		goto bail1;
	    }
	FcStrListDone (list);
    }
    return new;
bail1:
    FcLangSetDestroy (new);
bail0:
    return 0;
}

static int
FcLangSetIndex (const FcChar8 *lang)
{
    int	    low, high, mid = 0;
    int	    cmp = 0;
    FcChar8 firstChar = FcToLower(lang[0]); 
    FcChar8 secondChar = firstChar ? FcToLower(lang[1]) : '\0';
    
    if (firstChar < 'a')
    {
	low = 0;
	high = fcLangCharSetRanges[0].begin;
    }
    else if(firstChar > 'z')
    {
	low = fcLangCharSetRanges[25].begin;
	high = NUM_LANG_CHAR_SET - 1;
    }
    else
    {
	low = fcLangCharSetRanges[firstChar - 'a'].begin;
	high = fcLangCharSetRanges[firstChar - 'a'].end;
	/* no matches */
	if (low > high)
	    return -low; /* next entry after where it would be */
    }

    while (low <= high)
    {
	mid = (high + low) >> 1;
	if(fcLangCharSets[mid].lang[0] != firstChar)
	    cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang, lang);
	else
	{   /* fast path for resolving 2-letter languages (by far the most common) after
	     * finding the first char (probably already true because of the hash table) */
	    cmp = fcLangCharSets[mid].lang[1] - secondChar;
	    if (cmp == 0 && 
		(fcLangCharSets[mid].lang[2] != '\0' || 
		 lang[2] != '\0'))
	    {
		cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang+2, 
					 lang+2);
	    }
	}
	if (cmp == 0)
	    return mid;
	if (cmp < 0)
	    low = mid + 1;
	else
	    high = mid - 1;
    }
    if (cmp < 0)
	mid++;
    return -(mid + 1);
}

FcBool
FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang)
{
    int	    id;

    id = FcLangSetIndex (lang);
    if (id >= 0)
    {
	FcLangSetBitSet (ls, id);
	return FcTrue;
    }
    if (!ls->extra)
    {
	ls->extra = FcStrSetCreate ();
	if (!ls->extra)
	    return FcFalse;
    }
    return FcStrSetAdd (ls->extra, lang);
}

FcLangResult
FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang)
{
    int		    id;
    FcLangResult    best, r;
    int		    i;

    id = FcLangSetIndex (lang);
    if (id < 0)
	id = -id - 1;
    else if (FcLangSetBitGet (ls, id))
	return FcLangEqual;
    best = FcLangDifferentLang;
    for (i = id - 1; i >= 0; i--)
    {
	r = FcLangCompare (lang, fcLangCharSets[i].lang);
	if (r == FcLangDifferentLang)
	    break;
	if (FcLangSetBitGet (ls, i) && r < best)
	    best = r;
    }
    for (i = id; i < NUM_LANG_CHAR_SET; i++)
    {
	r = FcLangCompare (lang, fcLangCharSets[i].lang);
	if (r == FcLangDifferentLang)
	    break;
	if (FcLangSetBitGet (ls, i) && r < best)
	    best = r;
    }
    if (ls->extra)
    {
	FcStrList	*list = FcStrListCreate (ls->extra);
	FcChar8		*extra;
	
	if (list)
	{
	    while (best > FcLangEqual && (extra = FcStrListNext (list)))
	    {
		r = FcLangCompare (lang, extra);
		if (r < best)
		    best = r;
	    }
	    FcStrListDone (list);
	}
    }
    return best;
}

static FcLangResult
FcLangSetCompareStrSet (const FcLangSet *ls, FcStrSet *set)
{
    FcStrList	    *list = FcStrListCreate (set);
    FcLangResult    r, best = FcLangDifferentLang;
    FcChar8	    *extra;

    if (list)
    {
	while (best > FcLangEqual && (extra = FcStrListNext (list)))
	{
	    r = FcLangSetHasLang (ls, extra);
	    if (r < best)
		best = r;
	}
	FcStrListDone (list);
    }
    return best;
}

FcLangResult
FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb)
{
    int		    i, j, count;
    FcLangResult    best, r;

    count = FC_MIN (lsa->map_size, lsb->map_size);
    count = FC_MIN (NUM_LANG_SET_MAP, count);
    for (i = 0; i < count; i++)
	if (lsa->map[i] & lsb->map[i])
	    return FcLangEqual;
    best = FcLangDifferentLang;
    for (j = 0; j < NUM_COUNTRY_SET; j++)
	for (i = 0; i < count; i++)
	    if ((lsa->map[i] & fcLangCountrySets[j][i]) &&
		(lsb->map[i] & fcLangCountrySets[j][i]))
	    {
		best = FcLangDifferentTerritory;
		break;
	    }
    if (lsa->extra)
    {
	r = FcLangSetCompareStrSet (lsb, lsa->extra);
	if (r < best)
	    best = r;
    }
    if (best > FcLangEqual && lsb->extra)
    {
	r = FcLangSetCompareStrSet (lsa, lsb->extra);
	if (r < best)
	    best = r;
    }
    return best;
}

/*
 * Used in computing values -- mustn't allocate any storage
 */
FcLangSet *
FcLangSetPromote (const FcChar8 *lang)
{
    static FcLangSet	ls;
    static FcStrSet	strs;
    static FcChar8	*str;
    int			id;

    memset (ls.map, '\0', sizeof (ls.map));
    ls.extra = 0;
    id = FcLangSetIndex (lang);
    if (id > 0)
    {
	FcLangSetBitSet (&ls, id);
    }
    else
    {
	ls.extra = &strs;
	strs.num = 1;
	strs.size = 1;
	strs.strs = &str;
	strs.ref = 1;
	str = (FcChar8 *) lang;
    }
    return &ls;
}

FcChar32
FcLangSetHash (const FcLangSet *ls)
{
    FcChar32	h = 0;
    int		i, count;

    count = FC_MIN (ls->map_size, NUM_LANG_SET_MAP);
    for (i = 0; i < count; i++)
	h ^= ls->map[i];
    if (ls->extra)
	h ^= ls->extra->num;
    return h;
}

FcLangSet *
FcNameParseLangSet (const FcChar8 *string)
{
    FcChar8	    lang[32], c = 0;
    int i;
    FcLangSet	    *ls;

    ls = FcLangSetCreate ();
    if (!ls)
	goto bail0;

    for(;;)
    {
	for(i = 0; i < 31;i++)
	{
	    c = *string++;
	    if(c == '\0' || c == '|')
		break; /* end of this code */
	    lang[i] = c;
	}
	lang[i] = '\0';
	if (!FcLangSetAdd (ls, lang))
	    goto bail1;
	if(c == '\0')
	    break;
    }
    return ls;
bail1:
    FcLangSetDestroy (ls);
bail0:
    return 0;
}

FcBool
FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls)
{
    int		i, bit, count;
    FcChar32	bits;
    FcBool	first = FcTrue;

    count = FC_MIN (ls->map_size, NUM_LANG_SET_MAP);
    for (i = 0; i < count; i++)
    {
	if ((bits = ls->map[i]))
	{
	    for (bit = 0; bit <= 31; bit++)
		if (bits & (1 << bit))
		{
		    int id = (i << 5) | bit;
		    if (!first)
			if (!FcStrBufChar (buf, '|'))
			    return FcFalse;
		    if (!FcStrBufString (buf, fcLangCharSets[fcLangCharSetIndicesInv[id]].lang))
			return FcFalse;
		    first = FcFalse;
		}
	}
    }
    if (ls->extra)
    {
	FcStrList   *list = FcStrListCreate (ls->extra);
	FcChar8	    *extra;

	if (!list)
	    return FcFalse;
	while ((extra = FcStrListNext (list)))
	{
	    if (!first)
		if (!FcStrBufChar (buf, '|'))
                {
                    FcStrListDone (list);
		    return FcFalse;
                }
	    if (!FcStrBufString (buf, extra))
                {
                    FcStrListDone (list);
                    return FcFalse;
                }
	    first = FcFalse;
	}
        FcStrListDone (list);
    }
    return FcTrue;
}

FcBool
FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb)
{
    int	    i, count;

    count = FC_MIN (lsa->map_size, lsb->map_size);
    count = FC_MIN (NUM_LANG_SET_MAP, count);
    for (i = 0; i < count; i++)
    {
	if (lsa->map[i] != lsb->map[i])
	    return FcFalse;
    }
    if (!lsa->extra && !lsb->extra)
	return FcTrue;
    if (lsa->extra && lsb->extra)
	return FcStrSetEqual (lsa->extra, lsb->extra);
    return FcFalse;
}

static FcBool
FcLangSetContainsLang (const FcLangSet *ls, const FcChar8 *lang)
{
    int		    id;
    int		    i;

    id = FcLangSetIndex (lang);
    if (id < 0)
	id = -id - 1;
    else if (FcLangSetBitGet (ls, id))
	return FcTrue;
    /*
     * search up and down among equal languages for a match
     */
    for (i = id - 1; i >= 0; i--)
    {
	if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
	    break;
	if (FcLangSetBitGet (ls, i) &&
	    FcLangContains (fcLangCharSets[i].lang, lang))
	    return FcTrue;
    }
    for (i = id; i < NUM_LANG_CHAR_SET; i++)
    {
	if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
	    break;
	if (FcLangSetBitGet (ls, i) &&
	    FcLangContains (fcLangCharSets[i].lang, lang))
	    return FcTrue;
    }
    if (ls->extra)
    {
	FcStrList	*list = FcStrListCreate (ls->extra);
	FcChar8		*extra;
	
	if (list)
	{
	    while ((extra = FcStrListNext (list)))
	    {
		if (FcLangContains (extra, lang))
		    break;
	    }
	    FcStrListDone (list);
    	    if (extra)
		return FcTrue;
	}
    }
    return FcFalse;
}

/*
 * return FcTrue if lsa contains every language in lsb
 */
FcBool
FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb)
{
    int		    i, j, count;
    FcChar32	    missing;

    if (FcDebug() & FC_DBG_MATCHV)
    {
	printf ("FcLangSet "); FcLangSetPrint (lsa);
	printf (" contains "); FcLangSetPrint (lsb);
	printf ("\n");
    }
    /*
     * check bitmaps for missing language support
     */
    count = FC_MIN (lsa->map_size, lsb->map_size);
    count = FC_MIN (NUM_LANG_SET_MAP, count);
    for (i = 0; i < count; i++)
    {
	missing = lsb->map[i] & ~lsa->map[i];
	if (missing)
	{
	    for (j = 0; j < 32; j++)
		if (missing & (1 << j)) 
		{
		    if (!FcLangSetContainsLang (lsa,
						fcLangCharSets[fcLangCharSetIndicesInv[i*32 + j]].lang))
		    {
			if (FcDebug() & FC_DBG_MATCHV)
			    printf ("\tMissing bitmap %s\n", fcLangCharSets[fcLangCharSetIndicesInv[i*32+j]].lang);
			return FcFalse;
		    }
		}
	}
    }
    if (lsb->extra)
    {
	FcStrList   *list = FcStrListCreate (lsb->extra);
	FcChar8	    *extra;

	if (list)
	{
	    while ((extra = FcStrListNext (list)))
	    {
		if (!FcLangSetContainsLang (lsa, extra))
		{
		    if (FcDebug() & FC_DBG_MATCHV)
			printf ("\tMissing string %s\n", extra);
		    break;
		}
	    }
	    FcStrListDone (list);
	    if (extra)
		return FcFalse;
	}
    }
    return FcTrue;
}

FcBool
FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l)
{
    if (!FcSerializeAlloc (serialize, l, sizeof (FcLangSet)))
	return FcFalse;
    return FcTrue;
}

FcLangSet *
FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l)
{
    FcLangSet	*l_serialize = FcSerializePtr (serialize, l);

    if (!l_serialize)
	return NULL;
    memset (l_serialize->map, '\0', sizeof (l_serialize->map));
    memcpy (l_serialize->map, l->map, FC_MIN (sizeof (l_serialize->map), l->map_size * sizeof (l->map[0])));
    l_serialize->map_size = NUM_LANG_SET_MAP;
    l_serialize->extra = NULL; /* We don't serialize ls->extra */
    return l_serialize;
}

FcStrSet *
FcLangSetGetLangs (const FcLangSet *ls)
{
    FcStrSet *langs;
    int	      i;

    langs = FcStrSetCreate();
    if (!langs)
	return 0;

    for (i = 0; i < NUM_LANG_CHAR_SET; i++)
	if (FcLangSetBitGet (ls, i))
	    FcStrSetAdd (langs, fcLangCharSets[i].lang);

    if (ls->extra)
    {
	FcStrList	*list = FcStrListCreate (ls->extra);
	FcChar8		*extra;

	if (list)
	{
	    while ((extra = FcStrListNext (list)))
		FcStrSetAdd (langs, extra);

	    FcStrListDone (list);
	}
    }

    return langs;
}

#define __fclang__
#include "fcaliastail.h"
#include "fcftaliastail.h"
#undef __fclang__
Commit	Line	Data
3de8881e	1	/*
317b8492	2	* fontconfig/src/fclang.c
3de8881e	3	*
46b51147	4	* Copyright © 2002 Keith Packard
3de8881e KP	5	*
	6	* Permission to use, copy, modify, distribute, and sell this software and its
	7	* documentation for any purpose is hereby granted without fee, provided that
	8	* the above copyright notice appear in all copies and that both that
	9	* copyright notice and this permission notice appear in supporting
	10	* documentation, and that the name of Keith Packard not be used in
	11	* advertising or publicity pertaining to distribution of the software without
	12	* specific, written prior permission. Keith Packard makes no
	13	* representations about the suitability of this software for any purpose. It
	14	* is provided "as is" without express or implied warranty.
	15	*
3074a73b	16	* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
3de8881e	17	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
3074a73b	18	* EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
3de8881e KP	19	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	20	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	21	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	22	* PERFORMANCE OF THIS SOFTWARE.
	23	*/
	24
	25	#include "fcint.h"
dbd065ad	26	#include "fcftint.h"
3de8881e KP	27
3de8881e KP	28	typedef struct {
e85789a9	29	const FcChar8 lang[8];
21696e5b	30	const FcCharSet charset;
3de8881e KP	31	} FcLangCharSet;
3de8881e KP	32
793e946c KP	33	typedef struct {
	34	int begin;
	35	int end;
	36	} FcLangCharSetRange;
	37
e50b9ae7	38	#include "../fc-lang/fclang.h"
3de8881e	39
d8d73958	40	struct _FcLangSet {
4262e0b3	41	FcStrSet *extra;
8480c6f8	42	FcChar32 map_size;
1f4e6fec	43	FcChar32 map[NUM_LANG_SET_MAP];
d8d73958 KP	44	};
d8d73958 KP	45
1f4e6fec BE	46	static void
	47	FcLangSetBitSet (FcLangSet *ls,
	48	unsigned int id)
	49	{
	50	int bucket;
	51
	52	id = fcLangCharSetIndices[id];
	53	bucket = id >> 5;
	54	if (bucket >= ls->map_size)
	55	return; /* shouldn't happen really */
	56
	57	ls->map[bucket] \|= ((FcChar32) 1 << (id & 0x1f));
	58	}
	59
	60	static FcBool
	61	FcLangSetBitGet (const FcLangSet *ls,
	62	unsigned int id)
	63	{
	64	int bucket;
	65
	66	id = fcLangCharSetIndices[id];
	67	bucket = id >> 5;
	68	if (bucket >= ls->map_size)
	69	return FcFalse;
	70
	71	return ((ls->map[bucket] >> (id & 0x1f)) & 1) ? FcTrue : FcFalse;
	72	}
d8d73958 KP	73
	74	FcLangSet *
	75	FcFreeTypeLangSet (const FcCharSet *charset,
e50b9ae7	76	const FcChar8 *exclusiveLang)
3de8881e	77	{
cd2ec1a9	78	int i, j;
e50b9ae7	79	FcChar32 missing;
e50b9ae7	80	const FcCharSet *exclusiveCharset = 0;
d8d73958	81	FcLangSet *ls;
82f35f8b	82
e50b9ae7	83	if (exclusiveLang)
cf223cc7	84	exclusiveCharset = FcLangGetCharSet (exclusiveLang);
d8d73958 KP	85	ls = FcLangSetCreate ();
	86	if (!ls)
	87	return 0;
7ce19673 KP	88	if (FcDebug() & FC_DBG_LANGSET)
7ce19673 KP	89	{
7c12181f	90	printf ("font charset");
7ce19673 KP	91	FcCharSetPrint (charset);
	92	printf ("\n");
	93	}
3de8881e KP	94	for (i = 0; i < NUM_LANG_CHAR_SET; i++)
3de8881e KP	95	{
7ce19673 KP	96	if (FcDebug() & FC_DBG_LANGSET)
7ce19673 KP	97	{
7c12181f	98	printf ("%s charset", fcLangCharSets[i].lang);
7ce19673 KP	99	FcCharSetPrint (&fcLangCharSets[i].charset);
	100	printf ("\n");
	101	}
	102
e50b9ae7 KP	103	/*
	104	* Check for Han charsets to make fonts
	105	* which advertise support for a single language
	106	* not support other Han languages
	107	*/
	108	if (exclusiveCharset &&
cd2ec1a9	109	FcFreeTypeIsExclusiveLang (fcLangCharSets[i].lang))
e50b9ae7	110	{
cd2ec1a9 PL	111	if (fcLangCharSets[i].charset.num != exclusiveCharset->num)
	112	continue;
	113
	114	for (j = 0; j < fcLangCharSets[i].charset.num; j++)
7ce19673 KP	115	if (FcCharSetLeaf(&fcLangCharSets[i].charset, j) !=
7ce19673 KP	116	FcCharSetLeaf(exclusiveCharset, j))
cd2ec1a9	117	continue;
e50b9ae7	118	}
3de8881e KP	119	missing = FcCharSetSubtractCount (&fcLangCharSets[i].charset, charset);
3de8881e KP	120	if (FcDebug() & FC_DBG_SCANV)
c80d2ac4 KP	121	{
	122	if (missing && missing < 10)
	123	{
	124	FcCharSet *missed = FcCharSetSubtract (&fcLangCharSets[i].charset,
	125	charset);
	126	FcChar32 ucs4;
	127	FcChar32 map[FC_CHARSET_MAP_SIZE];
	128	FcChar32 next;
	129
0d745819	130	printf ("\n%s(%u) ", fcLangCharSets[i].lang, missing);
c80d2ac4 KP	131	printf ("{");
	132	for (ucs4 = FcCharSetFirstPage (missed, map, &next);
	133	ucs4 != FC_CHARSET_DONE;
	134	ucs4 = FcCharSetNextPage (missed, map, &next))
	135	{
	136	int i, j;
	137	for (i = 0; i < FC_CHARSET_MAP_SIZE; i++)
	138	if (map[i])
	139	{
	140	for (j = 0; j < 32; j++)
	141	if (map[i] & (1 << j))
	142	printf (" %04x", ucs4 + i * 32 + j);
	143	}
	144	}
	145	printf (" }\n\t");
	146	FcCharSetDestroy (missed);
	147	}
	148	else
0d745819	149	printf ("%s(%u) ", fcLangCharSets[i].lang, missing);
c80d2ac4	150	}
e50b9ae7	151	if (!missing)
d8d73958	152	FcLangSetBitSet (ls, i);
3de8881e	153	}
e50b9ae7	154
3de8881e KP	155	if (FcDebug() & FC_DBG_SCANV)
3de8881e KP	156	printf ("\n");
d8d73958 KP	157
	158
	159	return ls;
3de8881e KP	160	}
3de8881e KP	161
d8d73958	162	#define FcLangEnd(c) ((c) == '-' \|\| (c) == '\0')
3de8881e KP	163
	164	FcLangResult
	165	FcLangCompare (const FcChar8 s1, const FcChar8 s2)
	166	{
3de8881e	167	FcChar8 c1, c2;
d8d73958 KP	168	FcLangResult result = FcLangDifferentLang;
d8d73958 KP	169
3de8881e KP	170	for (;;)
	171	{
	172	c1 = *s1++;
	173	c2 = *s2++;
d8d73958	174
3de8881e KP	175	c1 = FcToLower (c1);
	176	c2 = FcToLower (c2);
	177	if (c1 != c2)
d8d73958 KP	178	{
d8d73958 KP	179	if (FcLangEnd (c1) && FcLangEnd (c2))
c833409f	180	result = FcLangDifferentTerritory;
d8d73958 KP	181	return result;
	182	}
	183	else if (!c1)
	184	return FcLangEqual;
	185	else if (c1 == '-')
c833409f	186	result = FcLangDifferentTerritory;
3de8881e	187	}
3de8881e KP	188	}
3de8881e KP	189
793e946c	190	/*
74a623e0	191	* Return FcTrue when super contains sub.
793e946c	192	*
74a623e0 KP	193	* super contains sub if super and sub have the same
	194	* language and either the same country or one
	195	* is missing the country
793e946c KP	196	*/
	197
	198	static FcBool
74a623e0	199	FcLangContains (const FcChar8 super, const FcChar8 sub)
793e946c KP	200	{
	201	FcChar8 c1, c2;
	202
	203	for (;;)
	204	{
74a623e0 KP	205	c1 = *super++;
74a623e0 KP	206	c2 = *sub++;
793e946c KP	207
	208	c1 = FcToLower (c1);
	209	c2 = FcToLower (c2);
	210	if (c1 != c2)
	211	{
74a623e0	212	/* see if super has a country while sub is mising one */
793e946c KP	213	if (c1 == '-' && c2 == '\0')
793e946c KP	214	return FcTrue;
74a623e0 KP	215	/* see if sub has a country while super is mising one */
	216	if (c1 == '\0' && c2 == '-')
	217	return FcTrue;
793e946c KP	218	return FcFalse;
	219	}
	220	else if (!c1)
	221	return FcTrue;
	222	}
	223	}
	224
3de8881e	225	const FcCharSet *
cf223cc7	226	FcLangGetCharSet (const FcChar8 *lang)
3de8881e KP	227	{
	228	int i;
	229	int country = -1;
82f35f8b	230
3de8881e KP	231	for (i = 0; i < NUM_LANG_CHAR_SET; i++)
	232	{
	233	switch (FcLangCompare (lang, fcLangCharSets[i].lang)) {
	234	case FcLangEqual:
	235	return &fcLangCharSets[i].charset;
c833409f	236	case FcLangDifferentTerritory:
3de8881e KP	237	if (country == -1)
3de8881e KP	238	country = i;
1f4e6fec	239	case FcLangDifferentLang:
3de8881e KP	240	default:
	241	break;
	242	}
	243	}
	244	if (country == -1)
	245	return 0;
b36f2a39	246	return &fcLangCharSets[country].charset;
3de8881e	247	}
d8d73958	248
cf223cc7 BE	249	FcStrSet *
	250	FcGetLangs (void)
	251	{
	252	FcStrSet *langs;
	253	int i;
	254
	255	langs = FcStrSetCreate();
	256	if (!langs)
	257	return 0;
	258
	259	for (i = 0; i < NUM_LANG_CHAR_SET; i++)
	260	FcStrSetAdd (langs, fcLangCharSets[i].lang);
	261
	262	return langs;
	263	}
	264
d8d73958 KP	265	FcLangSet *
	266	FcLangSetCreate (void)
	267	{
	268	FcLangSet *ls;
	269
	270	ls = malloc (sizeof (FcLangSet));
	271	if (!ls)
	272	return 0;
	273	FcMemAlloc (FC_MEM_LANGSET, sizeof (FcLangSet));
	274	memset (ls->map, '\0', sizeof (ls->map));
1f4e6fec	275	ls->map_size = NUM_LANG_SET_MAP;
4262e0b3	276	ls->extra = 0;
d8d73958 KP	277	return ls;
	278	}
	279
	280	void
	281	FcLangSetDestroy (FcLangSet *ls)
	282	{
4262e0b3 PL	283	if (ls->extra)
4262e0b3 PL	284	FcStrSetDestroy (ls->extra);
d8d73958 KP	285	FcMemFree (FC_MEM_LANGSET, sizeof (FcLangSet));
	286	free (ls);
	287	}
	288
	289	FcLangSet *
	290	FcLangSetCopy (const FcLangSet *ls)
	291	{
	292	FcLangSet *new;
	293
	294	new = FcLangSetCreate ();
	295	if (!new)
	296	goto bail0;
1f4e6fec BE	297	memset (new->map, '\0', sizeof (new->map));
1f4e6fec BE	298	memcpy (new->map, ls->map, FC_MIN (sizeof (new->map), ls->map_size * sizeof (ls->map[0])));
4262e0b3	299	if (ls->extra)
d8d73958 KP	300	{
	301	FcStrList *list;
	302	FcChar8 *extra;
	303
4262e0b3 PL	304	new->extra = FcStrSetCreate ();
4262e0b3 PL	305	if (!new->extra)
d8d73958 KP	306	goto bail1;
d8d73958 KP	307
4262e0b3	308	list = FcStrListCreate (ls->extra);
d8d73958 KP	309	if (!list)
	310	goto bail1;
	311
	312	while ((extra = FcStrListNext (list)))
4262e0b3	313	if (!FcStrSetAdd (new->extra, extra))
d8d73958 KP	314	{
	315	FcStrListDone (list);
	316	goto bail1;
	317	}
	318	FcStrListDone (list);
	319	}
	320	return new;
	321	bail1:
	322	FcLangSetDestroy (new);
	323	bail0:
	324	return 0;
	325	}
	326
	327	static int
	328	FcLangSetIndex (const FcChar8 *lang)
	329	{
12d49d3c CW	330	int low, high, mid = 0;
12d49d3c CW	331	int cmp = 0;
793e946c	332	FcChar8 firstChar = FcToLower(lang[0]);
947afeb5	333	FcChar8 secondChar = firstChar ? FcToLower(lang[1]) : '\0';
793e946c KP	334
	335	if (firstChar < 'a')
	336	{
	337	low = 0;
	338	high = fcLangCharSetRanges[0].begin;
	339	}
	340	else if(firstChar > 'z')
	341	{
	342	low = fcLangCharSetRanges[25].begin;
	343	high = NUM_LANG_CHAR_SET - 1;
	344	}
	345	else
	346	{
	347	low = fcLangCharSetRanges[firstChar - 'a'].begin;
	348	high = fcLangCharSetRanges[firstChar - 'a'].end;
	349	/* no matches */
	350	if (low > high)
	351	return -low; /* next entry after where it would be */
	352	}
d8d73958	353
d8d73958 KP	354	while (low <= high)
	355	{
	356	mid = (high + low) >> 1;
793e946c KP	357	if(fcLangCharSets[mid].lang[0] != firstChar)
	358	cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang, lang);
	359	else
	360	{ /* fast path for resolving 2-letter languages (by far the most common) after
	361	* finding the first char (probably already true because of the hash table) */
947afeb5 KP	362	cmp = fcLangCharSets[mid].lang[1] - secondChar;
	363	if (cmp == 0 &&
	364	(fcLangCharSets[mid].lang[2] != '\0' \|\|
	365	lang[2] != '\0'))
793e946c	366	{
947afeb5 KP	367	cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang+2,
947afeb5 KP	368	lang+2);
793e946c	369	}
793e946c KP	370	}
793e946c KP	371	if (cmp == 0)
d8d73958 KP	372	return mid;
	373	if (cmp < 0)
	374	low = mid + 1;
	375	else
	376	high = mid - 1;
	377	}
	378	if (cmp < 0)
	379	mid++;
	380	return -(mid + 1);
	381	}
	382
	383	FcBool
	384	FcLangSetAdd (FcLangSet ls, const FcChar8 lang)
	385	{
	386	int id;
	387
	388	id = FcLangSetIndex (lang);
	389	if (id >= 0)
	390	{
	391	FcLangSetBitSet (ls, id);
	392	return FcTrue;
	393	}
4262e0b3	394	if (!ls->extra)
d8d73958	395	{
4262e0b3 PL	396	ls->extra = FcStrSetCreate ();
4262e0b3 PL	397	if (!ls->extra)
d8d73958 KP	398	return FcFalse;
d8d73958 KP	399	}
4262e0b3	400	return FcStrSetAdd (ls->extra, lang);
d8d73958 KP	401	}
	402
	403	FcLangResult
	404	FcLangSetHasLang (const FcLangSet ls, const FcChar8 lang)
	405	{
	406	int id;
	407	FcLangResult best, r;
	408	int i;
	409
	410	id = FcLangSetIndex (lang);
2458a6d8 KP	411	if (id < 0)
	412	id = -id - 1;
	413	else if (FcLangSetBitGet (ls, id))
d8d73958	414	return FcLangEqual;
d8d73958 KP	415	best = FcLangDifferentLang;
	416	for (i = id - 1; i >= 0; i--)
	417	{
	418	r = FcLangCompare (lang, fcLangCharSets[i].lang);
	419	if (r == FcLangDifferentLang)
	420	break;
	421	if (FcLangSetBitGet (ls, i) && r < best)
	422	best = r;
	423	}
	424	for (i = id; i < NUM_LANG_CHAR_SET; i++)
	425	{
	426	r = FcLangCompare (lang, fcLangCharSets[i].lang);
	427	if (r == FcLangDifferentLang)
	428	break;
	429	if (FcLangSetBitGet (ls, i) && r < best)
	430	best = r;
	431	}
4262e0b3	432	if (ls->extra)
d8d73958	433	{
4262e0b3	434	FcStrList *list = FcStrListCreate (ls->extra);
d8d73958	435	FcChar8 *extra;
d8d73958 KP	436
	437	if (list)
	438	{
	439	while (best > FcLangEqual && (extra = FcStrListNext (list)))
	440	{
	441	r = FcLangCompare (lang, extra);
	442	if (r < best)
	443	best = r;
	444	}
	445	FcStrListDone (list);
	446	}
	447	}
	448	return best;
	449	}
	450
	451	static FcLangResult
	452	FcLangSetCompareStrSet (const FcLangSet ls, FcStrSet set)
	453	{
	454	FcStrList *list = FcStrListCreate (set);
	455	FcLangResult r, best = FcLangDifferentLang;
	456	FcChar8 *extra;
	457
	458	if (list)
	459	{
	460	while (best > FcLangEqual && (extra = FcStrListNext (list)))
	461	{
	462	r = FcLangSetHasLang (ls, extra);
	463	if (r < best)
	464	best = r;
	465	}
	466	FcStrListDone (list);
	467	}
	468	return best;
	469	}
	470
	471	FcLangResult
	472	FcLangSetCompare (const FcLangSet lsa, const FcLangSet lsb)
	473	{
1f4e6fec	474	int i, j, count;
d8d73958 KP	475	FcLangResult best, r;
d8d73958 KP	476
1f4e6fec BE	477	count = FC_MIN (lsa->map_size, lsb->map_size);
	478	count = FC_MIN (NUM_LANG_SET_MAP, count);
	479	for (i = 0; i < count; i++)
d8d73958 KP	480	if (lsa->map[i] & lsb->map[i])
	481	return FcLangEqual;
	482	best = FcLangDifferentLang;
234397b4	483	for (j = 0; j < NUM_COUNTRY_SET; j++)
1f4e6fec	484	for (i = 0; i < count; i++)
234397b4 DD	485	if ((lsa->map[i] & fcLangCountrySets[j][i]) &&
	486	(lsb->map[i] & fcLangCountrySets[j][i]))
	487	{
c833409f	488	best = FcLangDifferentTerritory;
234397b4 DD	489	break;
234397b4 DD	490	}
4262e0b3	491	if (lsa->extra)
d8d73958	492	{
4262e0b3	493	r = FcLangSetCompareStrSet (lsb, lsa->extra);
d8d73958 KP	494	if (r < best)
	495	best = r;
	496	}
4262e0b3	497	if (best > FcLangEqual && lsb->extra)
d8d73958	498	{
4262e0b3	499	r = FcLangSetCompareStrSet (lsa, lsb->extra);
d8d73958 KP	500	if (r < best)
	501	best = r;
	502	}
	503	return best;
	504	}
	505
	506	/*
	507	* Used in computing values -- mustn't allocate any storage
	508	*/
	509	FcLangSet *
	510	FcLangSetPromote (const FcChar8 *lang)
	511	{
	512	static FcLangSet ls;
	513	static FcStrSet strs;
	514	static FcChar8 *str;
	515	int id;
	516
	517	memset (ls.map, '\0', sizeof (ls.map));
4262e0b3	518	ls.extra = 0;
d8d73958 KP	519	id = FcLangSetIndex (lang);
	520	if (id > 0)
	521	{
	522	FcLangSetBitSet (&ls, id);
	523	}
	524	else
	525	{
4262e0b3	526	ls.extra = &strs;
d8d73958 KP	527	strs.num = 1;
d8d73958 KP	528	strs.size = 1;
4262e0b3	529	strs.strs = &str;
47d4f950	530	strs.ref = 1;
d8d73958 KP	531	str = (FcChar8 *) lang;
	532	}
	533	return &ls;
	534	}
	535
	536	FcChar32
	537	FcLangSetHash (const FcLangSet *ls)
	538	{
	539	FcChar32 h = 0;
a3b24268	540	int i, count;
d8d73958	541
a3b24268 BE	542	count = FC_MIN (ls->map_size, NUM_LANG_SET_MAP);
a3b24268 BE	543	for (i = 0; i < count; i++)
d8d73958	544	h ^= ls->map[i];
4262e0b3 PL	545	if (ls->extra)
4262e0b3 PL	546	h ^= ls->extra->num;
d8d73958 KP	547	return h;
	548	}
	549
	550	FcLangSet *
	551	FcNameParseLangSet (const FcChar8 *string)
	552	{
1f4e6fec	553	FcChar8 lang[32], c = 0;
793e946c	554	int i;
d8d73958 KP	555	FcLangSet *ls;
	556
	557	ls = FcLangSetCreate ();
	558	if (!ls)
	559	goto bail0;
	560
793e946c	561	for(;;)
d8d73958	562	{
793e946c	563	for(i = 0; i < 31;i++)
d8d73958	564	{
793e946c KP	565	c = *string++;
	566	if(c == '\0' \|\| c == '\|')
	567	break; /* end of this code */
	568	lang[i] = c;
d8d73958	569	}
793e946c KP	570	lang[i] = '\0';
	571	if (!FcLangSetAdd (ls, lang))
	572	goto bail1;
	573	if(c == '\0')
	574	break;
d8d73958 KP	575	}
	576	return ls;
	577	bail1:
	578	FcLangSetDestroy (ls);
	579	bail0:
	580	return 0;
	581	}
	582
	583	FcBool
	584	FcNameUnparseLangSet (FcStrBuf buf, const FcLangSet ls)
	585	{
1f4e6fec	586	int i, bit, count;
c5f0a65b	587	FcChar32 bits;
d8d73958 KP	588	FcBool first = FcTrue;
d8d73958 KP	589
1f4e6fec BE	590	count = FC_MIN (ls->map_size, NUM_LANG_SET_MAP);
1f4e6fec BE	591	for (i = 0; i < count; i++)
c5f0a65b BE	592	{
	593	if ((bits = ls->map[i]))
	594	{
	595	for (bit = 0; bit <= 31; bit++)
	596	if (bits & (1 << bit))
	597	{
	598	int id = (i << 5) \| bit;
	599	if (!first)
	600	if (!FcStrBufChar (buf, '\|'))
	601	return FcFalse;
	602	if (!FcStrBufString (buf, fcLangCharSets[fcLangCharSetIndicesInv[id]].lang))
d8d73958	603	return FcFalse;
c5f0a65b BE	604	first = FcFalse;
	605	}
	606	}
	607	}
4262e0b3	608	if (ls->extra)
d8d73958	609	{
4262e0b3	610	FcStrList *list = FcStrListCreate (ls->extra);
d8d73958 KP	611	FcChar8 *extra;
	612
	613	if (!list)
	614	return FcFalse;
	615	while ((extra = FcStrListNext (list)))
	616	{
	617	if (!first)
	618	if (!FcStrBufChar (buf, '\|'))
04f7d3e7 PL	619	{
04f7d3e7 PL	620	FcStrListDone (list);
d8d73958	621	return FcFalse;
04f7d3e7	622	}
793e946c	623	if (!FcStrBufString (buf, extra))
04f7d3e7 PL	624	{
	625	FcStrListDone (list);
	626	return FcFalse;
	627	}
d8d73958 KP	628	first = FcFalse;
d8d73958 KP	629	}
2de24638	630	FcStrListDone (list);
d8d73958 KP	631	}
	632	return FcTrue;
	633	}
	634
	635	FcBool
	636	FcLangSetEqual (const FcLangSet lsa, const FcLangSet lsb)
	637	{
1f4e6fec	638	int i, count;
d8d73958	639
1f4e6fec BE	640	count = FC_MIN (lsa->map_size, lsb->map_size);
	641	count = FC_MIN (NUM_LANG_SET_MAP, count);
	642	for (i = 0; i < count; i++)
d8d73958 KP	643	{
	644	if (lsa->map[i] != lsb->map[i])
	645	return FcFalse;
	646	}
4262e0b3	647	if (!lsa->extra && !lsb->extra)
d8d73958	648	return FcTrue;
4262e0b3 PL	649	if (lsa->extra && lsb->extra)
4262e0b3 PL	650	return FcStrSetEqual (lsa->extra, lsb->extra);
d8d73958 KP	651	return FcFalse;
d8d73958 KP	652	}
793e946c KP	653
	654	static FcBool
	655	FcLangSetContainsLang (const FcLangSet ls, const FcChar8 lang)
	656	{
	657	int id;
793e946c KP	658	int i;
	659
	660	id = FcLangSetIndex (lang);
	661	if (id < 0)
	662	id = -id - 1;
	663	else if (FcLangSetBitGet (ls, id))
	664	return FcTrue;
	665	/*
	666	* search up and down among equal languages for a match
	667	*/
	668	for (i = id - 1; i >= 0; i--)
	669	{
	670	if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
	671	break;
	672	if (FcLangSetBitGet (ls, i) &&
	673	FcLangContains (fcLangCharSets[i].lang, lang))
	674	return FcTrue;
	675	}
	676	for (i = id; i < NUM_LANG_CHAR_SET; i++)
	677	{
	678	if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
	679	break;
	680	if (FcLangSetBitGet (ls, i) &&
	681	FcLangContains (fcLangCharSets[i].lang, lang))
	682	return FcTrue;
	683	}
4262e0b3	684	if (ls->extra)
793e946c	685	{
4262e0b3	686	FcStrList *list = FcStrListCreate (ls->extra);
793e946c	687	FcChar8 *extra;
793e946c KP	688
	689	if (list)
	690	{
	691	while ((extra = FcStrListNext (list)))
	692	{
	693	if (FcLangContains (extra, lang))
	694	break;
	695	}
	696	FcStrListDone (list);
	697	if (extra)
	698	return FcTrue;
	699	}
	700	}
	701	return FcFalse;
	702	}
	703
	704	/*
	705	* return FcTrue if lsa contains every language in lsb
	706	*/
	707	FcBool
	708	FcLangSetContains (const FcLangSet lsa, const FcLangSet lsb)
	709	{
1f4e6fec	710	int i, j, count;
793e946c KP	711	FcChar32 missing;
	712
	713	if (FcDebug() & FC_DBG_MATCHV)
	714	{
	715	printf ("FcLangSet "); FcLangSetPrint (lsa);
	716	printf (" contains "); FcLangSetPrint (lsb);
	717	printf ("\n");
	718	}
	719	/*
	720	* check bitmaps for missing language support
	721	*/
1f4e6fec BE	722	count = FC_MIN (lsa->map_size, lsb->map_size);
	723	count = FC_MIN (NUM_LANG_SET_MAP, count);
	724	for (i = 0; i < count; i++)
793e946c KP	725	{
	726	missing = lsb->map[i] & ~lsa->map[i];
	727	if (missing)
	728	{
	729	for (j = 0; j < 32; j++)
	730	if (missing & (1 << j))
	731	{
	732	if (!FcLangSetContainsLang (lsa,
d354a321	733	fcLangCharSets[fcLangCharSetIndicesInv[i*32 + j]].lang))
793e946c KP	734	{
793e946c KP	735	if (FcDebug() & FC_DBG_MATCHV)
d354a321	736	printf ("\tMissing bitmap %s\n", fcLangCharSets[fcLangCharSetIndicesInv[i*32+j]].lang);
793e946c KP	737	return FcFalse;
	738	}
	739	}
	740	}
	741	}
4262e0b3	742	if (lsb->extra)
793e946c	743	{
4262e0b3	744	FcStrList *list = FcStrListCreate (lsb->extra);
793e946c KP	745	FcChar8 *extra;
	746
	747	if (list)
	748	{
	749	while ((extra = FcStrListNext (list)))
	750	{
	751	if (!FcLangSetContainsLang (lsa, extra))
	752	{
	753	if (FcDebug() & FC_DBG_MATCHV)
	754	printf ("\tMissing string %s\n", extra);
	755	break;
	756	}
	757	}
	758	FcStrListDone (list);
	759	if (extra)
	760	return FcFalse;
	761	}
	762	}
	763	return FcTrue;
	764	}
cd2ec1a9	765
7ce19673 KP	766	FcBool
7ce19673 KP	767	FcLangSetSerializeAlloc (FcSerialize serialize, const FcLangSet l)
cd2ec1a9	768	{
7ce19673 KP	769	if (!FcSerializeAlloc (serialize, l, sizeof (FcLangSet)))
7ce19673 KP	770	return FcFalse;
4262e0b3	771	return FcTrue;
cd2ec1a9	772	}
212c9f43	773
4262e0b3	774	FcLangSet *
7ce19673	775	FcLangSetSerialize(FcSerialize serialize, const FcLangSet l)
4262e0b3	776	{
7ce19673	777	FcLangSet *l_serialize = FcSerializePtr (serialize, l);
4262e0b3	778
7ce19673 KP	779	if (!l_serialize)
7ce19673 KP	780	return NULL;
a3b24268 BE	781	memset (l_serialize->map, '\0', sizeof (l_serialize->map));
	782	memcpy (l_serialize->map, l->map, FC_MIN (sizeof (l_serialize->map), l->map_size * sizeof (l->map[0])));
	783	l_serialize->map_size = NUM_LANG_SET_MAP;
1f4e6fec	784	l_serialize->extra = NULL; /* We don't serialize ls->extra */
7ce19673	785	return l_serialize;
212c9f43	786	}
d62b85af BE	787
	788	FcStrSet *
	789	FcLangSetGetLangs (const FcLangSet *ls)
	790	{
	791	FcStrSet *langs;
	792	int i;
	793
	794	langs = FcStrSetCreate();
	795	if (!langs)
	796	return 0;
	797
	798	for (i = 0; i < NUM_LANG_CHAR_SET; i++)
	799	if (FcLangSetBitGet (ls, i))
	800	FcStrSetAdd (langs, fcLangCharSets[i].lang);
	801
	802	if (ls->extra)
	803	{
	804	FcStrList *list = FcStrListCreate (ls->extra);
	805	FcChar8 *extra;
	806
	807	if (list)
	808	{
	809	while ((extra = FcStrListNext (list)))
	810	FcStrSetAdd (langs, extra);
	811
	812	FcStrListDone (list);
	813	}
	814	}
	815
	816	return langs;
	817	}
	818
23816bf9 KP	819	#define __fclang__
23816bf9 KP	820	#include "fcaliastail.h"
a0a1da22	821	#include "fcftaliastail.h"
23816bf9	822	#undef __fclang__