ban = br[m].BaseAnchor;            for ( n = 0; n < num_classes; n++ )        Free_Anchor( &ban[n] );      FREE( ban );    }    FREE( br );    return error;  }  static void  Free_BaseArray( TTO_BaseArray*  ba,                               UShort          num_classes )  {    UShort           m, n, count;    TTO_BaseRecord*  br;    TTO_Anchor*      ban;    if ( ba->BaseRecord )    {      count = ba->BaseCount;      br    = ba->BaseRecord;      for ( m = 0; m < count; m++ )      {        ban = br[m].BaseAnchor;        for ( n = 0; n < num_classes; n++ )          Free_Anchor( &ban[n] );        FREE( ban );      }      FREE( br );    }  }  /* MarkBasePosFormat1 */  TT_Error  Load_MarkBasePos( TTO_MarkBasePos*  mbp,                              PFace             input )  {    DEFINE_LOAD_LOCALS( input->stream );    ULong  cur_offset, new_offset, base_offset;    base_offset = FILE_Pos();    if ( ACCESS_Frame( 4L ) )      return error;    mbp->PosFormat = GET_UShort();    new_offset     = GET_UShort() + base_offset;    FORGET_Frame();    cur_offset = FILE_Pos();    if ( FILE_Seek( new_offset ) ||         ( error = Load_Coverage( &mbp->MarkCoverage, input ) ) != TT_Err_Ok )      return error;    (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 = Load_Coverage( &mbp->BaseCoverage, input ) ) != TT_Err_Ok )      goto Fail3;    (void)FILE_Seek( cur_offset );    if ( ACCESS_Frame( 4L ) )      goto Fail2;    mbp->ClassCount = GET_UShort();    new_offset      = GET_UShort() + base_offset;    FORGET_Frame();    cur_offset = FILE_Pos();    if ( FILE_Seek( new_offset ) ||         ( error = Load_MarkArray( &mbp->MarkArray, input ) ) != TT_Err_Ok )      goto Fail2;    (void)FILE_Seek( cur_offset );    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_BaseArray( &mbp->BaseArray, mbp->ClassCount,                                   input ) ) != TT_Err_Ok )      goto Fail1;    return TT_Err_Ok;  Fail1:    Free_MarkArray( &mbp->MarkArray );  Fail2:    Free_Coverage( &mbp->BaseCoverage );  Fail3:    Free_Coverage( &mbp->MarkCoverage );    return error;  }  void  Free_MarkBasePos( TTO_MarkBasePos*  mbp )  {    Free_BaseArray( &mbp->BaseArray, mbp->ClassCount );    Free_MarkArray( &mbp->MarkArray );    Free_Coverage( &mbp->BaseCoverage );    Free_Coverage( &mbp->MarkCoverage );  }  static TT_Error  Lookup_MarkBasePos( GPOS_Instance*    gpi,                                       TTO_MarkBasePos*  mbp,                                       TTO_GSUB_String*  in,                                       TTO_GPOS_Data*    out,                                       UShort            flags,                                       UShort            context_length )  {    TT_UInt          i, j;    UShort           mark_index, base_index, property, class;    TT_Pos           x_mark_value, y_mark_value, x_base_value, y_base_value;    TT_Error         error;    TTO_GPOSHeader*  gpos = gpi->gpos;    TTO_MarkArray*   ma;    TTO_BaseArray*   ba;    TTO_BaseRecord*  br;    TTO_Anchor*      mark_anchor;    TTO_Anchor*      base_anchor;    TTO_GPOS_Data*   o;    if ( context_length != 0xFFFF && context_length < 1 )      return TTO_Err_Not_Covered;    if ( flags & IGNORE_BASE_GLYPHS )      return TTO_Err_Not_Covered;    if ( CHECK_Property( gpos->gdef, in->string[in->pos],                         flags, &property ) )      return error;    error = Coverage_Index( &mbp->MarkCoverage, in->string[in->pos],                            &mark_index );    if ( error )      return error;    /* now we search backwards for a non-mark glyph */    i = 1;    j = in->pos - 1;    while ( i <= in->pos )    {      error = TT_GDEF_Get_Glyph_Property( gpos->gdef, in->string[j],                                          &property );      if ( error )        return error;      if ( !( property == TTO_MARK || property & IGNORE_SPECIAL_MARKS ) )        break;      i++;      j--;    }    /* The following assertion is too strong -- at least for mangal.ttf. */#if 0    if ( property != TTO_BASE_GLYPH )      return TTO_Err_Not_Covered;#endif    if ( i > in->pos )      return TTO_Err_Not_Covered;    error = Coverage_Index( &mbp->BaseCoverage, in->string[j],                            &base_index );    if ( error )      return error;    ma = &mbp->MarkArray;    if ( mark_index >= ma->MarkCount )      return TTO_Err_Invalid_GPOS_SubTable;    class       = ma->MarkRecord[mark_index].Class;    mark_anchor = &ma->MarkRecord[mark_index].MarkAnchor;    if ( class >= mbp->ClassCount )      return TTO_Err_Invalid_GPOS_SubTable;    ba = &mbp->BaseArray;    if ( base_index >= ba->BaseCount )      return TTO_Err_Invalid_GPOS_SubTable;    br          = &ba->BaseRecord[base_index];    base_anchor = &br->BaseAnchor[class];    error = Get_Anchor( gpi, mark_anchor, in->string[in->pos],                        &x_mark_value, &y_mark_value );    if ( error )      return error;    error = Get_Anchor( gpi, base_anchor, in->string[j],                        &x_base_value, &y_base_value );    if ( error )      return error;    /* anchor points are not cumulative */    o = &out[in->pos];    o->x_pos     = x_base_value - x_mark_value;    o->y_pos     = y_base_value - y_mark_value;    o->x_advance = 0;    o->y_advance = 0;    o->back      = i;    (in->pos)++;    return TT_Err_Ok;  }  /* LookupType 5 */  /* LigatureAttach */  static TT_Error  Load_LigatureAttach( TTO_LigatureAttach*  lat,                                        UShort               num_classes,                                        PFace                input )  {    DEFINE_LOAD_LOCALS( input->stream );    UShort                m, n, count;    ULong                 cur_offset, new_offset, base_offset;    TTO_ComponentRecord*  cr;    TTO_Anchor*           lan;    base_offset = FILE_Pos();    if ( ACCESS_Frame( 2L ) )      return error;    count = lat->ComponentCount = GET_UShort();        FORGET_Frame();    lat->ComponentRecord = NULL;    if ( ALLOC_ARRAY( lat->ComponentRecord, count, TTO_ComponentRecord ) )      return error;    cr = lat->ComponentRecord;    for ( m = 0; m < count; m++ )    {      cr[m].LigatureAnchor = NULL;      if ( ALLOC_ARRAY( cr[m].LigatureAnchor, num_classes, TTO_Anchor ) )        goto Fail;      lan = cr[m].LigatureAnchor;      for ( n = 0; n < num_classes; n++ )      {        if ( ACCESS_Frame( 2L ) )          goto Fail;        new_offset = GET_UShort();        FORGET_Frame();        if ( new_offset )        {          new_offset += base_offset;          cur_offset = FILE_Pos();          if ( FILE_Seek( new_offset ) ||               ( error = Load_Anchor( &lan[n], input ) ) != TT_Err_Ok )            goto Fail;          (void)FILE_Seek( cur_offset );        }        else          lan[n].PosFormat = 0;      }    }    return TT_Err_Ok;  Fail:    for ( m = 0; m < count; m++ )    {      lan = cr[m].LigatureAnchor;            for ( n = 0; n < num_classes; n++ )        Free_Anchor( &lan[n] );      FREE( lan );    }    FREE( cr );    return error;  }  static void  Free_LigatureAttach( TTO_LigatureAttach*  lat,                                    UShort               num_classes )  {    UShort           m, n, count;    TTO_ComponentRecord*  cr;    TTO_Anchor*           lan;    if ( lat->ComponentRecord )    {      count = lat->ComponentCount;      cr    = lat->ComponentRecord;      for ( m = 0; m < count; m++ )      {        lan = cr[m].LigatureAnchor;        for ( n = 0; n < num_classes; n++ )          Free_Anchor( &lan[n] );        FREE( lan );      }      FREE( cr );    }  }  /* LigatureArray */  static TT_Error  Load_LigatureArray( TTO_LigatureArray*  la,                                       UShort              num_classes,                                       PFace               input )  {    DEFINE_LOAD_LOCALS( input->stream );    UShort               n, count;    ULong                cur_offset, new_offset, base_offset;    TTO_LigatureAttach*  lat;    base_offset = FILE_Pos();    if ( ACCESS_Frame( 2L ) )      return error;    count = la->LigatureCount = GET_UShort();    FORGET_Frame();    la->LigatureAttach = NULL;    if ( ALLOC_ARRAY( la->LigatureAttach, count, TTO_LigatureAttach ) )      return error;    lat = la->LigatureAttach;    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_LigatureAttach( &lat[n], num_classes,                                          input ) ) != TT_Err_Ok )        goto Fail;      (void)FILE_Seek( cur_offset );    }    return TT_Err_Ok;  Fail:    for ( n = 0; n < count; n++ )      Free_LigatureAttach( &lat[n], num_classes );    FREE( lat );    return error;  }  static void  Free_LigatureArray( TTO_LigatureArray*  la,                                   UShort              num_classes )  {    UShort               n, count;    TTO_LigatureAttach*  lat;    if ( la->LigatureAttach )    {      count = la->LigatureCount;      lat   = la->LigatureAttach;      for ( n = 0; n < count; n++ )        Free_LigatureAttach( &lat[n], num_classes );      FREE( lat );    }  }  /* MarkLigPosFormat1 */  TT_Error  Load_MarkLigPos( TTO_MarkLigPos*  mlp,                             PFace            input )  {    DEFINE_LOAD_LOCALS( input->stream );    ULong  cur_offset, new_offset, base_offset;    base_offset = FILE_Pos();    if ( ACCESS_Frame( 4L ) )      return error;    mlp->PosFormat = GET_UShort();    new_offset     = GET_UShort() + base_offset;    FORGET_Frame();    cur_offset = FILE_Pos();    if ( FILE_Seek( new_offset ) ||         ( error = Load_Coverage( &mlp->MarkCoverage, input ) ) != TT_Err_Ok )      return error;    (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 = Load_Coverage( &mlp->LigatureCoverage,                                  input ) ) != TT_Err_Ok )      goto Fail3;    (void)FILE_Seek( cur_offset );    if ( ACCESS_Frame( 4L ) )      goto Fail2;    mlp->ClassCount = GET_UShort();    new_offset      = GET_UShort() + base_offset;    FORGET_Frame();    cur_offset = FILE_Pos();    if ( FILE_Seek( new_offset ) ||         ( error = Load_MarkArray( &mlp->MarkArray, input ) ) != TT_Err_Ok )      goto Fail2;    (void)FILE_Seek( cur_offset );    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_LigatureArray( &mlp->LigatureArray, mlp->ClassCount,                                       input ) ) != TT_Err_Ok )      goto Fail1;    return TT_Err_Ok;  Fail1:    Free_MarkArray( &mlp->MarkArray );  Fail2:    Free_Coverage( &mlp->LigatureCoverage );  Fail3:    Free_Coverage( &mlp->MarkCoverage );    return error;  }  void  Free_MarkLigPos( TTO_MarkLigPos*  mlp )  {    Free_LigatureArray( &mlp->LigatureArray, mlp->ClassCount );    Free_MarkArray( &mlp->MarkArray );    Free_Coverage( &mlp->LigatureCoverage );    Free_Coverage( &mlp->MarkCoverage );  }  static TT_Error  Lookup_MarkLigPos( GPOS_Instance*    gpi,                                      TTO_MarkLigPos*   mlp,                                      TTO_GSUB_String*  in,                                      TTO_GPOS_Data*    out,                                      UShort            flags,                                      UShort            context_length )  {    TT_UInt          i, j;    UShort           mark_index, lig_index, property, class;    UShort           mark_glyph;    TT_Pos