Changeset 498

Timestamp:

Jan 6, 2012, 3:23:31 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Lucide 1.3.4: new beta source

Location:

trunk/poppler/fc-emulate-os2

Files:

• Makefile.kmk (modified) (1 diff)
• fontconfig/fcint.h (modified) (2 diffs)
• fontconfig/fclang.c (modified) (1 diff)
• fontconfig/fclang.h (added)
• fontconfig/fcpat.c (modified) (5 diffs)
• fontconfig/fcstr.c (added)
• fontconfig/fontconfig.c (modified) (1 diff)

trunk/poppler/fc-emulate-os2/Makefile.kmk ¶

@@ -21 +21 @@
         fontconfig/fontconfig.c \
         fontconfig/fcpat.c \
-        fontconfig/fclang.c
+        fontconfig/fclang.c \
+        fontconfig/fcstr.c
 
 include $(FILE_KBUILD_SUB_FOOTER)

trunk/poppler/fc-emulate-os2/fontconfig/fcint.h ¶

@@ -41 +41 @@
 #define FC_CACHE_VERSION_STRING "v1.3_with_GCC"
 
+#define FC_MEM_CHARSET      0
+#define FC_MEM_CHARLEAF     1
+#define FC_MEM_FONTSET      2
+#define FC_MEM_FONTPTR      3
+#define FC_MEM_OBJECTSET    4
+#define FC_MEM_OBJECTPTR    5
+#define FC_MEM_MATRIX       6
+#define FC_MEM_PATTERN      7
+#define FC_MEM_PATELT       8
+#define FC_MEM_VALLIST      9
+#define FC_MEM_SUBSTATE     10
+#define FC_MEM_STRING       11
+#define FC_MEM_LISTBUCK     12
+#define FC_MEM_STRSET       13
+#define FC_MEM_STRLIST      14
+#define FC_MEM_CONFIG       15
+#define FC_MEM_LANGSET      16
+#define FC_MEM_ATOMIC       17
+#define FC_MEM_BLANKS       18
+#define FC_MEM_CACHE        19
+#define FC_MEM_STRBUF       20
+#define FC_MEM_SUBST        21
+#define FC_MEM_OBJECTTYPE   22
+#define FC_MEM_CONSTANT     23
+#define FC_MEM_TEST         24
+#define FC_MEM_EXPR         25
+#define FC_MEM_VSTACK       26
+#define FC_MEM_ATTR         27
+#define FC_MEM_PSTACK       28
+#define FC_MEM_STATICSTR    29
+
+#define FC_MEM_NUM          30
+
+#define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
+#define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
+#define FC_ABS(a)   ((a) < 0 ? -(a) : (a))
 
 #ifdef FC_EXPORT_FUNCTIONS
@@ -93 +129 @@
     char *lang;
     FontDescriptionCache_p pFontDesc;
+    FcLangSet *langset;
 };
+
+struct _FcCharSet {
+    int             ref;        /* reference count */
+    int             num;        /* size of leaves and numbers arrays */
+    intptr_t        leaves_offset;
+    intptr_t        numbers_offset;
+};
+
+typedef struct _FcCharLeaf {
+    FcChar32    map[256/32];
+} FcCharLeaf;
+
+struct _FcStrSet {
+    int             ref;        /* reference count */
+    int             num;
+    int             size;
+    FcChar8         **strs;
+};
+
+struct _FcStrList {
+    FcStrSet        *set;
+    int             n;
+};
+
+#define FC_REF_CONSTANT     -1
 
 void *pConfig;

trunk/poppler/fc-emulate-os2/fontconfig/fclang.c ¶

@@ -15 +15 @@
 #include "fcint.h"
 
+typedef struct {
+    const FcChar8       lang[8];
+    const FcCharSet     charset;
+} FcLangCharSet;
+
+typedef struct {
+    int begin;
+    int end;
+} FcLangCharSetRange;
+
+#include "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;
+}
+
+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);
+}
+
+#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;
+    }
+}
 
 /*
- * test langset for language support
- * FcLangSetHasLang checks whether ls supports lang. If ls has a matching
- * language and territory pair, this function returns FcLangEqual. If ls has
- * a matching language but differs in which territory that language is for,
- * this function returns FcLangDiffentTerritory. If ls has no matching
- * language, this function returns FcLangDifferentLang.
+ * 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;
+    }
+}
+
 fcExport FcLangResult FcLangSetHasLang(const FcLangSet *ls, const FcChar8 *lang)
 {
-  // Stub
-  return FcLangEqual;
-}
-
+    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;
+}
+
+fcExport FcLangSet* FcLangSetCreate (void)
+{
+    FcLangSet   *ls;
+
+    ls = malloc (sizeof (FcLangSet));
+    if (!ls)
+        return 0;
+    memset (ls->map, '\0', sizeof (ls->map));
+    ls->map_size = NUM_LANG_SET_MAP;
+    ls->extra = 0;
+    return ls;
+}
+
+fcExport void FcLangSetDestroy (FcLangSet *ls)
+{
+    if (ls->extra)
+        FcStrSetDestroy (ls->extra);
+    free (ls);
+}
+
+fcExport 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;
+}
+
+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);
+}
+
+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;
+
+    /*
+     * 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))
+                    {
+                        return FcFalse;
+                    }
+                }
+        }
+    }
+    if (lsb->extra)
+    {
+        FcStrList   *list = FcStrListCreate (lsb->extra);
+        FcChar8     *extra;
+
+        if (list)
+        {
+            while ((extra = FcStrListNext (list)))
+            {
+                if (!FcLangSetContainsLang (lsa, extra))
+                {
+                    break;
+                }
+            }
+            FcStrListDone (list);
+            if (extra)
+                return FcFalse;
+        }
+    }
+    return FcTrue;
+}
+

trunk/poppler/fc-emulate-os2/fontconfig/fcpat.c ¶

@@ -33 +33 @@
   pResult->style = NULL;
   pResult->lang = NULL;
+  pResult->langset = NULL;
   pResult->ref = 1;
   return pResult;
@@ -50 +51 @@
   if (p->lang)
     free(p->lang);
+  if (p->langset)
+    FcLangSetDestroy(p->langset);
   free(p);
 }
@@ -197 +200 @@
 }
 
+fcExport FcResult FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **ls)
+{
+
+  if (id) // we don't support more than one property of the same type
+    return FcResultNoId;
+
+  if (p->langset)
+  {
+    *ls = p->langset;
+    return FcResultMatch;
+  }
+  return FcResultNoMatch;
+}
 
 fcExport FcBool FcPatternAddInteger(FcPattern *p, const char *object, int i)
@@ -305 +321 @@
     }
     p->lang = strdup((const char *)s);
+
+/* as in newer fontconfig also the langset is built we need to do that here also */
+    if (p->langset)
+    {
+      FcLangSetDestroy(p->langset); p->langset = NULL;
+    }
+    p->langset = FcLangSetCreate();
+    if (p->langset)
+    {
+      if (!FcLangSetAdd (p->langset, p->lang))
+         {
+            FcLangSetDestroy(p->langset);
+            p->langset = NULL;
+         }
+
+    }
     return FcTrue;
   }
@@ -487 +519 @@
     if (p->lang)
       pResult->lang = strdup(p->lang);
+    if (p->langset)
+      pResult->langset = FcLangSetCopy(p->langset);
 
     /* this is doubtful, but for now set the reference to 1,

trunk/poppler/fc-emulate-os2/fontconfig/fontconfig.c ¶

@@ -1471 +1471 @@
 }
 
-fcExport int FcStrCmpIgnoreCase(const FcChar8 *s1, const FcChar8 *s2)
-{
-  /* It's actually wrong to use stricmp here, because this doesn't know
-   * anything about UTF-8. But in the original FC package this also just
-   * lowers ASCII characters for comparison, so this should be a good
-   * and simple replacement.
-   */
-  return stricmp((char *)s1, (char *)s2);
-}
-