fix for freetype 2.2

(Portage version: 2.1)

2 files changed, 704 insertions, 0 deletions

diff --git a/media-libs/fontconfig/files/digest-fontconfig-2.3.2-r2 b/media-libs/fontconfig/files/digest-fontconfig-2.3.2-r2
new file mode 100644
index 000000000000..cfe4f11048a6
--- /dev/null
+++ b/media-libs/fontconfig/files/digest-fontconfig-2.3.2-r2
@@ -0,0 +1,3 @@
+MD5 7354f9f125ea78a8f2851cb9c31d4866 fontconfig-2.3.2.tar.gz 964045
+RMD160 42668475cca88f265a3b12c289eea2ff61ddaa2b fontconfig-2.3.2.tar.gz 964045
+SHA256 6f7b91d328d6408c097ec11777bf4b1c2c710613b573b399794bc5999ff12227 fontconfig-2.3.2.tar.gz 964045
diff --git a/media-libs/fontconfig/files/fontconfig-2.3.2-noftinternals.patch b/media-libs/fontconfig/files/fontconfig-2.3.2-noftinternals.patch
new file mode 100644
index 000000000000..06ee8425d158
--- /dev/null
+++ b/media-libs/fontconfig/files/fontconfig-2.3.2-noftinternals.patch
@@ -0,0 +1,701 @@
+diff -urN fontconfig-2.3.2/src/fcfreetype.c fontconfig-2.3.2-new/src/fcfreetype.c
+--- fontconfig-2.3.2/src/fcfreetype.c	2005-04-21 14:37:43.000000000 +0200
++++ fontconfig-2.3.2-new/src/fcfreetype.c	2005-07-07 13:17:32.224401218 +0200
+@@ -50,14 +50,11 @@
+ #include "fcint.h"
+ #include <ft2build.h>
+ #include FT_FREETYPE_H
+-#include FT_INTERNAL_OBJECTS_H
+ #include FT_TRUETYPE_TABLES_H
+ #include FT_SFNT_NAMES_H
+ #include FT_TRUETYPE_IDS_H
+ #include FT_TYPE1_TABLES_H
+-#include FT_INTERNAL_STREAM_H
+-#include FT_INTERNAL_SFNT_H
+-#include FT_INTERNAL_TRUETYPE_TYPES_H
++#include "fcftglue.h"
+ #if HAVE_FT_GET_X11_FONT_FORMAT
+ #include FT_XFREE86_H
+ #endif
+@@ -65,8 +62,7 @@
+ #if HAVE_FT_GET_BDF_PROPERTY
+ #include FT_BDF_H
+ #include FT_MODULE_H
+-#define HAS_BDF_PROPERTY(f) ((f) && (f)->driver && \
+-			     (f)->driver->root.clazz->get_interface)
++#define HAS_BDF_PROPERTY(f) ((f))
+ #define MY_Get_BDF_Property(f,n,p) (HAS_BDF_PROPERTY(f) ? \
+ 				    FT_Get_BDF_Property(f,n,p) : \
+ 				    FT_Err_Invalid_Argument)
+@@ -1559,7 +1555,7 @@
+      */
+     if (FcCharSetCount (cs) == 0)
+     {
+-	if (!strcmp(FT_MODULE_CLASS(&face->driver->root)->module_name, "pcf"))
++	if (!strcmp(FT_Get_X11_Font_Format(face),"PCF"))
+ 	    goto bail2;
+     }
+ 
+@@ -2706,8 +2702,7 @@
+ static FT_Error
+ GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *script_count)
+ {
+-    FT_ULong         cur_offset, new_offset, base_offset;
+-    TT_Face          tt_face = (TT_Face)face;
++    FT_ULong   cur_offset, new_offset, base_offset;
+     FT_Stream  stream = face->stream;
+     FT_Error   error;
+     FT_UShort          n, p;
+@@ -2716,51 +2711,43 @@
+     if ( !stream )
+ 	return TT_Err_Invalid_Face_Handle;
+ 
+-    if (( error = tt_face->goto_table( tt_face, tabletag, stream, 0 ) ))
++    if ( (error = fcft_face_goto_table( face, tabletag, stream )) != 0 )
+ 	return error;
+ 
+-    base_offset = FT_STREAM_POS();
++    base_offset = FCFT_STREAM_POS();
+ 
+     /* skip version */
+ 
+-    if ( FT_STREAM_SEEK( base_offset + 4L ) || FT_FRAME_ENTER( 2L ) )
+-	return error;
+-
+-    new_offset = FT_GET_USHORT() + base_offset;
+-
+-    FT_FRAME_EXIT();
+-
+-    cur_offset = FT_STREAM_POS();
+-
+-    if ( FT_STREAM_SEEK( new_offset ) != TT_Err_Ok )
+-	return error;
+-
+-    base_offset = FT_STREAM_POS();
++    if ( FCFT_STREAM_SEEK( base_offset + 4L ) ||
++         FCFT_READ_USHORT( new_offset )       ) 
++      return error;
++    
++    new_offset += base_offset;
++    cur_offset  = FCFT_STREAM_POS();
+ 
+-    if ( FT_FRAME_ENTER( 2L ) )
++    if ( FCFT_STREAM_SEEK( new_offset ) != TT_Err_Ok )
+ 	return error;
+ 
+-    *script_count = FT_GET_USHORT();
++    base_offset = FCFT_STREAM_POS();
+ 
+-    FT_FRAME_EXIT();
+-
+-    if ( FT_SET_ERROR (FT_MEM_ALLOC_ARRAY( *stags, *script_count, FT_ULong )) )
+-	return error;
++    if ( FCFT_READ_USHORT(*script_count)                         ||
++         FCFT_MEM_ALLOC_ARRAY( *stags, *script_count, FT_ULong ) )
++ 	return error;
+ 
+     p = 0;
+     for ( n = 0; n < *script_count; n++ )
+     {
+-	if ( FT_FRAME_ENTER( 6L ) )
++	if ( FCFT_FRAME_ENTER( 6L ) )
+ 	    goto Fail;
+ 
+-	(*stags)[p] = FT_GET_ULONG();
+-	new_offset = FT_GET_USHORT() + base_offset;
++	(*stags)[p] = FCFT_GET_ULONG();
++	new_offset  = FCFT_GET_USHORT() + base_offset;
+ 
+-	FT_FRAME_EXIT();
++	FCFT_FRAME_EXIT();
+ 
+-	cur_offset = FT_STREAM_POS();
++	cur_offset = FCFT_STREAM_POS();
+ 
+-	if ( FT_STREAM_SEEK( new_offset ) )
++	if ( FCFT_STREAM_SEEK( new_offset ) )
+ 	    goto Fail;
+ 
+ 	if ( error == TT_Err_Ok )
+@@ -2768,7 +2755,7 @@
+ 	else if ( error != TTO_Err_Empty_Script )
+ 	    goto Fail;
+ 
+-	(void)FT_STREAM_SEEK( cur_offset );
++	(void)FCFT_STREAM_SEEK( cur_offset );
+     }
+ 
+     if (!p)
+@@ -2784,7 +2771,7 @@
+ 
+ Fail:
+     *script_count = 0;
+-    FT_FREE( *stags );
++    FCFT_FREE( *stags );
+     return error;
+ }
+ 
+@@ -2841,7 +2828,7 @@
+     if (FcDebug () & FC_DBG_SCANV)
+ 	printf("complex features in this font: %s\n", complex);
+ bail:
+-    FT_FREE(gsubtags);
+-    FT_FREE(gpostags);
++    FCFT_FREE(gsubtags);
++    FCFT_FREE(gpostags);
+     return complex;
+ }
+diff -urN fontconfig-2.3.2/src/fcftglue.c fontconfig-2.3.2-new/src/fcftglue.c
+--- fontconfig-2.3.2/src/fcftglue.c	1970-01-01 01:00:00.000000000 +0100
++++ fontconfig-2.3.2-new/src/fcftglue.c	2005-07-07 13:34:48.630254000 +0200
+@@ -0,0 +1,380 @@
++#include "fcftglue.h"
++
++/***************************************************************************/
++/***************************************************************************/
++/*****                                                                 *****/
++/*****                                                                 *****/
++/*****                                                                 *****/
++/***************************************************************************/
++/***************************************************************************/
++
++/* only used internall */
++static FT_Pointer
++fcft_qalloc( FT_Memory  memory,
++             FT_ULong   size,
++             FT_Error  *perror )
++{
++  FT_Error    error = 0;
++  FT_Pointer  block = NULL;
++
++  if ( size > 0 )
++  {
++    block = memory->alloc( memory, size );
++    if ( !block )
++      error = FT_Err_Out_Of_Memory;
++  }
++
++  *perror = error;
++  return block;
++}
++
++#define  FCFT_QALLOC(ptr,size)    ( (ptr) = fcft_qalloc( memory, (size), &error ), error != 0 )
++
++
++FCFT_APIDEF( FT_Pointer )
++fcft_alloc( FT_Memory  memory,
++            FT_ULong   size,
++            FT_Error  *perror )
++{
++  FT_Error    error = 0;
++  FT_Pointer  block = NULL;
++
++  if ( size > 0 )
++  {
++    block = memory->alloc( memory, size );
++    if ( !block )
++      error = FT_Err_Out_Of_Memory;
++    else
++      memset( (char*)block, 0, (size_t)size );
++  }
++
++  *perror = error;
++  return block;
++}
++
++
++FCFT_APIDEF( FT_Pointer )
++fcft_realloc( FT_Memory   memory,
++              FT_Pointer  block,
++              FT_ULong    old_size,
++              FT_ULong    new_size,
++              FT_Error   *perror )
++{
++  FT_Pointer  block2 = NULL;
++  FT_Error    error  = 0;
++
++  if ( block == NULL )
++  {
++    block2 = fcft_alloc( memory, new_size, &error );
++  }
++  else if ( new_size <= 0 )
++  {
++    fcft_free( memory, block );
++  }
++  else
++  {
++    block2 = fcft_alloc( memory, new_size, &error );
++    if ( !error )
++    {
++      memcpy( (char*)block2, (const char*)block, (size_t)old_size );
++      if ( new_size > old_size )
++        memset( (char*)block2 + old_size, 0, (size_t)(new_size - old_size) );
++    }
++  }
++
++  if ( !error )
++    block = block2;
++
++  *perror = error;
++  return block;
++}
++
++
++FCFT_APIDEF( void )
++fcft_free( FT_Memory   memory,
++           FT_Pointer  block )
++{
++  if ( block )
++    memory->free( memory, block );
++}
++
++
++FCFT_APIDEF( FT_Long )
++fcft_stream_pos( FT_Stream   stream )
++{
++  return stream->pos;
++}
++
++
++FCFT_APIDEF( FT_Error )
++fcft_stream_seek( FT_Stream   stream,
++                  FT_Long     pos )
++{
++  FT_Error  error = 0;
++
++  stream->pos = pos;
++  if ( stream->read )
++  {
++    if ( stream->read( stream, pos, 0, 0 ) )
++      error = FT_Err_Invalid_Stream_Operation;
++  }
++  else if ( pos > stream->size )
++    error = FT_Err_Invalid_Stream_Operation;
++
++  return error;
++}
++
++
++FCFT_APIDEF( FT_Error )
++fcft_stream_frame_enter( FT_Stream   stream,
++                         FT_ULong    count )
++{
++  FT_Error  error = FT_Err_Ok;
++  FT_ULong  read_bytes;
++
++  if ( stream->read )
++  {
++    /* allocate the frame in memory */
++    FT_Memory  memory = stream->memory;
++
++
++    if ( FCFT_QALLOC( stream->base, count ) )
++      goto Exit;
++
++    /* read it */
++    read_bytes = stream->read( stream, stream->pos,
++                               stream->base, count );
++    if ( read_bytes < count )
++    {
++      FCFT_FREE( stream->base );
++      error = FT_Err_Invalid_Stream_Operation;
++    }
++    stream->cursor = stream->base;
++    stream->limit  = stream->cursor + count;
++    stream->pos   += read_bytes;
++  }
++  else
++  {
++    /* check current and new position */
++    if ( stream->pos >= stream->size        ||
++         stream->pos + count > stream->size )
++    {
++      error = FT_Err_Invalid_Stream_Operation;
++      goto Exit;
++    }
++
++    /* set cursor */
++    stream->cursor = stream->base + stream->pos;
++    stream->limit  = stream->cursor + count;
++    stream->pos   += count;
++  }
++
++Exit:
++  return error;
++}
++
++
++FCFT_APIDEF( void )
++fcft_stream_frame_exit( FT_Stream  stream )
++{
++  if ( stream->read )
++  {
++    FT_Memory  memory = stream->memory;
++
++    FCFT_FREE( stream->base );
++  }
++  stream->cursor = 0;
++  stream->limit  = 0;
++}
++
++
++FCFT_APIDEF( FT_Byte )
++fcft_stream_get_byte( FT_Stream  stream )
++{
++  FT_Byte  result = 0;
++
++  if ( stream->cursor < stream->limit )
++    result = *stream->cursor++;
++
++  return result;
++}
++
++
++FCFT_APIDEF( FT_Short )
++fcft_stream_get_short( FT_Stream  stream )
++{
++  FT_Byte*  p;
++  FT_Short  result = 0;
++
++  p = stream->cursor;
++  if ( p + 2 <= stream->limit )
++  {
++    result         = (FT_Short)((p[0] << 8) | p[1]);
++    stream->cursor = p+2;
++  }
++  return result;
++}
++
++
++FCFT_APIDEF( FT_Long )
++fcft_stream_get_long( FT_Stream   stream )
++{
++  FT_Byte*  p;
++  FT_Long   result = 0;
++
++  p = stream->cursor;
++  if ( p + 4 <= stream->limit )
++  {
++    result         = (FT_Long)(((FT_Long)p[0] << 24) |
++                               ((FT_Long)p[1] << 16) |
++                               ((FT_Long)p[2] << 8)  |
++                                         p[3]        );
++    stream->cursor = p+4;
++  }
++  return result;
++}
++
++
++static FT_Error
++fcft_stream_readp( FT_Stream   stream,
++                   FT_Byte*   *pbuffer,
++                   FT_ULong    count )
++{
++  FT_Error  error = 0;
++
++  if ( stream->read )
++  {
++    FT_ULong  read_bytes = stream->read( stream, stream->pos, *pbuffer, count );
++
++    if ( read_bytes != count )
++      goto Fail;
++
++    stream->pos += count;
++  }
++  else
++  {
++    if ( stream->pos >= stream->size        ||
++         stream->pos + count > stream->size )
++      goto Fail;
++
++    *pbuffer     = stream->base + stream->pos;
++    stream->pos += count;
++  }
++
++Exit:
++  return error;
++
++Fail:
++  error = FT_Err_Invalid_Stream_Operation;
++  goto Exit;
++}
++
++
++FCFT_API( FT_Byte )
++fcft_stream_read_byte( FT_Stream   stream,
++                       FT_Error   *perror )
++{
++  FT_Byte   temp[1], *p = temp, result = 0;
++  FT_Error  error = fcft_stream_readp( stream, &p, 1 );
++
++  if ( !error )
++    result = *p;
++
++  return error;
++}
++
++FCFT_API( FT_Short )
++fcft_stream_read_short( FT_Stream  stream,
++                        FT_Error  *perror )
++{
++  FT_Byte   temp[2], *p = temp;
++  FT_Short  result = 0;
++  FT_Error  error  = fcft_stream_readp( stream, &p, 2 );
++
++  if ( !error )
++    result = (FT_Short)((p[0] << 8) | p[1]);
++
++  return error;
++}
++
++FCFT_API( FT_Long )
++fcft_stream_read_long( FT_Stream  stream,
++                       FT_Error  *perror )
++{
++  FT_Byte   temp[4], *p = temp;
++  FT_Long   result = 0;
++  FT_Error  error  = fcft_stream_readp( stream, &p, 4 );
++
++  if ( !error )
++    result = (FT_Long)((FT_Long)(p[0] << 24) |
++                       (FT_Long)(p[1] << 16) |
++                                (p[2] << 8)  |
++                                 p[3]        );
++
++  return error;
++}
++
++
++FCFT_APIDEF( FT_Error )
++fcft_face_goto_table( FT_Face    face,
++                      FT_ULong   the_tag,
++                      FT_Stream  stream )
++{
++  FT_Error  error;
++
++  if ( !FT_IS_SFNT(face) )
++    error = FT_Err_Invalid_Face_Handle;
++  else
++  {
++   /* parse the directory table directly, without using
++    * FreeType's built-in data structures
++    */
++    FT_UInt   count, nn;
++    FT_ULong  offset = 0;
++
++    if ( face->num_faces > 1 )
++    {
++      /* deal with TrueType collections */
++      FT_ULong  offset;
++
++      if ( FCFT_STREAM_SEEK( 12 + face->face_index*4 ) ||
++           FCFT_READ_ULONG(offset)                     )
++        goto Exit;
++    }
++
++    if ( FCFT_STREAM_SEEK( offset+4 ) ||
++         FCFT_READ_USHORT(count)      )
++      goto Exit;
++
++
++    if ( FCFT_STREAM_SEEK( offset+12 ) ||
++         FCFT_FRAME_ENTER( count*16 )  )
++      goto Exit;
++
++    for ( nn = 0; nn < count; nn++ )
++    {
++      FT_ULong  tag      = FCFT_GET_TAG();
++      FT_ULong  checksum = FCFT_GET_ULONG();
++      FT_ULong  start    = FCFT_GET_ULONG();
++      FT_ULong  size     = FCFT_GET_ULONG();
++
++      FT_UNUSED(checksum);
++      FT_UNUSED(size);
++
++      if ( tag == the_tag )
++      {
++        error = fcft_stream_seek( stream, offset+start );
++        goto FoundIt;
++      }
++    }
++    error = FT_Err_Table_Missing;
++
++  FoundIt:
++    FCFT_FRAME_EXIT();
++  }
++
++Exit:
++  return error;
++}
++
++#undef FCFT_QALLOC
+diff -urN fontconfig-2.3.2/src/fcftglue.h fontconfig-2.3.2-new/src/fcftglue.h
+--- fontconfig-2.3.2/src/fcftglue.h	1970-01-01 01:00:00.000000000 +0100
++++ fontconfig-2.3.2-new/src/fcftglue.h	2005-07-07 13:15:43.292717000 +0200
+@@ -0,0 +1,135 @@
++/* the following contains code used to prevent FontConfig from
++ * abusing FreeType internals. We simply duplicate some of the FreeType
++ * functionality using only publicly defined APIs and structures
++ */
++#ifndef __FONTCONFIG_FTGLUE_H__
++#define __FONTCONFIG_FTGLUE_H__
++
++#include <ft2build.h>
++#include FT_FREETYPE_H
++
++FT_BEGIN_HEADER
++
++
++/* utility macros */
++#define  FCFT_SET_ERR(c)   ( (error = (c)) != 0 )
++
++#ifndef FCFT_API
++#define FCFT_API(x)  extern x
++#endif
++
++#ifndef FCFT_APIDEF
++#define FCFT_APIDEF(x)  x
++#endif
++
++/* stream macros used by the OpenType parser */
++#define  FCFT_STREAM_POS()       fcft_stream_pos( stream )
++#define  FCFT_STREAM_SEEK(pos)   FCFT_SET_ERR( fcft_stream_seek( stream, pos ) )
++#define  FCFT_FRAME_ENTER(size)  FCFT_SET_ERR( fcft_stream_frame_enter( stream, size ) )
++#define  FCFT_FRAME_EXIT()       fcft_stream_frame_exit( stream )
++
++#define  FCFT_GET_BYTE()         fcft_stream_get_byte( stream )
++#define  FCFT_GET_SHORT()        fcft_stream_get_short( stream )
++#define  FCFT_GET_LONG()         fcft_stream_get_long( stream )
++
++#define  FCFT_GET_CHAR()        ((FT_Char)FCFT_GET_BYTE())
++#define  FCFT_GET_USHORT()      ((FT_UShort)FCFT_GET_SHORT())
++#define  FCFT_GET_ULONG()       ((FT_ULong)FCFT_GET_LONG())
++#define  FCFT_GET_TAG()         FCFT_GET_ULONG()
++
++#define  FCFT_READ_(val,type,suffix)   \
++   ( (val) = (type) fcft_stream_read_##suffix (stream, &error), error != 0 )
++
++#define  FCFT_READ_BYTE(val)    FCFT_READ_(val,FT_Byte,byte)
++#define  FCFT_READ_SHORT(val)   FCFT_READ_(val,FT_Short,short)
++#define  FCFT_READ_LONG(val)    FCFT_READ_(val,FT_Long,long)
++
++#define  FCFT_READ_CHAR(val)    FCFT_READ_(val,FT_Char,byte)
++#define  FCFT_READ_USHORT(val)  FCFT_READ_(val,FT_UShort,short)
++#define  FCFT_READ_ULONG(val)   FCFT_READ_(val,FT_ULong,long)
++
++
++FCFT_API( FT_Long )
++fcft_stream_pos( FT_Stream   stream );
++
++FCFT_API( FT_Error )
++fcft_stream_seek( FT_Stream   stream,
++                  FT_Long     pos );
++
++FCFT_API( FT_Error )
++fcft_stream_frame_enter( FT_Stream   stream,
++                         FT_ULong    size );
++
++FCFT_API( void )
++fcft_stream_frame_exit( FT_Stream  stream );
++
++FCFT_API( FT_Byte )
++fcft_stream_get_byte( FT_Stream  stream );
++
++FCFT_API( FT_Short )
++fcft_stream_get_short( FT_Stream  stream );
++
++FCFT_API( FT_Long )
++fcft_stream_get_long( FT_Stream   stream );
++
++FCFT_API( FT_Byte )
++fcft_stream_read_byte( FT_Stream   stream,
++                       FT_Error   *perror );
++
++FCFT_API( FT_Short )
++fcft_stream_read_short( FT_Stream  stream,
++                        FT_Error  *perror );
++
++FCFT_API( FT_Long )
++fcft_stream_read_long( FT_Stream  stream,
++                       FT_Error  *perror );
++
++FCFT_API( FT_Error )
++fcft_face_goto_table( FT_Face    face,
++                      FT_ULong   tag,
++                      FT_Stream  stream );
++
++/* memory macros used by the OpenType parser */
++#define  FCFT_MEM_ALLOC(_ptr,_size)   \
++           ( (_ptr) = fcft_alloc( memory, _size, &error ), error != 0 )
++
++#define  FCFT_MEM_REALLOC(_ptr,_oldsz,_newsz)  \
++           ( (_ptr) = fcft_realloc( memory, (_ptr), (_oldsz), (_newsz), &error ), error != 0 )
++
++#define  FCFT_FREE(_ptr)               \
++  FT_BEGIN_STMNT                       \
++    if ( (_ptr) )                      \
++    {                                  \
++      fcft_free( memory, _ptr );       \
++      _ptr = NULL;                     \
++    }                                  \
++  FT_END_STMNT
++
++#define  FCFT_MEM_ALLOC_ARRAY(_ptr,_count,_type)   \
++           FCFT_MEM_ALLOC(_ptr,(_count)*sizeof(_type))
++
++#define  FCFT_MEM_REALLOC_ARRAY(_ptr,_oldcnt,_newcnt,_type) \
++           FCFT_MEM_REALLOC(_ptr,(_oldcnt)*sizeof(_type),(_newcnt)*sizeof(_type))
++
++
++FCFT_API( FT_Pointer )
++fcft_alloc( FT_Memory  memory,
++            FT_ULong   size,
++            FT_Error  *perror );
++
++FCFT_API( FT_Pointer )
++fcft_realloc( FT_Memory   memory,
++              FT_Pointer  block,
++              FT_ULong    old_size,
++              FT_ULong    new_size,
++              FT_Error   *perror );
++
++FCFT_API( void )
++fcft_free( FT_Memory   memory,
++           FT_Pointer  block );
++
++/* */
++
++FT_END_HEADER
++
++#endif /* __OPENTYPE_FCFT_H__ */
+diff -urN fontconfig-2.3.2/src/Makefile.am fontconfig-2.3.2-new/src/Makefile.am
+--- fontconfig-2.3.2/src/Makefile.am	2004-12-05 06:49:20.000000000 +0100
++++ fontconfig-2.3.2-new/src/Makefile.am	2005-07-07 13:09:15.416637082 +0200
+@@ -86,6 +86,7 @@
+ 	fcdefault.c \
+ 	fcdir.c \
+ 	fcfreetype.c \
++	fcftglue.c \
+ 	fcfs.c \
+ 	fcinit.c \
+ 	fclang.c \
+diff -urN fontconfig-2.3.2/src/Makefile.in fontconfig-2.3.2-new/src/Makefile.in
+--- fontconfig-2.3.2/src/Makefile.in	2005-04-27 21:08:51.000000000 +0200
++++ fontconfig-2.3.2-new/src/Makefile.in	2005-07-07 13:09:15.417636939 +0200
+@@ -228,6 +228,7 @@
+ 	fcdefault.c \
+ 	fcdir.c \
+ 	fcfreetype.c \
++	fcftglue.c \
+ 	fcfs.c \
+ 	fcinit.c \
+ 	fclang.c \
+@@ -257,7 +258,7 @@
+ libfontconfig_la_DEPENDENCIES =
+ am_libfontconfig_la_OBJECTS = fcatomic.lo fcblanks.lo fccache.lo \
+ 	fccfg.lo fccharset.lo fcdbg.lo fcdefault.lo fcdir.lo \
+-	fcfreetype.lo fcfs.lo fcinit.lo fclang.lo fclist.lo fcmatch.lo \
++	fcfreetype.lo fcftglue.lo fcfs.lo fcinit.lo fclang.lo fclist.lo fcmatch.lo \
+ 	fcmatrix.lo fcname.lo fcpat.lo fcstr.lo fcxml.lo
+ libfontconfig_la_OBJECTS = $(am_libfontconfig_la_OBJECTS)
+