src/fcfs.c

   1 /*
   2  * $RCSId: $
   3  *
   4  * Copyright © 2000 Keith Packard
   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  *
  16  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  18  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  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"
  26 #include <stdlib.h>
  27
  28 FcFontSet *
  29 FcFontSetCreate (void)
  30 {
  31     FcFontSet   *s;
  32
  33     s = (FcFontSet *) malloc (sizeof (FcFontSet));
  34     if (!s)
  35         return 0;
  36     FcMemAlloc (FC_MEM_FONTSET, sizeof (FcFontSet));
  37     s->nfont = 0;
  38     s->sfont = 0;
  39     s->fonts = 0;
  40     return s;
  41 }
  42
  43 void
  44 FcFontSetDestroy (FcFontSet *s)
  45 {
  46     int     i;
  47
  48     for (i = 0; i < s->nfont; i++)
  49         FcPatternDestroy (s->fonts[i]);
  50     if (s->fonts)
  51     {
  52         FcMemFree (FC_MEM_FONTPTR, s->sfont * sizeof (FcPattern *));
  53         free (s->fonts);
  54     }
  55     FcMemFree (FC_MEM_FONTSET, sizeof (FcFontSet));
  56     free (s);
  57 }
  58
  59 FcBool
  60 FcFontSetAdd (FcFontSet *s, FcPattern *font)
  61 {
  62     FcPattern   **f;
  63     int         sfont;
  64
  65     if (s->nfont == s->sfont)
  66     {
  67         sfont = s->sfont + 32;
  68         if (s->fonts)
  69             f = (FcPattern **) realloc (s->fonts, sfont * sizeof (FcPattern *));
  70         else
  71             f = (FcPattern **) malloc (sfont * sizeof (FcPattern *));
  72         if (!f)
  73             return FcFalse;
  74         if (s->sfont)
  75             FcMemFree (FC_MEM_FONTPTR, s->sfont * sizeof (FcPattern *));
  76         FcMemAlloc (FC_MEM_FONTPTR, sfont * sizeof (FcPattern *));
  77         s->sfont = sfont;
  78         s->fonts = f;
  79     }
  80     s->fonts[s->nfont++] = font;
  81     return FcTrue;
  82 }
  83
  84 static int * fcfs_pat_count;
  85
  86 void
  87 FcFontSetNewBank (void)
  88 {
  89     FcPatternNewBank();
  90 }
  91
  92 int
  93 FcFontSetNeededBytes (FcFontSet *s)
  94 {
  95     int i, c, cum = 0;
  96
  97     for (i = 0; i < s->nfont; i++)
  98     {
  99         c = FcPatternNeededBytes(s->fonts[i]);
 100         if (c < 0)
 101             return c;
 102         cum += c;
 103     }
 104
 105     if (cum > 0)
 106         return cum + sizeof(int) + FcObjectNeededBytes();
 107     else
 108         return 0;
 109 }
 110
 111 /* Returns an overestimate of the number of bytes that
 112  * might later get eaten up by padding in the ALIGN macro. */
 113 int
 114 FcFontSetNeededBytesAlign (void)
 115 {
 116     return fc_alignof (int) +
 117         FcPatternNeededBytesAlign () + FcObjectNeededBytesAlign ();
 118 }
 119
 120 void *
 121 FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr)
 122 {
 123     block_ptr = ALIGN (block_ptr, int);
 124     fcfs_pat_count = (int *)block_ptr;
 125     block_ptr = (int *)block_ptr + 1;
 126     /* we don't consume any bytes for the fontset itself, */
 127     /* since we don't allocate it statically. */
 128     block_ptr = FcPatternDistributeBytes (metadata, block_ptr);
 129
 130     /* for good measure, write out the object ids used for */
 131     /* this bank to the file. */
 132     return FcObjectDistributeBytes (metadata, block_ptr);
 133 }
 134
 135 FcBool
 136 FcFontSetSerialize (int bank, FcFontSet * s)
 137 {
 138     int i;
 139     FcPattern * p;
 140     *fcfs_pat_count = s->nfont;
 141
 142     for (i = 0; i < s->nfont; i++)
 143     {
 144         p = FcPatternSerialize (bank, s->fonts[i]);
 145         if (!p) return FcFalse;
 146     }
 147     FcObjectSerialize();
 148
 149     return FcTrue;
 150 }
 151
 152 FcBool
 153 FcFontSetUnserialize(FcCache * metadata, FcFontSet * s, void * block_ptr)
 154 {
 155     int nfont;
 156     int i, n;
 157
 158     block_ptr = ALIGN (block_ptr, int);
 159     nfont = *(int *)block_ptr;
 160     block_ptr = (int *)block_ptr + 1;
 161
 162     /* comparing nfont and metadata.count is a bit like comparing
 163        apples and oranges. Its just for rejecting totally insane
 164        nfont values, and for that its good enough */
 165     if (nfont > 0 && nfont < metadata->count / sizeof(void*))
 166     {
 167         FcPattern * p = (FcPattern *)block_ptr;
 168
 169         if (s->sfont < s->nfont + nfont)
 170         {
 171             int sfont = s->nfont + nfont;
 172             FcPattern ** pp;
 173             pp = realloc (s->fonts, sfont * sizeof (FcPattern));
 174             if (!pp)
 175                 return FcFalse;
 176             s->fonts = pp;
 177             s->sfont = sfont;
 178         }
 179         n = s->nfont;
 180         s->nfont += nfont;
 181
 182         /* The following line is a bit counterintuitive.  The usual
 183          * convention is that FcPatternUnserialize is responsible for
 184          * aligning the FcPattern.  However, the FontSet also stores
 185          * the FcPatterns in its own array, so we need to align here
 186          * too. */
 187         p = ALIGN(p, FcPattern);
 188         for (i = 0; i < nfont; i++)
 189             s->fonts[n + i] = p+i;
 190
 191         block_ptr = FcPatternUnserialize (metadata, block_ptr);
 192         block_ptr = FcObjectUnserialize (metadata, block_ptr);
 193         return block_ptr != 0;
 194     }
 195
 196     return FcFalse;
 197 }