Print out full pathname in fc-match -v as well. Reported by Frederic

[fontconfig.git] / src / fcname.c

diff --git a/src/fcname.c b/src/fcname.c
index b4d417e2d637cb1fddf35449a80fbbbbdd341f2e..3c902cde625e3fd685eb352ad08e39efd6091d74 100644 (file)
--- a/src/fcname.c
+++ b/src/fcname.c
@@ -29,7 +29,11 @@
 #include "fcint.h"
 
 /* Please do not revoke any of these bindings. */
+/* The __DUMMY__ object enables callers to distinguish the error return
+ * of FcObjectToPtrLookup from FC_FAMILY's FcObjectPtr, which would
+ * otherwise be 0. */
 static const FcObjectType _FcBaseObjectTypes[] = {
+    { "__DUMMY__",      FcTypeVoid, }, 
     { FC_FAMILY,       FcTypeString, },
     { FC_FAMILYLANG,   FcTypeString, },
     { FC_STYLE,                FcTypeString, },
@@ -71,12 +75,14 @@ static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_CAPABILITY,   FcTypeString },
     { FC_FONTFORMAT,   FcTypeString },
     { FC_EMBOLDEN,     FcTypeBool },
+    { FC_EMBEDDED_BITMAP,   FcTypeBool },
 };
 
 #define NUM_OBJECT_TYPES    (sizeof _FcBaseObjectTypes / sizeof _FcBaseObjectTypes[0])
 
 static FcObjectType * _FcUserObjectNames = 0;
 static int user_obj_alloc = 0;
+static int next_basic_offset = NUM_OBJECT_TYPES;
 
 typedef struct _FcObjectTypeList    FcObjectTypeList;
 
@@ -84,12 +90,14 @@ struct _FcObjectTypeList {
     const FcObjectTypeList  *next;
     const FcObjectType     *types;
     int                            ntypes;
+    int                            basic_offset;
 };
 
 static const FcObjectTypeList _FcBaseObjectTypesList = {
     0,
     _FcBaseObjectTypes,
-    NUM_OBJECT_TYPES
+    NUM_OBJECT_TYPES,
+    0
 };
 
 static const FcObjectTypeList  *_FcObjectTypes = &_FcBaseObjectTypesList;
@@ -106,6 +114,8 @@ FcNameRegisterObjectTypes (const FcObjectType *types, int ntypes)
     l->types = types;
     l->ntypes = ntypes;
     l->next = _FcObjectTypes;
+    l->basic_offset = next_basic_offset;
+    next_basic_offset += ntypes;
     _FcObjectTypes = l;
     return FcTrue;
 }
@@ -148,6 +158,9 @@ FcNameGetObjectType (const char *object)
     
     for (l = _FcObjectTypes; l; l = l->next)
     {
+        if (l == (FcObjectTypeList*)_FcUserObjectNames)
+            continue;
+
        for (i = 0; i < l->ntypes; i++)
        {
            t = &l->types[i];
@@ -166,6 +179,8 @@ struct objectBucket {
 };
 static struct objectBucket *FcObjectBuckets[OBJECT_HASH_SIZE];
 
+/* Design constraint: biggest_known_ntypes must never change
+ * after any call to FcNameRegisterObjectTypes. */
 static const FcObjectType *biggest_known_types = _FcBaseObjectTypes; 
 static FcBool allocated_biggest_known_types;
 static int biggest_known_ntypes = NUM_OBJECT_TYPES;
@@ -188,15 +203,15 @@ FcObjectToPtrLookup (const char * object)
            if (!strcmp (object, t->object))
            {
                if (l == (FcObjectTypeList*)_FcUserObjectNames)
-                   return i + biggest_known_ntypes;
+                    return -i;
                else
-                   return i;
+                   return l->basic_offset + i;
            }
        }
     }
 
-    /* We didn't match.  Look for the correct FcObjectTypeList
-     * to replace it in-place. */
+    /* We didn't match.  Look for the application's FcObjectTypeList
+     * and replace it in-place. */
     for (l = _FcObjectTypes; l; l = l->next)
     {
        if (l->types == _FcUserObjectNames)
@@ -210,7 +225,7 @@ FcObjectToPtrLookup (const char * object)
         FcObjectType * t = realloc (_FcUserObjectNames, 
                                    nt * sizeof (FcObjectType));
         if (!t)
-            return -1;
+            return 0;
        _FcUserObjectNames = t;
        user_obj_alloc = nt;
     }
@@ -240,7 +255,7 @@ FcObjectToPtrLookup (const char * object)
     t[n].object = object;
     t[n].type = FcTypeVoid;
 
-    return n+biggest_known_ntypes;
+    return -n;
 }
 
 FcObjectPtr
@@ -256,10 +271,11 @@ FcObjectToPtr (const char * name)
         if (b->hash == hash && !strcmp (name, (char *) (b + 1)))
             return b->id;
     size = sizeof (struct objectBucket) + strlen (name) + 1;
-    b = malloc (size);
-    FcMemAlloc (FC_MEM_STATICSTR, size);
+    /* workaround glibc bug which reads strlen in groups of 4 */
+    b = malloc (size + sizeof (int));
+    FcMemAlloc (FC_MEM_STATICSTR, size + sizeof(int));
     if (!b)
-        return -1;
+        return 0;
     b->next = 0;
     b->hash = hash;
     b->id = FcObjectToPtrLookup (name);
@@ -292,10 +308,22 @@ FcObjectStaticNameFini (void)
 const char *
 FcObjectPtrU (FcObjectPtr si)
 {
-    if (si < biggest_known_ntypes)
-       return biggest_known_types[si].object;
-    else
-       return _FcUserObjectNames[si-biggest_known_ntypes].object;
+    const FcObjectTypeList  *l;
+    int i, j;
+
+    if (si > 0)
+    {
+        if (si < biggest_known_ntypes)
+            return biggest_known_types[si].object;
+
+        j = 0;
+        for (l = _FcObjectTypes; l; l = l->next)
+            for (i = 0; i < l->ntypes; i++, j++)
+                if (j == si)
+                    return l->types[i].object;
+    }
+
+    return _FcUserObjectNames[-si].object;
 }
 
 int
@@ -311,11 +339,19 @@ FcObjectNeededBytes ()
     return num + sizeof(int);
 }
 
+int
+FcObjectNeededBytesAlign (void)
+{
+    return __alignof__ (int) + __alignof__ (char);
+}
+
 void *
 FcObjectDistributeBytes (FcCache * metadata, void * block_ptr)
 {
+    block_ptr = ALIGN (block_ptr, int);
     *(int *)block_ptr = biggest_known_ntypes;
     block_ptr = (int *) block_ptr + 1;
+    block_ptr = ALIGN (block_ptr, char);
     biggest_ptr = block_ptr;
     block_ptr = (char *) block_ptr + biggest_known_count;
     return block_ptr;
@@ -334,10 +370,11 @@ FcObjectSerialize ()
 }
 
 void *
-FcObjectUnserialize (FcCache metadata, void *block_ptr)
+FcObjectUnserialize (FcCache * metadata, void *block_ptr)
 {
     int new_biggest;
     new_biggest = *(int *)block_ptr;
+    block_ptr = ALIGN (block_ptr, int);
     block_ptr = (int *) block_ptr + 1;
     if (biggest_known_ntypes < new_biggest)
     {
@@ -380,16 +417,11 @@ FcObjectUnserialize (FcCache metadata, void *block_ptr)
        biggest_known_ntypes = new_biggest;
        biggest_known_types = (const FcObjectType *)bn;
     }
+    block_ptr = ALIGN (block_ptr, char);
     block_ptr = (char *) block_ptr + biggest_known_count;
     return block_ptr;
 }
 
-int
-FcObjectPtrCompare (const FcObjectPtr a, const FcObjectPtr b)
-{
-    return a - b;
-}
-
 static const FcConstant _FcBaseConstants[] = {
     { (FcChar8 *) "thin",          "weight",   FC_WEIGHT_THIN, },
     { (FcChar8 *) "extralight",            "weight",   FC_WEIGHT_EXTRALIGHT, },
@@ -674,7 +706,7 @@ FcNameParse (const FcChar8 *name)
                for (;;)
                {
                    name = FcNameFindNext (name, ":,", save, &delim);
-                   if (t)
+                   if (t && strcmp (t->object, _FcBaseObjectTypes[0].object))
                    {
                        v = FcNameConvert (t->type, save, &m);
                        if (!FcPatternAdd (pat, t->object, v, FcTrue))
@@ -748,7 +780,6 @@ FcNameUnparseString (FcStrBuf           *buf,
 
 static FcBool
 FcNameUnparseValue (FcStrBuf   *buf,
-                   int         bank,
                    FcValue     *v0,
                    FcChar8     *escape)
 {
@@ -789,7 +820,7 @@ FcNameUnparseValueList (FcStrBuf    *buf,
 {
     while (FcValueListPtrU(v))
     {
-       if (!FcNameUnparseValue (buf, v.bank, &FcValueListPtrU(v)->value, escape))
+       if (!FcNameUnparseValue (buf, &FcValueListPtrU(v)->value, escape))
            return FcFalse;
        if (FcValueListPtrU(v = FcValueListPtrU(v)->next))
            if (!FcNameUnparseString (buf, (FcChar8 *) ",", 0))
@@ -803,6 +834,12 @@ FcNameUnparseValueList (FcStrBuf   *buf,
 
 FcChar8 *
 FcNameUnparse (FcPattern *pat)
+{
+    return FcNameUnparseEscaped (pat, FcTrue);
+}
+
+FcChar8 *
+FcNameUnparseEscaped (FcPattern *pat, FcBool escape)
 {
     FcStrBuf               buf;
     FcChar8                buf_static[8192];
@@ -815,7 +852,7 @@ FcNameUnparse (FcPattern *pat)
     e = FcPatternFindElt (pat, FC_FAMILY);
     if (e)
     {
-       if (!FcNameUnparseValueList (&buf, e->values, (FcChar8 *) FC_ESCAPE_FIXED))
+        if (!FcNameUnparseValueList (&buf, e->values, escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
            goto bail0;
     }
     e = FcPatternFindElt (pat, FC_SIZE);
@@ -823,7 +860,7 @@ FcNameUnparse (FcPattern *pat)
     {
        if (!FcNameUnparseString (&buf, (FcChar8 *) "-", 0))
            goto bail0;
-       if (!FcNameUnparseValueList (&buf, e->values, (FcChar8 *) FC_ESCAPE_FIXED))
+       if (!FcNameUnparseValueList (&buf, e->values, escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
            goto bail0;
     }
     for (l = _FcObjectTypes; l; l = l->next)
@@ -841,12 +878,12 @@ FcNameUnparse (FcPattern *pat)
            {
                if (!FcNameUnparseString (&buf, (FcChar8 *) ":", 0))
                    goto bail0;
-               if (!FcNameUnparseString (&buf, (FcChar8 *) o->object, (FcChar8 *) FC_ESCAPE_VARIABLE))
+               if (!FcNameUnparseString (&buf, (FcChar8 *) o->object, escape ? (FcChar8 *) FC_ESCAPE_VARIABLE : 0))
                    goto bail0;
                if (!FcNameUnparseString (&buf, (FcChar8 *) "=", 0))
                    goto bail0;
-               if (!FcNameUnparseValueList (&buf, e->values, 
-                                            (FcChar8 *) FC_ESCAPE_VARIABLE))
+               if (!FcNameUnparseValueList (&buf, e->values, escape ? 
+                                            (FcChar8 *) FC_ESCAPE_VARIABLE : 0))
                    goto bail0;
            }
        }