Remove an unecessary set of block2.

2005-07-22  Owen Taylor  <otaylor@redhat.com>

        * pango/opentype/ftglue.c (ftglue_realloc): Remove
        an unecessary set of block2.

2005-07-22  Owen Taylor  <otaylor@redhat.com>

        Patch from David Turner. Review and testing by Behdad Esfahbod

        * pango/opentype/ftglue.[ch] Makefile.am: Glue layer that provides
        implementation of the internal functions that the opentype code
        expects in terms of publically exported FreeType API.

        * pango/opentype/ftxgdef.c pango/opentype/ftxgpos.c
        pango/opentype/ftxgsub.c pango/opentype/ftxopen.c
        pango/opentype/otlbuffer.c pango/opentype/pango-ot-info.c
        pango/opentype/pango-ot-ruleset.c: Remove includes of
        internal headers. Small changes to work with ftglue.[ch]

        * pango/opentype/fterrcompat.h: Remove: no longer needed.

        * pango/opentype/ftxgpos.c: Use FT_IS_SFNT(face) rather
        than poking at FT_MODULE_CLASS (face->driver)->module_name.

        * pango/opentype/ftxopen.c (Free_FeatureList): Free
        fl->ApplyOrder. (Found by Behdad)

4 files changed, 515 insertions, 0 deletions

diff --git a/ChangeLog b/ChangeLog
index bae68a8c..1d421b5c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,10 @@
 2005-07-22  Owen Taylor  <otaylor@redhat.com>
 
+	* pango/opentype/ftglue.c (ftglue_realloc): Remove
+	an unecessary set of block2.
+
+2005-07-22  Owen Taylor  <otaylor@redhat.com>
+	
 	Patch from David Turner. Review and testing by Behdad Esfahbod
 
 	* pango/opentype/ftglue.[ch] Makefile.am: Glue layer that provides
diff --git a/ChangeLog.pre-1-10 b/ChangeLog.pre-1-10
index bae68a8c..1d421b5c 100644
--- a/ChangeLog.pre-1-10
+++ b/ChangeLog.pre-1-10
@@ -1,5 +1,10 @@
 2005-07-22  Owen Taylor  <otaylor@redhat.com>
 
+	* pango/opentype/ftglue.c (ftglue_realloc): Remove
+	an unecessary set of block2.
+
+2005-07-22  Owen Taylor  <otaylor@redhat.com>
+	
 	Patch from David Turner. Review and testing by Behdad Esfahbod
 
 	* pango/opentype/ftglue.[ch] Makefile.am: Glue layer that provides
diff --git a/pango/opentype/ftglue.c b/pango/opentype/ftglue.c
new file mode 100644
index 00000000..ebddfa74
--- /dev/null
+++ b/pango/opentype/ftglue.c
@@ -0,0 +1,349 @@
+/* ftglue.c: Glue code for compiling the OpenType code from
+ *           FreeType 1 using only the public API of FreeType 2
+ *
+ * By David Turner, The FreeType Project (www.freetype.org)
+ *
+ * This code is explicitely put in the public domain
+ *
+ * See ftglue.h for more information.
+ */
+
+#include "ftglue.h"
+
+#if 0
+#include <stdio.h>
+#define  LOG(x)  ftglue_log x
+
+static void
+ftglue_log( const char*   format, ... )
+{
+  va_list  ap;
+ 
+  va_start( ap, format );
+  vfprintf( stderr, format, ap );
+  va_end( ap );
+}
+
+#else
+#define  LOG(x)  do {} while (0)
+#endif
+
+/* only used internally */
+static FT_Pointer
+ftglue_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;
+}
+
+#undef   QALLOC  /* just in case */
+#define  QALLOC(ptr,size)    ( (ptr) = ftglue_qalloc( memory, (size), &error ), error != 0 )
+
+
+FTGLUE_APIDEF( FT_Pointer )
+ftglue_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;
+}
+
+
+FTGLUE_APIDEF( FT_Pointer )
+ftglue_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 ( old_size == 0 || block == NULL )
+  {
+    block2 = ftglue_alloc( memory, new_size, &error );
+  }
+  else if ( new_size == 0 )
+  {
+    ftglue_free( memory, block );
+  }
+  else
+  {
+    block2 = memory->realloc( memory, old_size, new_size, block );
+    if ( block2 == NULL )
+      error = FT_Err_Out_Of_Memory;
+    else 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;
+}
+
+
+FTGLUE_APIDEF( void )
+ftglue_free( FT_Memory   memory,
+             FT_Pointer  block )
+{
+  if ( block )
+    memory->free( memory, block );
+}
+
+
+FTGLUE_APIDEF( FT_Long )
+ftglue_stream_pos( FT_Stream   stream )
+{
+  LOG(( "ftglue:stream:pos() -> %ld\n", stream->pos ));
+  return stream->pos;
+}
+
+
+FTGLUE_APIDEF( FT_Error )
+ftglue_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;
+
+  LOG(( "ftglue:stream:seek(%ld) -> %d\n", pos, error ));
+  return error;
+}
+
+
+FTGLUE_APIDEF( FT_Error )
+ftglue_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 ( QALLOC( stream->base, count ) )
+      goto Exit;
+
+    /* read it */
+    read_bytes = stream->read( stream, stream->pos,
+                               stream->base, count );
+    if ( read_bytes < count )
+    {
+      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:
+  LOG(( "ftglue:stream:frame_enter(%ld) -> %d\n", count, error ));
+  return error;
+}
+
+
+FTGLUE_APIDEF( void )
+ftglue_stream_frame_exit( FT_Stream  stream )
+{
+  if ( stream->read )
+  {
+    FT_Memory  memory = stream->memory;
+
+    FREE( stream->base );
+  }
+  stream->cursor = 0;
+  stream->limit  = 0;
+
+  LOG(( "ftglue:stream:frame_exit()\n" ));
+}
+
+
+FTGLUE_APIDEF( FT_Byte )
+ftglue_stream_get_byte( FT_Stream  stream )
+{
+  FT_Byte  result = 0;
+
+  if ( stream->cursor < stream->limit )
+    result = *stream->cursor++;
+
+  return result;
+}
+
+
+FTGLUE_APIDEF( FT_Short )
+ftglue_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;
+}
+
+
+FTGLUE_APIDEF( FT_Long )
+ftglue_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;
+}
+
+
+FTGLUE_APIDEF( FT_Error )
+ftglue_face_goto_table( FT_Face    face,
+                        FT_ULong   the_tag,
+                        FT_Stream  stream )
+{
+  FT_Error  error;
+
+  LOG(( "ftglue_face_goto_table( %p, %c%c%c%c, %p )\n",
+                face, 
+                (int)((the_tag >> 24) & 0xFF), 
+                (int)((the_tag >> 16) & 0xFF), 
+                (int)((the_tag >> 8) & 0xFF), 
+                (int)(the_tag & 0xFF),
+                stream ));
+
+  if ( !FT_IS_SFNT(face) )
+  {
+    LOG(( "not a SFNT face !!\n" ));
+    error = FT_Err_Invalid_Face_Handle;
+  }
+  else
+  {
+   /* parse the directory table directly, without using
+    * FreeType's built-in data structures
+    */
+    FT_ULong  offset = 0;
+    FT_UInt   count, nn;
+
+    if ( face->num_faces > 1 )
+    {
+      /* deal with TrueType collections */
+      FT_ULong  offset;
+
+      LOG(( ">> This is a TrueType Collection\n" ));
+
+      if ( FILE_Seek( 12 + face->face_index*4 ) ||
+           ACCESS_Frame( 4 )                    )
+        goto Exit;
+
+      offset = GET_ULong();
+
+      FORGET_Frame();
+    }
+
+    LOG(( "TrueType offset = %ld\n", offset ));
+
+    if ( FILE_Seek( offset+4 ) ||
+         ACCESS_Frame( 2 )     )
+      goto Exit;
+
+    count = GET_UShort();
+
+    FORGET_Frame();
+
+    if ( FILE_Seek( offset+12 )   ||
+         ACCESS_Frame( count*16 ) )
+      goto Exit;
+
+    for ( nn = 0; nn < count; nn++ )
+    {
+      FT_ULong  tag      = GET_ULong();
+      FT_ULong  checksum = GET_ULong();
+      FT_ULong  start    = GET_ULong();
+      FT_ULong  size     = GET_ULong();
+
+      FT_UNUSED(checksum);
+      FT_UNUSED(size);
+      
+      if ( tag == the_tag )
+      {
+        LOG(( "TrueType table (start: %ld) (size: %ld)\n", start, size ));
+        error = ftglue_stream_seek( stream, offset+start );
+        goto FoundIt;
+      }
+    }
+    error = TT_Err_Table_Missing;
+
+  FoundIt:
+    FORGET_Frame();
+  }
+
+Exit:
+  LOG(( "TrueType error=%d\n", error ));
+  
+  return error;
+}                        
+
+#undef QALLOC
diff --git a/pango/opentype/ftglue.h b/pango/opentype/ftglue.h
new file mode 100644
index 00000000..cc780fe6
--- /dev/null
+++ b/pango/opentype/ftglue.h
@@ -0,0 +1,156 @@
+/* ftglue.c: Glue code for compiling the OpenType code from
+ *           FreeType 1 using only the public API of FreeType 2
+ *
+ * By David Turner, The FreeType Project (www.freetype.org)
+ *
+ * This code is explicitely put in the public domain
+ *
+ * ==========================================================================
+ *
+ * the OpenType parser codes was originally written as an extension to
+ * FreeType 1.x. As such, its source code was embedded within the library,
+ * and used many internal FreeType functions to deal with memory and
+ * stream i/o.
+ *
+ * When it was 'salvaged' for Pango and Qt, the code was "ported" to FreeType 2,
+ * which basically means that some macro tricks were performed in order to
+ * directly access FT2 _internal_ functions.
+ *
+ * these functions were never part of FT2 public API, and _did_ change between
+ * various releases. This created chaos for many users: when they upgraded the
+ * FreeType library on their system, they couldn't run Gnome anymore since
+ * Pango refused to link.
+ *
+ * Very fortunately, it's possible to completely avoid this problem because
+ * the FT_StreamRec and FT_MemoryRec structure types, which describe how
+ * memory and stream implementations interface with the rest of the font
+ * library, have always been part of the public API, and never changed.
+ *
+ * What we do thus is re-implement, within the OpenType parser, the few
+ * functions that depend on them. This only adds one or two kilobytes of
+ * code, and ensures that the parser can work with _any_ version
+ * of FreeType installed on your system. How sweet... !
+ *
+ * Note that we assume that Pango doesn't use any other internal functions
+ * from FreeType. It used to in old versions, but this should no longer
+ * be the case. (crossing my fingers).
+ *
+ *  - David Turner
+ *  - The FreeType Project  (www.freetype.org)
+ *
+ * PS: This "glue" code is explicitely put in the public domain
+ */
+#ifndef __OPENTYPE_FTGLUE_H__
+#define __OPENTYPE_FTGLUE_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+
+/* utility macros */
+#define  TT_Err_Ok                   FT_Err_Ok
+#define  TT_Err_Invalid_Argument     FT_Err_Invalid_Argument
+#define  TT_Err_Invalid_Face_Handle  FT_Err_Invalid_Face_Handle
+#define  TT_Err_Table_Missing        FT_Err_Table_Missing
+
+#define  SET_ERR(c)   ( (error = (c)) != 0 )
+
+#ifndef FTGLUE_API
+#define FTGLUE_API(x)  extern x
+#endif
+
+#ifndef FTGLUE_APIDEF
+#define FTGLUE_APIDEF(x)  x
+#endif
+
+/* stream macros used by the OpenType parser */
+#define  FILE_Pos()      ftglue_stream_pos( stream )
+#define  FILE_Seek(pos)  SET_ERR( ftglue_stream_seek( stream, pos ) )
+#define  ACCESS_Frame(size)  SET_ERR( ftglue_stream_frame_enter( stream, size ) )
+#define  FORGET_Frame()      ftglue_stream_frame_exit( stream )
+
+#define  GET_Byte()      ftglue_stream_get_byte( stream )
+#define  GET_Short()     ftglue_stream_get_short( stream )
+#define  GET_Long()      ftglue_stream_get_long( stream )
+
+#define  GET_Char()      ((FT_Char)GET_Byte())
+#define  GET_UShort()    ((FT_UShort)GET_Short())
+#define  GET_ULong()     ((FT_ULong)GET_Long())
+#define  GET_Tag4()      GET_ULong()
+
+FTGLUE_API( FT_Long )
+ftglue_stream_pos( FT_Stream   stream );
+
+FTGLUE_API( FT_Error )
+ftglue_stream_seek( FT_Stream   stream,
+                    FT_Long     pos );
+
+FTGLUE_API( FT_Error )
+ftglue_stream_frame_enter( FT_Stream   stream,
+                           FT_ULong    size );
+
+FTGLUE_API( void )
+ftglue_stream_frame_exit( FT_Stream  stream );
+
+FTGLUE_API( FT_Byte )
+ftglue_stream_get_byte( FT_Stream  stream );
+
+FTGLUE_API( FT_Short )
+ftglue_stream_get_short( FT_Stream  stream );
+
+FTGLUE_API( FT_Long )
+ftglue_stream_get_long( FT_Stream   stream );
+
+FTGLUE_API( FT_Error )
+ftglue_face_goto_table( FT_Face    face,
+                        FT_ULong   tag,
+                        FT_Stream  stream );
+
+/* memory macros used by the OpenType parser */
+#define  ALLOC(_ptr,_size)   \
+           ( (_ptr) = ftglue_alloc( memory, _size, &error ), error != 0 )
+
+#define  REALLOC(_ptr,_oldsz,_newsz)  \
+           ( (_ptr) = ftglue_realloc( memory, (_ptr), (_oldsz), (_newsz), &error ), error != 0 )
+
+#define  FREE(_ptr)                    \
+  FT_BEGIN_STMNT                       \
+    if ( (_ptr) )                      \
+    {                                  \
+      ftglue_free( memory, _ptr );     \
+      _ptr = NULL;                     \
+    }                                  \
+  FT_END_STMNT
+
+#define  ALLOC_ARRAY(_ptr,_count,_type)   \
+           ALLOC(_ptr,(_count)*sizeof(_type))
+
+#define  REALLOC_ARRAY(_ptr,_oldcnt,_newcnt,_type) \
+           REALLOC(_ptr,(_oldcnt)*sizeof(_type),(_newcnt)*sizeof(_type))
+
+#define  MEM_Copy(dest,source,count)   memcpy( (char*)(dest), (const char*)(source), (size_t)(count) )
+
+
+FTGLUE_API( FT_Pointer )
+ftglue_alloc( FT_Memory  memory,
+              FT_ULong   size,
+              FT_Error  *perror );
+
+FTGLUE_API( FT_Pointer )
+ftglue_realloc( FT_Memory   memory,
+                FT_Pointer  block,
+                FT_ULong    old_size,
+                FT_ULong    new_size,
+                FT_Error   *perror );
+
+FTGLUE_API( void )
+ftglue_free( FT_Memory   memory,
+             FT_Pointer  block );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __OPENTYPE_FTGLUE_H__ */