Changeset 498


Ignore:
Timestamp:
Jan 6, 2012, 2:23:31 PM (10 years ago)
Author:
Silvan Scherrer
Message:

Lucide 1.3.4: new beta source

Location:
trunk/poppler/fc-emulate-os2
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/fc-emulate-os2/Makefile.kmk

    r497 r498  
    2121        fontconfig/fontconfig.c \
    2222        fontconfig/fcpat.c \
    23         fontconfig/fclang.c
     23        fontconfig/fclang.c \
     24        fontconfig/fcstr.c
    2425
    2526include $(FILE_KBUILD_SUB_FOOTER)
  • trunk/poppler/fc-emulate-os2/fontconfig/fcint.h

    r497 r498  
    4141#define FC_CACHE_VERSION_STRING "v1.3_with_GCC"
    4242
     43#define FC_MEM_CHARSET      0
     44#define FC_MEM_CHARLEAF     1
     45#define FC_MEM_FONTSET      2
     46#define FC_MEM_FONTPTR      3
     47#define FC_MEM_OBJECTSET    4
     48#define FC_MEM_OBJECTPTR    5
     49#define FC_MEM_MATRIX       6
     50#define FC_MEM_PATTERN      7
     51#define FC_MEM_PATELT       8
     52#define FC_MEM_VALLIST      9
     53#define FC_MEM_SUBSTATE     10
     54#define FC_MEM_STRING       11
     55#define FC_MEM_LISTBUCK     12
     56#define FC_MEM_STRSET       13
     57#define FC_MEM_STRLIST      14
     58#define FC_MEM_CONFIG       15
     59#define FC_MEM_LANGSET      16
     60#define FC_MEM_ATOMIC       17
     61#define FC_MEM_BLANKS       18
     62#define FC_MEM_CACHE        19
     63#define FC_MEM_STRBUF       20
     64#define FC_MEM_SUBST        21
     65#define FC_MEM_OBJECTTYPE   22
     66#define FC_MEM_CONSTANT     23
     67#define FC_MEM_TEST         24
     68#define FC_MEM_EXPR         25
     69#define FC_MEM_VSTACK       26
     70#define FC_MEM_ATTR         27
     71#define FC_MEM_PSTACK       28
     72#define FC_MEM_STATICSTR    29
     73
     74#define FC_MEM_NUM          30
     75
     76#define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
     77#define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
     78#define FC_ABS(a)   ((a) < 0 ? -(a) : (a))
    4379
    4480#ifdef FC_EXPORT_FUNCTIONS
     
    93129    char *lang;
    94130    FontDescriptionCache_p pFontDesc;
     131    FcLangSet *langset;
    95132};
     133
     134struct _FcCharSet {
     135    int             ref;        /* reference count */
     136    int             num;        /* size of leaves and numbers arrays */
     137    intptr_t        leaves_offset;
     138    intptr_t        numbers_offset;
     139};
     140
     141typedef struct _FcCharLeaf {
     142    FcChar32    map[256/32];
     143} FcCharLeaf;
     144
     145struct _FcStrSet {
     146    int             ref;        /* reference count */
     147    int             num;
     148    int             size;
     149    FcChar8         **strs;
     150};
     151
     152struct _FcStrList {
     153    FcStrSet        *set;
     154    int             n;
     155};
     156
     157#define FC_REF_CONSTANT     -1
    96158
    97159void *pConfig;
  • trunk/poppler/fc-emulate-os2/fontconfig/fclang.c

    r497 r498  
    1515#include "fcint.h"
    1616
     17typedef struct {
     18    const FcChar8       lang[8];
     19    const FcCharSet     charset;
     20} FcLangCharSet;
     21
     22typedef struct {
     23    int begin;
     24    int end;
     25} FcLangCharSetRange;
     26
     27#include "fclang.h"
     28
     29struct _FcLangSet {
     30    FcStrSet    *extra;
     31    FcChar32    map_size;
     32    FcChar32    map[NUM_LANG_SET_MAP];
     33};
     34
     35static void FcLangSetBitSet (FcLangSet *ls, unsigned int id)
     36{
     37  int bucket;
     38
     39  id = fcLangCharSetIndices[id];
     40  bucket = id >> 5;
     41  if (bucket >= ls->map_size)
     42    return; /* shouldn't happen really */
     43
     44  ls->map[bucket] |= ((FcChar32) 1 << (id & 0x1f));
     45}
     46
     47static FcBool FcLangSetBitGet (const FcLangSet *ls, unsigned int id)
     48{
     49  int bucket;
     50
     51  id = fcLangCharSetIndices[id];
     52  bucket = id >> 5;
     53  if (bucket >= ls->map_size)
     54    return FcFalse;
     55
     56  return ((ls->map[bucket] >> (id & 0x1f)) & 1) ? FcTrue : FcFalse;
     57}
     58
     59static int FcLangSetIndex (const FcChar8 *lang)
     60{
     61    int     low, high, mid = 0;
     62    int     cmp = 0;
     63    FcChar8 firstChar = FcToLower(lang[0]);
     64    FcChar8 secondChar = firstChar ? FcToLower(lang[1]) : '\0';
     65   
     66    if (firstChar < 'a')
     67    {
     68        low = 0;
     69        high = fcLangCharSetRanges[0].begin;
     70    }
     71    else if(firstChar > 'z')
     72    {
     73        low = fcLangCharSetRanges[25].begin;
     74        high = NUM_LANG_CHAR_SET - 1;
     75    }
     76    else
     77    {
     78        low = fcLangCharSetRanges[firstChar - 'a'].begin;
     79        high = fcLangCharSetRanges[firstChar - 'a'].end;
     80        /* no matches */
     81        if (low > high)
     82            return -low; /* next entry after where it would be */
     83    }
     84
     85    while (low <= high)
     86    {
     87        mid = (high + low) >> 1;
     88        if(fcLangCharSets[mid].lang[0] != firstChar)
     89            cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang, lang);
     90        else
     91        {   /* fast path for resolving 2-letter languages (by far the most common) after
     92             * finding the first char (probably already true because of the hash table) */
     93            cmp = fcLangCharSets[mid].lang[1] - secondChar;
     94            if (cmp == 0 &&
     95                (fcLangCharSets[mid].lang[2] != '\0' ||
     96                 lang[2] != '\0'))
     97            {
     98                cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang+2,
     99                                         lang+2);
     100            }
     101        }
     102        if (cmp == 0)
     103            return mid;
     104        if (cmp < 0)
     105            low = mid + 1;
     106        else
     107            high = mid - 1;
     108    }
     109    if (cmp < 0)
     110        mid++;
     111    return -(mid + 1);
     112}
     113
     114#define FcLangEnd(c)    ((c) == '-' || (c) == '\0')
     115
     116FcLangResult FcLangCompare (const FcChar8 *s1, const FcChar8 *s2)
     117{
     118    FcChar8         c1, c2;
     119    FcLangResult    result = FcLangDifferentLang;
     120
     121    for (;;)
     122    {
     123        c1 = *s1++;
     124        c2 = *s2++;
     125       
     126        c1 = FcToLower (c1);
     127        c2 = FcToLower (c2);
     128        if (c1 != c2)
     129        {
     130            if (FcLangEnd (c1) && FcLangEnd (c2))
     131                result = FcLangDifferentTerritory;
     132            return result;
     133        }
     134        else if (!c1)
     135            return FcLangEqual;
     136        else if (c1 == '-')
     137            result = FcLangDifferentTerritory;
     138    }
     139}
    17140
    18141/*
    19  * test langset for language support
    20  * FcLangSetHasLang checks whether ls supports lang. If ls has a matching
    21  * language and territory pair, this function returns FcLangEqual. If ls has
    22  * a matching language but differs in which territory that language is for,
    23  * this function returns FcLangDiffentTerritory. If ls has no matching
    24  * language, this function returns FcLangDifferentLang.
     142 * Return FcTrue when super contains sub.
     143 *
     144 * super contains sub if super and sub have the same
     145 * language and either the same country or one
     146 * is missing the country
    25147 */
     148
     149static FcBool FcLangContains (const FcChar8 *super, const FcChar8 *sub)
     150{
     151    FcChar8         c1, c2;
     152
     153    for (;;)
     154    {
     155        c1 = *super++;
     156        c2 = *sub++;
     157       
     158        c1 = FcToLower (c1);
     159        c2 = FcToLower (c2);
     160        if (c1 != c2)
     161        {
     162            /* see if super has a country while sub is mising one */
     163            if (c1 == '-' && c2 == '\0')
     164                return FcTrue;
     165            /* see if sub has a country while super is mising one */
     166            if (c1 == '\0' && c2 == '-')
     167                return FcTrue;
     168            return FcFalse;
     169        }
     170        else if (!c1)
     171            return FcTrue;
     172    }
     173}
     174
    26175fcExport FcLangResult FcLangSetHasLang(const FcLangSet *ls, const FcChar8 *lang)
    27176{
    28   // Stub
    29   return FcLangEqual;
    30 }
    31 
     177    int             id;
     178    FcLangResult    best, r;
     179    int             i;
     180
     181    id = FcLangSetIndex (lang);
     182    if (id < 0)
     183        id = -id - 1;
     184    else if (FcLangSetBitGet (ls, id))
     185        return FcLangEqual;
     186    best = FcLangDifferentLang;
     187    for (i = id - 1; i >= 0; i--)
     188    {
     189        r = FcLangCompare (lang, fcLangCharSets[i].lang);
     190        if (r == FcLangDifferentLang)
     191            break;
     192        if (FcLangSetBitGet (ls, i) && r < best)
     193            best = r;
     194    }
     195    for (i = id; i < NUM_LANG_CHAR_SET; i++)
     196    {
     197        r = FcLangCompare (lang, fcLangCharSets[i].lang);
     198        if (r == FcLangDifferentLang)
     199            break;
     200        if (FcLangSetBitGet (ls, i) && r < best)
     201            best = r;
     202    }
     203    if (ls->extra)
     204    {
     205        FcStrList       *list = FcStrListCreate (ls->extra);
     206        FcChar8         *extra;
     207       
     208        if (list)
     209        {
     210            while (best > FcLangEqual && (extra = FcStrListNext (list)))
     211            {
     212                r = FcLangCompare (lang, extra);
     213                if (r < best)
     214                    best = r;
     215            }
     216            FcStrListDone (list);
     217        }
     218    }
     219    return best;
     220}
     221
     222fcExport FcLangSet* FcLangSetCreate (void)
     223{
     224    FcLangSet   *ls;
     225
     226    ls = malloc (sizeof (FcLangSet));
     227    if (!ls)
     228        return 0;
     229    memset (ls->map, '\0', sizeof (ls->map));
     230    ls->map_size = NUM_LANG_SET_MAP;
     231    ls->extra = 0;
     232    return ls;
     233}
     234
     235fcExport void FcLangSetDestroy (FcLangSet *ls)
     236{
     237    if (ls->extra)
     238        FcStrSetDestroy (ls->extra);
     239    free (ls);
     240}
     241
     242fcExport FcLangSet* FcLangSetCopy (const FcLangSet *ls)
     243{
     244    FcLangSet   *new;
     245
     246    new = FcLangSetCreate ();
     247    if (!new)
     248        goto bail0;
     249    memset (new->map, '\0', sizeof (new->map));
     250    memcpy (new->map, ls->map, FC_MIN (sizeof (new->map), ls->map_size * sizeof (ls->map[0])));
     251    if (ls->extra)
     252    {
     253        FcStrList       *list;
     254        FcChar8         *extra;
     255       
     256        new->extra = FcStrSetCreate ();
     257        if (!new->extra)
     258            goto bail1;
     259
     260        list = FcStrListCreate (ls->extra);     
     261        if (!list)
     262            goto bail1;
     263       
     264        while ((extra = FcStrListNext (list)))
     265            if (!FcStrSetAdd (new->extra, extra))
     266            {
     267                FcStrListDone (list);
     268                goto bail1;
     269            }
     270        FcStrListDone (list);
     271    }
     272    return new;
     273bail1:
     274    FcLangSetDestroy (new);
     275bail0:
     276    return 0;
     277}
     278
     279FcBool FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang)
     280{
     281    int     id;
     282
     283    id = FcLangSetIndex (lang);
     284    if (id >= 0)
     285    {
     286        FcLangSetBitSet (ls, id);
     287        return FcTrue;
     288    }
     289    if (!ls->extra)
     290    {
     291        ls->extra = FcStrSetCreate ();
     292        if (!ls->extra)
     293            return FcFalse;
     294    }
     295    return FcStrSetAdd (ls->extra, lang);
     296}
     297
     298static FcBool FcLangSetContainsLang (const FcLangSet *ls, const FcChar8 *lang)
     299{
     300    int             id;
     301    int             i;
     302
     303    id = FcLangSetIndex (lang);
     304    if (id < 0)
     305        id = -id - 1;
     306    else if (FcLangSetBitGet (ls, id))
     307        return FcTrue;
     308    /*
     309     * search up and down among equal languages for a match
     310     */
     311    for (i = id - 1; i >= 0; i--)
     312    {
     313        if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
     314            break;
     315        if (FcLangSetBitGet (ls, i) &&
     316            FcLangContains (fcLangCharSets[i].lang, lang))
     317            return FcTrue;
     318    }
     319    for (i = id; i < NUM_LANG_CHAR_SET; i++)
     320    {
     321        if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang)
     322            break;
     323        if (FcLangSetBitGet (ls, i) &&
     324            FcLangContains (fcLangCharSets[i].lang, lang))
     325            return FcTrue;
     326    }
     327    if (ls->extra)
     328    {
     329        FcStrList       *list = FcStrListCreate (ls->extra);
     330        FcChar8         *extra;
     331       
     332        if (list)
     333        {
     334            while ((extra = FcStrListNext (list)))
     335            {
     336                if (FcLangContains (extra, lang))
     337                    break;
     338            }
     339            FcStrListDone (list);
     340            if (extra)
     341                return FcTrue;
     342        }
     343    }
     344    return FcFalse;
     345}
     346
     347/*
     348 * return FcTrue if lsa contains every language in lsb
     349 */
     350FcBool FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb)
     351{
     352    int             i, j, count;
     353    FcChar32        missing;
     354
     355    /*
     356     * check bitmaps for missing language support
     357     */
     358    count = FC_MIN (lsa->map_size, lsb->map_size);
     359    count = FC_MIN (NUM_LANG_SET_MAP, count);
     360    for (i = 0; i < count; i++)
     361    {
     362        missing = lsb->map[i] & ~lsa->map[i];
     363        if (missing)
     364        {
     365            for (j = 0; j < 32; j++)
     366                if (missing & (1 << j))
     367                {
     368                    if (!FcLangSetContainsLang (lsa,
     369                                                fcLangCharSets[fcLangCharSetIndicesInv[i*32 + j]].lang))
     370                    {
     371                        return FcFalse;
     372                    }
     373                }
     374        }
     375    }
     376    if (lsb->extra)
     377    {
     378        FcStrList   *list = FcStrListCreate (lsb->extra);
     379        FcChar8     *extra;
     380
     381        if (list)
     382        {
     383            while ((extra = FcStrListNext (list)))
     384            {
     385                if (!FcLangSetContainsLang (lsa, extra))
     386                {
     387                    break;
     388                }
     389            }
     390            FcStrListDone (list);
     391            if (extra)
     392                return FcFalse;
     393        }
     394    }
     395    return FcTrue;
     396}
     397
  • trunk/poppler/fc-emulate-os2/fontconfig/fcpat.c

    r497 r498  
    3333  pResult->style = NULL;
    3434  pResult->lang = NULL;
     35  pResult->langset = NULL;
    3536  pResult->ref = 1;
    3637  return pResult;
     
    5051  if (p->lang)
    5152    free(p->lang);
     53  if (p->langset)
     54    FcLangSetDestroy(p->langset);
    5255  free(p);
    5356}
     
    197200}
    198201
     202fcExport FcResult FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **ls)
     203{
     204
     205  if (id) // we don't support more than one property of the same type
     206    return FcResultNoId;
     207
     208  if (p->langset)
     209  {
     210    *ls = p->langset;
     211    return FcResultMatch;
     212  }
     213  return FcResultNoMatch;
     214}
    199215
    200216fcExport FcBool FcPatternAddInteger(FcPattern *p, const char *object, int i)
     
    305321    }
    306322    p->lang = strdup((const char *)s);
     323
     324/* as in newer fontconfig also the langset is built we need to do that here also */
     325    if (p->langset)
     326    {
     327      FcLangSetDestroy(p->langset); p->langset = NULL;
     328    }
     329    p->langset = FcLangSetCreate();
     330    if (p->langset)
     331    {
     332      if (!FcLangSetAdd (p->langset, p->lang))
     333         {
     334            FcLangSetDestroy(p->langset);
     335            p->langset = NULL;
     336         }
     337
     338    }
    307339    return FcTrue;
    308340  }
     
    487519    if (p->lang)
    488520      pResult->lang = strdup(p->lang);
     521    if (p->langset)
     522      pResult->langset = FcLangSetCopy(p->langset);
    489523
    490524    /* this is doubtful, but for now set the reference to 1,
  • trunk/poppler/fc-emulate-os2/fontconfig/fontconfig.c

    r497 r498  
    14711471}
    14721472
    1473 fcExport int FcStrCmpIgnoreCase(const FcChar8 *s1, const FcChar8 *s2)
    1474 {
    1475   /* It's actually wrong to use stricmp here, because this doesn't know
    1476    * anything about UTF-8. But in the original FC package this also just
    1477    * lowers ASCII characters for comparison, so this should be a good
    1478    * and simple replacement.
    1479    */
    1480   return stricmp((char *)s1, (char *)s2);
    1481 }
    1482 
Note: See TracChangeset for help on using the changeset viewer.