Added TQt4 HEAD

1 files changed, 4329 insertions, 0 deletions

diff --git a/tqtinterface/qt4/include/private/qt4_harfbuzz/src/harfbuzz-gsub.c b/tqtinterface/qt4/include/private/qt4_harfbuzz/src/harfbuzz-gsub.c
new file mode 100644
index 0000000..21fec51
--- /dev/null
+++ b/tqtinterface/qt4/include/private/qt4_harfbuzz/src/harfbuzz-gsub.c
@@ -0,0 +1,4329 @@
+/*
+ * Copyright (C) 1998-2004  David Turner and Werner Lemberg
+ * Copyright (C) 2006  Behdad Esfahbod
+ * Copyright (C) 2007  Red Hat, Inc.
+ *
+ * This is part of HarfBuzz, an OpenType Layout engine library.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ * Red Hat Author(s): Behdad Esfahbod
+ */
+
+#include "harfbuzz-impl.h"
+#include "harfbuzz-gsub-private.h"
+#include "harfbuzz-open-private.h"
+#include "harfbuzz-gdef-private.h"
+
+static HB_Error  GSUB_Do_Glyph_Lookup( HB_GSUBHeader*   gsub,
+				       HB_UShort         lookup_index,
+				       HB_Buffer        buffer,
+				       HB_UShort         context_length,
+				       int               nesting_level );
+
+
+
+/**********************
+ * Auxiliary functions
+ **********************/
+
+
+
+HB_Error  HB_Load_GSUB_Table( HB_Stream stream,
+			      HB_GSUBHeader** retptr,
+			      HB_GDEFHeader*  gdef,
+                              HB_Stream       gdefStream )
+{
+  HB_Error         error;
+  HB_UInt         cur_offset, new_offset, base_offset;
+
+  HB_GSUBHeader*  gsub;
+
+  if ( !retptr )
+    return ERR(HB_Err_Invalid_Argument);
+
+  if ( GOTO_Table( TTAG_GSUB ) )
+    return error;
+
+  base_offset = FILE_Pos();
+
+  if ( ALLOC ( gsub, sizeof( *gsub ) ) ) 
+      return error;
+  
+
+  /* skip version */
+
+  if ( FILE_Seek( base_offset + 4L ) ||
+       ACCESS_Frame( 2L ) )
+    goto Fail4;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_ScriptList( &gsub->ScriptList,
+				  stream ) ) != HB_Err_Ok )
+    goto Fail4;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail3;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_FeatureList( &gsub->FeatureList,
+				   stream ) ) != HB_Err_Ok )
+    goto Fail3;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_LookupList( &gsub->LookupList,
+				  stream, HB_Type_GSUB ) ) != HB_Err_Ok )
+    goto Fail2;
+
+  gsub->gdef = gdef;      /* can be NULL */
+
+  if ( ( error =  _HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( gdef, gdefStream,
+								     gsub->LookupList.Lookup,
+								     gsub->LookupList.LookupCount ) ) )
+    goto Fail1;
+
+  *retptr = gsub;
+
+  return HB_Err_Ok;
+
+Fail1:
+  _HB_OPEN_Free_LookupList( &gsub->LookupList, HB_Type_GSUB );
+
+Fail2:
+  _HB_OPEN_Free_FeatureList( &gsub->FeatureList );
+
+Fail3:
+  _HB_OPEN_Free_ScriptList( &gsub->ScriptList );
+
+Fail4:
+  FREE ( gsub );
+
+
+  return error;
+}
+
+
+HB_Error   HB_Done_GSUB_Table( HB_GSUBHeader* gsub )
+{
+  _HB_OPEN_Free_LookupList( &gsub->LookupList, HB_Type_GSUB );
+  _HB_OPEN_Free_FeatureList( &gsub->FeatureList );
+  _HB_OPEN_Free_ScriptList( &gsub->ScriptList );
+
+  FREE( gsub );
+
+  return HB_Err_Ok;
+}
+
+/*****************************
+ * SubTable related functions
+ *****************************/
+
+
+/* LookupType 1 */
+
+/* SingleSubstFormat1 */
+/* SingleSubstFormat2 */
+
+static HB_Error  Load_SingleSubst( HB_GSUB_SubTable* st,
+				   HB_Stream         stream )
+{
+  HB_Error error;
+  HB_SingleSubst*  ss = &st->single;
+
+  HB_UShort n, count;
+  HB_UInt cur_offset, new_offset, base_offset;
+
+  HB_UShort*  s;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  ss->SubstFormat = GET_UShort();
+  new_offset      = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &ss->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  switch ( ss->SubstFormat )
+  {
+  case 1:
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail2;
+
+    ss->ssf.ssf1.DeltaGlyphID = GET_UShort();
+
+    FORGET_Frame();
+
+    break;
+
+  case 2:
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail2;
+
+    count = ss->ssf.ssf2.GlyphCount = GET_UShort();
+
+    FORGET_Frame();
+
+    ss->ssf.ssf2.Substitute = NULL;
+
+    if ( ALLOC_ARRAY( ss->ssf.ssf2.Substitute, count, HB_UShort ) )
+      goto Fail2;
+
+    s = ss->ssf.ssf2.Substitute;
+
+    if ( ACCESS_Frame( count * 2L ) )
+      goto Fail1;
+
+    for ( n = 0; n < count; n++ )
+      s[n] = GET_UShort();
+
+    FORGET_Frame();
+
+    break;
+
+  default:
+    return ERR(HB_Err_Invalid_SubTable_Format);
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( s );
+
+Fail2:
+  _HB_OPEN_Free_Coverage( &ss->Coverage );
+  return error;
+}
+
+
+static void  Free_SingleSubst( HB_GSUB_SubTable* st )
+{
+  HB_SingleSubst*  ss = &st->single;
+
+  switch ( ss->SubstFormat )
+  {
+  case 1:
+    break;
+
+  case 2:
+    FREE( ss->ssf.ssf2.Substitute );
+    break;
+
+  default:
+    break;
+  }
+
+  _HB_OPEN_Free_Coverage( &ss->Coverage );
+}
+
+
+static HB_Error  Lookup_SingleSubst( HB_GSUBHeader*   gsub,
+				     HB_GSUB_SubTable* st,
+				     HB_Buffer        buffer,
+				     HB_UShort         flags,
+				     HB_UShort         context_length,
+				     int               nesting_level )
+{
+  HB_UShort index, value, property;
+  HB_Error  error;
+  HB_SingleSubst*  ss = &st->single;
+  HB_GDEFHeader*   gdef = gsub->gdef;
+
+  HB_UNUSED(nesting_level);
+
+  if ( context_length != 0xFFFF && context_length < 1 )
+    return HB_Err_Not_Covered;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  error = _HB_OPEN_Coverage_Index( &ss->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  switch ( ss->SubstFormat )
+  {
+  case 1:
+    value = ( IN_CURGLYPH() + ss->ssf.ssf1.DeltaGlyphID ) & 0xFFFF;
+    if ( REPLACE_Glyph( buffer, value, nesting_level ) )
+      return error;
+    break;
+
+  case 2:
+    if ( index >= ss->ssf.ssf2.GlyphCount )
+      return ERR(HB_Err_Invalid_SubTable);
+    value = ss->ssf.ssf2.Substitute[index];
+    if ( REPLACE_Glyph( buffer, value, nesting_level ) )
+      return error;
+    break;
+
+  default:
+    return ERR(HB_Err_Invalid_SubTable);
+  }
+
+  if ( gdef && gdef->NewGlyphClasses )
+  {
+    /* we inherit the old glyph class to the substituted glyph */
+
+    error = _HB_GDEF_Add_Glyph_Property( gdef, value, property );
+    if ( error && error != HB_Err_Not_Covered )
+      return error;
+  }
+
+  return HB_Err_Ok;
+}
+
+
+/* LookupType 2 */
+
+/* Sequence */
+
+static HB_Error  Load_Sequence( HB_Sequence*  s,
+				HB_Stream      stream )
+{
+  HB_Error error;
+
+  HB_UShort n, count;
+  HB_UShort*  sub;
+
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = s->GlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  s->Substitute = NULL;
+
+  if ( count )
+  {
+    if ( ALLOC_ARRAY( s->Substitute, count, HB_UShort ) )
+      return error;
+
+    sub = s->Substitute;
+
+    if ( ACCESS_Frame( count * 2L ) )
+    {
+      FREE( sub );
+      return error;
+    }
+
+    for ( n = 0; n < count; n++ )
+      sub[n] = GET_UShort();
+
+    FORGET_Frame();
+  }
+
+  return HB_Err_Ok;
+}
+
+
+static void  Free_Sequence( HB_Sequence*  s )
+{
+  FREE( s->Substitute );
+}
+
+
+/* MultipleSubstFormat1 */
+
+static HB_Error  Load_MultipleSubst( HB_GSUB_SubTable* st,
+				     HB_Stream         stream )
+{
+  HB_Error error;
+  HB_MultipleSubst*  ms = &st->multiple;
+
+  HB_UShort      n = 0, m, count;
+  HB_UInt       cur_offset, new_offset, base_offset;
+
+  HB_Sequence*  s;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  ms->SubstFormat = GET_UShort();             /* should be 1 */
+  new_offset      = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &ms->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  count = ms->SequenceCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ms->Sequence = NULL;
+
+  if ( ALLOC_ARRAY( ms->Sequence, count, HB_Sequence ) )
+    goto Fail2;
+
+  s = ms->Sequence;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_Sequence( &s[n], stream ) ) != HB_Err_Ok )
+      goto Fail1;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_Sequence( &s[m] );
+
+  FREE( s );
+
+Fail2:
+  _HB_OPEN_Free_Coverage( &ms->Coverage );
+  return error;
+}
+
+
+static void  Free_MultipleSubst( HB_GSUB_SubTable* st )
+{
+  HB_UShort      n, count;
+  HB_MultipleSubst*  ms = &st->multiple;
+
+  HB_Sequence*  s;
+
+
+  if ( ms->Sequence )
+  {
+    count = ms->SequenceCount;
+    s     = ms->Sequence;
+
+    for ( n = 0; n < count; n++ )
+      Free_Sequence( &s[n] );
+
+    FREE( s );
+  }
+
+  _HB_OPEN_Free_Coverage( &ms->Coverage );
+}
+
+
+static HB_Error  Lookup_MultipleSubst( HB_GSUBHeader*    gsub,
+				       HB_GSUB_SubTable* st,
+				       HB_Buffer         buffer,
+				       HB_UShort          flags,
+				       HB_UShort          context_length,
+				       int                nesting_level )
+{
+  HB_Error  error;
+  HB_UShort index, property, n, count;
+  HB_UShort*s;
+  HB_MultipleSubst*  ms = &st->multiple;
+  HB_GDEFHeader*     gdef = gsub->gdef;
+
+  HB_UNUSED(nesting_level);
+
+  if ( context_length != 0xFFFF && context_length < 1 )
+    return HB_Err_Not_Covered;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  error = _HB_OPEN_Coverage_Index( &ms->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  if ( index >= ms->SequenceCount )
+    return ERR(HB_Err_Invalid_SubTable);
+
+  count = ms->Sequence[index].GlyphCount;
+  s     = ms->Sequence[index].Substitute;
+
+  if ( ADD_String( buffer, 1, count, s, 0xFFFF, 0xFFFF ) )
+    return error;
+
+  if ( gdef && gdef->NewGlyphClasses )
+  {
+    /* this is a guess only ... */
+
+    if ( property == HB_GDEF_LIGATURE )
+      property = HB_GDEF_BASE_GLYPH;
+
+    for ( n = 0; n < count; n++ )
+    {
+      error = _HB_GDEF_Add_Glyph_Property( gdef, s[n], property );
+      if ( error && error != HB_Err_Not_Covered )
+	return error;
+    }
+  }
+
+  return HB_Err_Ok;
+}
+
+
+/* LookupType 3 */
+
+/* AlternateSet */
+
+static HB_Error  Load_AlternateSet( HB_AlternateSet*  as,
+				    HB_Stream          stream )
+{
+  HB_Error error;
+
+  HB_UShort n, count;
+  HB_UShort*  a;
+
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = as->GlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  as->Alternate = NULL;
+
+  if ( ALLOC_ARRAY( as->Alternate, count, HB_UShort ) )
+    return error;
+
+  a = as->Alternate;
+
+  if ( ACCESS_Frame( count * 2L ) )
+  {
+    FREE( a );
+    return error;
+  }
+
+  for ( n = 0; n < count; n++ )
+    a[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+}
+
+
+static void  Free_AlternateSet( HB_AlternateSet*  as )
+{
+  FREE( as->Alternate );
+}
+
+
+/* AlternateSubstFormat1 */
+
+static HB_Error  Load_AlternateSubst( HB_GSUB_SubTable* st,
+				      HB_Stream         stream )
+{
+  HB_Error error;
+  HB_AlternateSubst* as = &st->alternate;
+
+  HB_UShort          n = 0, m, count;
+  HB_UInt           cur_offset, new_offset, base_offset;
+
+  HB_AlternateSet*  aset;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  as->SubstFormat = GET_UShort();             /* should be 1 */
+  new_offset      = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &as->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  count = as->AlternateSetCount = GET_UShort();
+
+  FORGET_Frame();
+
+  as->AlternateSet = NULL;
+
+  if ( ALLOC_ARRAY( as->AlternateSet, count, HB_AlternateSet ) )
+    goto Fail2;
+
+  aset = as->AlternateSet;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_AlternateSet( &aset[n], stream ) ) != HB_Err_Ok )
+      goto Fail1;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_AlternateSet( &aset[m] );
+
+  FREE( aset );
+
+Fail2:
+  _HB_OPEN_Free_Coverage( &as->Coverage );
+  return error;
+}
+
+
+static void  Free_AlternateSubst( HB_GSUB_SubTable* st )
+{
+  HB_UShort          n, count;
+  HB_AlternateSubst* as = &st->alternate;
+
+  HB_AlternateSet*  aset;
+
+
+  if ( as->AlternateSet )
+  {
+    count = as->AlternateSetCount;
+    aset  = as->AlternateSet;
+
+    for ( n = 0; n < count; n++ )
+      Free_AlternateSet( &aset[n] );
+
+    FREE( aset );
+  }
+
+  _HB_OPEN_Free_Coverage( &as->Coverage );
+}
+
+
+static HB_Error  Lookup_AlternateSubst( HB_GSUBHeader*    gsub,
+					HB_GSUB_SubTable* st,
+					HB_Buffer         buffer,
+					HB_UShort          flags,
+					HB_UShort          context_length,
+					int                nesting_level )
+{
+  HB_Error          error;
+  HB_UShort         index, value, alt_index, property;
+  HB_AlternateSubst* as = &st->alternate;
+  HB_GDEFHeader*     gdef = gsub->gdef;
+  HB_AlternateSet  aset;
+
+  HB_UNUSED(nesting_level);
+
+  if ( context_length != 0xFFFF && context_length < 1 )
+    return HB_Err_Not_Covered;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  error = _HB_OPEN_Coverage_Index( &as->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  aset = as->AlternateSet[index];
+
+  /* we use a user-defined callback function to get the alternate index */
+
+  if ( gsub->altfunc )
+    alt_index = (gsub->altfunc)( buffer->out_pos, IN_CURGLYPH(),
+				 aset.GlyphCount, aset.Alternate,
+				 gsub->data );
+  else
+    alt_index = 0;
+
+  value = aset.Alternate[alt_index];
+  if ( REPLACE_Glyph( buffer, value, nesting_level ) )
+    return error;
+
+  if ( gdef && gdef->NewGlyphClasses )
+  {
+    /* we inherit the old glyph class to the substituted glyph */
+
+    error = _HB_GDEF_Add_Glyph_Property( gdef, value, property );
+    if ( error && error != HB_Err_Not_Covered )
+      return error;
+  }
+
+  return HB_Err_Ok;
+}
+
+
+/* LookupType 4 */
+
+/* Ligature */
+
+static HB_Error  Load_Ligature( HB_Ligature*  l,
+				HB_Stream      stream )
+{
+  HB_Error error;
+
+  HB_UShort n, count;
+  HB_UShort*  c;
+
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  l->LigGlyph       = GET_UShort();
+  l->ComponentCount = GET_UShort();
+
+  FORGET_Frame();
+
+  l->Component = NULL;
+
+  count = l->ComponentCount - 1;      /* only ComponentCount - 1 elements */
+
+  if ( ALLOC_ARRAY( l->Component, count, HB_UShort ) )
+    return error;
+
+  c = l->Component;
+
+  if ( ACCESS_Frame( count * 2L ) )
+  {
+    FREE( c );
+    return error;
+  }
+
+  for ( n = 0; n < count; n++ )
+    c[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+}
+
+
+static void  Free_Ligature( HB_Ligature*  l )
+{
+  FREE( l->Component );
+}
+
+
+/* LigatureSet */
+
+static HB_Error  Load_LigatureSet( HB_LigatureSet*  ls,
+				   HB_Stream         stream )
+{
+  HB_Error error;
+
+  HB_UShort      n = 0, m, count;
+  HB_UInt       cur_offset, new_offset, base_offset;
+
+  HB_Ligature*  l;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = ls->LigatureCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ls->Ligature = NULL;
+
+  if ( ALLOC_ARRAY( ls->Ligature, count, HB_Ligature ) )
+    return error;
+
+  l = ls->Ligature;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_Ligature( &l[n], stream ) ) != HB_Err_Ok )
+      goto Fail;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail:
+  for ( m = 0; m < n; m++ )
+    Free_Ligature( &l[m] );
+
+  FREE( l );
+  return error;
+}
+
+
+static void  Free_LigatureSet( HB_LigatureSet*  ls )
+{
+  HB_UShort      n, count;
+
+  HB_Ligature*  l;
+
+
+  if ( ls->Ligature )
+  {
+    count = ls->LigatureCount;
+    l     = ls->Ligature;
+
+    for ( n = 0; n < count; n++ )
+      Free_Ligature( &l[n] );
+
+    FREE( l );
+  }
+}
+
+
+/* LigatureSubstFormat1 */
+
+static HB_Error  Load_LigatureSubst( HB_GSUB_SubTable* st,
+				     HB_Stream         stream )
+{
+  HB_Error error;
+  HB_LigatureSubst*  ls = &st->ligature;
+
+  HB_UShort         n = 0, m, count;
+  HB_UInt          cur_offset, new_offset, base_offset;
+
+  HB_LigatureSet*  lset;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  ls->SubstFormat = GET_UShort();             /* should be 1 */
+  new_offset      = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &ls->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  count = ls->LigatureSetCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ls->LigatureSet = NULL;
+
+  if ( ALLOC_ARRAY( ls->LigatureSet, count, HB_LigatureSet ) )
+    goto Fail2;
+
+  lset = ls->LigatureSet;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_LigatureSet( &lset[n], stream ) ) != HB_Err_Ok )
+      goto Fail1;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_LigatureSet( &lset[m] );
+
+  FREE( lset );
+
+Fail2:
+  _HB_OPEN_Free_Coverage( &ls->Coverage );
+  return error;
+}
+
+
+static void  Free_LigatureSubst( HB_GSUB_SubTable* st )
+{
+  HB_UShort         n, count;
+  HB_LigatureSubst*  ls = &st->ligature;
+
+  HB_LigatureSet*  lset;
+
+
+  if ( ls->LigatureSet )
+  {
+    count = ls->LigatureSetCount;
+    lset  = ls->LigatureSet;
+
+    for ( n = 0; n < count; n++ )
+      Free_LigatureSet( &lset[n] );
+
+    FREE( lset );
+  }
+
+  _HB_OPEN_Free_Coverage( &ls->Coverage );
+}
+
+
+static HB_Error  Lookup_LigatureSubst( HB_GSUBHeader*    gsub,
+				       HB_GSUB_SubTable* st,
+				       HB_Buffer         buffer,
+				       HB_UShort          flags,
+				       HB_UShort          context_length,
+				       int                nesting_level )
+{
+  HB_UShort      index, property;
+  HB_Error       error;
+  HB_UShort      numlig, i, j, is_mark, first_is_mark = FALSE;
+  HB_UShort*     c;
+  HB_LigatureSubst*  ls = &st->ligature;
+  HB_GDEFHeader*     gdef = gsub->gdef;
+
+  HB_Ligature*  lig;
+
+  HB_UNUSED(nesting_level);
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  if ( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS )
+    first_is_mark = TRUE;
+
+  error = _HB_OPEN_Coverage_Index( &ls->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  if ( index >= ls->LigatureSetCount )
+     return ERR(HB_Err_Invalid_SubTable);
+
+  lig = ls->LigatureSet[index].Ligature;
+
+  for ( numlig = ls->LigatureSet[index].LigatureCount;
+	numlig;
+	numlig--, lig++ )
+  {
+    if ( buffer->in_pos + lig->ComponentCount > buffer->in_length )
+      goto next_ligature;               /* Not enough glyphs in input */
+
+    c    = lig->Component;
+
+    is_mark = first_is_mark;
+
+    if ( context_length != 0xFFFF && context_length < lig->ComponentCount )
+      break;
+
+    for ( i = 1, j = buffer->in_pos + 1; i < lig->ComponentCount; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  return error;
+
+	if ( j + lig->ComponentCount - i == (HB_Int)buffer->in_length )
+	  goto next_ligature;
+	j++;
+      }
+
+      if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) )
+	is_mark = FALSE;
+
+      if ( IN_GLYPH( j ) != c[i - 1] )
+	goto next_ligature;
+    }
+
+    if ( gdef && gdef->NewGlyphClasses )
+    {
+      /* this is just a guess ... */
+
+      error = _HB_GDEF_Add_Glyph_Property( gdef, lig->LigGlyph,
+				  is_mark ? HB_GDEF_MARK : HB_GDEF_LIGATURE );
+      if ( error && error != HB_Err_Not_Covered )
+	return error;
+    }
+
+    if ( j == buffer->in_pos + i ) /* No input glyphs skipped */
+    {
+      /* We don't use a new ligature ID if there are no skipped
+	 glyphs and the ligature already has an ID.             */
+
+      if ( IN_LIGID( buffer->in_pos ) )
+      {
+	if ( ADD_String( buffer, i, 1, &lig->LigGlyph,
+			0xFFFF, 0xFFFF ) )
+	  return error;
+      }
+      else
+      {
+	HB_UShort ligID = _hb_buffer_allocate_ligid( buffer );
+	if ( ADD_String( buffer, i, 1, &lig->LigGlyph,
+			0xFFFF, ligID ) )
+	  return error;
+      }
+    }
+    else
+    {
+      HB_UShort ligID = _hb_buffer_allocate_ligid( buffer );
+      if ( ADD_Glyph( buffer, lig->LigGlyph, 0xFFFF, ligID ) )
+	return error;
+
+      /* Now we must do a second loop to copy the skipped glyphs to
+	 `out' and assign component values to it.  We start with the
+	 glyph after the first component.  Glyphs between component
+	 i and i+1 belong to component i.  Together with the ligID
+	 value it is later possible to check whether a specific
+	 component value really belongs to a given ligature.         */
+
+      for ( i = 0; i < lig->ComponentCount - 1; i++ )
+      {
+	while ( CHECK_Property( gdef, IN_CURITEM(),
+				flags, &property ) )
+	  if ( ADD_Glyph( buffer, IN_CURGLYPH(), i, ligID ) )
+	    return error;
+
+	(buffer->in_pos)++;
+      }
+    }
+
+    return HB_Err_Ok;
+
+  next_ligature:
+    ;
+  }
+
+  return HB_Err_Not_Covered;
+}
+
+
+/* Do the actual substitution for a context substitution (either format
+   5 or 6).  This is only called after we've determined that the input
+   matches the subrule.                                                 */
+
+static HB_Error  Do_ContextSubst( HB_GSUBHeader*        gsub,
+				  HB_UShort              GlyphCount,
+				  HB_UShort              SubstCount,
+				  HB_SubstLookupRecord* subst,
+				  HB_Buffer             buffer,
+				  int                    nesting_level )
+{
+  HB_Error  error;
+  HB_UInt   i, old_pos;
+
+
+  i = 0;
+
+  while ( i < GlyphCount )
+  {
+    if ( SubstCount && i == subst->SequenceIndex )
+    {
+      old_pos = buffer->in_pos;
+
+      /* Do a substitution */
+
+      error = GSUB_Do_Glyph_Lookup( gsub, subst->LookupListIndex, buffer,
+				    GlyphCount, nesting_level );
+
+      subst++;
+      SubstCount--;
+      i += buffer->in_pos - old_pos;
+
+      if ( error == HB_Err_Not_Covered )
+      {
+	if ( COPY_Glyph( buffer ) )
+	  return error;
+	i++;
+      }
+      else if ( error )
+	return error;
+    }
+    else
+    {
+      /* No substitution for this index */
+
+      if ( COPY_Glyph( buffer ) )
+	return error;
+      i++;
+    }
+  }
+
+  return HB_Err_Ok;
+}
+
+
+/* LookupType 5 */
+
+/* SubRule */
+
+static HB_Error  Load_SubRule( HB_SubRule*  sr,
+			       HB_Stream     stream )
+{
+  HB_Error error;
+
+  HB_UShort               n, count;
+  HB_UShort*              i;
+
+  HB_SubstLookupRecord*  slr;
+
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  sr->GlyphCount = GET_UShort();
+  sr->SubstCount = GET_UShort();
+
+  FORGET_Frame();
+
+  sr->Input = NULL;
+
+  count = sr->GlyphCount - 1;         /* only GlyphCount - 1 elements */
+
+  if ( ALLOC_ARRAY( sr->Input, count, HB_UShort ) )
+    return error;
+
+  i = sr->Input;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail2;
+
+  for ( n = 0; n < count; n++ )
+    i[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  sr->SubstLookupRecord = NULL;
+
+  count = sr->SubstCount;
+
+  if ( ALLOC_ARRAY( sr->SubstLookupRecord, count, HB_SubstLookupRecord ) )
+    goto Fail2;
+
+  slr = sr->SubstLookupRecord;
+
+  if ( ACCESS_Frame( count * 4L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+  {
+    slr[n].SequenceIndex   = GET_UShort();
+    slr[n].LookupListIndex = GET_UShort();
+  }
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( slr );
+
+Fail2:
+  FREE( i );
+  return error;
+}
+
+
+static void  Free_SubRule( HB_SubRule*  sr )
+{
+  FREE( sr->SubstLookupRecord );
+  FREE( sr->Input );
+}
+
+
+/* SubRuleSet */
+
+static HB_Error  Load_SubRuleSet( HB_SubRuleSet*  srs,
+				  HB_Stream        stream )
+{
+  HB_Error error;
+
+  HB_UShort     n = 0, m, count;
+  HB_UInt      cur_offset, new_offset, base_offset;
+
+  HB_SubRule*  sr;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = srs->SubRuleCount = GET_UShort();
+
+  FORGET_Frame();
+
+  srs->SubRule = NULL;
+
+  if ( ALLOC_ARRAY( srs->SubRule, count, HB_SubRule ) )
+    return error;
+
+  sr = srs->SubRule;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_SubRule( &sr[n], stream ) ) != HB_Err_Ok )
+      goto Fail;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail:
+  for ( m = 0; m < n; m++ )
+    Free_SubRule( &sr[m] );
+
+  FREE( sr );
+  return error;
+}
+
+
+static void  Free_SubRuleSet( HB_SubRuleSet*  srs )
+{
+  HB_UShort     n, count;
+
+  HB_SubRule*  sr;
+
+
+  if ( srs->SubRule )
+  {
+    count = srs->SubRuleCount;
+    sr    = srs->SubRule;
+
+    for ( n = 0; n < count; n++ )
+      Free_SubRule( &sr[n] );
+
+    FREE( sr );
+  }
+}
+
+
+/* ContextSubstFormat1 */
+
+static HB_Error  Load_ContextSubst1( HB_ContextSubstFormat1*  csf1,
+				     HB_Stream                 stream )
+{
+  HB_Error error;
+
+  HB_UShort        n = 0, m, count;
+  HB_UInt         cur_offset, new_offset, base_offset;
+
+  HB_SubRuleSet*  srs;
+
+
+  base_offset = FILE_Pos() - 2L;
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &csf1->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  count = csf1->SubRuleSetCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csf1->SubRuleSet = NULL;
+
+  if ( ALLOC_ARRAY( csf1->SubRuleSet, count, HB_SubRuleSet ) )
+    goto Fail2;
+
+  srs = csf1->SubRuleSet;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_SubRuleSet( &srs[n], stream ) ) != HB_Err_Ok )
+      goto Fail1;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_SubRuleSet( &srs[m] );
+
+  FREE( srs );
+
+Fail2:
+  _HB_OPEN_Free_Coverage( &csf1->Coverage );
+  return error;
+}
+
+
+static void  Free_ContextSubst1( HB_ContextSubstFormat1* csf1 )
+{
+  HB_UShort        n, count;
+
+  HB_SubRuleSet*  srs;
+
+
+  if ( csf1->SubRuleSet )
+  {
+    count = csf1->SubRuleSetCount;
+    srs   = csf1->SubRuleSet;
+
+    for ( n = 0; n < count; n++ )
+      Free_SubRuleSet( &srs[n] );
+
+    FREE( srs );
+  }
+
+  _HB_OPEN_Free_Coverage( &csf1->Coverage );
+}
+
+
+/* SubClassRule */
+
+static HB_Error  Load_SubClassRule( HB_ContextSubstFormat2*  csf2,
+				    HB_SubClassRule*         scr,
+				    HB_Stream                 stream )
+{
+  HB_Error error;
+
+  HB_UShort               n, count;
+
+  HB_UShort*              c;
+  HB_SubstLookupRecord*  slr;
+
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  scr->GlyphCount = GET_UShort();
+  scr->SubstCount = GET_UShort();
+
+  if ( scr->GlyphCount > csf2->MaxContextLength )
+    csf2->MaxContextLength = scr->GlyphCount;
+
+  FORGET_Frame();
+
+  scr->Class = NULL;
+
+  count = scr->GlyphCount - 1;        /* only GlyphCount - 1 elements */
+
+  if ( ALLOC_ARRAY( scr->Class, count, HB_UShort ) )
+    return error;
+
+  c = scr->Class;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail2;
+
+  for ( n = 0; n < count; n++ )
+    c[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  scr->SubstLookupRecord = NULL;
+
+  count = scr->SubstCount;
+
+  if ( ALLOC_ARRAY( scr->SubstLookupRecord, count, HB_SubstLookupRecord ) )
+    goto Fail2;
+
+  slr = scr->SubstLookupRecord;
+
+  if ( ACCESS_Frame( count * 4L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+  {
+    slr[n].SequenceIndex   = GET_UShort();
+    slr[n].LookupListIndex = GET_UShort();
+  }
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( slr );
+
+Fail2:
+  FREE( c );
+  return error;
+}
+
+
+static void  Free_SubClassRule( HB_SubClassRule*  scr )
+{
+  FREE( scr->SubstLookupRecord );
+  FREE( scr->Class );
+}
+
+
+/* SubClassSet */
+
+static HB_Error  Load_SubClassSet( HB_ContextSubstFormat2*  csf2,
+				   HB_SubClassSet*          scs,
+				   HB_Stream                 stream )
+{
+  HB_Error error;
+
+  HB_UShort          n = 0, m, count;
+  HB_UInt           cur_offset, new_offset, base_offset;
+
+  HB_SubClassRule*  scr;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = scs->SubClassRuleCount = GET_UShort();
+
+  FORGET_Frame();
+
+  scs->SubClassRule = NULL;
+
+  if ( ALLOC_ARRAY( scs->SubClassRule, count, HB_SubClassRule ) )
+    return error;
+
+  scr = scs->SubClassRule;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_SubClassRule( csf2, &scr[n],
+				      stream ) ) != HB_Err_Ok )
+      goto Fail;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail:
+  for ( m = 0; m < n; m++ )
+    Free_SubClassRule( &scr[m] );
+
+  FREE( scr );
+  return error;
+}
+
+
+static void  Free_SubClassSet( HB_SubClassSet*  scs )
+{
+  HB_UShort          n, count;
+
+  HB_SubClassRule*  scr;
+
+
+  if ( scs->SubClassRule )
+  {
+    count = scs->SubClassRuleCount;
+    scr   = scs->SubClassRule;
+
+    for ( n = 0; n < count; n++ )
+      Free_SubClassRule( &scr[n] );
+
+    FREE( scr );
+  }
+}
+
+
+/* ContextSubstFormat2 */
+
+static HB_Error  Load_ContextSubst2( HB_ContextSubstFormat2*  csf2,
+				     HB_Stream                 stream )
+{
+  HB_Error error;
+
+  HB_UShort         n = 0, m, count;
+  HB_UInt          cur_offset, new_offset, base_offset;
+
+  HB_SubClassSet*  scs;
+
+
+  base_offset = FILE_Pos() - 2;
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &csf2->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 4L ) )
+    goto Fail3;
+
+  new_offset = GET_UShort() + base_offset;
+
+  /* `SubClassSetCount' is the upper limit for class values, thus we
+     read it now to make an additional safety check.                 */
+
+  count = csf2->SubClassSetCount = GET_UShort();
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_ClassDefinition( &csf2->ClassDef, count,
+				       stream ) ) != HB_Err_Ok )
+    goto Fail3;
+  (void)FILE_Seek( cur_offset );
+
+  csf2->SubClassSet      = NULL;
+  csf2->MaxContextLength = 0;
+
+  if ( ALLOC_ARRAY( csf2->SubClassSet, count, HB_SubClassSet ) )
+    goto Fail2;
+
+  scs = csf2->SubClassSet;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    if ( new_offset != base_offset )      /* not a NULL offset */
+    {
+      cur_offset = FILE_Pos();
+      if ( FILE_Seek( new_offset ) ||
+	   ( error = Load_SubClassSet( csf2, &scs[n],
+				       stream ) ) != HB_Err_Ok )
+	goto Fail1;
+      (void)FILE_Seek( cur_offset );
+    }
+    else
+    {
+      /* we create a SubClassSet table with no entries */
+
+      csf2->SubClassSet[n].SubClassRuleCount = 0;
+      csf2->SubClassSet[n].SubClassRule      = NULL;
+    }
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_SubClassSet( &scs[m] );
+
+  FREE( scs );
+
+Fail2:
+  _HB_OPEN_Free_ClassDefinition( &csf2->ClassDef );
+
+Fail3:
+  _HB_OPEN_Free_Coverage( &csf2->Coverage );
+  return error;
+}
+
+
+static void  Free_ContextSubst2( HB_ContextSubstFormat2*  csf2 )
+{
+  HB_UShort         n, count;
+
+  HB_SubClassSet*  scs;
+
+
+  if ( csf2->SubClassSet )
+  {
+    count = csf2->SubClassSetCount;
+    scs   = csf2->SubClassSet;
+
+    for ( n = 0; n < count; n++ )
+      Free_SubClassSet( &scs[n] );
+
+    FREE( scs );
+  }
+
+  _HB_OPEN_Free_ClassDefinition( &csf2->ClassDef );
+  _HB_OPEN_Free_Coverage( &csf2->Coverage );
+}
+
+
+/* ContextSubstFormat3 */
+
+static HB_Error  Load_ContextSubst3( HB_ContextSubstFormat3*  csf3,
+				     HB_Stream                 stream )
+{
+  HB_Error error;
+
+  HB_UShort               n = 0, m, count;
+  HB_UInt                cur_offset, new_offset, base_offset;
+
+  HB_Coverage*           c;
+  HB_SubstLookupRecord*  slr;
+
+
+  base_offset = FILE_Pos() - 2L;
+
+  if ( ACCESS_Frame( 4L ) )
+    return error;
+
+  csf3->GlyphCount = GET_UShort();
+  csf3->SubstCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csf3->Coverage = NULL;
+
+  count = csf3->GlyphCount;
+
+  if ( ALLOC_ARRAY( csf3->Coverage, count, HB_Coverage ) )
+    return error;
+
+  c = csf3->Coverage;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail2;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = _HB_OPEN_Load_Coverage( &c[n], stream ) ) != HB_Err_Ok )
+      goto Fail2;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  csf3->SubstLookupRecord = NULL;
+
+  count = csf3->SubstCount;
+
+  if ( ALLOC_ARRAY( csf3->SubstLookupRecord, count,
+		    HB_SubstLookupRecord ) )
+    goto Fail2;
+
+  slr = csf3->SubstLookupRecord;
+
+  if ( ACCESS_Frame( count * 4L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+  {
+    slr[n].SequenceIndex   = GET_UShort();
+    slr[n].LookupListIndex = GET_UShort();
+  }
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( slr );
+
+Fail2:
+  for ( m = 0; m < n; m++ )
+    _HB_OPEN_Free_Coverage( &c[m] );
+
+  FREE( c );
+  return error;
+}
+
+
+static void  Free_ContextSubst3( HB_ContextSubstFormat3*  csf3 )
+{
+  HB_UShort      n, count;
+
+  HB_Coverage*  c;
+
+
+  FREE( csf3->SubstLookupRecord );
+
+  if ( csf3->Coverage )
+  {
+    count = csf3->GlyphCount;
+    c     = csf3->Coverage;
+
+    for ( n = 0; n < count; n++ )
+      _HB_OPEN_Free_Coverage( &c[n] );
+
+    FREE( c );
+  }
+}
+
+
+/* ContextSubst */
+
+static HB_Error  Load_ContextSubst( HB_GSUB_SubTable* st,
+				    HB_Stream         stream )
+{
+  HB_Error error;
+  HB_ContextSubst*  cs = &st->context;
+
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  cs->SubstFormat = GET_UShort();
+
+  FORGET_Frame();
+
+  switch ( cs->SubstFormat )
+  {
+  case 1:  return Load_ContextSubst1( &cs->csf.csf1, stream );
+  case 2:  return Load_ContextSubst2( &cs->csf.csf2, stream );
+  case 3:  return Load_ContextSubst3( &cs->csf.csf3, stream );
+  default: return ERR(HB_Err_Invalid_SubTable_Format);
+  }
+
+  return HB_Err_Ok;               /* never reached */
+}
+
+
+static void  Free_ContextSubst( HB_GSUB_SubTable* st )
+{
+  HB_ContextSubst*  cs = &st->context;
+
+  switch ( cs->SubstFormat )
+  {
+  case 1:  Free_ContextSubst1( &cs->csf.csf1 ); break;
+  case 2:  Free_ContextSubst2( &cs->csf.csf2 ); break;
+  case 3:  Free_ContextSubst3( &cs->csf.csf3 ); break;
+  default:						break;
+  }
+}
+
+
+static HB_Error  Lookup_ContextSubst1( HB_GSUBHeader*          gsub,
+				       HB_ContextSubstFormat1* csf1,
+				       HB_Buffer               buffer,
+				       HB_UShort                flags,
+				       HB_UShort                context_length,
+				       int                      nesting_level )
+{
+  HB_UShort        index, property;
+  HB_UShort        i, j, k, numsr;
+  HB_Error         error;
+
+  HB_SubRule*     sr;
+  HB_GDEFHeader*  gdef;
+
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  error = _HB_OPEN_Coverage_Index( &csf1->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  sr    = csf1->SubRuleSet[index].SubRule;
+  numsr = csf1->SubRuleSet[index].SubRuleCount;
+
+  for ( k = 0; k < numsr; k++ )
+  {
+    if ( context_length != 0xFFFF && context_length < sr[k].GlyphCount )
+      goto next_subrule;
+
+    if ( buffer->in_pos + sr[k].GlyphCount > buffer->in_length )
+      goto next_subrule;                        /* context is too long */
+
+    for ( i = 1, j = buffer->in_pos + 1; i < sr[k].GlyphCount; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  return error;
+
+	if ( j + sr[k].GlyphCount - i == (HB_Int)buffer->in_length )
+	  goto next_subrule;
+	j++;
+      }
+
+      if ( IN_GLYPH( j ) != sr[k].Input[i - 1] )
+	goto next_subrule;
+    }
+
+    return Do_ContextSubst( gsub, sr[k].GlyphCount,
+			    sr[k].SubstCount, sr[k].SubstLookupRecord,
+			    buffer,
+			    nesting_level );
+  next_subrule:
+    ;
+  }
+
+  return HB_Err_Not_Covered;
+}
+
+
+static HB_Error  Lookup_ContextSubst2( HB_GSUBHeader*          gsub,
+				       HB_ContextSubstFormat2* csf2,
+				       HB_Buffer               buffer,
+				       HB_UShort                flags,
+				       HB_UShort                context_length,
+				       int                      nesting_level )
+{
+  HB_UShort          index, property;
+  HB_Error           error;
+  HB_UShort          i, j, k, known_classes;
+
+  HB_UShort*         classes;
+  HB_UShort*         cl;
+
+  HB_SubClassSet*   scs;
+  HB_SubClassRule*  sr;
+  HB_GDEFHeader*    gdef;
+
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  /* Note: The coverage table in format 2 doesn't give an index into
+	   anything.  It just lets us know whether or not we need to
+	   do any lookup at all.                                     */
+
+  error = _HB_OPEN_Coverage_Index( &csf2->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  if (csf2->MaxContextLength < 1)
+    return HB_Err_Not_Covered;
+
+  if ( ALLOC_ARRAY( classes, csf2->MaxContextLength, HB_UShort ) )
+    return error;
+
+  error = _HB_OPEN_Get_Class( &csf2->ClassDef, IN_CURGLYPH(),
+		     &classes[0], NULL );
+  if ( error && error != HB_Err_Not_Covered )
+    goto End;
+  known_classes = 0;
+
+  scs = &csf2->SubClassSet[classes[0]];
+  if ( !scs )
+  {
+    error = ERR(HB_Err_Invalid_SubTable);
+    goto End;
+  }
+
+  for ( k = 0; k < scs->SubClassRuleCount; k++ )
+  {
+    sr  = &scs->SubClassRule[k];
+
+    if ( context_length != 0xFFFF && context_length < sr->GlyphCount )
+      goto next_subclassrule;
+
+    if ( buffer->in_pos + sr->GlyphCount > buffer->in_length )
+      goto next_subclassrule;                      /* context is too long */
+
+    cl   = sr->Class;
+
+    /* Start at 1 because [0] is implied */
+
+    for ( i = 1, j = buffer->in_pos + 1; i < sr->GlyphCount; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  goto End;
+
+	if ( j + sr->GlyphCount - i < (HB_Int)buffer->in_length )
+	  goto next_subclassrule;
+	j++;
+      }
+
+      if ( i > known_classes )
+      {
+	/* Keeps us from having to do this for each rule */
+
+	error = _HB_OPEN_Get_Class( &csf2->ClassDef, IN_GLYPH( j ), &classes[i], NULL );
+	if ( error && error != HB_Err_Not_Covered )
+	  goto End;
+	known_classes = i;
+      }
+
+      if ( cl[i - 1] != classes[i] )
+	goto next_subclassrule;
+    }
+
+    error = Do_ContextSubst( gsub, sr->GlyphCount,
+			     sr->SubstCount, sr->SubstLookupRecord,
+			     buffer,
+			     nesting_level );
+    goto End;
+
+  next_subclassrule:
+    ;
+  }
+
+  error = HB_Err_Not_Covered;
+
+End:
+  FREE( classes );
+  return error;
+}
+
+
+static HB_Error  Lookup_ContextSubst3( HB_GSUBHeader*          gsub,
+				       HB_ContextSubstFormat3* csf3,
+				       HB_Buffer               buffer,
+				       HB_UShort                flags,
+				       HB_UShort                context_length,
+				       int                      nesting_level )
+{
+  HB_Error         error;
+  HB_UShort        index, i, j, property;
+
+  HB_Coverage*    c;
+  HB_GDEFHeader*  gdef;
+
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  if ( context_length != 0xFFFF && context_length < csf3->GlyphCount )
+    return HB_Err_Not_Covered;
+
+  if ( buffer->in_pos + csf3->GlyphCount > buffer->in_length )
+    return HB_Err_Not_Covered;         /* context is too long */
+
+  c    = csf3->Coverage;
+
+  for ( i = 1, j = buffer->in_pos + 1; i < csf3->GlyphCount; i++, j++ )
+  {
+    while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+    {
+      if ( error && error != HB_Err_Not_Covered )
+	return error;
+
+      if ( j + csf3->GlyphCount - i == (HB_Int)buffer->in_length )
+	return HB_Err_Not_Covered;
+      j++;
+    }
+
+    error = _HB_OPEN_Coverage_Index( &c[i], IN_GLYPH( j ), &index );
+    if ( error )
+      return error;
+  }
+
+  return Do_ContextSubst( gsub, csf3->GlyphCount,
+			  csf3->SubstCount, csf3->SubstLookupRecord,
+			  buffer,
+			  nesting_level );
+}
+
+
+static HB_Error  Lookup_ContextSubst( HB_GSUBHeader*    gsub,
+				      HB_GSUB_SubTable* st,
+				      HB_Buffer         buffer,
+				      HB_UShort          flags,
+				      HB_UShort          context_length,
+				      int                nesting_level )
+{
+  HB_ContextSubst*  cs = &st->context;
+
+  switch ( cs->SubstFormat )
+  {
+  case 1:  return Lookup_ContextSubst1( gsub, &cs->csf.csf1, buffer, flags, context_length, nesting_level );
+  case 2:  return Lookup_ContextSubst2( gsub, &cs->csf.csf2, buffer, flags, context_length, nesting_level );
+  case 3:  return Lookup_ContextSubst3( gsub, &cs->csf.csf3, buffer, flags, context_length, nesting_level );
+  default: return ERR(HB_Err_Invalid_SubTable_Format);
+  }
+
+  return HB_Err_Ok;               /* never reached */
+}
+
+
+/* LookupType 6 */
+
+/* ChainSubRule */
+
+static HB_Error  Load_ChainSubRule( HB_ChainSubRule*  csr,
+				    HB_Stream          stream )
+{
+  HB_Error error;
+
+  HB_UShort               n, count;
+  HB_UShort*              b;
+  HB_UShort*              i;
+  HB_UShort*              l;
+
+  HB_SubstLookupRecord*  slr;
+
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  csr->BacktrackGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csr->Backtrack = NULL;
+
+  count = csr->BacktrackGlyphCount;
+
+  if ( ALLOC_ARRAY( csr->Backtrack, count, HB_UShort ) )
+    return error;
+
+  b = csr->Backtrack;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail4;
+
+  for ( n = 0; n < count; n++ )
+    b[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail4;
+
+  csr->InputGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csr->Input = NULL;
+
+  count = csr->InputGlyphCount - 1;  /* only InputGlyphCount - 1 elements */
+
+  if ( ALLOC_ARRAY( csr->Input, count, HB_UShort ) )
+    goto Fail4;
+
+  i = csr->Input;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail3;
+
+  for ( n = 0; n < count; n++ )
+    i[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail3;
+
+  csr->LookaheadGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csr->Lookahead = NULL;
+
+  count = csr->LookaheadGlyphCount;
+
+  if ( ALLOC_ARRAY( csr->Lookahead, count, HB_UShort ) )
+    goto Fail3;
+
+  l = csr->Lookahead;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail2;
+
+  for ( n = 0; n < count; n++ )
+    l[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  csr->SubstCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csr->SubstLookupRecord = NULL;
+
+  count = csr->SubstCount;
+
+  if ( ALLOC_ARRAY( csr->SubstLookupRecord, count, HB_SubstLookupRecord ) )
+    goto Fail2;
+
+  slr = csr->SubstLookupRecord;
+
+  if ( ACCESS_Frame( count * 4L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+  {
+    slr[n].SequenceIndex   = GET_UShort();
+    slr[n].LookupListIndex = GET_UShort();
+  }
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( slr );
+
+Fail2:
+  FREE( l );
+
+Fail3:
+  FREE( i );
+
+Fail4:
+  FREE( b );
+  return error;
+}
+
+
+static void  Free_ChainSubRule( HB_ChainSubRule*  csr )
+{
+  FREE( csr->SubstLookupRecord );
+  FREE( csr->Lookahead );
+  FREE( csr->Input );
+  FREE( csr->Backtrack );
+}
+
+
+/* ChainSubRuleSet */
+
+static HB_Error  Load_ChainSubRuleSet( HB_ChainSubRuleSet*  csrs,
+				       HB_Stream             stream )
+{
+  HB_Error error;
+
+  HB_UShort          n = 0, m, count;
+  HB_UInt           cur_offset, new_offset, base_offset;
+
+  HB_ChainSubRule*  csr;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = csrs->ChainSubRuleCount = GET_UShort();
+
+  FORGET_Frame();
+
+  csrs->ChainSubRule = NULL;
+
+  if ( ALLOC_ARRAY( csrs->ChainSubRule, count, HB_ChainSubRule ) )
+    return error;
+
+  csr = csrs->ChainSubRule;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_ChainSubRule( &csr[n], stream ) ) != HB_Err_Ok )
+      goto Fail;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail:
+  for ( m = 0; m < n; m++ )
+    Free_ChainSubRule( &csr[m] );
+
+  FREE( csr );
+  return error;
+}
+
+
+static void  Free_ChainSubRuleSet( HB_ChainSubRuleSet*  csrs )
+{
+  HB_UShort          n, count;
+
+  HB_ChainSubRule*  csr;
+
+
+  if ( csrs->ChainSubRule )
+  {
+    count = csrs->ChainSubRuleCount;
+    csr   = csrs->ChainSubRule;
+
+    for ( n = 0; n < count; n++ )
+      Free_ChainSubRule( &csr[n] );
+
+    FREE( csr );
+  }
+}
+
+
+/* ChainContextSubstFormat1 */
+
+static HB_Error  Load_ChainContextSubst1(
+		   HB_ChainContextSubstFormat1*  ccsf1,
+		   HB_Stream                      stream )
+{
+  HB_Error error;
+
+  HB_UShort             n = 0, m, count;
+  HB_UInt              cur_offset, new_offset, base_offset;
+
+  HB_ChainSubRuleSet*  csrs;
+
+
+  base_offset = FILE_Pos() - 2L;
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &ccsf1->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  count = ccsf1->ChainSubRuleSetCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ccsf1->ChainSubRuleSet = NULL;
+
+  if ( ALLOC_ARRAY( ccsf1->ChainSubRuleSet, count, HB_ChainSubRuleSet ) )
+    goto Fail2;
+
+  csrs = ccsf1->ChainSubRuleSet;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_ChainSubRuleSet( &csrs[n], stream ) ) != HB_Err_Ok )
+      goto Fail1;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_ChainSubRuleSet( &csrs[m] );
+
+  FREE( csrs );
+
+Fail2:
+  _HB_OPEN_Free_Coverage( &ccsf1->Coverage );
+  return error;
+}
+
+
+static void  Free_ChainContextSubst1( HB_ChainContextSubstFormat1*  ccsf1 )
+{
+  HB_UShort             n, count;
+
+  HB_ChainSubRuleSet*  csrs;
+
+
+  if ( ccsf1->ChainSubRuleSet )
+  {
+    count = ccsf1->ChainSubRuleSetCount;
+    csrs  = ccsf1->ChainSubRuleSet;
+
+    for ( n = 0; n < count; n++ )
+      Free_ChainSubRuleSet( &csrs[n] );
+
+    FREE( csrs );
+  }
+
+  _HB_OPEN_Free_Coverage( &ccsf1->Coverage );
+}
+
+
+/* ChainSubClassRule */
+
+static HB_Error  Load_ChainSubClassRule(
+		   HB_ChainContextSubstFormat2*  ccsf2,
+		   HB_ChainSubClassRule*         cscr,
+		   HB_Stream                      stream )
+{
+  HB_Error error;
+
+  HB_UShort               n, count;
+
+  HB_UShort*              b;
+  HB_UShort*              i;
+  HB_UShort*              l;
+  HB_SubstLookupRecord*  slr;
+
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  cscr->BacktrackGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( cscr->BacktrackGlyphCount > ccsf2->MaxBacktrackLength )
+    ccsf2->MaxBacktrackLength = cscr->BacktrackGlyphCount;
+
+  cscr->Backtrack = NULL;
+
+  count = cscr->BacktrackGlyphCount;
+
+  if ( ALLOC_ARRAY( cscr->Backtrack, count, HB_UShort ) )
+    return error;
+
+  b = cscr->Backtrack;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail4;
+
+  for ( n = 0; n < count; n++ )
+    b[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail4;
+
+  cscr->InputGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( cscr->InputGlyphCount > ccsf2->MaxInputLength )
+    ccsf2->MaxInputLength = cscr->InputGlyphCount;
+
+  cscr->Input = NULL;
+
+  count = cscr->InputGlyphCount - 1; /* only InputGlyphCount - 1 elements */
+
+  if ( ALLOC_ARRAY( cscr->Input, count, HB_UShort ) )
+    goto Fail4;
+
+  i = cscr->Input;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail3;
+
+  for ( n = 0; n < count; n++ )
+    i[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail3;
+
+  cscr->LookaheadGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( cscr->LookaheadGlyphCount > ccsf2->MaxLookaheadLength )
+    ccsf2->MaxLookaheadLength = cscr->LookaheadGlyphCount;
+
+  cscr->Lookahead = NULL;
+
+  count = cscr->LookaheadGlyphCount;
+
+  if ( ALLOC_ARRAY( cscr->Lookahead, count, HB_UShort ) )
+    goto Fail3;
+
+  l = cscr->Lookahead;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail2;
+
+  for ( n = 0; n < count; n++ )
+    l[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  cscr->SubstCount = GET_UShort();
+
+  FORGET_Frame();
+
+  cscr->SubstLookupRecord = NULL;
+
+  count = cscr->SubstCount;
+
+  if ( ALLOC_ARRAY( cscr->SubstLookupRecord, count,
+		    HB_SubstLookupRecord ) )
+    goto Fail2;
+
+  slr = cscr->SubstLookupRecord;
+
+  if ( ACCESS_Frame( count * 4L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+  {
+    slr[n].SequenceIndex   = GET_UShort();
+    slr[n].LookupListIndex = GET_UShort();
+  }
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( slr );
+
+Fail2:
+  FREE( l );
+
+Fail3:
+  FREE( i );
+
+Fail4:
+  FREE( b );
+  return error;
+}
+
+
+static void  Free_ChainSubClassRule( HB_ChainSubClassRule*  cscr )
+{
+  FREE( cscr->SubstLookupRecord );
+  FREE( cscr->Lookahead );
+  FREE( cscr->Input );
+  FREE( cscr->Backtrack );
+}
+
+
+/* SubClassSet */
+
+static HB_Error  Load_ChainSubClassSet(
+		   HB_ChainContextSubstFormat2*  ccsf2,
+		   HB_ChainSubClassSet*          cscs,
+		   HB_Stream                      stream )
+{
+  HB_Error error;
+
+  HB_UShort               n = 0, m, count;
+  HB_UInt                cur_offset, new_offset, base_offset;
+
+  HB_ChainSubClassRule*  cscr;
+
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  count = cscs->ChainSubClassRuleCount = GET_UShort();
+
+  FORGET_Frame();
+
+  cscs->ChainSubClassRule = NULL;
+
+  if ( ALLOC_ARRAY( cscs->ChainSubClassRule, count,
+		    HB_ChainSubClassRule ) )
+    return error;
+
+  cscr = cscs->ChainSubClassRule;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = Load_ChainSubClassRule( ccsf2, &cscr[n],
+					   stream ) ) != HB_Err_Ok )
+      goto Fail;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  return HB_Err_Ok;
+
+Fail:
+  for ( m = 0; m < n; m++ )
+    Free_ChainSubClassRule( &cscr[m] );
+
+  FREE( cscr );
+  return error;
+}
+
+
+static void  Free_ChainSubClassSet( HB_ChainSubClassSet*  cscs )
+{
+  HB_UShort               n, count;
+
+  HB_ChainSubClassRule*  cscr;
+
+
+  if ( cscs->ChainSubClassRule )
+  {
+    count = cscs->ChainSubClassRuleCount;
+    cscr  = cscs->ChainSubClassRule;
+
+    for ( n = 0; n < count; n++ )
+      Free_ChainSubClassRule( &cscr[n] );
+
+    FREE( cscr );
+  }
+}
+
+
+/* ChainContextSubstFormat2 */
+
+static HB_Error  Load_ChainContextSubst2(
+		   HB_ChainContextSubstFormat2*  ccsf2,
+		   HB_Stream                      stream )
+{
+  HB_Error error;
+
+  HB_UShort              n = 0, m, count;
+  HB_UInt               cur_offset, new_offset, base_offset;
+  HB_UInt               backtrack_offset, input_offset, lookahead_offset;
+
+  HB_ChainSubClassSet*  cscs;
+
+
+  base_offset = FILE_Pos() - 2;
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &ccsf2->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+  if ( ACCESS_Frame( 8L ) )
+    goto Fail5;
+
+  backtrack_offset = GET_UShort();
+  input_offset     = GET_UShort();
+  lookahead_offset = GET_UShort();
+
+  /* `ChainSubClassSetCount' is the upper limit for input class values,
+     thus we read it now to make an additional safety check. No limit
+     is known or needed for the other two class definitions          */
+
+  count = ccsf2->ChainSubClassSetCount = GET_UShort();
+
+  FORGET_Frame();
+
+  if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccsf2->BacktrackClassDef, 65535,
+						       backtrack_offset, base_offset,
+						       stream ) ) != HB_Err_Ok )
+      goto Fail5;
+
+  if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccsf2->InputClassDef, count,
+						       input_offset, base_offset,
+						       stream ) ) != HB_Err_Ok )
+      goto Fail4;
+  if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccsf2->LookaheadClassDef, 65535,
+						       lookahead_offset, base_offset,
+						       stream ) ) != HB_Err_Ok )
+    goto Fail3;
+
+  ccsf2->ChainSubClassSet   = NULL;
+  ccsf2->MaxBacktrackLength = 0;
+  ccsf2->MaxInputLength     = 0;
+  ccsf2->MaxLookaheadLength = 0;
+
+  if ( ALLOC_ARRAY( ccsf2->ChainSubClassSet, count, HB_ChainSubClassSet ) )
+    goto Fail2;
+
+  cscs = ccsf2->ChainSubClassSet;
+
+  for ( n = 0; n < count; n++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail1;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    if ( new_offset != base_offset )      /* not a NULL offset */
+    {
+      cur_offset = FILE_Pos();
+      if ( FILE_Seek( new_offset ) ||
+	   ( error = Load_ChainSubClassSet( ccsf2, &cscs[n],
+					    stream ) ) != HB_Err_Ok )
+	goto Fail1;
+      (void)FILE_Seek( cur_offset );
+    }
+    else
+    {
+      /* we create a ChainSubClassSet table with no entries */
+
+      ccsf2->ChainSubClassSet[n].ChainSubClassRuleCount = 0;
+      ccsf2->ChainSubClassSet[n].ChainSubClassRule      = NULL;
+    }
+  }
+
+  return HB_Err_Ok;
+
+Fail1:
+  for ( m = 0; m < n; m++ )
+    Free_ChainSubClassSet( &cscs[m] );
+
+  FREE( cscs );
+
+Fail2:
+  _HB_OPEN_Free_ClassDefinition( &ccsf2->LookaheadClassDef );
+
+Fail3:
+  _HB_OPEN_Free_ClassDefinition( &ccsf2->InputClassDef );
+
+Fail4:
+  _HB_OPEN_Free_ClassDefinition( &ccsf2->BacktrackClassDef );
+
+Fail5:
+  _HB_OPEN_Free_Coverage( &ccsf2->Coverage );
+  return error;
+}
+
+
+static void  Free_ChainContextSubst2( HB_ChainContextSubstFormat2*  ccsf2 )
+{
+  HB_UShort              n, count;
+
+  HB_ChainSubClassSet*  cscs;
+
+
+  if ( ccsf2->ChainSubClassSet )
+  {
+    count = ccsf2->ChainSubClassSetCount;
+    cscs  = ccsf2->ChainSubClassSet;
+
+    for ( n = 0; n < count; n++ )
+      Free_ChainSubClassSet( &cscs[n] );
+
+    FREE( cscs );
+  }
+
+  _HB_OPEN_Free_ClassDefinition( &ccsf2->LookaheadClassDef );
+  _HB_OPEN_Free_ClassDefinition( &ccsf2->InputClassDef );
+  _HB_OPEN_Free_ClassDefinition( &ccsf2->BacktrackClassDef );
+
+  _HB_OPEN_Free_Coverage( &ccsf2->Coverage );
+}
+
+
+/* ChainContextSubstFormat3 */
+
+static HB_Error  Load_ChainContextSubst3(
+		   HB_ChainContextSubstFormat3*  ccsf3,
+		   HB_Stream                      stream )
+{
+  HB_Error error;
+
+  HB_UShort               n, nb = 0, ni =0, nl = 0, m, count;
+  HB_UShort               backtrack_count, input_count, lookahead_count;
+  HB_UInt                cur_offset, new_offset, base_offset;
+
+  HB_Coverage*           b;
+  HB_Coverage*           i;
+  HB_Coverage*           l;
+  HB_SubstLookupRecord*  slr;
+
+
+  base_offset = FILE_Pos() - 2L;
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  ccsf3->BacktrackGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ccsf3->BacktrackCoverage = NULL;
+
+  backtrack_count = ccsf3->BacktrackGlyphCount;
+
+  if ( ALLOC_ARRAY( ccsf3->BacktrackCoverage, backtrack_count,
+		    HB_Coverage ) )
+    return error;
+
+  b = ccsf3->BacktrackCoverage;
+
+  for ( nb = 0; nb < backtrack_count; nb++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail4;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = _HB_OPEN_Load_Coverage( &b[nb], stream ) ) != HB_Err_Ok )
+      goto Fail4;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail4;
+
+  ccsf3->InputGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ccsf3->InputCoverage = NULL;
+
+  input_count = ccsf3->InputGlyphCount;
+
+  if ( ALLOC_ARRAY( ccsf3->InputCoverage, input_count, HB_Coverage ) )
+    goto Fail4;
+
+  i = ccsf3->InputCoverage;
+
+  for ( ni = 0; ni < input_count; ni++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail3;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = _HB_OPEN_Load_Coverage( &i[ni], stream ) ) != HB_Err_Ok )
+      goto Fail3;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail3;
+
+  ccsf3->LookaheadGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ccsf3->LookaheadCoverage = NULL;
+
+  lookahead_count = ccsf3->LookaheadGlyphCount;
+
+  if ( ALLOC_ARRAY( ccsf3->LookaheadCoverage, lookahead_count,
+		    HB_Coverage ) )
+    goto Fail3;
+
+  l = ccsf3->LookaheadCoverage;
+
+  for ( nl = 0; nl < lookahead_count; nl++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail2;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = _HB_OPEN_Load_Coverage( &l[nl], stream ) ) != HB_Err_Ok )
+      goto Fail2;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  ccsf3->SubstCount = GET_UShort();
+
+  FORGET_Frame();
+
+  ccsf3->SubstLookupRecord = NULL;
+
+  count = ccsf3->SubstCount;
+
+  if ( ALLOC_ARRAY( ccsf3->SubstLookupRecord, count,
+		    HB_SubstLookupRecord ) )
+    goto Fail2;
+
+  slr = ccsf3->SubstLookupRecord;
+
+  if ( ACCESS_Frame( count * 4L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+  {
+    slr[n].SequenceIndex   = GET_UShort();
+    slr[n].LookupListIndex = GET_UShort();
+  }
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( slr );
+
+Fail2:
+  for ( m = 0; m < nl; m++ )
+    _HB_OPEN_Free_Coverage( &l[m] );
+
+  FREE( l );
+
+Fail3:
+  for ( m = 0; m < ni; m++ )
+    _HB_OPEN_Free_Coverage( &i[m] );
+
+  FREE( i );
+
+Fail4:
+  for ( m = 0; m < nb; m++ )
+    _HB_OPEN_Free_Coverage( &b[m] );
+
+  FREE( b );
+  return error;
+}
+
+
+static void  Free_ChainContextSubst3( HB_ChainContextSubstFormat3*  ccsf3 )
+{
+  HB_UShort      n, count;
+
+  HB_Coverage*  c;
+
+
+  FREE( ccsf3->SubstLookupRecord );
+
+  if ( ccsf3->LookaheadCoverage )
+  {
+    count = ccsf3->LookaheadGlyphCount;
+    c     = ccsf3->LookaheadCoverage;
+
+    for ( n = 0; n < count; n++ )
+      _HB_OPEN_Free_Coverage( &c[n] );
+
+    FREE( c );
+  }
+
+  if ( ccsf3->InputCoverage )
+  {
+    count = ccsf3->InputGlyphCount;
+    c     = ccsf3->InputCoverage;
+
+    for ( n = 0; n < count; n++ )
+      _HB_OPEN_Free_Coverage( &c[n] );
+
+    FREE( c );
+  }
+
+  if ( ccsf3->BacktrackCoverage )
+  {
+    count = ccsf3->BacktrackGlyphCount;
+    c     = ccsf3->BacktrackCoverage;
+
+    for ( n = 0; n < count; n++ )
+      _HB_OPEN_Free_Coverage( &c[n] );
+
+    FREE( c );
+  }
+}
+
+
+/* ChainContextSubst */
+
+static HB_Error  Load_ChainContextSubst( HB_GSUB_SubTable* st,
+					 HB_Stream         stream )
+{
+  HB_Error error;
+  HB_ChainContextSubst*  ccs = &st->chain;
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  ccs->SubstFormat = GET_UShort();
+
+  FORGET_Frame();
+
+  switch ( ccs->SubstFormat ) {
+    case 1:  return Load_ChainContextSubst1( &ccs->ccsf.ccsf1, stream );
+    case 2:  return Load_ChainContextSubst2( &ccs->ccsf.ccsf2, stream );
+    case 3:  return Load_ChainContextSubst3( &ccs->ccsf.ccsf3, stream );
+    default: return ERR(HB_Err_Invalid_SubTable_Format);
+  }
+
+  return HB_Err_Ok;               /* never reached */
+}
+
+
+static void  Free_ChainContextSubst( HB_GSUB_SubTable* st )
+{
+  HB_ChainContextSubst*  ccs = &st->chain;
+
+  switch ( ccs->SubstFormat ) {
+    case 1:  Free_ChainContextSubst1( &ccs->ccsf.ccsf1 ); break;
+    case 2:  Free_ChainContextSubst2( &ccs->ccsf.ccsf2 ); break;
+    case 3:  Free_ChainContextSubst3( &ccs->ccsf.ccsf3 ); break;
+    default:							  break;
+  }
+}
+
+
+static HB_Error  Lookup_ChainContextSubst1( HB_GSUBHeader*               gsub,
+					    HB_ChainContextSubstFormat1* ccsf1,
+					    HB_Buffer                    buffer,
+					    HB_UShort                     flags,
+					    HB_UShort                     context_length,
+					    int                           nesting_level )
+{
+  HB_UShort          index, property;
+  HB_UShort          i, j, k, num_csr;
+  HB_UShort          bgc, igc, lgc;
+  HB_Error           error;
+
+  HB_ChainSubRule*  csr;
+  HB_ChainSubRule   curr_csr;
+  HB_GDEFHeader*    gdef;
+
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  error = _HB_OPEN_Coverage_Index( &ccsf1->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  csr     = ccsf1->ChainSubRuleSet[index].ChainSubRule;
+  num_csr = ccsf1->ChainSubRuleSet[index].ChainSubRuleCount;
+
+  for ( k = 0; k < num_csr; k++ )
+  {
+    curr_csr = csr[k];
+    bgc      = curr_csr.BacktrackGlyphCount;
+    igc      = curr_csr.InputGlyphCount;
+    lgc      = curr_csr.LookaheadGlyphCount;
+
+    if ( context_length != 0xFFFF && context_length < igc )
+      goto next_chainsubrule;
+
+    /* check whether context is too long; it is a first guess only */
+
+    if ( bgc > buffer->out_pos || buffer->in_pos + igc + lgc > buffer->in_length )
+      goto next_chainsubrule;
+
+    if ( bgc )
+    {
+      /* since we don't know in advance the number of glyphs to inspect,
+	 we search backwards for matches in the backtrack glyph array    */
+
+      for ( i = 0, j = buffer->out_pos - 1; i < bgc; i++, j-- )
+      {
+	while ( CHECK_Property( gdef, OUT_ITEM( j ), flags, &property ) )
+	{
+	  if ( error && error != HB_Err_Not_Covered )
+	    return error;
+
+	  if ( j + 1 == bgc - i )
+	    goto next_chainsubrule;
+	  j--;
+	}
+
+	/* In OpenType 1.3, it is undefined whether the offsets of
+	   backtrack glyphs is in logical order or not.  Version 1.4
+	   will clarify this:
+
+	     Logical order -      a  b  c  d  e  f  g  h  i  j
+					      i
+	     Input offsets -                  0  1
+	     Backtrack offsets -  3  2  1  0
+	     Lookahead offsets -                    0  1  2  3           */
+
+	if ( OUT_GLYPH( j ) != curr_csr.Backtrack[i] )
+	  goto next_chainsubrule;
+      }
+    }
+
+    /* Start at 1 because [0] is implied */
+
+    for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  return error;
+
+	if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
+	  goto next_chainsubrule;
+	j++;
+      }
+
+      if ( IN_GLYPH( j ) != curr_csr.Input[i - 1] )
+	  goto next_chainsubrule;
+    }
+
+    /* we are starting to check for lookahead glyphs right after the
+       last context glyph                                            */
+
+    for ( i = 0; i < lgc; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  return error;
+
+	if ( j + lgc - i == (HB_Int)buffer->in_length )
+	  goto next_chainsubrule;
+	j++;
+      }
+
+      if ( IN_GLYPH( j ) != curr_csr.Lookahead[i] )
+	goto next_chainsubrule;
+    }
+
+    return Do_ContextSubst( gsub, igc,
+			    curr_csr.SubstCount,
+			    curr_csr.SubstLookupRecord,
+			    buffer,
+			    nesting_level );
+
+  next_chainsubrule:
+    ;
+  }
+
+  return HB_Err_Not_Covered;
+}
+
+
+static HB_Error  Lookup_ChainContextSubst2( HB_GSUBHeader*               gsub,
+					    HB_ChainContextSubstFormat2* ccsf2,
+					    HB_Buffer                    buffer,
+					    HB_UShort                     flags,
+					    HB_UShort                     context_length,
+					    int                           nesting_level )
+{
+  HB_UShort              index, property;
+  HB_Error               error;
+  HB_UShort              i, j, k;
+  HB_UShort              bgc, igc, lgc;
+  HB_UShort              known_backtrack_classes,
+			 known_input_classes,
+			 known_lookahead_classes;
+
+  HB_UShort*             backtrack_classes;
+  HB_UShort*             input_classes;
+  HB_UShort*             lookahead_classes;
+
+  HB_UShort*             bc;
+  HB_UShort*             ic;
+  HB_UShort*             lc;
+
+  HB_ChainSubClassSet*  cscs;
+  HB_ChainSubClassRule  ccsr;
+  HB_GDEFHeader*        gdef;
+
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  /* Note: The coverage table in format 2 doesn't give an index into
+	   anything.  It just lets us know whether or not we need to
+	   do any lookup at all.                                     */
+
+  error = _HB_OPEN_Coverage_Index( &ccsf2->Coverage, IN_CURGLYPH(), &index );
+  if ( error )
+    return error;
+
+  if ( ALLOC_ARRAY( backtrack_classes, ccsf2->MaxBacktrackLength, HB_UShort ) )
+    return error;
+  known_backtrack_classes = 0;
+
+  if (ccsf2->MaxInputLength < 1)
+    return HB_Err_Not_Covered;
+
+  if ( ALLOC_ARRAY( input_classes, ccsf2->MaxInputLength, HB_UShort ) )
+    goto End3;
+  known_input_classes = 1;
+
+  if ( ALLOC_ARRAY( lookahead_classes, ccsf2->MaxLookaheadLength, HB_UShort ) )
+    goto End2;
+  known_lookahead_classes = 0;
+
+  error = _HB_OPEN_Get_Class( &ccsf2->InputClassDef, IN_CURGLYPH(),
+		     &input_classes[0], NULL );
+  if ( error && error != HB_Err_Not_Covered )
+    goto End1;
+
+  cscs = &ccsf2->ChainSubClassSet[input_classes[0]];
+  if ( !cscs )
+  {
+    error = ERR(HB_Err_Invalid_SubTable);
+    goto End1;
+  }
+
+  for ( k = 0; k < cscs->ChainSubClassRuleCount; k++ )
+  {
+    ccsr = cscs->ChainSubClassRule[k];
+    bgc  = ccsr.BacktrackGlyphCount;
+    igc  = ccsr.InputGlyphCount;
+    lgc  = ccsr.LookaheadGlyphCount;
+
+    if ( context_length != 0xFFFF && context_length < igc )
+      goto next_chainsubclassrule;
+
+    /* check whether context is too long; it is a first guess only */
+
+    if ( bgc > buffer->out_pos || buffer->in_pos + igc + lgc > buffer->in_length )
+      goto next_chainsubclassrule;
+
+    if ( bgc )
+    {
+      /* Since we don't know in advance the number of glyphs to inspect,
+	 we search backwards for matches in the backtrack glyph array.
+	 Note that `known_backtrack_classes' starts at index 0.         */
+
+      bc       = ccsr.Backtrack;
+
+      for ( i = 0, j = buffer->out_pos - 1; i < bgc; i++, j-- )
+      {
+	while ( CHECK_Property( gdef, OUT_ITEM( j ), flags, &property ) )
+	{
+	  if ( error && error != HB_Err_Not_Covered )
+	    goto End1;
+
+	  if ( j + 1 == bgc - i )
+	    goto next_chainsubclassrule;
+	  j--;
+	}
+
+	if ( i >= known_backtrack_classes )
+	{
+	  /* Keeps us from having to do this for each rule */
+
+	  error = _HB_OPEN_Get_Class( &ccsf2->BacktrackClassDef, OUT_GLYPH( j ),
+			     &backtrack_classes[i], NULL );
+	  if ( error && error != HB_Err_Not_Covered )
+	    goto End1;
+	  known_backtrack_classes = i;
+	}
+
+	if ( bc[i] != backtrack_classes[i] )
+	  goto next_chainsubclassrule;
+      }
+    }
+
+    ic       = ccsr.Input;
+
+    /* Start at 1 because [0] is implied */
+
+    for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  goto End1;
+
+	if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
+	  goto next_chainsubclassrule;
+	j++;
+      }
+
+      if ( i >= known_input_classes )
+      {
+	error = _HB_OPEN_Get_Class( &ccsf2->InputClassDef, IN_GLYPH( j ),
+			   &input_classes[i], NULL );
+	if ( error && error != HB_Err_Not_Covered )
+	  goto End1;
+	known_input_classes = i;
+      }
+
+      if ( ic[i - 1] != input_classes[i] )
+	goto next_chainsubclassrule;
+    }
+
+    /* we are starting to check for lookahead glyphs right after the
+       last context glyph                                            */
+
+    lc       = ccsr.Lookahead;
+
+    for ( i = 0; i < lgc; i++, j++ )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  goto End1;
+
+	if ( j + lgc - i == (HB_Int)buffer->in_length )
+	  goto next_chainsubclassrule;
+	j++;
+      }
+
+      if ( i >= known_lookahead_classes )
+      {
+	error = _HB_OPEN_Get_Class( &ccsf2->LookaheadClassDef, IN_GLYPH( j ),
+			   &lookahead_classes[i], NULL );
+	if ( error && error != HB_Err_Not_Covered )
+	  goto End1;
+	known_lookahead_classes = i;
+      }
+
+      if ( lc[i] != lookahead_classes[i] )
+	goto next_chainsubclassrule;
+    }
+
+    error = Do_ContextSubst( gsub, igc,
+			     ccsr.SubstCount,
+			     ccsr.SubstLookupRecord,
+			     buffer,
+			     nesting_level );
+    goto End1;
+
+  next_chainsubclassrule:
+    ;
+  }
+
+  error = HB_Err_Not_Covered;
+
+End1:
+  FREE( lookahead_classes );
+
+End2:
+  FREE( input_classes );
+
+End3:
+  FREE( backtrack_classes );
+  return error;
+}
+
+
+static HB_Error  Lookup_ChainContextSubst3( HB_GSUBHeader*               gsub,
+					    HB_ChainContextSubstFormat3* ccsf3,
+					    HB_Buffer                    buffer,
+					    HB_UShort                     flags,
+					    HB_UShort                     context_length,
+					    int                           nesting_level )
+{
+  HB_UShort        index, i, j, property;
+  HB_UShort        bgc, igc, lgc;
+  HB_Error         error;
+
+  HB_Coverage*    bc;
+  HB_Coverage*    ic;
+  HB_Coverage*    lc;
+  HB_GDEFHeader*  gdef;
+
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  bgc = ccsf3->BacktrackGlyphCount;
+  igc = ccsf3->InputGlyphCount;
+  lgc = ccsf3->LookaheadGlyphCount;
+
+  if ( context_length != 0xFFFF && context_length < igc )
+    return HB_Err_Not_Covered;
+
+  /* check whether context is too long; it is a first guess only */
+
+  if ( bgc > buffer->out_pos || buffer->in_pos + igc + lgc > buffer->in_length )
+    return HB_Err_Not_Covered;
+
+  if ( bgc )
+  {
+    /* Since we don't know in advance the number of glyphs to inspect,
+       we search backwards for matches in the backtrack glyph array    */
+
+    bc       = ccsf3->BacktrackCoverage;
+
+    for ( i = 0, j = buffer->out_pos - 1; i < bgc; i++, j-- )
+    {
+      while ( CHECK_Property( gdef, OUT_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  return error;
+
+	if ( j + 1 == bgc - i )
+	  return HB_Err_Not_Covered;
+	j--;
+      }
+
+      error = _HB_OPEN_Coverage_Index( &bc[i], OUT_GLYPH( j ), &index );
+      if ( error )
+	return error;
+    }
+  }
+
+  ic       = ccsf3->InputCoverage;
+
+  for ( i = 0, j = buffer->in_pos; i < igc; i++, j++ )
+  {
+    /* We already called CHECK_Property for IN_GLYPH( buffer->in_pos ) */
+    while ( j > buffer->in_pos && CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+    {
+      if ( error && error != HB_Err_Not_Covered )
+	return error;
+
+      if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
+	return HB_Err_Not_Covered;
+      j++;
+    }
+
+    error = _HB_OPEN_Coverage_Index( &ic[i], IN_GLYPH( j ), &index );
+    if ( error )
+      return error;
+  }
+
+  /* we are starting for lookahead glyphs right after the last context
+     glyph                                                             */
+
+  lc       = ccsf3->LookaheadCoverage;
+
+  for ( i = 0; i < lgc; i++, j++ )
+  {
+    while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+    {
+      if ( error && error != HB_Err_Not_Covered )
+	return error;
+
+      if ( j + lgc - i == (HB_Int)buffer->in_length )
+	return HB_Err_Not_Covered;
+      j++;
+    }
+
+    error = _HB_OPEN_Coverage_Index( &lc[i], IN_GLYPH( j ), &index );
+    if ( error )
+      return error;
+  }
+
+  return Do_ContextSubst( gsub, igc,
+			  ccsf3->SubstCount,
+			  ccsf3->SubstLookupRecord,
+			  buffer,
+			  nesting_level );
+}
+
+
+static HB_Error  Lookup_ChainContextSubst( HB_GSUBHeader*    gsub,
+					   HB_GSUB_SubTable* st,
+					   HB_Buffer         buffer,
+					   HB_UShort          flags,
+					   HB_UShort          context_length,
+					   int                nesting_level )
+{
+  HB_ChainContextSubst*  ccs = &st->chain;
+
+  switch ( ccs->SubstFormat ) {
+    case 1:  return Lookup_ChainContextSubst1( gsub, &ccs->ccsf.ccsf1, buffer, flags, context_length, nesting_level );
+    case 2:  return Lookup_ChainContextSubst2( gsub, &ccs->ccsf.ccsf2, buffer, flags, context_length, nesting_level );
+    case 3:  return Lookup_ChainContextSubst3( gsub, &ccs->ccsf.ccsf3, buffer, flags, context_length, nesting_level );
+    default: return ERR(HB_Err_Invalid_SubTable_Format);
+  }
+}
+
+
+static HB_Error  Load_ReverseChainContextSubst( HB_GSUB_SubTable* st,
+					        HB_Stream         stream )
+{
+  HB_Error error;
+  HB_ReverseChainContextSubst*  rccs = &st->reverse;
+
+  HB_UShort               m, count;
+
+  HB_UShort               nb = 0, nl = 0, n;
+  HB_UShort               backtrack_count, lookahead_count;
+  HB_UInt                cur_offset, new_offset, base_offset;
+
+  HB_Coverage*           b;
+  HB_Coverage*           l;
+  HB_UShort*              sub;
+
+  base_offset = FILE_Pos();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  rccs->SubstFormat = GET_UShort();
+
+  if ( rccs->SubstFormat != 1 )
+    return ERR(HB_Err_Invalid_SubTable_Format);
+
+  FORGET_Frame();
+
+  if ( ACCESS_Frame( 2L ) )
+    return error;
+
+  new_offset = GET_UShort() + base_offset;
+
+  FORGET_Frame();
+
+  cur_offset = FILE_Pos();
+  if ( FILE_Seek( new_offset ) ||
+       ( error = _HB_OPEN_Load_Coverage( &rccs->Coverage, stream ) ) != HB_Err_Ok )
+    return error;
+  (void)FILE_Seek( cur_offset );
+
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail4;
+
+  rccs->BacktrackGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  rccs->BacktrackCoverage = NULL;
+
+  backtrack_count = rccs->BacktrackGlyphCount;
+
+  if ( ALLOC_ARRAY( rccs->BacktrackCoverage, backtrack_count,
+		    HB_Coverage ) )
+    goto Fail4;
+
+  b = rccs->BacktrackCoverage;
+
+  for ( nb = 0; nb < backtrack_count; nb++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail3;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = _HB_OPEN_Load_Coverage( &b[nb], stream ) ) != HB_Err_Ok )
+      goto Fail3;
+    (void)FILE_Seek( cur_offset );
+  }
+
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail3;
+
+  rccs->LookaheadGlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  rccs->LookaheadCoverage = NULL;
+
+  lookahead_count = rccs->LookaheadGlyphCount;
+
+  if ( ALLOC_ARRAY( rccs->LookaheadCoverage, lookahead_count,
+		    HB_Coverage ) )
+    goto Fail3;
+
+  l = rccs->LookaheadCoverage;
+
+  for ( nl = 0; nl < lookahead_count; nl++ )
+  {
+    if ( ACCESS_Frame( 2L ) )
+      goto Fail2;
+
+    new_offset = GET_UShort() + base_offset;
+
+    FORGET_Frame();
+
+    cur_offset = FILE_Pos();
+    if ( FILE_Seek( new_offset ) ||
+	 ( error = _HB_OPEN_Load_Coverage( &l[nl], stream ) ) != HB_Err_Ok )
+      goto Fail2;
+    (void)FILE_Seek( cur_offset );
+  }
+
+  if ( ACCESS_Frame( 2L ) )
+    goto Fail2;
+
+  rccs->GlyphCount = GET_UShort();
+
+  FORGET_Frame();
+
+  rccs->Substitute = NULL;
+
+  count = rccs->GlyphCount;
+
+  if ( ALLOC_ARRAY( rccs->Substitute, count,
+		    HB_UShort ) )
+    goto Fail2;
+
+  sub = rccs->Substitute;
+
+  if ( ACCESS_Frame( count * 2L ) )
+    goto Fail1;
+
+  for ( n = 0; n < count; n++ )
+    sub[n] = GET_UShort();
+
+  FORGET_Frame();
+
+  return HB_Err_Ok;
+
+Fail1:
+  FREE( sub );
+
+Fail2:
+  for ( m = 0; m < nl; m++ )
+    _HB_OPEN_Free_Coverage( &l[m] );
+
+  FREE( l );
+
+Fail3:
+  for ( m = 0; m < nb; m++ )
+    _HB_OPEN_Free_Coverage( &b[m] );
+
+  FREE( b );
+
+Fail4:
+  _HB_OPEN_Free_Coverage( &rccs->Coverage );
+  return error;
+}
+
+
+static void  Free_ReverseChainContextSubst( HB_GSUB_SubTable* st )
+{
+  HB_UShort      n, count;
+  HB_ReverseChainContextSubst*  rccs = &st->reverse;
+
+  HB_Coverage*  c;
+
+  _HB_OPEN_Free_Coverage( &rccs->Coverage );
+
+  if ( rccs->LookaheadCoverage )
+  {
+    count = rccs->LookaheadGlyphCount;
+    c     = rccs->LookaheadCoverage;
+
+    for ( n = 0; n < count; n++ )
+      _HB_OPEN_Free_Coverage( &c[n] );
+
+    FREE( c );
+  }
+
+  if ( rccs->BacktrackCoverage )
+  {
+    count = rccs->BacktrackGlyphCount;
+    c     = rccs->BacktrackCoverage;
+
+    for ( n = 0; n < count; n++ )
+      _HB_OPEN_Free_Coverage( &c[n] );
+
+    FREE( c );
+  }
+
+  FREE ( rccs->Substitute );
+}
+
+
+static HB_Error  Lookup_ReverseChainContextSubst( HB_GSUBHeader*    gsub,
+						  HB_GSUB_SubTable* st,
+						  HB_Buffer         buffer,
+						  HB_UShort          flags,
+						  HB_UShort         context_length,
+						  int               nesting_level )
+{
+  HB_UShort        index, input_index, i, j, property;
+  HB_UShort        bgc, lgc;
+  HB_Error         error;
+
+  HB_ReverseChainContextSubst*  rccs = &st->reverse;
+  HB_Coverage*    bc;
+  HB_Coverage*    lc;
+  HB_GDEFHeader*  gdef;
+
+  if ( nesting_level != 1 || context_length != 0xFFFF )
+    return HB_Err_Not_Covered;
+
+  gdef = gsub->gdef;
+
+  if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
+    return error;
+
+  bgc = rccs->BacktrackGlyphCount;
+  lgc = rccs->LookaheadGlyphCount;
+
+  /* check whether context is too long; it is a first guess only */
+
+  if ( bgc > buffer->in_pos || buffer->in_pos + 1 + lgc > buffer->in_length )
+    return HB_Err_Not_Covered;
+
+  if ( bgc )
+  {
+    /* Since we don't know in advance the number of glyphs to inspect,
+       we search backwards for matches in the backtrack glyph array    */
+
+    bc       = rccs->BacktrackCoverage;
+
+    for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- )
+    {
+      while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+      {
+	if ( error && error != HB_Err_Not_Covered )
+	  return error;
+
+	if ( j + 1 == bgc - i )
+	  return HB_Err_Not_Covered;
+	j--;
+      }
+
+      error = _HB_OPEN_Coverage_Index( &bc[i], IN_GLYPH( j ), &index );
+      if ( error )
+	return error;
+    }
+  }
+
+  j = buffer->in_pos;
+
+  error = _HB_OPEN_Coverage_Index( &rccs->Coverage, IN_GLYPH( j ), &input_index );
+  if ( error )
+      return error;
+
+  lc       = rccs->LookaheadCoverage;
+
+  for ( i = 0, j = buffer->in_pos + 1; i < lgc; i++, j++ )
+  {
+    while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
+    {
+      if ( error && error != HB_Err_Not_Covered )
+	return error;
+
+      if ( j + lgc - i == (HB_Int)buffer->in_length )
+	return HB_Err_Not_Covered;
+      j++;
+    }
+
+    error = _HB_OPEN_Coverage_Index( &lc[i], IN_GLYPH( j ), &index );
+    if ( error )
+      return error;
+  }
+
+  IN_CURGLYPH() = rccs->Substitute[input_index];
+  buffer->in_pos--; /* Reverse! */
+
+  return error;
+}
+
+
+
+/***********
+ * GSUB API
+ ***********/
+
+
+
+HB_Error  HB_GSUB_Select_Script( HB_GSUBHeader*  gsub,
+				 HB_UInt         script_tag,
+				 HB_UShort*       script_index )
+{
+  HB_UShort          n;
+
+  HB_ScriptList*    sl;
+  HB_ScriptRecord*  sr;
+
+
+  if ( !gsub || !script_index )
+    return ERR(HB_Err_Invalid_Argument);
+
+  sl = &gsub->ScriptList;
+  sr = sl->ScriptRecord;
+
+  for ( n = 0; n < sl->ScriptCount; n++ )
+    if ( script_tag == sr[n].ScriptTag )
+    {
+      *script_index = n;
+
+      return HB_Err_Ok;
+    }
+
+  return HB_Err_Not_Covered;
+}
+
+
+
+HB_Error  HB_GSUB_Select_Language( HB_GSUBHeader*  gsub,
+				   HB_UInt         language_tag,
+				   HB_UShort        script_index,
+				   HB_UShort*       language_index,
+				   HB_UShort*       req_feature_index )
+{
+  HB_UShort           n;
+
+  HB_ScriptList*     sl;
+  HB_ScriptRecord*   sr;
+  HB_ScriptTable*    s;
+  HB_LangSysRecord*  lsr;
+
+
+  if ( !gsub || !language_index || !req_feature_index )
+    return ERR(HB_Err_Invalid_Argument);
+
+  sl = &gsub->ScriptList;
+  sr = sl->ScriptRecord;
+
+  if ( script_index >= sl->ScriptCount )
+    return ERR(HB_Err_Invalid_Argument);
+
+  s   = &sr[script_index].Script;
+  lsr = s->LangSysRecord;
+
+  for ( n = 0; n < s->LangSysCount; n++ )
+    if ( language_tag == lsr[n].LangSysTag )
+    {
+      *language_index = n;
+      *req_feature_index = lsr[n].LangSys.ReqFeatureIndex;
+
+      return HB_Err_Ok;
+    }
+
+  return HB_Err_Not_Covered;
+}
+
+
+/* selecting 0xFFFF for language_index asks for the values of the
+   default language (DefaultLangSys)                              */
+
+
+HB_Error  HB_GSUB_Select_Feature( HB_GSUBHeader*  gsub,
+				  HB_UInt         feature_tag,
+				  HB_UShort        script_index,
+				  HB_UShort        language_index,
+				  HB_UShort*       feature_index )
+{
+  HB_UShort           n;
+
+  HB_ScriptList*     sl;
+  HB_ScriptRecord*   sr;
+  HB_ScriptTable*    s;
+  HB_LangSysRecord*  lsr;
+  HB_LangSys*        ls;
+  HB_UShort*          fi;
+
+  HB_FeatureList*    fl;
+  HB_FeatureRecord*  fr;
+
+
+  if ( !gsub || !feature_index )
+    return ERR(HB_Err_Invalid_Argument);
+
+  sl = &gsub->ScriptList;
+  sr = sl->ScriptRecord;
+
+  fl = &gsub->FeatureList;
+  fr = fl->FeatureRecord;
+
+  if ( script_index >= sl->ScriptCount )
+    return ERR(HB_Err_Invalid_Argument);
+
+  s   = &sr[script_index].Script;
+  lsr = s->LangSysRecord;
+
+  if ( language_index == 0xFFFF )
+    ls = &s->DefaultLangSys;
+  else
+  {
+    if ( language_index >= s->LangSysCount )
+      return ERR(HB_Err_Invalid_Argument);
+
+    ls = &lsr[language_index].LangSys;
+  }
+
+  fi = ls->FeatureIndex;
+
+  for ( n = 0; n < ls->FeatureCount; n++ )
+  {
+    if ( fi[n] >= fl->FeatureCount )
+      return ERR(HB_Err_Invalid_SubTable_Format);
+
+    if ( feature_tag == fr[fi[n]].FeatureTag )
+    {
+      *feature_index = fi[n];
+
+      return HB_Err_Ok;
+    }
+  }
+
+  return HB_Err_Not_Covered;
+}
+
+
+/* The next three functions return a null-terminated list */
+
+
+HB_Error  HB_GSUB_Query_Scripts( HB_GSUBHeader*  gsub,
+				 HB_UInt**       script_tag_list )
+{
+  HB_UShort          n;
+  HB_Error           error;
+  HB_UInt*          stl;
+
+  HB_ScriptList*    sl;
+  HB_ScriptRecord*  sr;
+
+
+  if ( !gsub || !script_tag_list )
+    return ERR(HB_Err_Invalid_Argument);
+
+  sl = &gsub->ScriptList;
+  sr = sl->ScriptRecord;
+
+  if ( ALLOC_ARRAY( stl, sl->ScriptCount + 1, HB_UInt ) )
+    return error;
+
+  for ( n = 0; n < sl->ScriptCount; n++ )
+    stl[n] = sr[n].ScriptTag;
+  stl[n] = 0;
+
+  *script_tag_list = stl;
+
+  return HB_Err_Ok;
+}
+
+
+
+HB_Error  HB_GSUB_Query_Languages( HB_GSUBHeader*  gsub,
+				   HB_UShort        script_index,
+				   HB_UInt**       language_tag_list )
+{
+  HB_UShort           n;
+  HB_Error            error;
+  HB_UInt*           ltl;
+
+  HB_ScriptList*     sl;
+  HB_ScriptRecord*   sr;
+  HB_ScriptTable*    s;
+  HB_LangSysRecord*  lsr;
+
+
+  if ( !gsub || !language_tag_list )
+    return ERR(HB_Err_Invalid_Argument);
+
+  sl = &gsub->ScriptList;
+  sr = sl->ScriptRecord;
+
+  if ( script_index >= sl->ScriptCount )
+    return ERR(HB_Err_Invalid_Argument);
+
+  s   = &sr[script_index].Script;
+  lsr = s->LangSysRecord;
+
+  if ( ALLOC_ARRAY( ltl, s->LangSysCount + 1, HB_UInt ) )
+    return error;
+
+  for ( n = 0; n < s->LangSysCount; n++ )
+    ltl[n] = lsr[n].LangSysTag;
+  ltl[n] = 0;
+
+  *language_tag_list = ltl;
+
+  return HB_Err_Ok;
+}
+
+
+/* selecting 0xFFFF for language_index asks for the values of the
+   default language (DefaultLangSys)                              */
+
+
+HB_Error  HB_GSUB_Query_Features( HB_GSUBHeader*  gsub,
+				  HB_UShort        script_index,
+				  HB_UShort        language_index,
+				  HB_UInt**       feature_tag_list )
+{
+  HB_UShort           n;
+  HB_Error            error;
+  HB_UInt*           ftl;
+
+  HB_ScriptList*     sl;
+  HB_ScriptRecord*   sr;
+  HB_ScriptTable*    s;
+  HB_LangSysRecord*  lsr;
+  HB_LangSys*        ls;
+  HB_UShort*          fi;
+
+  HB_FeatureList*    fl;
+  HB_FeatureRecord*  fr;
+
+
+  if ( !gsub || !feature_tag_list )
+    return ERR(HB_Err_Invalid_Argument);
+
+  sl = &gsub->ScriptList;
+  sr = sl->ScriptRecord;
+
+  fl = &gsub->FeatureList;
+  fr = fl->FeatureRecord;
+
+  if ( script_index >= sl->ScriptCount )
+    return ERR(HB_Err_Invalid_Argument);
+
+  s   = &sr[script_index].Script;
+  lsr = s->LangSysRecord;
+
+  if ( language_index == 0xFFFF )
+    ls = &s->DefaultLangSys;
+  else
+  {
+    if ( language_index >= s->LangSysCount )
+      return ERR(HB_Err_Invalid_Argument);
+
+    ls = &lsr[language_index].LangSys;
+  }
+
+  fi = ls->FeatureIndex;
+
+  if ( ALLOC_ARRAY( ftl, ls->FeatureCount + 1, HB_UInt ) )
+    return error;
+
+  for ( n = 0; n < ls->FeatureCount; n++ )
+  {
+    if ( fi[n] >= fl->FeatureCount )
+    {
+      FREE( ftl );
+      return ERR(HB_Err_Invalid_SubTable_Format);
+    }
+    ftl[n] = fr[fi[n]].FeatureTag;
+  }
+  ftl[n] = 0;
+
+  *feature_tag_list = ftl;
+
+  return HB_Err_Ok;
+}
+
+
+/* Do an individual subtable lookup.  Returns HB_Err_Ok if substitution
+   has been done, or HB_Err_Not_Covered if not.                        */
+static HB_Error  GSUB_Do_Glyph_Lookup( HB_GSUBHeader* gsub,
+				       HB_UShort       lookup_index,
+				       HB_Buffer      buffer,
+				       HB_UShort       context_length,
+				       int             nesting_level )
+{
+  HB_Error               error = HB_Err_Not_Covered;
+  HB_UShort              i, flags, lookup_count;
+  HB_Lookup*             lo;
+  int                    lookup_type;
+
+  nesting_level++;
+
+  if ( nesting_level > HB_MAX_NESTING_LEVEL )
+    return ERR(HB_Err_Not_Covered); /* ERR() call intended */
+
+  lookup_count = gsub->LookupList.LookupCount;
+  if (lookup_index >= lookup_count)
+    return error;
+
+  lo    = &gsub->LookupList.Lookup[lookup_index];
+  flags = lo->LookupFlag;
+  lookup_type = lo->LookupType;
+
+  for ( i = 0; i < lo->SubTableCount; i++ )
+  {
+    HB_GSUB_SubTable *st = &lo->SubTable[i].st.gsub;
+
+    switch (lookup_type) {
+      case HB_GSUB_LOOKUP_SINGLE:
+	error = Lookup_SingleSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
+      case HB_GSUB_LOOKUP_MULTIPLE:
+	error = Lookup_MultipleSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
+      case HB_GSUB_LOOKUP_ALTERNATE:
+	error = Lookup_AlternateSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
+      case HB_GSUB_LOOKUP_LIGATURE:
+	error = Lookup_LigatureSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
+      case HB_GSUB_LOOKUP_CONTEXT:
+	error = Lookup_ContextSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
+      case HB_GSUB_LOOKUP_CHAIN:
+	error = Lookup_ChainContextSubst	( gsub, st, buffer, flags, context_length, nesting_level ); break;
+    /*case HB_GSUB_LOOKUP_EXTENSION:
+	error = Lookup_ExtensionSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;*/
+      case HB_GSUB_LOOKUP_REVERSE_CHAIN:
+	error = Lookup_ReverseChainContextSubst	( gsub, st, buffer, flags, context_length, nesting_level ); break;
+      default:
+	error = HB_Err_Not_Covered;
+    };
+
+    /* Check whether we have a successful substitution or an error other
+       than HB_Err_Not_Covered                                          */
+    if ( error != HB_Err_Not_Covered )
+      return error;
+  }
+
+  return HB_Err_Not_Covered;
+}
+
+
+HB_INTERNAL HB_Error
+_HB_GSUB_Load_SubTable( HB_GSUB_SubTable* st,
+			HB_Stream         stream,
+			HB_UShort         lookup_type )
+{
+  switch (lookup_type) {
+    case HB_GSUB_LOOKUP_SINGLE:		return Load_SingleSubst			( st, stream );
+    case HB_GSUB_LOOKUP_MULTIPLE:	return Load_MultipleSubst		( st, stream );
+    case HB_GSUB_LOOKUP_ALTERNATE:	return Load_AlternateSubst		( st, stream );
+    case HB_GSUB_LOOKUP_LIGATURE:	return Load_LigatureSubst		( st, stream );
+    case HB_GSUB_LOOKUP_CONTEXT:	return Load_ContextSubst		( st, stream );
+    case HB_GSUB_LOOKUP_CHAIN:		return Load_ChainContextSubst		( st, stream );
+  /*case HB_GSUB_LOOKUP_EXTENSION:	return Load_ExtensionSubst		( st, stream );*/
+    case HB_GSUB_LOOKUP_REVERSE_CHAIN:	return Load_ReverseChainContextSubst	( st, stream );
+    default:				return ERR(HB_Err_Invalid_SubTable_Format);
+  };
+}
+
+
+HB_INTERNAL void
+_HB_GSUB_Free_SubTable( HB_GSUB_SubTable* st,
+			HB_UShort         lookup_type )
+{
+  switch ( lookup_type ) {
+    case HB_GSUB_LOOKUP_SINGLE:		Free_SingleSubst		( st ); return;
+    case HB_GSUB_LOOKUP_MULTIPLE:	Free_MultipleSubst		( st ); return;
+    case HB_GSUB_LOOKUP_ALTERNATE:	Free_AlternateSubst		( st ); return;
+    case HB_GSUB_LOOKUP_LIGATURE:	Free_LigatureSubst		( st ); return;
+    case HB_GSUB_LOOKUP_CONTEXT:	Free_ContextSubst		( st ); return;
+    case HB_GSUB_LOOKUP_CHAIN:		Free_ChainContextSubst		( st ); return;
+  /*case HB_GSUB_LOOKUP_EXTENSION:	Free_ExtensionSubst		( st ); return;*/
+    case HB_GSUB_LOOKUP_REVERSE_CHAIN:	Free_ReverseChainContextSubst	( st ); return;
+    default:									return;
+  };
+}
+
+
+
+/* apply one lookup to the input string object */
+
+static HB_Error  GSUB_Do_String_Lookup( HB_GSUBHeader*   gsub,
+				   HB_UShort         lookup_index,
+				   HB_Buffer        buffer )
+{
+  HB_Error  error, retError = HB_Err_Not_Covered;
+
+  HB_UInt*  properties = gsub->LookupList.Properties;
+  int       lookup_type = gsub->LookupList.Lookup[lookup_index].LookupType;
+
+  const int       nesting_level = 0;
+  /* 0xFFFF indicates that we don't have a context length yet */
+  const HB_UShort context_length = 0xFFFF;
+
+  switch (lookup_type) {
+
+    case HB_GSUB_LOOKUP_SINGLE:
+    case HB_GSUB_LOOKUP_MULTIPLE:
+    case HB_GSUB_LOOKUP_ALTERNATE:
+    case HB_GSUB_LOOKUP_LIGATURE:
+    case HB_GSUB_LOOKUP_CONTEXT:
+    case HB_GSUB_LOOKUP_CHAIN:
+      /* in/out forward substitution (implemented lazy) */
+
+      _hb_buffer_clear_output ( buffer );
+      buffer->in_pos = 0;
+  while ( buffer->in_pos < buffer->in_length )
+  {
+    if ( ~IN_PROPERTIES( buffer->in_pos ) & properties[lookup_index] )
+    {
+	  error = GSUB_Do_Glyph_Lookup( gsub, lookup_index, buffer, context_length, nesting_level );
+      if ( error )
+      {
+	if ( error != HB_Err_Not_Covered )
+	  return error;
+      }
+      else
+	retError = error;
+    }
+    else
+      error = HB_Err_Not_Covered;
+
+    if ( error == HB_Err_Not_Covered )
+	  if ( COPY_Glyph ( buffer ) )
+	return error;
+  }
+      /* we shouldn't swap if error occurred.
+       *
+       * also don't swap if nothing changed (ie HB_Err_Not_Covered).
+       * shouldn't matter in that case though.
+       */
+      if ( retError == HB_Err_Ok )
+	_hb_buffer_swap( buffer );
+
+  return retError;
+
+    case HB_GSUB_LOOKUP_REVERSE_CHAIN:
+      /* in-place backward substitution */
+
+      buffer->in_pos = buffer->in_length - 1;
+    do
+    {
+      if ( ~IN_PROPERTIES( buffer->in_pos ) & properties[lookup_index] )
+	{
+	  error = GSUB_Do_Glyph_Lookup( gsub, lookup_index, buffer, context_length, nesting_level );
+	  if ( error )
+	    {
+	      if ( error != HB_Err_Not_Covered )
+		return error;
+	    }
+	  else
+	    retError = error;
+	}
+	else
+	  error = HB_Err_Not_Covered;
+
+	if ( error == HB_Err_Not_Covered )
+	  buffer->in_pos--;
+      }
+      while ((HB_Int) buffer->in_pos >= 0);
+
+      return retError;
+
+  /*case HB_GSUB_LOOKUP_EXTENSION:*/
+    default:
+  return retError;
+  };
+}
+
+
+HB_Error  HB_GSUB_Add_Feature( HB_GSUBHeader*  gsub,
+			       HB_UShort        feature_index,
+			       HB_UInt          property )
+{
+  HB_UShort    i;
+
+  HB_Feature  feature;
+  HB_UInt*     properties;
+  HB_UShort*   index;
+  HB_UShort    lookup_count;
+
+  /* Each feature can only be added once */
+
+  if ( !gsub ||
+       feature_index >= gsub->FeatureList.FeatureCount ||
+       gsub->FeatureList.ApplyCount == gsub->FeatureList.FeatureCount )
+    return ERR(HB_Err_Invalid_Argument);
+
+  gsub->FeatureList.ApplyOrder[gsub->FeatureList.ApplyCount++] = feature_index;
+
+  properties = gsub->LookupList.Properties;
+
+  feature = gsub->FeatureList.FeatureRecord[feature_index].Feature;
+  index   = feature.LookupListIndex;
+  lookup_count = gsub->LookupList.LookupCount;
+
+  for ( i = 0; i < feature.LookupListCount; i++ )
+  {
+    HB_UShort lookup_index = index[i];
+    if (lookup_index < lookup_count)
+      properties[lookup_index] |= property;
+  }
+
+  return HB_Err_Ok;
+}
+
+
+
+HB_Error  HB_GSUB_Clear_Features( HB_GSUBHeader*  gsub )
+{
+  HB_UShort i;
+
+  HB_UInt*  properties;
+
+
+  if ( !gsub )
+    return ERR(HB_Err_Invalid_Argument);
+
+  gsub->FeatureList.ApplyCount = 0;
+
+  properties = gsub->LookupList.Properties;
+
+  for ( i = 0; i < gsub->LookupList.LookupCount; i++ )
+    properties[i] = 0;
+
+  return HB_Err_Ok;
+}
+
+
+
+HB_Error  HB_GSUB_Register_Alternate_Function( HB_GSUBHeader*  gsub,
+					       HB_AltFunction  altfunc,
+					       void*            data )
+{
+  if ( !gsub )
+    return ERR(HB_Err_Invalid_Argument);
+
+  gsub->altfunc = altfunc;
+  gsub->data    = data;
+
+  return HB_Err_Ok;
+}
+
+/* returns error if one happened, otherwise returns HB_Err_Not_Covered if no
+ * feature were applied, or HB_Err_Ok otherwise.
+ */
+HB_Error  HB_GSUB_Apply_String( HB_GSUBHeader*   gsub,
+				HB_Buffer        buffer )
+{
+  HB_Error          error, retError = HB_Err_Not_Covered;
+  int               i, j, lookup_count, num_features;
+
+  if ( !gsub ||
+       !buffer)
+    return ERR(HB_Err_Invalid_Argument);
+
+  if ( buffer->in_length == 0 )
+    return retError;
+
+  lookup_count = gsub->LookupList.LookupCount;
+  num_features = gsub->FeatureList.ApplyCount;
+
+  for ( i = 0; i < num_features; i++)
+  {
+    HB_UShort  feature_index = gsub->FeatureList.ApplyOrder[i];
+    HB_Feature feature = gsub->FeatureList.FeatureRecord[feature_index].Feature;
+
+    for ( j = 0; j < feature.LookupListCount; j++ )
+    {
+      HB_UShort         lookup_index = feature.LookupListIndex[j];
+
+      /* Skip nonexistant lookups */
+      if (lookup_index >= lookup_count)
+       continue;
+
+	error = GSUB_Do_String_Lookup( gsub, lookup_index, buffer );
+      if ( error )
+      {
+	if ( error != HB_Err_Not_Covered )
+	  return error;
+      }
+      else
+	retError = error;
+    }
+  }
+
+  error = retError;
+
+  return error;
+}
+
+
+/* END */