--- a/make/sun/awt/FILES_c_unix.gmk	Thu Aug 18 02:14:45 2011 +0100
+++ b/make/sun/awt/FILES_c_unix.gmk	Wed Aug 24 03:39:33 2011 +0100
@@ -234,3 +234,8 @@
 FILES_NO_MOTIF_c = \
 	cups_fp.c
 endif
+
+ifndef USE_SYSTEM_FONTCONFIG
+FILES_NO_MOTIF_c = \
+	fontconfig_fp.c
+endif

--- a/make/sun/awt/mawt.gmk	Thu Aug 18 02:14:45 2011 +0100
+++ b/make/sun/awt/mawt.gmk	Wed Aug 24 03:39:33 2011 +0100
@@ -103,6 +103,10 @@
 vpath %.cpp $(SHARE_SRC)/native/$(PKGDIR)/image
 vpath %.c   $(PLATFORM_SRC)/native/$(PKGDIR)/robot_child
 
+ifndef USE_SYSTEM_FONTCONFIG
+vpath %.c   $(PLATFORM_SRC)/native/common/deps
+endif
+
 #
 # Libraries to link in.
 #
@@ -182,6 +186,10 @@
 OTHER_LDLIBS += $(JVMLIB) $(LIBCXX) \
                 -lawt $(LIBM) -ldl
 
+ifdef USE_SYSTEM_FONTCONFIG
+  OTHER_LDLIBS += $(FONTCONFIG_LIBS)
+endif
+
 #
 # Sun CC with -Xa misdefines __STDC__ to 0 (zero).
 # The following will force checking of X11 prototypes.
@@ -204,6 +212,12 @@
   LDFLAGS += $(CUPS_LIBS)
 endif
 
+ifdef USE_SYSTEM_FONTCONFIG
+  CPPFLAGS += $(FONTCONFIG_CFLAGS) -DUSE_SYSTEM_FONTCONFIG
+else
+  CPPFLAGS += -I$(PLATFORM_SRC)/native/common/deps
+endif
+
 ifndef HEADLESS
 CPPFLAGS += -I$(OPENWIN_HOME)/include 
 LDFLAGS  += -L$(OPENWIN_LIB)

--- a/make/sun/xawt/FILES_c_unix.gmk	Thu Aug 18 02:14:45 2011 +0100
+++ b/make/sun/xawt/FILES_c_unix.gmk	Wed Aug 24 03:39:33 2011 +0100
@@ -93,3 +93,8 @@
 FILES_c += \
 	cups_fp.c
 endif
+
+ifndef USE_SYSTEM_FONTCONFIG
+FILES_c += \
+	fontconfig_fp.c
+endif

--- a/make/sun/xawt/Makefile	Thu Aug 18 02:14:45 2011 +0100
+++ b/make/sun/xawt/Makefile	Wed Aug 24 03:39:33 2011 +0100
@@ -96,6 +96,10 @@
 vpath %.c   $(PLATFORM_SRC)/native/sun/awt/gtk2
 endif
 
+ifndef USE_SYSTEM_FONTCONFIG
+vpath %.c   $(PLATFORM_SRC)/native/common/deps
+endif
+
 OTHER_LDLIBS = $(LIBM) -lawt -lXext -lX11 -lXrender -ldl \
                    $(LDFLAGS_COMMON) $(AWT_RUNPATH) $(OTHER_LDFLAGS) -lXtst -lXi
 
@@ -107,6 +111,10 @@
   OTHER_LDLIBS += $(CUPS_LIBS)
 endif
 
+ifdef USE_SYSTEM_FONTCONFIG
+  OTHER_LDLIBS += $(FONTCONFIG_LIBS)
+endif
+
 ifeq  ($(PLATFORM), solaris)
 CPPFLAGS += -DFUNCPROTO=15
 dummy := $(shell $(MKDIR) -p $(LIB_LOCATION))
@@ -154,6 +162,12 @@
   CPPFLAGS += -DUSE_SYSTEM_CUPS
 endif
 
+ifdef USE_SYSTEM_FONTCONFIG
+  CPPFLAGS += $(FONTCONFIG_CFLAGS) -DUSE_SYSTEM_FONTCONFIG
+else
+  CPPFLAGS += -I$(PLATFORM_SRC)/native/common/deps
+endif
+
 ifeq ($(PLATFORM), linux)
   ifndef CROSS_COMPILE_ARCH
     # Allows for builds on Debian GNU Linux, X11 is in a different place 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/solaris/native/common/deps/fontconfig/fontconfig.h	Wed Aug 24 03:39:33 2011 +0100
@@ -0,0 +1,302 @@
+/*
+ * $RCSId: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.30 2002/09/26 00:17:27 keithp Exp $
+ *
+ * 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 Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD 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 _FONTCONFIG_H_
+#define _FONTCONFIG_H_
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdarg.h>
+
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#define FC_ATTRIBUTE_SENTINEL(x) __attribute__((__sentinel__(0)))
+#else
+#define FC_ATTRIBUTE_SENTINEL(x)
+#endif
+
+#ifndef FcPublic
+#define FcPublic
+#endif
+
+typedef unsigned char   FcChar8;
+typedef unsigned short  FcChar16;
+typedef unsigned int    FcChar32;
+typedef int             FcBool;
+
+/*
+ * Current Fontconfig version number.  This same number
+ * must appear in the fontconfig configure.in file. Yes,
+ * it'a a pain to synchronize version numbers like this.
+ */
+
+#define FC_MAJOR        2
+#define FC_MINOR        5
+#define FC_REVISION     0
+
+#define FC_VERSION      ((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION))
+
+/*
+ * Current font cache file format version
+ * This is appended to the cache files so that multiple
+ * versions of the library will peacefully coexist
+ *
+ * Change this value whenever the disk format for the cache file
+ * changes in any non-compatible way.  Try to avoid such changes as
+ * it means multiple copies of the font information.
+ */
+
+#define FC_CACHE_VERSION    "2"
+
+#define FcTrue          1
+#define FcFalse         0
+
+#define FC_FAMILY           "family"            /* String */
+#define FC_STYLE            "style"             /* String */
+#define FC_SLANT            "slant"             /* Int */
+#define FC_WEIGHT           "weight"            /* Int */
+#define FC_SIZE             "size"              /* Double */
+#define FC_ASPECT           "aspect"            /* Double */
+#define FC_PIXEL_SIZE       "pixelsize"         /* Double */
+#define FC_SPACING          "spacing"           /* Int */
+#define FC_FOUNDRY          "foundry"           /* String */
+#define FC_ANTIALIAS        "antialias"         /* Bool (depends) */
+#define FC_HINTING          "hinting"           /* Bool (true) */
+#define FC_HINT_STYLE       "hintstyle"         /* Int */
+#define FC_VERTICAL_LAYOUT  "verticallayout"    /* Bool (false) */
+#define FC_AUTOHINT         "autohint"          /* Bool (false) */
+#define FC_GLOBAL_ADVANCE   "globaladvance"     /* Bool (true) */
+#define FC_WIDTH            "width"             /* Int */
+#define FC_FILE             "file"              /* String */
+#define FC_INDEX            "index"             /* Int */
+#define FC_FT_FACE          "ftface"            /* FT_Face */
+#define FC_RASTERIZER       "rasterizer"        /* String */
+#define FC_OUTLINE          "outline"           /* Bool */
+#define FC_SCALABLE         "scalable"          /* Bool */
+#define FC_SCALE            "scale"             /* double */
+#define FC_DPI              "dpi"               /* double */
+#define FC_RGBA             "rgba"              /* Int */
+#define FC_MINSPACE         "minspace"          /* Bool use minimum line spacing */
+#define FC_SOURCE           "source"            /* String (deprecated) */
+#define FC_CHARSET          "charset"           /* CharSet */
+#define FC_LANG             "lang"              /* String RFC 3066 langs */
+#define FC_FONTVERSION      "fontversion"       /* Int from 'head' table */
+#define FC_FULLNAME         "fullname"          /* String */
+#define FC_FAMILYLANG       "familylang"        /* String RFC 3066 langs */
+#define FC_STYLELANG        "stylelang"         /* String RFC 3066 langs */
+#define FC_FULLNAMELANG     "fullnamelang"      /* String RFC 3066 langs */
+#define FC_CAPABILITY       "capability"        /* String */
+#define FC_FONTFORMAT       "fontformat"        /* String */
+#define FC_EMBOLDEN         "embolden"          /* Bool - true if emboldening needed*/
+#define FC_EMBEDDED_BITMAP  "embeddedbitmap"    /* Bool - true to enable embedded bitmaps */
+#define FC_DECORATIVE       "decorative"        /* Bool - true if style is a decorative variant */
+
+#define FC_CACHE_SUFFIX             ".cache-"FC_CACHE_VERSION
+#define FC_DIR_CACHE_FILE           "fonts.cache-"FC_CACHE_VERSION
+#define FC_USER_CACHE_FILE          ".fonts.cache-"FC_CACHE_VERSION
+
+/* Adjust outline rasterizer */
+#define FC_CHAR_WIDTH       "charwidth" /* Int */
+#define FC_CHAR_HEIGHT      "charheight"/* Int */
+#define FC_MATRIX           "matrix"    /* FcMatrix */
+
+#define FC_WEIGHT_THIN              0
+#define FC_WEIGHT_EXTRALIGHT        40
+#define FC_WEIGHT_ULTRALIGHT        FC_WEIGHT_EXTRALIGHT
+#define FC_WEIGHT_LIGHT             50
+#define FC_WEIGHT_BOOK              75
+#define FC_WEIGHT_REGULAR           80
+#define FC_WEIGHT_NORMAL            FC_WEIGHT_REGULAR
+#define FC_WEIGHT_MEDIUM            100
+#define FC_WEIGHT_DEMIBOLD          180
+#define FC_WEIGHT_SEMIBOLD          FC_WEIGHT_DEMIBOLD
+#define FC_WEIGHT_BOLD              200
+#define FC_WEIGHT_EXTRABOLD         205
+#define FC_WEIGHT_ULTRABOLD         FC_WEIGHT_EXTRABOLD
+#define FC_WEIGHT_BLACK             210
+#define FC_WEIGHT_HEAVY             FC_WEIGHT_BLACK
+#define FC_WEIGHT_EXTRABLACK        215
+#define FC_WEIGHT_ULTRABLACK        FC_WEIGHT_EXTRABLACK
+
+#define FC_SLANT_ROMAN              0
+#define FC_SLANT_ITALIC             100
+#define FC_SLANT_OBLIQUE            110
+
+#define FC_WIDTH_ULTRACONDENSED     50
+#define FC_WIDTH_EXTRACONDENSED     63
+#define FC_WIDTH_CONDENSED          75
+#define FC_WIDTH_SEMICONDENSED      87
+#define FC_WIDTH_NORMAL             100
+#define FC_WIDTH_SEMIEXPANDED       113
+#define FC_WIDTH_EXPANDED           125
+#define FC_WIDTH_EXTRAEXPANDED      150
+#define FC_WIDTH_ULTRAEXPANDED      200
+
+#define FC_PROPORTIONAL             0
+#define FC_DUAL                     90
+#define FC_MONO                     100
+#define FC_CHARCELL                 110
+
+/* sub-pixel order */
+#define FC_RGBA_UNKNOWN     0
+#define FC_RGBA_RGB         1
+#define FC_RGBA_BGR         2
+#define FC_RGBA_VRGB        3
+#define FC_RGBA_VBGR        4
+#define FC_RGBA_NONE        5
+
+/* hinting style */
+#define FC_HINT_NONE        0
+#define FC_HINT_SLIGHT      1
+#define FC_HINT_MEDIUM      2
+#define FC_HINT_FULL        3
+
+typedef enum _FcType {
+    FcTypeVoid,
+    FcTypeInteger,
+    FcTypeDouble,
+    FcTypeString,
+    FcTypeBool,
+    FcTypeMatrix,
+    FcTypeCharSet,
+    FcTypeFTFace,
+    FcTypeLangSet
+} FcType;
+
+typedef struct _FcMatrix {
+    double xx, xy, yx, yy;
+} FcMatrix;
+
+#define FcMatrixInit(m) ((m)->xx = (m)->yy = 1, \
+                         (m)->xy = (m)->yx = 0)
+
+/*
+ * A data structure to represent the available glyphs in a font.
+ * This is represented as a sparse boolean btree.
+ */
+
+typedef struct _FcCharSet FcCharSet;
+
+typedef struct _FcObjectType {
+    const char  *object;
+    FcType      type;
+} FcObjectType;
+
+typedef struct _FcConstant {
+    const FcChar8  *name;
+    const char  *object;
+    int         value;
+} FcConstant;
+
+typedef enum _FcResult {
+    FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, FcResultNoId,
+    FcResultOutOfMemory
+} FcResult;
+
+typedef struct _FcPattern   FcPattern;
+
+typedef struct _FcLangSet   FcLangSet;
+
+typedef struct _FcValue {
+    FcType      type;
+    union {
+        const FcChar8   *s;
+        int             i;
+        FcBool          b;
+        double          d;
+        const FcMatrix  *m;
+        const FcCharSet *c;
+        void            *f;
+        const FcLangSet *l;
+    } u;
+} FcValue;
+
+typedef struct _FcFontSet {
+    int         nfont;
+    int         sfont;
+    FcPattern   **fonts;
+} FcFontSet;
+
+typedef struct _FcObjectSet {
+    int         nobject;
+    int         sobject;
+    const char  **objects;
+} FcObjectSet;
+
+typedef enum _FcMatchKind {
+    FcMatchPattern, FcMatchFont, FcMatchScan
+} FcMatchKind;
+
+typedef enum _FcLangResult {
+    FcLangEqual = 0,
+    FcLangDifferentCountry = 1,
+    FcLangDifferentTerritory = 1,
+    FcLangDifferentLang = 2
+} FcLangResult;
+
+typedef enum _FcSetName {
+    FcSetSystem = 0,
+    FcSetApplication = 1
+} FcSetName;
+
+typedef struct _FcAtomic FcAtomic;
+
+#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */
+#define _FCFUNCPROTOBEGIN extern "C" {  /* do not leave open across includes */
+#define _FCFUNCPROTOEND }
+#else
+#define _FCFUNCPROTOBEGIN
+#define _FCFUNCPROTOEND
+#endif
+
+typedef enum { FcEndianBig, FcEndianLittle } FcEndian;
+
+typedef struct _FcConfig    FcConfig;
+
+typedef struct _FcGlobalCache   FcFileCache;
+
+typedef struct _FcBlanks    FcBlanks;
+
+typedef struct _FcStrList   FcStrList;
+
+typedef struct _FcStrSet    FcStrSet;
+
+typedef struct _FcCache     FcCache;
+
+#undef FC_ATTRIBUTE_SENTINEL
+
+
+#ifndef _FCINT_H_
+
+/*
+ * Deprecated functions are placed here to help users fix their code without
+ * digging through documentation
+ */
+
+#define FcConfigGetRescanInverval   FcConfigGetRescanInverval_REPLACE_BY_FcConfigGetRescanInterval
+#define FcConfigSetRescanInverval   FcConfigSetRescanInverval_REPLACE_BY_FcConfigSetRescanInterval
+
+#endif
+
+#endif /* _FONTCONFIG_H_ */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/solaris/native/common/deps/fontconfig_fp.c	Wed Aug 24 03:39:33 2011 +0100
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include <fontconfig_fp.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+void* dlOpenFontConfig() {
+
+    char *homeEnv;
+    static char *homeEnvStr = "HOME="; /* must be static */
+    void* libfontconfig = NULL;
+#ifdef __solaris__
+#define SYSINFOBUFSZ 8
+    char sysinfobuf[SYSINFOBUFSZ];
+#endif
+
+    /* Private workaround to not use fontconfig library.
+     * May be useful during testing/debugging
+     */
+    char *useFC = getenv("USE_J2D_FONTCONFIG");
+    if (useFC != NULL && !strcmp(useFC, "no")) {
+        return NULL;
+    }
+
+#ifdef __solaris__
+    /* fontconfig is likely not properly configured on S8/S9 - skip it,
+     * although allow user to override this behaviour with an env. variable
+     * ie if USE_J2D_FONTCONFIG=yes then we skip this test.
+     * NB "4" is the length of a string which matches our patterns.
+     */
+    if (useFC == NULL || strcmp(useFC, "yes")) {
+        if (sysinfo(SI_RELEASE, sysinfobuf, SYSINFOBUFSZ) == 4) {
+            if ((!strcmp(sysinfobuf, "5.8") || !strcmp(sysinfobuf, "5.9"))) {
+                return NULL;
+            }
+        }
+    }
+#endif
+    /* 64 bit sparc should pick up the right version from the lib path.
+     * New features may be added to libfontconfig, this is expected to
+     * be compatible with old features, but we may need to start
+     * distinguishing the library version, to know whether to expect
+     * certain symbols - and functionality - to be available.
+     * Also add explicit search for .so.1 in case .so symlink doesn't exist.
+     */
+    libfontconfig = dlopen("libfontconfig.so.1", RTLD_LOCAL|RTLD_LAZY);
+    if (libfontconfig == NULL) {
+        libfontconfig = dlopen("libfontconfig.so", RTLD_LOCAL|RTLD_LAZY);
+        if (libfontconfig == NULL) {
+            return NULL;
+        }
+    }
+
+    /* Version 1.0 of libfontconfig crashes if HOME isn't defined in
+     * the environment. This should generally never happen, but we can't
+     * control it, and can't control the version of fontconfig, so iff
+     * its not defined we set it to an empty value which is sufficient
+     * to prevent a crash. I considered unsetting it before exit, but
+     * it doesn't appear to work on Solaris, so I will leave it set.
+     */
+    homeEnv = getenv("HOME");
+    if (homeEnv == NULL) {
+        putenv(homeEnvStr);
+    }
+
+    if (libfontconfig == NULL) {
+        return NULL;
+    }
+
+    PatternBuild     =
+        (FcPatternBuildFuncType)dlsym(libfontconfig, "FcPatternBuild");
+    ObjectSetBuild   =
+        (FcObjectSetFuncType)dlsym(libfontconfig, "FcObjectSetBuild");
+    FontList         =
+        (FcFontListFuncType)dlsym(libfontconfig, "FcFontList");
+    PatternGetString =
+        (FcPatternGetStringFuncType)dlsym(libfontconfig, "FcPatternGetString");
+    StrDirname       =
+        (FcStrDirnameFuncType)dlsym(libfontconfig, "FcStrDirname");
+    PatternDestroy   =
+        (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy");
+    FontSetDestroy   =
+        (FcFontSetDestroyFuncType)dlsym(libfontconfig, "FcFontSetDestroy");
+#if 0
+    Fini             =
+        (FcFiniFuncType)dlsym(libfontconfig, "FcFini");
+#endif
+    NameParse = (FcNameParseFuncType)dlsym(libfontconfig, "FcNameParse");
+    PatternAddString =
+        (FcPatternAddStringFuncType)dlsym(libfontconfig, "FcPatternAddString");
+    ConfigSubstitute =
+        (FcConfigSubstituteFuncType)dlsym(libfontconfig, "FcConfigSubstitute");
+    DefaultSubstitute = (FcDefaultSubstituteFuncType)
+        dlsym(libfontconfig, "FcDefaultSubstitute");
+    FontMatch = (FcFontMatchFuncType)dlsym(libfontconfig, "FcFontMatch");
+    PatternGetBool = (FcPatternGetBoolFuncType)
+        dlsym(libfontconfig, "FcPatternGetBool");
+    PatternGetInteger = (FcPatternGetIntegerFuncType)
+        dlsym(libfontconfig, "FcPatternGetInteger");
+    PatternDestroy =
+        (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy");
+    GetVersion = (FcGetVersionFuncType)dlsym(libfontconfig, "FcGetVersion");
+    PatternGetCharSet =
+        (FcPatternGetCharSetFuncType)dlsym(libfontconfig,
+                                           "FcPatternGetCharSet");
+    FontSort =
+        (FcFontSortFuncType)dlsym(libfontconfig, "FcFontSort");
+    FontSetDestroy =
+        (FcFontSetDestroyFuncType)dlsym(libfontconfig, "FcFontSetDestroy");
+    CharSetUnion =
+        (FcCharSetUnionFuncType)dlsym(libfontconfig, "FcCharSetUnion");
+    CharSetSubtractCount =
+        (FcCharSetSubtractCountFuncType)dlsym(libfontconfig,
+                                              "FcCharSetSubtractCount");
+
+    if (PatternBuild     == NULL ||
+        ObjectSetBuild   == NULL ||
+        PatternGetString == NULL ||
+        FontList         == NULL ||
+        StrDirname       == NULL ||
+        PatternDestroy   == NULL ||
+        FontSetDestroy   == NULL ||
+        NameParse          == NULL ||
+        PatternAddString   == NULL ||
+        ConfigSubstitute   == NULL ||
+        DefaultSubstitute  == NULL ||
+        FontMatch          == NULL ||
+        PatternGetBool     == NULL ||
+        PatternGetInteger  == NULL ||
+        PatternDestroy     == NULL ||
+	GetVersion         == NULL ||
+        PatternGetCharSet  == NULL ||
+        CharSetUnion       == NULL ||
+        GetVersion         == NULL ||
+        CharSetSubtractCount == NULL) {/* problem with the library: return.*/
+        dlCloseFontConfig (libfontconfig);
+        return NULL;
+    }
+
+    /* Optionally get the cache dir locations. This isn't
+     * available until v 2.4.x, but this is OK since on those later versions
+     * we can check the time stamps on the cache dirs to see if we
+     * are out of date. There are a couple of assumptions here. First
+     * that the time stamp on the directory changes when the contents are
+     * updated. Secondly that the locations don't change. The latter is
+     * most likely if a new version of fontconfig is installed, but we also
+     * invalidate the cache if we detect that. Arguably even that is "rare",
+     * and most likely is tied to an OS upgrade which gets a new file anyway.
+     */
+    ConfigGetCacheDirs =
+        (FcConfigGetCacheDirsFuncType)dlsym(libfontconfig,
+                                            "FcConfigGetCacheDirs");
+    StrListNext =
+        (FcStrListNextFuncType)dlsym(libfontconfig, "FcStrListNext");
+    StrListDone =
+        (FcStrListDoneFuncType)dlsym(libfontconfig, "FcStrListDone");
+
+    return libfontconfig;
+}
+
+void dlCloseFontConfig(void* libfontconfig)
+{
+    dlclose(libfontconfig);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/solaris/native/common/deps/fontconfig_fp.h	Wed Aug 24 03:39:33 2011 +0100
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef __FONTCONFIG_FP_H__
+#define __FONTCONFIG_FP_H__
+
+#include <dlfcn.h>
+#ifndef __linux__ /* i.e. is solaris */
+#include <link.h>
+#endif
+
+#include <fontconfig/fontconfig.h>
+
+void* dlOpenFontConfig();
+void dlCloseFontConfig(void *libfontconfig);
+
+typedef void* (FcFiniFuncType)();
+typedef FcConfig* (*FcInitLoadConfigFuncType)();
+typedef FcPattern* (*FcPatternBuildFuncType)(FcPattern *orig, ...);
+typedef FcObjectSet* (*FcObjectSetFuncType)(const char *first, ...);
+typedef FcFontSet* (*FcFontListFuncType)(FcConfig *config,
+                                         FcPattern *p,
+                                         FcObjectSet *os);
+typedef FcResult (*FcPatternGetBoolFuncType)(const FcPattern *p,
+                                               const char *object,
+                                               int n,
+                                               FcBool *b);
+typedef FcResult (*FcPatternGetIntegerFuncType)(const FcPattern *p,
+                                                const char *object,
+                                                int n,
+                                                int *i);
+typedef FcResult (*FcPatternGetStringFuncType)(const FcPattern *p,
+                                               const char *object,
+                                               int n,
+                                               FcChar8 ** s);
+typedef FcChar8* (*FcStrDirnameFuncType)(const FcChar8 *file);
+typedef void (*FcPatternDestroyFuncType)(FcPattern *p);
+typedef void (*FcFontSetDestroyFuncType)(FcFontSet *s);
+typedef FcPattern* (*FcNameParseFuncType)(const FcChar8 *name);
+typedef FcBool (*FcPatternAddStringFuncType)(FcPattern *p,
+                                             const char *object,
+                                             const FcChar8 *s);
+typedef void (*FcDefaultSubstituteFuncType)(FcPattern *p);
+typedef FcBool (*FcConfigSubstituteFuncType)(FcConfig *config,
+                                             FcPattern *p,
+                                             FcMatchKind kind);
+typedef FcPattern* (*FcFontMatchFuncType)(FcConfig *config,
+                                          FcPattern *p,
+                                          FcResult *result);
+typedef FcFontSet* (*FcFontSetCreateFuncType)();
+typedef FcBool (*FcFontSetAddFuncType)(FcFontSet *s, FcPattern *font);
+
+typedef FcResult (*FcPatternGetCharSetFuncType)(FcPattern *p,
+                                                const char *object,
+                                                int n,
+                                                FcCharSet **c);
+typedef FcFontSet* (*FcFontSortFuncType)(FcConfig *config,
+                                         FcPattern *p,
+                                         FcBool trim,
+                                         FcCharSet **csp,
+                                         FcResult *result);
+typedef FcCharSet* (*FcCharSetUnionFuncType)(const FcCharSet *a,
+                                             const FcCharSet *b);
+typedef FcChar32 (*FcCharSetSubtractCountFuncType)(const FcCharSet *a,
+                                                   const FcCharSet *b);
+
+typedef int (*FcGetVersionFuncType)();
+
+typedef FcStrList* (*FcConfigGetCacheDirsFuncType)(FcConfig *config);
+typedef FcChar8* (*FcStrListNextFuncType)(FcStrList *list);
+typedef FcChar8* (*FcStrListDoneFuncType)(FcStrList *list);
+
+FcInitLoadConfigFuncType InitLoadConfig;
+FcPatternBuildFuncType PatternBuild;
+FcObjectSetFuncType ObjectSetBuild;
+FcFontListFuncType FontList;
+FcPatternGetStringFuncType PatternGetString;
+FcStrDirnameFuncType StrDirname;
+FcPatternDestroyFuncType PatternDestroy;
+FcFontSetDestroyFuncType FontSetDestroy;
+FcNameParseFuncType NameParse;
+FcPatternAddStringFuncType PatternAddString;
+FcConfigSubstituteFuncType ConfigSubstitute;
+FcDefaultSubstituteFuncType  DefaultSubstitute;
+FcFontMatchFuncType FontMatch;
+FcPatternGetBoolFuncType PatternGetBool;
+FcPatternGetIntegerFuncType PatternGetInteger;
+FcGetVersionFuncType GetVersion;
+FcPatternGetCharSetFuncType PatternGetCharSet;
+FcFontSortFuncType FontSort;
+FcFontSetDestroyFuncType FontSetDestroy;
+FcCharSetUnionFuncType CharSetUnion;
+FcCharSetSubtractCountFuncType CharSetSubtractCount;
+FcConfigGetCacheDirsFuncType ConfigGetCacheDirs;
+FcStrListNextFuncType StrListNext;
+FcStrListDoneFuncType StrListDone;
+#if 0
+FcFiniFuncType Fini;
+#endif
+
+#define FcPatternBuild (*PatternBuild)
+#define FcObjectSetBuild (*ObjectSetBuild)
+#define FcFontList (*FontList)
+#define FcPatternGetString (*PatternGetString)
+#define FcStrDirname (*StrDirname)
+#define FcFontSetDestroy (*FontSetDestroy)
+#define FcPatternDestroy (*PatternDestroy)
+#define FcNameParse (*NameParse)
+#define FcPatternAddString (*PatternAddString)
+#define FcConfigSubstitute (*ConfigSubstitute)
+#define FcDefaultSubstitute (*DefaultSubstitute)
+#define FcFontMatch (*FontMatch)
+#define FcPatternGetBool (*PatternGetBool)
+#define FcPatternGetInteger (*PatternGetInteger)
+#define FcGetVersion (*GetVersion)
+#define FcStrListNext (*StrListNext)
+#define FcStrListDone (*StrListDone)
+#define FcConfigGetCacheDirs (*ConfigGetCacheDirs)
+#define FcFontSort (*FontSort)
+#define FcPatternGetCharSet (*PatternGetCharSet)
+#define FcCharSetSubtractCount (*CharSetSubtractCount)
+#define FcCharSetUnion (*CharSetUnion)
+
+#endif

--- a/src/solaris/native/sun/awt/fontconfig.h	Thu Aug 18 02:14:45 2011 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,941 +0,0 @@
-/*
- * $RCSId: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.30 2002/09/26 00:17:27 keithp Exp $
- *
- * 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 Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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 _FONTCONFIG_H_
-#define _FONTCONFIG_H_
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <stdarg.h>
-
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#define FC_ATTRIBUTE_SENTINEL(x) __attribute__((__sentinel__(0)))
-#else
-#define FC_ATTRIBUTE_SENTINEL(x)
-#endif
-
-#ifndef FcPublic
-#define FcPublic
-#endif
-
-typedef unsigned char   FcChar8;
-typedef unsigned short  FcChar16;
-typedef unsigned int    FcChar32;
-typedef int             FcBool;
-
-/*
- * Current Fontconfig version number.  This same number
- * must appear in the fontconfig configure.in file. Yes,
- * it'a a pain to synchronize version numbers like this.
- */
-
-#define FC_MAJOR        2
-#define FC_MINOR        5
-#define FC_REVISION     0
-
-#define FC_VERSION      ((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION))
-
-/*
- * Current font cache file format version
- * This is appended to the cache files so that multiple
- * versions of the library will peacefully coexist
- *
- * Change this value whenever the disk format for the cache file
- * changes in any non-compatible way.  Try to avoid such changes as
- * it means multiple copies of the font information.
- */
-
-#define FC_CACHE_VERSION    "2"
-
-#define FcTrue          1
-#define FcFalse         0
-
-#define FC_FAMILY           "family"            /* String */
-#define FC_STYLE            "style"             /* String */
-#define FC_SLANT            "slant"             /* Int */
-#define FC_WEIGHT           "weight"            /* Int */
-#define FC_SIZE             "size"              /* Double */
-#define FC_ASPECT           "aspect"            /* Double */
-#define FC_PIXEL_SIZE       "pixelsize"         /* Double */
-#define FC_SPACING          "spacing"           /* Int */
-#define FC_FOUNDRY          "foundry"           /* String */
-#define FC_ANTIALIAS        "antialias"         /* Bool (depends) */
-#define FC_HINTING          "hinting"           /* Bool (true) */
-#define FC_HINT_STYLE       "hintstyle"         /* Int */
-#define FC_VERTICAL_LAYOUT  "verticallayout"    /* Bool (false) */
-#define FC_AUTOHINT         "autohint"          /* Bool (false) */
-#define FC_GLOBAL_ADVANCE   "globaladvance"     /* Bool (true) */
-#define FC_WIDTH            "width"             /* Int */
-#define FC_FILE             "file"              /* String */
-#define FC_INDEX            "index"             /* Int */
-#define FC_FT_FACE          "ftface"            /* FT_Face */
-#define FC_RASTERIZER       "rasterizer"        /* String */
-#define FC_OUTLINE          "outline"           /* Bool */
-#define FC_SCALABLE         "scalable"          /* Bool */
-#define FC_SCALE            "scale"             /* double */
-#define FC_DPI              "dpi"               /* double */
-#define FC_RGBA             "rgba"              /* Int */
-#define FC_MINSPACE         "minspace"          /* Bool use minimum line spacing */
-#define FC_SOURCE           "source"            /* String (deprecated) */
-#define FC_CHARSET          "charset"           /* CharSet */
-#define FC_LANG             "lang"              /* String RFC 3066 langs */
-#define FC_FONTVERSION      "fontversion"       /* Int from 'head' table */
-#define FC_FULLNAME         "fullname"          /* String */
-#define FC_FAMILYLANG       "familylang"        /* String RFC 3066 langs */
-#define FC_STYLELANG        "stylelang"         /* String RFC 3066 langs */
-#define FC_FULLNAMELANG     "fullnamelang"      /* String RFC 3066 langs */
-#define FC_CAPABILITY       "capability"        /* String */
-#define FC_FONTFORMAT       "fontformat"        /* String */
-#define FC_EMBOLDEN         "embolden"          /* Bool - true if emboldening needed*/
-#define FC_EMBEDDED_BITMAP  "embeddedbitmap"    /* Bool - true to enable embedded bitmaps */
-#define FC_DECORATIVE       "decorative"        /* Bool - true if style is a decorative variant */
-
-#define FC_CACHE_SUFFIX             ".cache-"FC_CACHE_VERSION
-#define FC_DIR_CACHE_FILE           "fonts.cache-"FC_CACHE_VERSION
-#define FC_USER_CACHE_FILE          ".fonts.cache-"FC_CACHE_VERSION
-
-/* Adjust outline rasterizer */
-#define FC_CHAR_WIDTH       "charwidth" /* Int */
-#define FC_CHAR_HEIGHT      "charheight"/* Int */
-#define FC_MATRIX           "matrix"    /* FcMatrix */
-
-#define FC_WEIGHT_THIN              0
-#define FC_WEIGHT_EXTRALIGHT        40
-#define FC_WEIGHT_ULTRALIGHT        FC_WEIGHT_EXTRALIGHT
-#define FC_WEIGHT_LIGHT             50
-#define FC_WEIGHT_BOOK              75
-#define FC_WEIGHT_REGULAR           80
-#define FC_WEIGHT_NORMAL            FC_WEIGHT_REGULAR
-#define FC_WEIGHT_MEDIUM            100
-#define FC_WEIGHT_DEMIBOLD          180
-#define FC_WEIGHT_SEMIBOLD          FC_WEIGHT_DEMIBOLD
-#define FC_WEIGHT_BOLD              200
-#define FC_WEIGHT_EXTRABOLD         205
-#define FC_WEIGHT_ULTRABOLD         FC_WEIGHT_EXTRABOLD
-#define FC_WEIGHT_BLACK             210
-#define FC_WEIGHT_HEAVY             FC_WEIGHT_BLACK
-#define FC_WEIGHT_EXTRABLACK        215
-#define FC_WEIGHT_ULTRABLACK        FC_WEIGHT_EXTRABLACK
-
-#define FC_SLANT_ROMAN              0
-#define FC_SLANT_ITALIC             100
-#define FC_SLANT_OBLIQUE            110
-
-#define FC_WIDTH_ULTRACONDENSED     50
-#define FC_WIDTH_EXTRACONDENSED     63
-#define FC_WIDTH_CONDENSED          75
-#define FC_WIDTH_SEMICONDENSED      87
-#define FC_WIDTH_NORMAL             100
-#define FC_WIDTH_SEMIEXPANDED       113
-#define FC_WIDTH_EXPANDED           125
-#define FC_WIDTH_EXTRAEXPANDED      150
-#define FC_WIDTH_ULTRAEXPANDED      200
-
-#define FC_PROPORTIONAL             0
-#define FC_DUAL                     90
-#define FC_MONO                     100
-#define FC_CHARCELL                 110
-
-/* sub-pixel order */
-#define FC_RGBA_UNKNOWN     0
-#define FC_RGBA_RGB         1
-#define FC_RGBA_BGR         2
-#define FC_RGBA_VRGB        3
-#define FC_RGBA_VBGR        4
-#define FC_RGBA_NONE        5
-
-/* hinting style */
-#define FC_HINT_NONE        0
-#define FC_HINT_SLIGHT      1
-#define FC_HINT_MEDIUM      2
-#define FC_HINT_FULL        3
-
-typedef enum _FcType {
-    FcTypeVoid,
-    FcTypeInteger,
-    FcTypeDouble,
-    FcTypeString,
-    FcTypeBool,
-    FcTypeMatrix,
-    FcTypeCharSet,
-    FcTypeFTFace,
-    FcTypeLangSet
-} FcType;
-
-typedef struct _FcMatrix {
-    double xx, xy, yx, yy;
-} FcMatrix;
-
-#define FcMatrixInit(m) ((m)->xx = (m)->yy = 1, \
-                         (m)->xy = (m)->yx = 0)
-
-/*
- * A data structure to represent the available glyphs in a font.
- * This is represented as a sparse boolean btree.
- */
-
-typedef struct _FcCharSet FcCharSet;
-
-typedef struct _FcObjectType {
-    const char  *object;
-    FcType      type;
-} FcObjectType;
-
-typedef struct _FcConstant {
-    const FcChar8  *name;
-    const char  *object;
-    int         value;
-} FcConstant;
-
-typedef enum _FcResult {
-    FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, FcResultNoId,
-    FcResultOutOfMemory
-} FcResult;
-
-typedef struct _FcPattern   FcPattern;
-
-typedef struct _FcLangSet   FcLangSet;
-
-typedef struct _FcValue {
-    FcType      type;
-    union {
-        const FcChar8   *s;
-        int             i;
-        FcBool          b;
-        double          d;
-        const FcMatrix  *m;
-        const FcCharSet *c;
-        void            *f;
-        const FcLangSet *l;
-    } u;
-} FcValue;
-
-typedef struct _FcFontSet {
-    int         nfont;
-    int         sfont;
-    FcPattern   **fonts;
-} FcFontSet;
-
-typedef struct _FcObjectSet {
-    int         nobject;
-    int         sobject;
-    const char  **objects;
-} FcObjectSet;
-
-typedef enum _FcMatchKind {
-    FcMatchPattern, FcMatchFont, FcMatchScan
-} FcMatchKind;
-
-typedef enum _FcLangResult {
-    FcLangEqual = 0,
-    FcLangDifferentCountry = 1,
-    FcLangDifferentTerritory = 1,
-    FcLangDifferentLang = 2
-} FcLangResult;
-
-typedef enum _FcSetName {
-    FcSetSystem = 0,
-    FcSetApplication = 1
-} FcSetName;
-
-typedef struct _FcAtomic FcAtomic;
-
-#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */
-#define _FCFUNCPROTOBEGIN extern "C" {  /* do not leave open across includes */
-#define _FCFUNCPROTOEND }
-#else
-#define _FCFUNCPROTOBEGIN
-#define _FCFUNCPROTOEND
-#endif
-
-typedef enum { FcEndianBig, FcEndianLittle } FcEndian;
-
-typedef struct _FcConfig    FcConfig;
-
-typedef struct _FcGlobalCache   FcFileCache;
-
-typedef struct _FcBlanks    FcBlanks;
-
-typedef struct _FcStrList   FcStrList;
-
-typedef struct _FcStrSet    FcStrSet;
-
-typedef struct _FcCache     FcCache;
-
-_FCFUNCPROTOBEGIN
-
-/* fcblanks.c */
-FcPublic FcBlanks *
-FcBlanksCreate (void);
-
-FcPublic void
-FcBlanksDestroy (FcBlanks *b);
-
-FcPublic FcBool
-FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);
-
-FcPublic FcBool
-FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);
-
-/* fccache.c */
-
-FcPublic const FcChar8 *
-FcCacheDir(const FcCache *c);
-
-FcPublic FcFontSet *
-FcCacheCopySet(const FcCache *c);
-
-FcPublic const FcChar8 *
-FcCacheSubdir (const FcCache *c, int i);
-
-FcPublic int
-FcCacheNumSubdir (const FcCache *c);
-
-FcPublic int
-FcCacheNumFont (const FcCache *c);
-
-FcPublic FcBool
-FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
-
-FcPublic FcBool
-FcDirCacheValid (const FcChar8 *cache_file);
-
-/* fccfg.c */
-FcPublic FcChar8 *
-FcConfigHome (void);
-
-FcPublic FcBool
-FcConfigEnableHome (FcBool enable);
-
-FcPublic FcChar8 *
-FcConfigFilename (const FcChar8 *url);
-
-FcPublic FcConfig *
-FcConfigCreate (void);
-
-FcPublic void
-FcConfigDestroy (FcConfig *config);
-
-FcPublic FcBool
-FcConfigSetCurrent (FcConfig *config);
-
-FcPublic FcConfig *
-FcConfigGetCurrent (void);
-
-FcPublic FcBool
-FcConfigUptoDate (FcConfig *config);
-
-FcPublic FcBool
-FcConfigBuildFonts (FcConfig *config);
-
-FcPublic FcStrList *
-FcConfigGetFontDirs (FcConfig   *config);
-
-FcPublic FcStrList *
-FcConfigGetConfigDirs (FcConfig   *config);
-
-FcPublic FcStrList *
-FcConfigGetConfigFiles (FcConfig    *config);
-
-FcPublic FcChar8 *
-FcConfigGetCache (FcConfig  *config);
-
-FcPublic FcBlanks *
-FcConfigGetBlanks (FcConfig *config);
-
-FcPublic FcStrList *
-FcConfigGetCacheDirs (FcConfig  *config);
-
-FcPublic int
-FcConfigGetRescanInterval (FcConfig *config);
-
-FcPublic FcBool
-FcConfigSetRescanInterval (FcConfig *config, int rescanInterval);
-
-FcPublic FcFontSet *
-FcConfigGetFonts (FcConfig      *config,
-                  FcSetName     set);
-
-FcPublic FcBool
-FcConfigAppFontAddFile (FcConfig    *config,
-                        const FcChar8  *file);
-
-FcPublic FcBool
-FcConfigAppFontAddDir (FcConfig     *config,
-                       const FcChar8   *dir);
-
-FcPublic void
-FcConfigAppFontClear (FcConfig      *config);
-
-FcPublic FcBool
-FcConfigSubstituteWithPat (FcConfig     *config,
-                           FcPattern    *p,
-                           FcPattern    *p_pat,
-                           FcMatchKind  kind);
-
-FcPublic FcBool
-FcConfigSubstitute (FcConfig    *config,
-                    FcPattern   *p,
-                    FcMatchKind kind);
-
-/* fccharset.c */
-FcPublic FcCharSet*
-FcCharSetCreate (void);
-
-/* deprecated alias for FcCharSetCreate */
-FcPublic FcCharSet *
-FcCharSetNew (void);
-
-FcPublic void
-FcCharSetDestroy (FcCharSet *fcs);
-
-FcPublic FcBool
-FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);
-
-FcPublic FcCharSet*
-FcCharSetCopy (FcCharSet *src);
-
-FcPublic FcBool
-FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);
-
-FcPublic FcCharSet*
-FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);
-
-FcPublic FcCharSet*
-FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);
-
-FcPublic FcCharSet*
-FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);
-
-FcPublic FcBool
-FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);
-
-FcPublic FcChar32
-FcCharSetCount (const FcCharSet *a);
-
-FcPublic FcChar32
-FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);
-
-FcPublic FcChar32
-FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);
-
-FcPublic FcBool
-FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);
-
-#define FC_CHARSET_MAP_SIZE (256/32)
-#define FC_CHARSET_DONE ((FcChar32) -1)
-
-FcPublic FcChar32
-FcCharSetFirstPage (const FcCharSet *a,
-                    FcChar32        map[FC_CHARSET_MAP_SIZE],
-                    FcChar32        *next);
-
-FcPublic FcChar32
-FcCharSetNextPage (const FcCharSet  *a,
-                   FcChar32         map[FC_CHARSET_MAP_SIZE],
-                   FcChar32         *next);
-
-/*
- * old coverage API, rather hard to use correctly
- */
-
-FcPublic FcChar32
-FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
-
-/* fcdbg.c */
-FcPublic void
-FcValuePrint (const FcValue v);
-
-FcPublic void
-FcPatternPrint (const FcPattern *p);
-
-FcPublic void
-FcFontSetPrint (const FcFontSet *s);
-
-/* fcdefault.c */
-FcPublic void
-FcDefaultSubstitute (FcPattern *pattern);
-
-/* fcdir.c */
-FcPublic FcBool
-FcFileIsDir (const FcChar8 *file);
-
-FcPublic FcBool
-FcFileScan (FcFontSet       *set,
-            FcStrSet        *dirs,
-            FcFileCache     *cache,
-            FcBlanks        *blanks,
-            const FcChar8   *file,
-            FcBool          force);
-
-FcPublic FcBool
-FcDirScan (FcFontSet        *set,
-           FcStrSet         *dirs,
-           FcFileCache      *cache,
-           FcBlanks         *blanks,
-           const FcChar8    *dir,
-           FcBool           force);
-
-FcPublic FcBool
-FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
-
-FcPublic FcCache *
-FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file);
-
-FcPublic FcCache *
-FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
-
-FcPublic FcCache *
-FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat);
-
-FcPublic void
-FcDirCacheUnload (FcCache *cache);
-
-/* fcfreetype.c */
-FcPublic FcPattern *
-FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
-
-/* fcfs.c */
-
-FcPublic FcFontSet *
-FcFontSetCreate (void);
-
-FcPublic void
-FcFontSetDestroy (FcFontSet *s);
-
-FcPublic FcBool
-FcFontSetAdd (FcFontSet *s, FcPattern *font);
-
-/* fcinit.c */
-FcPublic FcConfig *
-FcInitLoadConfig (void);
-
-FcPublic FcConfig *
-FcInitLoadConfigAndFonts (void);
-
-FcPublic FcBool
-FcInit (void);
-
-FcPublic void
-FcFini (void);
-
-FcPublic int
-FcGetVersion (void);
-
-FcPublic FcBool
-FcInitReinitialize (void);
-
-FcPublic FcBool
-FcInitBringUptoDate (void);
-
-/* fclang.c */
-FcPublic FcStrSet *
-FcGetLangs (void);
-
-FcPublic const FcCharSet *
-FcLangGetCharSet (const FcChar8 *lang);
-
-FcPublic FcLangSet*
-FcLangSetCreate (void);
-
-FcPublic void
-FcLangSetDestroy (FcLangSet *ls);
-
-FcPublic FcLangSet*
-FcLangSetCopy (const FcLangSet *ls);
-
-FcPublic FcBool
-FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);
-
-FcPublic FcLangResult
-FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);
-
-FcPublic FcLangResult
-FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
-
-FcPublic FcBool
-FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
-
-FcPublic FcBool
-FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
-
-FcPublic FcChar32
-FcLangSetHash (const FcLangSet *ls);
-
-/* fclist.c */
-FcPublic FcObjectSet *
-FcObjectSetCreate (void);
-
-FcPublic FcBool
-FcObjectSetAdd (FcObjectSet *os, const char *object);
-
-FcPublic void
-FcObjectSetDestroy (FcObjectSet *os);
-
-FcPublic FcObjectSet *
-FcObjectSetVaBuild (const char *first, va_list va);
-
-FcPublic FcObjectSet *
-FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL(0);
-
-FcPublic FcFontSet *
-FcFontSetList (FcConfig     *config,
-               FcFontSet    **sets,
-               int          nsets,
-               FcPattern    *p,
-               FcObjectSet  *os);
-
-FcPublic FcFontSet *
-FcFontList (FcConfig    *config,
-            FcPattern   *p,
-            FcObjectSet *os);
-
-/* fcatomic.c */
-
-FcPublic FcAtomic *
-FcAtomicCreate (const FcChar8   *file);
-
-FcPublic FcBool
-FcAtomicLock (FcAtomic *atomic);
-
-FcPublic FcChar8 *
-FcAtomicNewFile (FcAtomic *atomic);
-
-FcPublic FcChar8 *
-FcAtomicOrigFile (FcAtomic *atomic);
-
-FcPublic FcBool
-FcAtomicReplaceOrig (FcAtomic *atomic);
-
-FcPublic void
-FcAtomicDeleteNew (FcAtomic *atomic);
-
-FcPublic void
-FcAtomicUnlock (FcAtomic *atomic);
-
-FcPublic void
-FcAtomicDestroy (FcAtomic *atomic);
-
-/* fcmatch.c */
-FcPublic FcPattern *
-FcFontSetMatch (FcConfig    *config,
-                FcFontSet   **sets,
-                int         nsets,
-                FcPattern   *p,
-                FcResult    *result);
-
-FcPublic FcPattern *
-FcFontMatch (FcConfig   *config,
-             FcPattern  *p,
-             FcResult   *result);
-
-FcPublic FcPattern *
-FcFontRenderPrepare (FcConfig       *config,
-                     FcPattern      *pat,
-                     FcPattern      *font);
-
-FcPublic FcFontSet *
-FcFontSetSort (FcConfig     *config,
-               FcFontSet    **sets,
-               int          nsets,
-               FcPattern    *p,
-               FcBool       trim,
-               FcCharSet    **csp,
-               FcResult     *result);
-
-FcPublic FcFontSet *
-FcFontSort (FcConfig     *config,
-            FcPattern    *p,
-            FcBool       trim,
-            FcCharSet    **csp,
-            FcResult     *result);
-
-FcPublic void
-FcFontSetSortDestroy (FcFontSet *fs);
-
-/* fcmatrix.c */
-FcPublic FcMatrix *
-FcMatrixCopy (const FcMatrix *mat);
-
-FcPublic FcBool
-FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);
-
-FcPublic void
-FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);
-
-FcPublic void
-FcMatrixRotate (FcMatrix *m, double c, double s);
-
-FcPublic void
-FcMatrixScale (FcMatrix *m, double sx, double sy);
-
-FcPublic void
-FcMatrixShear (FcMatrix *m, double sh, double sv);
-
-/* fcname.c */
-
-FcPublic FcBool
-FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);
-
-FcPublic FcBool
-FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
-
-FcPublic const FcObjectType *
-FcNameGetObjectType (const char *object);
-
-FcPublic FcBool
-FcNameRegisterConstants (const FcConstant *consts, int nconsts);
-
-FcPublic FcBool
-FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
-
-FcPublic const FcConstant *
-FcNameGetConstant (FcChar8 *string);
-
-FcPublic FcBool
-FcNameConstant (FcChar8 *string, int *result);
-
-FcPublic FcPattern *
-FcNameParse (const FcChar8 *name);
-
-FcPublic FcChar8 *
-FcNameUnparse (FcPattern *pat);
-
-/* fcpat.c */
-FcPublic FcPattern *
-FcPatternCreate (void);
-
-FcPublic FcPattern *
-FcPatternDuplicate (const FcPattern *p);
-
-FcPublic void
-FcPatternReference (FcPattern *p);
-
-FcPublic void
-FcValueDestroy (FcValue v);
-
-FcPublic FcBool
-FcValueEqual (FcValue va, FcValue vb);
-
-FcPublic FcValue
-FcValueSave (FcValue v);
-
-FcPublic void
-FcPatternDestroy (FcPattern *p);
-
-FcPublic FcBool
-FcPatternEqual (const FcPattern *pa, const FcPattern *pb);
-
-FcPublic FcBool
-FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);
-
-FcPublic FcChar32
-FcPatternHash (const FcPattern *p);
-
-FcPublic FcBool
-FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
-
-FcPublic FcBool
-FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
-
-FcPublic FcResult
-FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
-
-FcPublic FcBool
-FcPatternDel (FcPattern *p, const char *object);
-
-FcPublic FcBool
-FcPatternRemove (FcPattern *p, const char *object, int id);
-
-FcPublic FcBool
-FcPatternAddInteger (FcPattern *p, const char *object, int i);
-
-FcPublic FcBool
-FcPatternAddDouble (FcPattern *p, const char *object, double d);
-
-FcPublic FcBool
-FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
-
-FcPublic FcBool
-FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);
-
-FcPublic FcBool
-FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);
-
-FcPublic FcBool
-FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
-
-FcPublic FcBool
-FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
-
-FcPublic FcResult
-FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);
-
-FcPublic FcResult
-FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d);
-
-FcPublic FcResult
-FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 ** s);
-
-FcPublic FcResult
-FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s);
-
-FcPublic FcResult
-FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c);
-
-FcPublic FcResult
-FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);
-
-FcPublic FcResult
-FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);
-
-FcPublic FcPattern *
-FcPatternVaBuild (FcPattern *orig, va_list va);
-
-FcPublic FcPattern *
-FcPatternBuild (FcPattern *orig, ...) FC_ATTRIBUTE_SENTINEL(0);
-
-/* fcstr.c */
-
-FcPublic FcChar8 *
-FcStrCopy (const FcChar8 *s);
-
-FcPublic FcChar8 *
-FcStrCopyFilename (const FcChar8 *s);
-
-FcPublic FcChar8 *
-FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
-
-FcPublic void
-FcStrFree (FcChar8 *s);
-
-/* These are ASCII only, suitable only for pattern element names */
-#define FcIsUpper(c)    ((0101 <= (c) && (c) <= 0132))
-#define FcIsLower(c)    ((0141 <= (c) && (c) <= 0172))
-#define FcToLower(c)    (FcIsUpper(c) ? (c) - 0101 + 0141 : (c))
-
-FcPublic FcChar8 *
-FcStrDowncase (const FcChar8 *s);
-
-FcPublic int
-FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
-
-FcPublic int
-FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);
-
-FcPublic const FcChar8 *
-FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
-
-FcPublic const FcChar8 *
-FcStrStr (const FcChar8 *s1, const FcChar8 *s2);
-
-FcPublic int
-FcUtf8ToUcs4 (const FcChar8 *src_orig,
-              FcChar32      *dst,
-              int           len);
-
-FcPublic FcBool
-FcUtf8Len (const FcChar8    *string,
-           int              len,
-           int              *nchar,
-           int              *wchar);
-
-#define FC_UTF8_MAX_LEN 6
-
-FcPublic int
-FcUcs4ToUtf8 (FcChar32  ucs4,
-              FcChar8   dest[FC_UTF8_MAX_LEN]);
-
-FcPublic int
-FcUtf16ToUcs4 (const FcChar8    *src_orig,
-               FcEndian         endian,
-               FcChar32         *dst,
-               int              len);       /* in bytes */
-
-FcPublic FcBool
-FcUtf16Len (const FcChar8   *string,
-            FcEndian        endian,
-            int             len,            /* in bytes */
-            int             *nchar,
-            int             *wchar);
-
-FcPublic FcChar8 *
-FcStrDirname (const FcChar8 *file);
-
-FcPublic FcChar8 *
-FcStrBasename (const FcChar8 *file);
-
-FcPublic FcStrSet *
-FcStrSetCreate (void);
-
-FcPublic FcBool
-FcStrSetMember (FcStrSet *set, const FcChar8 *s);
-
-FcPublic FcBool
-FcStrSetEqual (FcStrSet *sa, FcStrSet *sb);
-
-FcPublic FcBool
-FcStrSetAdd (FcStrSet *set, const FcChar8 *s);
-
-FcPublic FcBool
-FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s);
-
-FcPublic FcBool
-FcStrSetDel (FcStrSet *set, const FcChar8 *s);
-
-FcPublic void
-FcStrSetDestroy (FcStrSet *set);
-
-FcPublic FcStrList *
-FcStrListCreate (FcStrSet *set);
-
-FcPublic FcChar8 *
-FcStrListNext (FcStrList *list);
-
-FcPublic void
-FcStrListDone (FcStrList *list);
-
-/* fcxml.c */
-FcPublic FcBool
-FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
-
-_FCFUNCPROTOEND
-
-#undef FC_ATTRIBUTE_SENTINEL
-
-
-#ifndef _FCINT_H_
-
-/*
- * Deprecated functions are placed here to help users fix their code without
- * digging through documentation
- */
-
-#define FcConfigGetRescanInverval   FcConfigGetRescanInverval_REPLACE_BY_FcConfigGetRescanInterval
-#define FcConfigSetRescanInverval   FcConfigSetRescanInverval_REPLACE_BY_FcConfigSetRescanInterval
-
-#endif
-
-#endif /* _FONTCONFIG_H_ */

--- a/src/solaris/native/sun/awt/fontpath.c	Thu Aug 18 02:14:45 2011 +0100
+++ b/src/solaris/native/sun/awt/fontpath.c	Wed Aug 24 03:39:33 2011 +0100
@@ -58,6 +58,9 @@
 extern Display *awt_display;
 #endif /* !HEADLESS */
 
+#ifndef USE_SYSTEM_FONTCONFIG
+#include <fontconfig_fp.h>
+#endif
 
 #define MAXFDIRS 512    /* Max number of directories that contain fonts */
 
@@ -546,78 +549,16 @@
     return ret;
 }
 
-#include <dlfcn.h>
-#ifndef __linux__ /* i.e. is solaris */
-#include <link.h>
-#endif
-
-#include "fontconfig.h"
-
+#include <fontconfig/fontconfig.h>
 
 static void* openFontConfig() {
-
-    char *homeEnv;
-    static char *homeEnvStr = "HOME="; /* must be static */
-    void* libfontconfig = NULL;
-#ifdef __solaris__
-#define SYSINFOBUFSZ 8
-    char sysinfobuf[SYSINFOBUFSZ];
-#endif
-
-    /* Private workaround to not use fontconfig library.
-     * May be useful during testing/debugging
-     */
-    char *useFC = getenv("USE_J2D_FONTCONFIG");
-    if (useFC != NULL && !strcmp(useFC, "no")) {
-        return NULL;
-    }
-
-#ifdef __solaris__
-    /* fontconfig is likely not properly configured on S8/S9 - skip it,
-     * although allow user to override this behaviour with an env. variable
-     * ie if USE_J2D_FONTCONFIG=yes then we skip this test.
-     * NB "4" is the length of a string which matches our patterns.
-     */
-    if (useFC == NULL || strcmp(useFC, "yes")) {
-        if (sysinfo(SI_RELEASE, sysinfobuf, SYSINFOBUFSZ) == 4) {
-            if ((!strcmp(sysinfobuf, "5.8") || !strcmp(sysinfobuf, "5.9"))) {
-                return NULL;
-            }
-        }
-    }
+#ifdef USE_SYSTEM_FONTCONFIG
+    return NULL;
+#else
+    return dlOpenFontConfig();
 #endif
-    /* 64 bit sparc should pick up the right version from the lib path.
-     * New features may be added to libfontconfig, this is expected to
-     * be compatible with old features, but we may need to start
-     * distinguishing the library version, to know whether to expect
-     * certain symbols - and functionality - to be available.
-     * Also add explicit search for .so.1 in case .so symlink doesn't exist.
-     */
-    libfontconfig = dlopen("libfontconfig.so.1", RTLD_LOCAL|RTLD_LAZY);
-    if (libfontconfig == NULL) {
-        libfontconfig = dlopen("libfontconfig.so", RTLD_LOCAL|RTLD_LAZY);
-        if (libfontconfig == NULL) {
-            return NULL;
-        }
-    }
-
-    /* Version 1.0 of libfontconfig crashes if HOME isn't defined in
-     * the environment. This should generally never happen, but we can't
-     * control it, and can't control the version of fontconfig, so iff
-     * its not defined we set it to an empty value which is sufficient
-     * to prevent a crash. I considered unsetting it before exit, but
-     * it doesn't appear to work on Solaris, so I will leave it set.
-     */
-    homeEnv = getenv("HOME");
-    if (homeEnv == NULL) {
-        putenv(homeEnvStr);
-    }
-
-    return libfontconfig;
 }
 
-typedef void* (FcFiniFuncType)();
-
 static void closeFontConfig(void* libfontconfig, jboolean fcFini) {
 
   /* NB FcFini is not in (eg) the Solaris 10 version of fontconfig. Its not
@@ -629,83 +570,23 @@
    */
 #if 0
     if (fcFini) { /* release resources */
-        FcFiniFuncType FcFini = (FcFiniFuncType)dlsym(libfontconfig, "FcFini");
 
         if (FcFini != NULL) {
             (*FcFini)();
         }
     }
 #endif
-    dlclose(libfontconfig);
+
+#ifndef USE_SYSTEM_FONTCONFIG
+    dlCloseFontConfig (libfontconfig);
+#endif
 }
 
-typedef FcConfig* (*FcInitLoadConfigFuncType)();
-typedef FcPattern* (*FcPatternBuildFuncType)(FcPattern *orig, ...);
-typedef FcObjectSet* (*FcObjectSetFuncType)(const char *first, ...);
-typedef FcFontSet* (*FcFontListFuncType)(FcConfig *config,
-                                         FcPattern *p,
-                                         FcObjectSet *os);
-typedef FcResult (*FcPatternGetBoolFuncType)(const FcPattern *p,
-                                               const char *object,
-                                               int n,
-                                               FcBool *b);
-typedef FcResult (*FcPatternGetIntegerFuncType)(const FcPattern *p,
-                                                const char *object,
-                                                int n,
-                                                int *i);
-typedef FcResult (*FcPatternGetStringFuncType)(const FcPattern *p,
-                                               const char *object,
-                                               int n,
-                                               FcChar8 ** s);
-typedef FcChar8* (*FcStrDirnameFuncType)(const FcChar8 *file);
-typedef void (*FcPatternDestroyFuncType)(FcPattern *p);
-typedef void (*FcFontSetDestroyFuncType)(FcFontSet *s);
-typedef FcPattern* (*FcNameParseFuncType)(const FcChar8 *name);
-typedef FcBool (*FcPatternAddStringFuncType)(FcPattern *p,
-                                             const char *object,
-                                             const FcChar8 *s);
-typedef void (*FcDefaultSubstituteFuncType)(FcPattern *p);
-typedef FcBool (*FcConfigSubstituteFuncType)(FcConfig *config,
-                                             FcPattern *p,
-                                             FcMatchKind kind);
-typedef FcPattern* (*FcFontMatchFuncType)(FcConfig *config,
-                                          FcPattern *p,
-                                          FcResult *result);
-typedef FcFontSet* (*FcFontSetCreateFuncType)();
-typedef FcBool (*FcFontSetAddFuncType)(FcFontSet *s, FcPattern *font);
-
-typedef FcResult (*FcPatternGetCharSetFuncType)(FcPattern *p,
-                                                const char *object,
-                                                int n,
-                                                FcCharSet **c);
-typedef FcFontSet* (*FcFontSortFuncType)(FcConfig *config,
-                                         FcPattern *p,
-                                         FcBool trim,
-                                         FcCharSet **csp,
-                                         FcResult *result);
-typedef FcCharSet* (*FcCharSetUnionFuncType)(const FcCharSet *a,
-                                             const FcCharSet *b);
-typedef FcChar32 (*FcCharSetSubtractCountFuncType)(const FcCharSet *a,
-                                                   const FcCharSet *b);
-
-typedef int (*FcGetVersionFuncType)();
-
-typedef FcStrList* (*FcConfigGetCacheDirsFuncType)(FcConfig *config);
-typedef FcChar8* (*FcStrListNextFuncType)(FcStrList *list);
-typedef FcChar8* (*FcStrListDoneFuncType)(FcStrList *list);
 
 static char **getFontConfigLocations() {
 
     char **fontdirs;
     int numdirs = 0;
-    FcInitLoadConfigFuncType FcInitLoadConfig;
-    FcPatternBuildFuncType FcPatternBuild;
-    FcObjectSetFuncType FcObjectSetBuild;
-    FcFontListFuncType FcFontList;
-    FcPatternGetStringFuncType FcPatternGetString;
-    FcStrDirnameFuncType FcStrDirname;
-    FcPatternDestroyFuncType FcPatternDestroy;
-    FcFontSetDestroyFuncType FcFontSetDestroy;
 
     FcConfig *fontconfig;
     FcPattern *pattern;
@@ -718,36 +599,6 @@
 
     void* libfontconfig = openFontConfig();
 
-    if (libfontconfig == NULL) {
-        return NULL;
-    }
-
-    FcPatternBuild     =
-        (FcPatternBuildFuncType)dlsym(libfontconfig, "FcPatternBuild");
-    FcObjectSetBuild   =
-        (FcObjectSetFuncType)dlsym(libfontconfig, "FcObjectSetBuild");
-    FcFontList         =
-        (FcFontListFuncType)dlsym(libfontconfig, "FcFontList");
-    FcPatternGetString =
-        (FcPatternGetStringFuncType)dlsym(libfontconfig, "FcPatternGetString");
-    FcStrDirname       =
-        (FcStrDirnameFuncType)dlsym(libfontconfig, "FcStrDirname");
-    FcPatternDestroy   =
-        (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy");
-    FcFontSetDestroy   =
-        (FcFontSetDestroyFuncType)dlsym(libfontconfig, "FcFontSetDestroy");
-
-    if (FcPatternBuild     == NULL ||
-        FcObjectSetBuild   == NULL ||
-        FcPatternGetString == NULL ||
-        FcFontList         == NULL ||
-        FcStrDirname       == NULL ||
-        FcPatternDestroy   == NULL ||
-        FcFontSetDestroy   == NULL) { /* problem with the library: return. */
-        closeFontConfig(libfontconfig, JNI_FALSE);
-        return NULL;
-    }
-
     /* Make calls into the fontconfig library to build a search for
      * outline fonts, and to get the set of full file paths from the matches.
      * This set is returned from the call to FcFontList(..)
@@ -761,16 +612,16 @@
      * Finally we clean up, freeing allocated resources, and return the
      * array of unique directories.
      */
-    pattern = (*FcPatternBuild)(NULL, FC_OUTLINE, FcTypeBool, FcTrue, NULL);
-    objset = (*FcObjectSetBuild)(FC_FILE, NULL);
-    fontSet = (*FcFontList)(NULL, pattern, objset);
+    pattern = FcPatternBuild (NULL, FC_OUTLINE, FcTypeBool, FcTrue, NULL);
+    objset = FcObjectSetBuild (FC_FILE, NULL);
+    fontSet = FcFontList (NULL, pattern, objset);
     fontdirs = (char**)calloc(fontSet->nfont+1, sizeof(char*));
     for (f=0; f < fontSet->nfont; f++) {
         FcChar8 *file;
         FcChar8 *dir;
-        if ((*FcPatternGetString)(fontSet->fonts[f], FC_FILE, 0, &file) ==
+        if (FcPatternGetString (fontSet->fonts[f], FC_FILE, 0, &file) ==
                                   FcResultMatch) {
-            dir = (*FcStrDirname)(file);
+            dir = FcStrDirname (file);
             found = 0;
             for (i=0;i<numdirs; i++) {
                 if (strcmp(fontdirs[i], (char*)dir) == 0) {
@@ -787,8 +638,8 @@
     }
 
     /* Free memory and close the ".so" */
-    (*FcFontSetDestroy)(fontSet);
-    (*FcPatternDestroy)(pattern);
+    FcFontSetDestroy (fontSet);
+    FcPatternDestroy (pattern);
     closeFontConfig(libfontconfig, JNI_TRUE);
     return fontdirs;
 }
@@ -807,15 +658,6 @@
 Java_sun_font_FontConfigManager_getFontConfigAASettings
 (JNIEnv *env, jclass obj, jstring localeStr, jstring fcNameStr) {
 
-    FcNameParseFuncType FcNameParse;
-    FcPatternAddStringFuncType FcPatternAddString;
-    FcConfigSubstituteFuncType FcConfigSubstitute;
-    FcDefaultSubstituteFuncType  FcDefaultSubstitute;
-    FcFontMatchFuncType FcFontMatch;
-    FcPatternGetBoolFuncType FcPatternGetBool;
-    FcPatternGetIntegerFuncType FcPatternGetInteger;
-    FcPatternDestroyFuncType FcPatternDestroy;
-
     FcPattern *pattern, *matchPattern;
     FcResult result;
     FcBool antialias = FcFalse;
@@ -833,6 +675,7 @@
     }
     locale = (*env)->GetStringUTFChars(env, localeStr, 0);
 
+#ifndef USE_SYSTEM_FONTCONFIG
     if ((libfontconfig = openFontConfig()) == NULL) {
         (*env)->ReleaseStringUTFChars (env, fcNameStr, (const char*)fcName);
         if (locale) {
@@ -840,57 +683,25 @@
         }
         return -1;
     }
-
-    FcNameParse = (FcNameParseFuncType)dlsym(libfontconfig, "FcNameParse");
-    FcPatternAddString =
-        (FcPatternAddStringFuncType)dlsym(libfontconfig, "FcPatternAddString");
-    FcConfigSubstitute =
-        (FcConfigSubstituteFuncType)dlsym(libfontconfig, "FcConfigSubstitute");
-    FcDefaultSubstitute = (FcDefaultSubstituteFuncType)
-        dlsym(libfontconfig, "FcDefaultSubstitute");
-    FcFontMatch = (FcFontMatchFuncType)dlsym(libfontconfig, "FcFontMatch");
-    FcPatternGetBool = (FcPatternGetBoolFuncType)
-        dlsym(libfontconfig, "FcPatternGetBool");
-    FcPatternGetInteger = (FcPatternGetIntegerFuncType)
-        dlsym(libfontconfig, "FcPatternGetInteger");
-    FcPatternDestroy =
-        (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy");
+#endif
 
-    if (FcNameParse          == NULL ||
-        FcPatternAddString   == NULL ||
-        FcConfigSubstitute   == NULL ||
-        FcDefaultSubstitute  == NULL ||
-        FcFontMatch          == NULL ||
-        FcPatternGetBool     == NULL ||
-        FcPatternGetInteger  == NULL ||
-        FcPatternDestroy     == NULL) { /* problem with the library: return. */
-
-        (*env)->ReleaseStringUTFChars (env, fcNameStr, (const char*)fcName);
-        if (locale) {
-            (*env)->ReleaseStringUTFChars (env, localeStr,(const char*)locale);
-        }
-        closeFontConfig(libfontconfig, JNI_FALSE);
-        return -1;
+    pattern = FcNameParse ((FcChar8 *)fcName);
+    if (locale != NULL) {
+        FcPatternAddString (pattern, FC_LANG, (unsigned char*)locale);
     }
-
-
-    pattern = (*FcNameParse)((FcChar8 *)fcName);
-    if (locale != NULL) {
-        (*FcPatternAddString)(pattern, FC_LANG, (unsigned char*)locale);
-    }
-    (*FcConfigSubstitute)(NULL, pattern, FcMatchPattern);
-    (*FcDefaultSubstitute)(pattern);
-    matchPattern = (*FcFontMatch)(NULL, pattern, &result);
+    FcConfigSubstitute (NULL, pattern, FcMatchPattern);
+    FcDefaultSubstitute (pattern);
+    matchPattern = FcFontMatch (NULL, pattern, &result);
     /* Perhaps should call FcFontRenderPrepare() here as some pattern
      * elements might change as a result of that call, but I'm not seeing
      * any difference in testing.
      */
     if (matchPattern) {
-        (*FcPatternGetBool)(matchPattern, FC_ANTIALIAS, 0, &antialias);
-        (*FcPatternGetInteger)(matchPattern, FC_RGBA, 0, &rgba);
-        (*FcPatternDestroy)(matchPattern);
+        FcPatternGetBool (matchPattern, FC_ANTIALIAS, 0, &antialias);
+        FcPatternGetInteger (matchPattern, FC_RGBA, 0, &rgba);
+        FcPatternDestroy (matchPattern);
     }
-    (*FcPatternDestroy)(pattern);
+    FcPatternDestroy (pattern);
 
     (*env)->ReleaseStringUTFChars (env, fcNameStr, (const char*)fcName);
     if (locale) {
@@ -918,20 +729,15 @@
     (JNIEnv *env, jclass obj) {
 
     void* libfontconfig;
-    FcGetVersionFuncType FcGetVersion;
     int version = 0;
 
+#ifndef USE_SYSTEM_FONTCONFIG
     if ((libfontconfig = openFontConfig()) == NULL) {
         return 0;
     }
-
-    FcGetVersion = (FcGetVersionFuncType)dlsym(libfontconfig, "FcGetVersion");
+#endif
 
-    if (FcGetVersion == NULL) {
-        closeFontConfig(libfontconfig, JNI_FALSE);
-        return 0;
-    }
-    version = (*FcGetVersion)();
+    version = FcGetVersion ();
     closeFontConfig(libfontconfig, JNI_FALSE);
 
     return version;
@@ -943,23 +749,6 @@
 (JNIEnv *env, jclass obj, jstring localeStr, jobject fcInfoObj,
  jobjectArray fcCompFontArray,  jboolean includeFallbacks) {
 
-    FcNameParseFuncType FcNameParse;
-    FcPatternAddStringFuncType FcPatternAddString;
-    FcConfigSubstituteFuncType FcConfigSubstitute;
-    FcDefaultSubstituteFuncType  FcDefaultSubstitute;
-    FcFontMatchFuncType FcFontMatch;
-    FcPatternGetStringFuncType FcPatternGetString;
-    FcPatternDestroyFuncType FcPatternDestroy;
-    FcPatternGetCharSetFuncType FcPatternGetCharSet;
-    FcFontSortFuncType FcFontSort;
-    FcFontSetDestroyFuncType FcFontSetDestroy;
-    FcCharSetUnionFuncType FcCharSetUnion;
-    FcCharSetSubtractCountFuncType FcCharSetSubtractCount;
-    FcGetVersionFuncType FcGetVersion;
-    FcConfigGetCacheDirsFuncType FcConfigGetCacheDirs;
-    FcStrListNextFuncType FcStrListNext;
-    FcStrListDoneFuncType FcStrListDone;
-
     int i, arrlen;
     jobject fcCompFontObj;
     jstring fcNameStr, jstr;
@@ -1017,73 +806,18 @@
         return;
     }
 
+#ifndef USE_SYSTEM_FONTCONFIG
     if ((libfontconfig = openFontConfig()) == NULL) {
         return;
     }
-
-    FcNameParse = (FcNameParseFuncType)dlsym(libfontconfig, "FcNameParse");
-    FcPatternAddString =
-        (FcPatternAddStringFuncType)dlsym(libfontconfig, "FcPatternAddString");
-    FcConfigSubstitute =
-        (FcConfigSubstituteFuncType)dlsym(libfontconfig, "FcConfigSubstitute");
-    FcDefaultSubstitute = (FcDefaultSubstituteFuncType)
-        dlsym(libfontconfig, "FcDefaultSubstitute");
-    FcFontMatch = (FcFontMatchFuncType)dlsym(libfontconfig, "FcFontMatch");
-    FcPatternGetString =
-        (FcPatternGetStringFuncType)dlsym(libfontconfig, "FcPatternGetString");
-    FcPatternDestroy =
-        (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy");
-    FcPatternGetCharSet =
-        (FcPatternGetCharSetFuncType)dlsym(libfontconfig,
-                                           "FcPatternGetCharSet");
-    FcFontSort =
-        (FcFontSortFuncType)dlsym(libfontconfig, "FcFontSort");
-    FcFontSetDestroy =
-        (FcFontSetDestroyFuncType)dlsym(libfontconfig, "FcFontSetDestroy");
-    FcCharSetUnion =
-        (FcCharSetUnionFuncType)dlsym(libfontconfig, "FcCharSetUnion");
-    FcCharSetSubtractCount =
-        (FcCharSetSubtractCountFuncType)dlsym(libfontconfig,
-                                              "FcCharSetSubtractCount");
-    FcGetVersion = (FcGetVersionFuncType)dlsym(libfontconfig, "FcGetVersion");
+#endif
 
-    if (FcNameParse          == NULL ||
-        FcPatternAddString   == NULL ||
-        FcConfigSubstitute   == NULL ||
-        FcDefaultSubstitute  == NULL ||
-        FcFontMatch          == NULL ||
-        FcPatternGetString   == NULL ||
-        FcPatternDestroy     == NULL ||
-        FcPatternGetCharSet  == NULL ||
-        FcFontSetDestroy     == NULL ||
-        FcCharSetUnion       == NULL ||
-        FcGetVersion         == NULL ||
-        FcCharSetSubtractCount == NULL) {/* problem with the library: return.*/
-        closeFontConfig(libfontconfig, JNI_FALSE);
-        return;
-    }
-
-    (*env)->SetIntField(env, fcInfoObj, fcVersionID, (*FcGetVersion)());
+    (*env)->SetIntField(env, fcInfoObj, fcVersionID, FcGetVersion ());
 
-    /* Optionally get the cache dir locations. This isn't
-     * available until v 2.4.x, but this is OK since on those later versions
-     * we can check the time stamps on the cache dirs to see if we
-     * are out of date. There are a couple of assumptions here. First
-     * that the time stamp on the directory changes when the contents are
-     * updated. Secondly that the locations don't change. The latter is
-     * most likely if a new version of fontconfig is installed, but we also
-     * invalidate the cache if we detect that. Arguably even that is "rare",
-     * and most likely is tied to an OS upgrade which gets a new file anyway.
-     */
-    FcConfigGetCacheDirs =
-        (FcConfigGetCacheDirsFuncType)dlsym(libfontconfig,
-                                            "FcConfigGetCacheDirs");
-    FcStrListNext =
-        (FcStrListNextFuncType)dlsym(libfontconfig, "FcStrListNext");
-    FcStrListDone =
-        (FcStrListDoneFuncType)dlsym(libfontconfig, "FcStrListDone");
+#ifndef USE_SYSTEM_FONTCONFIG
     if (FcStrListNext != NULL && FcStrListDone != NULL &&
         FcConfigGetCacheDirs != NULL) {
+#endif
 
         FcStrList* cacheDirs;
         FcChar8* cacheDir;
@@ -1092,15 +826,18 @@
             (*env)->GetObjectField(env, fcInfoObj, fcCacheDirsID);
         int max = (*env)->GetArrayLength(env, cacheDirArray);
 
-        cacheDirs = (*FcConfigGetCacheDirs)(NULL);
+        cacheDirs = FcConfigGetCacheDirs (NULL);
         if (cacheDirs != NULL) {
-            while ((cnt < max) && (cacheDir = (*FcStrListNext)(cacheDirs))) {
+            while ((cnt < max) && (cacheDir = FcStrListNext (cacheDirs))) {
                 jstr = (*env)->NewStringUTF(env, (const char*)cacheDir);
                 (*env)->SetObjectArrayElement(env, cacheDirArray, cnt++, jstr);
             }
-            (*FcStrListDone)(cacheDirs);
+            FcStrListDone (cacheDirs);
         }
+
+#ifndef USE_SYSTEM_FONTCONFIG
     }
+#endif
 
     locale = (*env)->GetStringUTFChars(env, localeStr, 0);
 
@@ -1119,7 +856,7 @@
         if (fcName == NULL) {
             continue;
         }
-        pattern = (*FcNameParse)((FcChar8 *)fcName);
+        pattern = FcNameParse ((FcChar8 *)fcName);
         if (pattern == NULL) {
             (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName);
             closeFontConfig(libfontconfig, JNI_FALSE);
@@ -1132,13 +869,13 @@
          * care of it.
          */
         if (locale != NULL) {
-            (*FcPatternAddString)(pattern, FC_LANG, (unsigned char*)locale);
+            FcPatternAddString (pattern, FC_LANG, (unsigned char*)locale);
         }
-        (*FcConfigSubstitute)(NULL, pattern, FcMatchPattern);
-        (*FcDefaultSubstitute)(pattern);
-        fontset = (*FcFontSort)(NULL, pattern, FcTrue, NULL, &result);
+        FcConfigSubstitute (NULL, pattern, FcMatchPattern);
+        FcDefaultSubstitute (pattern);
+        fontset = FcFontSort (NULL, pattern, FcTrue, NULL, &result);
         if (fontset == NULL) {
-            (*FcPatternDestroy)(pattern);
+            FcPatternDestroy (pattern);
             (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName);
             closeFontConfig(libfontconfig, JNI_FALSE);
             return;
@@ -1169,8 +906,8 @@
             if (file != NULL) {
                 free(file);
             }
-            (*FcPatternDestroy)(pattern);
-            (*FcFontSetDestroy)(fontset);
+            FcPatternDestroy (pattern);
+            FcFontSetDestroy (fontset);
             (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName);
             closeFontConfig(libfontconfig, JNI_FALSE);
             return;
@@ -1190,20 +927,20 @@
             FcCharSet *unionCharset = NULL, *charset;
 
             fontformat = NULL;
-            (*FcPatternGetString)(fontPattern, FC_FONTFORMAT, 0, &fontformat);
+            FcPatternGetString (fontPattern, FC_FONTFORMAT, 0, &fontformat);
             if (fontformat != NULL && strcmp((char*)fontformat, "TrueType")
                 != 0) {
                 continue;
             }
-            result = (*FcPatternGetCharSet)(fontPattern,
+            result = FcPatternGetCharSet (fontPattern,
                                             FC_CHARSET, 0, &charset);
             if (result != FcResultMatch) {
                 free(family);
                 free(family);
                 free(styleStr);
                 free(file);
-                (*FcPatternDestroy)(pattern);
-                (*FcFontSetDestroy)(fontset);
+                FcPatternDestroy (pattern);
+                FcFontSetDestroy (fontset);
                 (*env)->ReleaseStringUTFChars(env,
                                               fcNameStr, (const char*)fcName);
                 closeFontConfig(libfontconfig, JNI_FALSE);
@@ -1221,7 +958,7 @@
             if (unionCharset == NULL) {
                 unionCharset = charset;
             } else {
-                if ((*FcCharSetSubtractCount)(charset, unionCharset)
+                if (FcCharSetSubtractCount (charset, unionCharset)
                     > minGlyphs) {
                     unionCharset = (* FcCharSetUnion)(unionCharset, charset);
                 } else {
@@ -1230,10 +967,10 @@
             }
 
             fontCount++; // found a font we will use.
-            (*FcPatternGetString)(fontPattern, FC_FILE, 0, &file[j]);
-            (*FcPatternGetString)(fontPattern, FC_FAMILY, 0, &family[j]);
-            (*FcPatternGetString)(fontPattern, FC_STYLE, 0, &styleStr[j]);
-            (*FcPatternGetString)(fontPattern, FC_FULLNAME, 0, &fullname[j]);
+            FcPatternGetString (fontPattern, FC_FILE, 0, &file[j]);
+            FcPatternGetString (fontPattern, FC_FAMILY, 0, &family[j]);
+            FcPatternGetString (fontPattern, FC_STYLE, 0, &styleStr[j]);
+            FcPatternGetString (fontPattern, FC_FULLNAME, 0, &fullname[j]);
             if (!includeFallbacks) {
                 break;
             }
@@ -1284,8 +1021,8 @@
             }
         }
         (*env)->ReleaseStringUTFChars (env, fcNameStr, (const char*)fcName);
-        (*FcFontSetDestroy)(fontset);
-        (*FcPatternDestroy)(pattern);
+        FcFontSetDestroy (fontset);
+        FcPatternDestroy (pattern);
         free(family);
         free(styleStr);
         free(fullname);