Was losing local cached dirs in global cache list

[fontconfig.git] / src / fcname.c

diff --git a/src/fcname.c b/src/fcname.c
index 784171c9e6bcf672f7a1aaac5b204fc7a9f02e10..4c0eb96d4b6cf12761c84ee727e2122f7c4a426a 100644 (file)
--- a/src/fcname.c
+++ b/src/fcname.c
@@ -1,5 +1,5 @@
 /*
- * $XFree86: xc/lib/Fc/xftname.c,v 1.10 2001/03/30 18:50:18 keithp Exp $
+ * $XFree86: xc/lib/fontconfig/src/fcname.c,v 1.13 2002/08/22 07:36:45 keithp Exp $
  *
  * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
  *
@@ -34,17 +34,23 @@ static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_SLANT,                FcTypeInteger, },
     { FC_WEIGHT,       FcTypeInteger, },
     { FC_SIZE,         FcTypeDouble, },
+    { FC_ASPECT,       FcTypeDouble, },
     { FC_PIXEL_SIZE,   FcTypeDouble, },
     { FC_SPACING,      FcTypeInteger, },
     { FC_FOUNDRY,      FcTypeString, },
 /*    { FC_CORE,               FcTypeBool, }, */
     { FC_ANTIALIAS,    FcTypeBool, },
+    { FC_HINTING,      FcTypeBool, },
+    { FC_VERTICAL_LAYOUT,   FcTypeBool, },
+    { FC_AUTOHINT,     FcTypeBool, },
+    { FC_GLOBAL_ADVANCE,    FcTypeBool, },
 /*    { FC_XLFD,               FcTypeString, }, */
     { FC_FILE,         FcTypeString, },
     { FC_INDEX,                FcTypeInteger, },
     { FC_RASTERIZER,   FcTypeString, },
     { FC_OUTLINE,      FcTypeBool, },
     { FC_SCALABLE,     FcTypeBool, },
+    { FC_DPI,          FcTypeDouble },
     { FC_RGBA,         FcTypeInteger, },
     { FC_SCALE,                FcTypeDouble, },
 /*    { FC_RENDER,     FcTypeBool, },*/
@@ -53,7 +59,7 @@ static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_CHAR_HEIGHT,  FcTypeInteger },
     { FC_MATRIX,       FcTypeMatrix },
     { FC_CHARSET,      FcTypeCharSet },
-    { FC_LANG,         FcTypeString },
+    { FC_LANG,         FcTypeLangSet },
 };
 
 #define NUM_OBJECT_TYPES    (sizeof _FcBaseObjectTypes / sizeof _FcBaseObjectTypes[0])
@@ -82,6 +88,7 @@ FcNameRegisterObjectTypes (const FcObjectType *types, int ntypes)
     l = (FcObjectTypeList *) malloc (sizeof (FcObjectTypeList));
     if (!l)
        return FcFalse;
+    FcMemAlloc (FC_MEM_OBJECTTYPE, sizeof (FcObjectTypeList));
     l->types = types;
     l->ntypes = ntypes;
     l->next = _FcObjectTypes;
@@ -101,6 +108,7 @@ FcNameUnregisterObjectTypes (const FcObjectType *types, int ntypes)
        if (l->types == types && l->ntypes == ntypes)
        {
            *prev = l->next;
+           FcMemFree (FC_MEM_OBJECTTYPE, sizeof (FcObjectTypeList));
            free ((void *) l);
            return FcTrue;
        }
@@ -120,7 +128,7 @@ FcNameGetObjectType (const char *object)
        for (i = 0; i < l->ntypes; i++)
        {
            t = &l->types[i];
-           if (!FcStrCmpIgnoreCase ((FcChar8 *) object, (FcChar8 *) t->object))
+           if (!strcmp (object, t->object))
                return t;
        }
     }
@@ -142,6 +150,7 @@ static const FcConstant _FcBaseConstants[] = {
     { (FcChar8 *) "mono",          "spacing",  FC_MONO, },
     { (FcChar8 *) "charcell",      "spacing",  FC_CHARCELL, },
 
+    { (FcChar8 *) "none",          "rgba",         FC_RGBA_NONE },
     { (FcChar8 *) "rgb",           "rgba",         FC_RGBA_RGB, },
     { (FcChar8 *) "bgr",           "rgba",         FC_RGBA_BGR, },
     { (FcChar8 *) "vrgb",          "rgba",         FC_RGBA_VRGB },
@@ -174,6 +183,7 @@ FcNameRegisterConstants (const FcConstant *consts, int nconsts)
     l = (FcConstantList *) malloc (sizeof (FcConstantList));
     if (!l)
        return FcFalse;
+    FcMemAlloc (FC_MEM_CONSTANT, sizeof (FcConstantList));
     l->consts = consts;
     l->nconsts = nconsts;
     l->next = _FcConstants;
@@ -193,6 +203,7 @@ FcNameUnregisterConstants (const FcConstant *consts, int nconsts)
        if (l->consts == consts && l->nconsts == nconsts)
        {
            *prev = l->next;
+           FcMemFree (FC_MEM_CONSTANT, sizeof (FcConstantList));
            free ((void *) l);
            return FcTrue;
        }
@@ -293,6 +304,9 @@ FcNameConvert (FcType type, FcChar8 *string, FcMatrix *m)
     case FcTypeCharSet:
        v.u.c = FcNameParseCharSet (string);
        break;
+    case FcTypeLangSet:
+       v.u.l = FcNameParseLangSet (string);
+       break;
     default:
        break;
     }
@@ -337,6 +351,7 @@ FcNameParse (const FcChar8 *name)
     const FcObjectType *t;
     const FcConstant   *c;
 
+    /* freed below */
     save = malloc (strlen ((char *) name) + 1);
     if (!save)
        goto bail0;
@@ -381,17 +396,33 @@ FcNameParse (const FcChar8 *name)
                for (;;)
                {
                    name = FcNameFindNext (name, ":,", save, &delim);
-                   if (save[0] && t)
+                   if (t)
                    {
                        v = FcNameConvert (t->type, save, &m);
                        if (!FcPatternAdd (pat, t->object, v, FcTrue))
                        {
-                           if (v.type == FcTypeCharSet)
+                           switch (v.type) {
+                           case FcTypeCharSet:
                                FcCharSetDestroy ((FcCharSet *) v.u.c);
+                               break;
+                           case FcTypeLangSet:
+                               FcLangSetDestroy ((FcLangSet *) v.u.l);
+                               break;
+                           default:
+                               break;
+                           }
                            goto bail2;
                        }
-                       if (v.type == FcTypeCharSet)
+                       switch (v.type) {
+                       case FcTypeCharSet:
                            FcCharSetDestroy ((FcCharSet *) v.u.c);
+                           break;
+                       case FcTypeLangSet:
+                           FcLangSetDestroy ((FcLangSet *) v.u.l);
+                           break;
+                       default:
+                           break;
+                       }
                    }
                    if (delim != ',')
                        break;
@@ -418,86 +449,8 @@ bail1:
 bail0:
     return 0;
 }
-
-static void
-FcNameBufInit (FcNameBuf *buf, FcChar8 *init, int size)
-{
-    buf->buf = init;
-    buf->allocated = FcFalse;
-    buf->failed = FcFalse;
-    buf->len = 0;
-    buf->size = size;
-}
-
-static void
-FcNameBufDestroy (FcNameBuf *buf)
-{
-    if (buf->allocated)
-       free (buf->buf);
-}
-
-static FcChar8 *
-FcNameBufDone (FcNameBuf *buf)
-{
-    FcChar8 *ret;
-
-    ret = malloc (buf->len + 1);
-    if (ret)
-    {
-       memcpy (ret, buf->buf, buf->len);
-       ret[buf->len] = '\0';
-    }
-    FcNameBufDestroy (buf);
-    return ret;
-}
-
-FcBool
-FcNameBufChar (FcNameBuf *buf, FcChar8 c)
-{
-    if (buf->len == buf->size)
-    {
-       FcChar8     *new;
-       int         size;
-
-       if (buf->allocated)
-       {
-           size = buf->size * 2;
-           new = realloc (buf->buf, size);
-       }
-       else
-       {
-           size = buf->size + 1024;
-           new = malloc (size);
-           if (new)
-           {
-               buf->allocated = FcTrue;
-               memcpy (new, buf->buf, buf->len);
-           }
-       }
-       if (!new)
-       {
-           buf->failed = FcTrue;
-           return FcFalse;
-       }
-       buf->size = size;
-       buf->buf = new;
-    }
-    buf->buf[buf->len++] = c;
-    return FcTrue;
-}
-
-FcBool
-FcNameBufString (FcNameBuf *buf, const FcChar8 *s)
-{
-    FcChar8 c;
-    while ((c = *s++))
-       if (!FcNameBufChar (buf, c))
-           return FcFalse;
-    return FcTrue;
-}
-
 static FcBool
-FcNameUnparseString (FcNameBuf     *buf, 
+FcNameUnparseString (FcStrBuf      *buf, 
                     const FcChar8  *string,
                     const FcChar8  *escape)
 {
@@ -506,17 +459,17 @@ FcNameUnparseString (FcNameBuf        *buf,
     {
        if (escape && strchr ((char *) escape, (char) c))
        {
-           if (!FcNameBufChar (buf, escape[0]))
+           if (!FcStrBufChar (buf, escape[0]))
                return FcFalse;
        }
-       if (!FcNameBufChar (buf, c))
+       if (!FcStrBufChar (buf, c))
            return FcFalse;
     }
     return FcTrue;
 }
 
 static FcBool
-FcNameUnparseValue (FcNameBuf  *buf,
+FcNameUnparseValue (FcStrBuf   *buf,
                    FcValue     v,
                    FcChar8     *escape)
 {
@@ -541,12 +494,16 @@ FcNameUnparseValue (FcNameBuf     *buf,
        return FcNameUnparseString (buf, temp, 0);
     case FcTypeCharSet:
        return FcNameUnparseCharSet (buf, v.u.c);
+    case FcTypeLangSet:
+       return FcNameUnparseLangSet (buf, v.u.l);
+    case FcTypeFTFace:
+       return FcTrue;
     }
     return FcFalse;
 }
 
 static FcBool
-FcNameUnparseValueList (FcNameBuf      *buf,
+FcNameUnparseValueList (FcStrBuf       *buf,
                        FcValueList     *v,
                        FcChar8         *escape)
 {
@@ -567,21 +524,21 @@ FcNameUnparseValueList (FcNameBuf *buf,
 FcChar8 *
 FcNameUnparse (FcPattern *pat)
 {
-    FcNameBuf              buf;
+    FcStrBuf               buf;
     FcChar8                buf_static[8192];
     int                            i;
     FcPatternElt           *e;
     const FcObjectTypeList  *l;
     const FcObjectType     *o;
 
-    FcNameBufInit (&buf, buf_static, sizeof (buf_static));
-    e = FcPatternFind (pat, FC_FAMILY, FcFalse);
+    FcStrBufInit (&buf, buf_static, sizeof (buf_static));
+    e = FcPatternFindElt (pat, FC_FAMILY);
     if (e)
     {
        if (!FcNameUnparseValueList (&buf, e->values, (FcChar8 *) FC_ESCAPE_FIXED))
            goto bail0;
     }
-    e = FcPatternFind (pat, FC_SIZE, FcFalse);
+    e = FcPatternFindElt (pat, FC_SIZE);
     if (e)
     {
        if (!FcNameUnparseString (&buf, (FcChar8 *) "-", 0))
@@ -599,7 +556,7 @@ FcNameUnparse (FcPattern *pat)
                !strcmp (o->object, FC_FILE))
                continue;
            
-           e = FcPatternFind (pat, o->object, FcFalse);
+           e = FcPatternFindElt (pat, o->object);
            if (e)
            {
                if (!FcNameUnparseString (&buf, (FcChar8 *) ":", 0))
@@ -614,8 +571,8 @@ FcNameUnparse (FcPattern *pat)
            }
        }
     }
-    return FcNameBufDone (&buf);
+    return FcStrBufDone (&buf);
 bail0:
-    FcNameBufDestroy (&buf);
+    FcStrBufDestroy (&buf);
     return 0;
 }