laag-fontconfig 2.13.0.0

data/vendor/anongit.freedesktop.org/git/fontconfig/src/fcfs.c

@@ -0,0 +1,149 @@
+/*
+ * fontconfig/src/fcfs.c
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "fcint.h"
+#include <stdlib.h>
+
+FcFontSet *
+FcFontSetCreate (void)
+{
+    FcFontSet	*s;
+
+    s = (FcFontSet *) malloc (sizeof (FcFontSet));
+    if (!s)
+	return 0;
+    s->nfont = 0;
+    s->sfont = 0;
+    s->fonts = 0;
+    return s;
+}
+
+void
+FcFontSetDestroy (FcFontSet *s)
+{
+    int	    i;
+
+    for (i = 0; i < s->nfont; i++)
+	FcPatternDestroy (s->fonts[i]);
+    if (s->fonts)
+	free (s->fonts);
+    free (s);
+}
+
+FcBool
+FcFontSetAdd (FcFontSet *s, FcPattern *font)
+{
+    FcPattern	**f;
+    int		sfont;
+
+    if (s->nfont == s->sfont)
+    {
+	sfont = s->sfont + 32;
+	if (s->fonts)
+	    f = (FcPattern **) realloc (s->fonts, sfont * sizeof (FcPattern *));
+	else
+	    f = (FcPattern **) malloc (sfont * sizeof (FcPattern *));
+	if (!f)
+	    return FcFalse;
+	s->sfont = sfont;
+	s->fonts = f;
+    }
+    s->fonts[s->nfont++] = font;
+    return FcTrue;
+}
+
+FcBool
+FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s)
+{
+    int i;
+
+    if (!FcSerializeAlloc (serialize, s, sizeof (FcFontSet)))
+	return FcFalse;
+    if (!FcSerializeAlloc (serialize, s->fonts, s->nfont * sizeof (FcPattern *)))
+	return FcFalse;
+    for (i = 0; i < s->nfont; i++)
+    {
+	if (!FcPatternSerializeAlloc (serialize, s->fonts[i]))
+	    return FcFalse;
+    }
+    return FcTrue;
+}
+
+FcFontSet *
+FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s)
+{
+    int		i;
+    FcFontSet	*s_serialize;
+    FcPattern	**fonts_serialize;
+    FcPattern	*p_serialize;
+
+    s_serialize = FcSerializePtr (serialize, s);
+    if (!s_serialize)
+	return NULL;
+    *s_serialize = *s;
+    s_serialize->sfont = s_serialize->nfont;
+
+    fonts_serialize = FcSerializePtr (serialize, s->fonts);
+    if (!fonts_serialize)
+	return NULL;
+    s_serialize->fonts = FcPtrToEncodedOffset (s_serialize,
+					       fonts_serialize, FcPattern *);
+
+    for (i = 0; i < s->nfont; i++)
+    {
+	p_serialize = FcPatternSerialize (serialize, s->fonts[i]);
+	if (!p_serialize)
+	    return NULL;
+	fonts_serialize[i] = FcPtrToEncodedOffset (s_serialize,
+						   p_serialize,
+						   FcPattern);
+    }
+
+    return s_serialize;
+}
+
+FcFontSet *
+FcFontSetDeserialize (const FcFontSet *set)
+{
+    int i;
+    FcFontSet *new = FcFontSetCreate ();
+
+    if (!new)
+	return NULL;
+    for (i = 0; i < set->nfont; i++)
+    {
+	if (!FcFontSetAdd (new, FcPatternDuplicate (FcFontSetFont (set, i))))
+	    goto bail;
+    }
+
+    return new;
+bail:
+    FcFontSetDestroy (new);
+
+    return NULL;
+}
+
+#define __fcfs__
+#include "fcaliastail.h"
+#undef __fcfs__

data/vendor/anongit.freedesktop.org/git/fontconfig/src/fcftint.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2007 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _FCFTINT_H_
+#define _FCFTINT_H_
+
+#include <fontconfig/fcfreetype.h>
+
+#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun)
+#define FcPrivate		__attribute__((__visibility__("hidden")))
+#define HAVE_GNUC_ATTRIBUTE 1
+#include "fcftalias.h"
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define FcPrivate		__hidden
+#else /* not gcc >= 3.3 and not Sun Studio >= 8 */
+#define FcPrivate
+#endif
+
+/* fcfreetype.c */
+FcPrivate FcBool
+FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
+
+FcPrivate FcBool
+FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
+
+FcPrivate FcChar32
+FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
+
+FcPrivate FcChar32
+FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
+
+FcPrivate const FcCharMap *
+FcFreeTypeGetPrivateMap (FT_Encoding encoding);
+
+#endif /* _FCFTINT_H_ */

data/vendor/anongit.freedesktop.org/git/fontconfig/src/fchash.c

@@ -0,0 +1,216 @@
+/*
+ * Copyright © 2000 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+#include "fcint.h"
+#ifndef _WIN32
+#include <uuid/uuid.h>
+#endif
+
+#define FC_HASH_SIZE 227
+
+typedef struct _FcHashBucket {
+    struct _FcHashBucket  *next;
+    void                  *key;
+    void                  *value;
+} FcHashBucket;
+
+struct _FcHashTable {
+    FcHashBucket  *buckets[FC_HASH_SIZE];
+    FcHashFunc     hash_func;
+    FcCompareFunc  compare_func;
+    FcCopyFunc     key_copy_func;
+    FcCopyFunc     value_copy_func;
+    FcDestroyFunc  key_destroy_func;
+    FcDestroyFunc  value_destroy_func;
+};
+
+
+FcBool
+FcHashStrCopy (const void  *src,
+	       void       **dest)
+{
+    *dest = FcStrdup (src);
+
+    return *dest != NULL;
+}
+
+FcBool
+FcHashUuidCopy (const void  *src,
+		void       **dest)
+{
+#ifndef _WIN32
+    *dest = malloc (sizeof (uuid_t));
+    uuid_copy (*dest, src);
+#endif
+    return FcTrue;
+}
+
+void
+FcHashUuidFree (void *data)
+{
+    free (data);
+}
+
+FcHashTable *
+FcHashTableCreate (FcHashFunc    hash_func,
+		   FcCompareFunc compare_func,
+		   FcCopyFunc    key_copy_func,
+		   FcCopyFunc    value_copy_func,
+		   FcDestroyFunc key_destroy_func,
+		   FcDestroyFunc value_destroy_func)
+{
+    FcHashTable *ret = malloc (sizeof (FcHashTable));
+
+    if (ret)
+    {
+	memset (ret->buckets, 0, sizeof (FcHashBucket *) * FC_HASH_SIZE);
+	ret->hash_func = hash_func;
+	ret->compare_func = compare_func;
+	ret->key_copy_func = key_copy_func;
+	ret->value_copy_func = value_copy_func;
+	ret->key_destroy_func = key_destroy_func;
+	ret->value_destroy_func = value_destroy_func;
+    }
+    return ret;
+}
+
+void
+FcHashTableDestroy (FcHashTable *table)
+{
+    int i;
+
+    for (i = 0; i < FC_HASH_SIZE; i++)
+    {
+	FcHashBucket *bucket = table->buckets[i], *prev;
+
+	while (bucket)
+	{
+	    if (table->key_destroy_func)
+		table->key_destroy_func (bucket->key);
+	    if (table->value_destroy_func)
+		table->value_destroy_func (bucket->value);
+	    prev = bucket;
+	    bucket = bucket->next;
+	    free (prev);
+	}
+	table->buckets[i] = NULL;
+    }
+    free (table);
+}
+
+FcBool
+FcHashTableFind (FcHashTable  *table,
+		 const void   *key,
+		 void        **value)
+{
+    FcHashBucket *bucket;
+    FcChar32 hash = table->hash_func (key);
+
+    for (bucket = table->buckets[hash % FC_HASH_SIZE]; bucket; bucket = bucket->next)
+    {
+	if (!table->compare_func(bucket->key, key))
+	{
+	    if (table->value_copy_func)
+	    {
+		if (!table->value_copy_func (bucket->value, value))
+		    return FcFalse;
+	    }
+	    else
+		*value = bucket->value;
+	    return FcTrue;
+	}
+    }
+    return FcFalse;
+}
+
+static FcBool
+FcHashTableAddInternal (FcHashTable *table,
+			void        *key,
+			void        *value,
+			FcBool       replace)
+{
+    FcHashBucket **prev, *bucket, *b;
+    FcChar32 hash = table->hash_func (key);
+    FcBool ret = FcFalse;
+
+    bucket = (FcHashBucket *) malloc (sizeof (FcHashBucket));
+    if (!bucket)
+	return FcFalse;
+    memset (bucket, 0, sizeof (FcHashBucket));
+    if (table->key_copy_func)
+	ret |= !table->key_copy_func (key, &bucket->key);
+    else
+	bucket->key = key;
+    if (table->value_copy_func)
+	ret |= !table->value_copy_func (value, &bucket->value);
+    else
+	bucket->value = value;
+    if (ret)
+    {
+    destroy:
+	if (bucket->key && table->key_destroy_func)
+	    table->key_destroy_func (bucket->key);
+	if (bucket->value && table->value_destroy_func)
+	    table->value_destroy_func (bucket->value);
+	free (bucket);
+
+	return !ret;
+    }
+  retry:
+    for (prev = &table->buckets[hash % FC_HASH_SIZE];
+	 (b = fc_atomic_ptr_get (prev)); prev = &(b->next))
+    {
+	if (!table->compare_func (b->key, key))
+	{
+	    if (replace)
+	    {
+		bucket->next = b->next;
+		if (!fc_atomic_ptr_cmpexch (prev, b, bucket))
+		    goto retry;
+		bucket = b;
+	    }
+	    else
+		ret = FcTrue;
+	    goto destroy;
+	}
+    }
+    bucket->next = NULL;
+    if (!fc_atomic_ptr_cmpexch (prev, b, bucket))
+	goto retry;
+
+    return FcTrue;
+}
+
+FcBool
+FcHashTableAdd (FcHashTable *table,
+		void        *key,
+		void        *value)
+{
+    return FcHashTableAddInternal (table, key, value, FcFalse);
+}
+
+FcBool
+FcHashTableReplace (FcHashTable *table,
+		    void        *key,
+		    void        *value)
+{
+    return FcHashTableAddInternal (table, key, value, FcTrue);
+}

data/vendor/anongit.freedesktop.org/git/fontconfig/src/fcinit.c

@@ -0,0 +1,258 @@
+/*
+ * fontconfig/src/fcinit.c
+ *
+ * Copyright © 2001 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "fcint.h"
+#include <stdlib.h>
+
+#if defined(FC_ATOMIC_INT_NIL)
+#pragma message("Could not find any system to define atomic_int macros, library may NOT be thread-safe.")
+#endif
+#if defined(FC_MUTEX_IMPL_NIL)
+#pragma message("Could not find any system to define mutex macros, library may NOT be thread-safe.")
+#endif
+#if defined(FC_ATOMIC_INT_NIL) || defined(FC_MUTEX_IMPL_NIL)
+#pragma message("To suppress these warnings, define FC_NO_MT.")
+#endif
+
+static FcConfig *
+FcInitFallbackConfig (const FcChar8 *sysroot)
+{
+    FcConfig	*config;
+    const FcChar8 *fallback = (const FcChar8 *) ""	\
+	"<fontconfig>" \
+	"  <dir>" FC_DEFAULT_FONTS "</dir>" \
+	"  <dir prefix=\"xdg\">fonts</dir>" \
+	"  <cachedir>" FC_CACHEDIR "</cachedir>" \
+	"  <cachedir prefix=\"xdg\">fontconfig</cachedir>" \
+	"  <include ignore_missing=\"yes\" prefix=\"xdg\">fontconfig/conf.d</include>" \
+	"  <include ignore_missing=\"yes\" prefix=\"xdg\">fontconfig/fonts.conf</include>" \
+	"</fontconfig>";
+
+    config = FcConfigCreate ();
+    if (!config)
+	goto bail0;
+    FcConfigSetSysRoot (config, sysroot);
+    if (!FcConfigParseAndLoadFromMemory (config, fallback, FcFalse))
+	goto bail1;
+
+    return config;
+
+bail1:
+    FcConfigDestroy (config);
+bail0:
+    return 0;
+}
+
+int
+FcGetVersion (void)
+{
+    return FC_VERSION;
+}
+
+/*
+ * Load the configuration files
+ */
+FcConfig *
+FcInitLoadOwnConfig (FcConfig *config)
+{
+    if (!config)
+    {
+	config = FcConfigCreate ();
+	if (!config)
+	    return NULL;
+    }
+
+    FcInitDebug ();
+
+    if (!FcConfigParseAndLoad (config, 0, FcTrue))
+    {
+	const FcChar8 *sysroot = FcConfigGetSysRoot (config);
+	FcConfig *fallback = FcInitFallbackConfig (sysroot);
+
+	FcConfigDestroy (config);
+
+	return fallback;
+    }
+    (void) FcConfigParseOnly (config, (const FcChar8 *)FC_TEMPLATEDIR, FcFalse);
+
+    if (config->cacheDirs && config->cacheDirs->num == 0)
+    {
+	FcChar8 *prefix, *p;
+	size_t plen;
+	FcBool have_own = FcFalse;
+	char *env_file, *env_path;
+
+	env_file = getenv ("FONTCONFIG_FILE");
+	env_path = getenv ("FONTCONFIG_PATH");
+	if ((env_file != NULL && env_file[0] != 0) ||
+	    (env_path != NULL && env_path[0] != 0))
+	    have_own = FcTrue;
+
+	if (!have_own)
+	{
+	    fprintf (stderr,
+		     "Fontconfig warning: no <cachedir> elements found. Check configuration.\n");
+	    fprintf (stderr,
+		     "Fontconfig warning: adding <cachedir>%s</cachedir>\n",
+		     FC_CACHEDIR);
+	}
+	prefix = FcConfigXdgCacheHome ();
+	if (!prefix)
+	    goto bail;
+	plen = strlen ((const char *)prefix);
+	p = realloc (prefix, plen + 12);
+	if (!p)
+	    goto bail;
+	prefix = p;
+	memcpy (&prefix[plen], FC_DIR_SEPARATOR_S "fontconfig", 11);
+	prefix[plen + 11] = 0;
+	if (!have_own)
+	    fprintf (stderr,
+		     "Fontconfig warning: adding <cachedir prefix=\"xdg\">fontconfig</cachedir>\n");
+
+	if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR) ||
+	    !FcConfigAddCacheDir (config, (FcChar8 *) prefix))
+	{
+	    FcConfig *fallback;
+	    const FcChar8 *sysroot;
+
+	  bail:
+	    sysroot = FcConfigGetSysRoot (config);
+	    fprintf (stderr,
+		     "Fontconfig error: out of memory");
+	    if (prefix)
+		FcStrFree (prefix);
+	    fallback = FcInitFallbackConfig (sysroot);
+	    FcConfigDestroy (config);
+
+	    return fallback;
+	}
+	FcStrFree (prefix);
+    }
+
+    return config;
+}
+
+FcConfig *
+FcInitLoadConfig (void)
+{
+    return FcInitLoadOwnConfig (NULL);
+}
+
+/*
+ * Load the configuration files and scan for available fonts
+ */
+FcConfig *
+FcInitLoadOwnConfigAndFonts (FcConfig *config)
+{
+    config = FcInitLoadOwnConfig (config);
+    if (!config)
+	return 0;
+    if (!FcConfigBuildFonts (config))
+    {
+	FcConfigDestroy (config);
+	return 0;
+    }
+    return config;
+}
+
+FcConfig *
+FcInitLoadConfigAndFonts (void)
+{
+    return FcInitLoadOwnConfigAndFonts (NULL);
+}
+
+/*
+ * Initialize the default library configuration
+ */
+FcBool
+FcInit (void)
+{
+    return FcConfigInit ();
+}
+
+/*
+ * Free all library-allocated data structures.
+ */
+void
+FcFini (void)
+{
+    FcConfigFini ();
+    FcCacheFini ();
+    FcDefaultFini ();
+    FcObjectFini ();
+    FcConfigPathFini ();
+}
+
+/*
+ * Reread the configuration and available font lists
+ */
+FcBool
+FcInitReinitialize (void)
+{
+    FcConfig	*config;
+    FcBool	ret;
+
+    config = FcInitLoadConfigAndFonts ();
+    if (!config)
+	return FcFalse;
+    ret = FcConfigSetCurrent (config);
+    /* FcConfigSetCurrent() increases the refcount.
+     * decrease it here to avoid the memory leak.
+     */
+    FcConfigDestroy (config);
+
+    return ret;
+}
+
+FcBool
+FcInitBringUptoDate (void)
+{
+    FcConfig	*config = FcConfigGetCurrent ();
+    time_t	now;
+
+    if (!config)
+	return FcFalse;
+    /*
+     * rescanInterval == 0 disables automatic up to date
+     */
+    if (config->rescanInterval == 0)
+	return FcTrue;
+    /*
+     * Check no more often than rescanInterval seconds
+     */
+    now = time (0);
+    if (config->rescanTime + config->rescanInterval - now > 0)
+	return FcTrue;
+    /*
+     * If up to date, don't reload configuration
+     */
+    if (FcConfigUptoDate (0))
+	return FcTrue;
+    return FcInitReinitialize ();
+}
+
+#define __fcinit__
+#include "fcaliastail.h"
+#undef __fcinit__