Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 1998-2004  David Turner and Werner Lemberg
      3  * Copyright (C) 2006  Behdad Esfahbod
      4  * Copyright (C) 2007  Red Hat, Inc.
      5  *
      6  * This is part of HarfBuzz, an OpenType Layout engine library.
      7  *
      8  * Permission is hereby granted, without written agreement and without
      9  * license or royalty fees, to use, copy, modify, and distribute this
     10  * software and its documentation for any purpose, provided that the
     11  * above copyright notice and the following two paragraphs appear in
     12  * all copies of this software.
     13  *
     14  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
     15  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
     16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
     17  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
     18  * DAMAGE.
     19  *
     20  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
     21  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     22  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
     23  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
     24  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
     25  *
     26  * Red Hat Author(s): Behdad Esfahbod
     27  */
     28 
     29 #include "harfbuzz-impl.h"
     30 #include "harfbuzz-gsub-private.h"
     31 #include "harfbuzz-open-private.h"
     32 #include "harfbuzz-gdef-private.h"
     33 
     34 static HB_Error  GSUB_Do_Glyph_Lookup( HB_GSUBHeader*   gsub,
     35 				       HB_UShort         lookup_index,
     36 				       HB_Buffer        buffer,
     37 				       HB_UShort         context_length,
     38 				       int               nesting_level );
     39 
     40 
     41 
     42 /**********************
     43  * Auxiliary functions
     44  **********************/
     45 
     46 
     47 
     48 HB_Error  HB_Load_GSUB_Table( HB_Stream stream,
     49 			      HB_GSUBHeader** retptr,
     50 			      HB_GDEFHeader*  gdef,
     51                               HB_Stream       gdefStream )
     52 {
     53   HB_Error         error;
     54   HB_UInt         cur_offset, new_offset, base_offset;
     55 
     56   HB_GSUBHeader*  gsub;
     57 
     58   if ( !retptr )
     59     return ERR(HB_Err_Invalid_Argument);
     60 
     61   if ( GOTO_Table( TTAG_GSUB ) )
     62     return error;
     63 
     64   base_offset = FILE_Pos();
     65 
     66   if ( ALLOC ( gsub, sizeof( *gsub ) ) )
     67       return error;
     68 
     69 
     70   /* skip version */
     71 
     72   if ( FILE_Seek( base_offset + 4L ) ||
     73        ACCESS_Frame( 2L ) )
     74     goto Fail4;
     75 
     76   new_offset = GET_UShort() + base_offset;
     77 
     78   FORGET_Frame();
     79 
     80   cur_offset = FILE_Pos();
     81   if ( FILE_Seek( new_offset ) ||
     82        ( error = _HB_OPEN_Load_ScriptList( &gsub->ScriptList,
     83 				  stream ) ) != HB_Err_Ok )
     84     goto Fail4;
     85   (void)FILE_Seek( cur_offset );
     86 
     87   if ( ACCESS_Frame( 2L ) )
     88     goto Fail3;
     89 
     90   new_offset = GET_UShort() + base_offset;
     91 
     92   FORGET_Frame();
     93 
     94   cur_offset = FILE_Pos();
     95   if ( FILE_Seek( new_offset ) ||
     96        ( error = _HB_OPEN_Load_FeatureList( &gsub->FeatureList,
     97 				   stream ) ) != HB_Err_Ok )
     98     goto Fail3;
     99   (void)FILE_Seek( cur_offset );
    100 
    101   if ( ACCESS_Frame( 2L ) )
    102     goto Fail2;
    103 
    104   new_offset = GET_UShort() + base_offset;
    105 
    106   FORGET_Frame();
    107 
    108   cur_offset = FILE_Pos();
    109   if ( FILE_Seek( new_offset ) ||
    110        ( error = _HB_OPEN_Load_LookupList( &gsub->LookupList,
    111 				  stream, HB_Type_GSUB ) ) != HB_Err_Ok )
    112     goto Fail2;
    113 
    114   gsub->gdef = gdef;      /* can be NULL */
    115 
    116   if ( ( error =  _HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( gdef, gdefStream,
    117 								     gsub->LookupList.Lookup,
    118 								     gsub->LookupList.LookupCount ) ) )
    119     goto Fail1;
    120 
    121   *retptr = gsub;
    122 
    123   return HB_Err_Ok;
    124 
    125 Fail1:
    126   _HB_OPEN_Free_LookupList( &gsub->LookupList, HB_Type_GSUB );
    127 
    128 Fail2:
    129   _HB_OPEN_Free_FeatureList( &gsub->FeatureList );
    130 
    131 Fail3:
    132   _HB_OPEN_Free_ScriptList( &gsub->ScriptList );
    133 
    134 Fail4:
    135   FREE ( gsub );
    136 
    137 
    138   return error;
    139 }
    140 
    141 
    142 HB_Error   HB_Done_GSUB_Table( HB_GSUBHeader* gsub )
    143 {
    144   _HB_OPEN_Free_LookupList( &gsub->LookupList, HB_Type_GSUB );
    145   _HB_OPEN_Free_FeatureList( &gsub->FeatureList );
    146   _HB_OPEN_Free_ScriptList( &gsub->ScriptList );
    147 
    148   FREE( gsub );
    149 
    150   return HB_Err_Ok;
    151 }
    152 
    153 /*****************************
    154  * SubTable related functions
    155  *****************************/
    156 
    157 
    158 /* LookupType 1 */
    159 
    160 /* SingleSubstFormat1 */
    161 /* SingleSubstFormat2 */
    162 
    163 static HB_Error  Load_SingleSubst( HB_GSUB_SubTable* st,
    164 				   HB_Stream         stream )
    165 {
    166   HB_Error error;
    167   HB_SingleSubst*  ss = &st->single;
    168 
    169   HB_UShort n, count;
    170   HB_UInt cur_offset, new_offset, base_offset;
    171 
    172   HB_UShort*  s;
    173 
    174 
    175   base_offset = FILE_Pos();
    176 
    177   if ( ACCESS_Frame( 4L ) )
    178     return error;
    179 
    180   ss->SubstFormat = GET_UShort();
    181   new_offset      = GET_UShort() + base_offset;
    182 
    183   FORGET_Frame();
    184 
    185   cur_offset = FILE_Pos();
    186   if ( FILE_Seek( new_offset ) ||
    187        ( error = _HB_OPEN_Load_Coverage( &ss->Coverage, stream ) ) != HB_Err_Ok )
    188     return error;
    189   (void)FILE_Seek( cur_offset );
    190 
    191   switch ( ss->SubstFormat )
    192   {
    193   case 1:
    194     if ( ACCESS_Frame( 2L ) )
    195       goto Fail2;
    196 
    197     ss->ssf.ssf1.DeltaGlyphID = GET_UShort();
    198 
    199     FORGET_Frame();
    200 
    201     break;
    202 
    203   case 2:
    204     if ( ACCESS_Frame( 2L ) )
    205       goto Fail2;
    206 
    207     count = ss->ssf.ssf2.GlyphCount = GET_UShort();
    208 
    209     FORGET_Frame();
    210 
    211     ss->ssf.ssf2.Substitute = NULL;
    212 
    213     if ( ALLOC_ARRAY( ss->ssf.ssf2.Substitute, count, HB_UShort ) )
    214       goto Fail2;
    215 
    216     s = ss->ssf.ssf2.Substitute;
    217 
    218     if ( ACCESS_Frame( count * 2L ) )
    219       goto Fail1;
    220 
    221     for ( n = 0; n < count; n++ )
    222       s[n] = GET_UShort();
    223 
    224     FORGET_Frame();
    225 
    226     break;
    227 
    228   default:
    229     return ERR(HB_Err_Invalid_SubTable_Format);
    230   }
    231 
    232   return HB_Err_Ok;
    233 
    234 Fail1:
    235   FREE( s );
    236 
    237 Fail2:
    238   _HB_OPEN_Free_Coverage( &ss->Coverage );
    239   return error;
    240 }
    241 
    242 
    243 static void  Free_SingleSubst( HB_GSUB_SubTable* st )
    244 {
    245   HB_SingleSubst*  ss = &st->single;
    246 
    247   switch ( ss->SubstFormat )
    248   {
    249   case 1:
    250     break;
    251 
    252   case 2:
    253     FREE( ss->ssf.ssf2.Substitute );
    254     break;
    255 
    256   default:
    257     break;
    258   }
    259 
    260   _HB_OPEN_Free_Coverage( &ss->Coverage );
    261 }
    262 
    263 
    264 static HB_Error  Lookup_SingleSubst( HB_GSUBHeader*   gsub,
    265 				     HB_GSUB_SubTable* st,
    266 				     HB_Buffer        buffer,
    267 				     HB_UShort         flags,
    268 				     HB_UShort         context_length,
    269 				     int               nesting_level )
    270 {
    271   HB_UShort index, value, property;
    272   HB_Error  error;
    273   HB_SingleSubst*  ss = &st->single;
    274   HB_GDEFHeader*   gdef = gsub->gdef;
    275 
    276   HB_UNUSED(nesting_level);
    277 
    278   if ( context_length != 0xFFFF && context_length < 1 )
    279     return HB_Err_Not_Covered;
    280 
    281   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
    282     return error;
    283 
    284   error = _HB_OPEN_Coverage_Index( &ss->Coverage, IN_CURGLYPH(), &index );
    285   if ( error )
    286     return error;
    287 
    288   switch ( ss->SubstFormat )
    289   {
    290   case 1:
    291     value = ( IN_CURGLYPH() + ss->ssf.ssf1.DeltaGlyphID ) & 0xFFFF;
    292     if ( REPLACE_Glyph( buffer, value, nesting_level ) )
    293       return error;
    294     break;
    295 
    296   case 2:
    297     if ( index >= ss->ssf.ssf2.GlyphCount )
    298       return ERR(HB_Err_Invalid_SubTable);
    299     value = ss->ssf.ssf2.Substitute[index];
    300     if ( REPLACE_Glyph( buffer, value, nesting_level ) )
    301       return error;
    302     break;
    303 
    304   default:
    305     return ERR(HB_Err_Invalid_SubTable);
    306   }
    307 
    308   if ( gdef && gdef->NewGlyphClasses )
    309   {
    310     /* we inherit the old glyph class to the substituted glyph */
    311 
    312     error = _HB_GDEF_Add_Glyph_Property( gdef, value, property );
    313     if ( error && error != HB_Err_Not_Covered )
    314       return error;
    315   }
    316 
    317   return HB_Err_Ok;
    318 }
    319 
    320 
    321 /* LookupType 2 */
    322 
    323 /* Sequence */
    324 
    325 static HB_Error  Load_Sequence( HB_Sequence*  s,
    326 				HB_Stream      stream )
    327 {
    328   HB_Error error;
    329 
    330   HB_UShort n, count;
    331   HB_UShort*  sub;
    332 
    333 
    334   if ( ACCESS_Frame( 2L ) )
    335     return error;
    336 
    337   count = s->GlyphCount = GET_UShort();
    338 
    339   FORGET_Frame();
    340 
    341   s->Substitute = NULL;
    342 
    343   if ( count )
    344   {
    345     if ( ALLOC_ARRAY( s->Substitute, count, HB_UShort ) )
    346       return error;
    347 
    348     sub = s->Substitute;
    349 
    350     if ( ACCESS_Frame( count * 2L ) )
    351     {
    352       FREE( sub );
    353       return error;
    354     }
    355 
    356     for ( n = 0; n < count; n++ )
    357       sub[n] = GET_UShort();
    358 
    359     FORGET_Frame();
    360   }
    361 
    362   return HB_Err_Ok;
    363 }
    364 
    365 
    366 static void  Free_Sequence( HB_Sequence*  s )
    367 {
    368   FREE( s->Substitute );
    369 }
    370 
    371 
    372 /* MultipleSubstFormat1 */
    373 
    374 static HB_Error  Load_MultipleSubst( HB_GSUB_SubTable* st,
    375 				     HB_Stream         stream )
    376 {
    377   HB_Error error;
    378   HB_MultipleSubst*  ms = &st->multiple;
    379 
    380   HB_UShort      n = 0, m, count;
    381   HB_UInt       cur_offset, new_offset, base_offset;
    382 
    383   HB_Sequence*  s;
    384 
    385 
    386   base_offset = FILE_Pos();
    387 
    388   if ( ACCESS_Frame( 4L ) )
    389     return error;
    390 
    391   ms->SubstFormat = GET_UShort();             /* should be 1 */
    392   new_offset      = GET_UShort() + base_offset;
    393 
    394   FORGET_Frame();
    395 
    396   cur_offset = FILE_Pos();
    397   if ( FILE_Seek( new_offset ) ||
    398        ( error = _HB_OPEN_Load_Coverage( &ms->Coverage, stream ) ) != HB_Err_Ok )
    399     return error;
    400   (void)FILE_Seek( cur_offset );
    401 
    402   if ( ACCESS_Frame( 2L ) )
    403     goto Fail2;
    404 
    405   count = ms->SequenceCount = GET_UShort();
    406 
    407   FORGET_Frame();
    408 
    409   ms->Sequence = NULL;
    410 
    411   if ( ALLOC_ARRAY( ms->Sequence, count, HB_Sequence ) )
    412     goto Fail2;
    413 
    414   s = ms->Sequence;
    415 
    416   for ( n = 0; n < count; n++ )
    417   {
    418     if ( ACCESS_Frame( 2L ) )
    419       goto Fail1;
    420 
    421     new_offset = GET_UShort() + base_offset;
    422 
    423     FORGET_Frame();
    424 
    425     cur_offset = FILE_Pos();
    426     if ( FILE_Seek( new_offset ) ||
    427 	 ( error = Load_Sequence( &s[n], stream ) ) != HB_Err_Ok )
    428       goto Fail1;
    429     (void)FILE_Seek( cur_offset );
    430   }
    431 
    432   return HB_Err_Ok;
    433 
    434 Fail1:
    435   for ( m = 0; m < n; m++ )
    436     Free_Sequence( &s[m] );
    437 
    438   FREE( s );
    439 
    440 Fail2:
    441   _HB_OPEN_Free_Coverage( &ms->Coverage );
    442   return error;
    443 }
    444 
    445 
    446 static void  Free_MultipleSubst( HB_GSUB_SubTable* st )
    447 {
    448   HB_UShort      n, count;
    449   HB_MultipleSubst*  ms = &st->multiple;
    450 
    451   HB_Sequence*  s;
    452 
    453 
    454   if ( ms->Sequence )
    455   {
    456     count = ms->SequenceCount;
    457     s     = ms->Sequence;
    458 
    459     for ( n = 0; n < count; n++ )
    460       Free_Sequence( &s[n] );
    461 
    462     FREE( s );
    463   }
    464 
    465   _HB_OPEN_Free_Coverage( &ms->Coverage );
    466 }
    467 
    468 
    469 static HB_Error  Lookup_MultipleSubst( HB_GSUBHeader*    gsub,
    470 				       HB_GSUB_SubTable* st,
    471 				       HB_Buffer         buffer,
    472 				       HB_UShort          flags,
    473 				       HB_UShort          context_length,
    474 				       int                nesting_level )
    475 {
    476   HB_Error  error;
    477   HB_UShort index, property, n, count;
    478   HB_UShort*s;
    479   HB_MultipleSubst*  ms = &st->multiple;
    480   HB_GDEFHeader*     gdef = gsub->gdef;
    481 
    482   HB_UNUSED(nesting_level);
    483 
    484   if ( context_length != 0xFFFF && context_length < 1 )
    485     return HB_Err_Not_Covered;
    486 
    487   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
    488     return error;
    489 
    490   error = _HB_OPEN_Coverage_Index( &ms->Coverage, IN_CURGLYPH(), &index );
    491   if ( error )
    492     return error;
    493 
    494   if ( index >= ms->SequenceCount )
    495     return ERR(HB_Err_Invalid_SubTable);
    496 
    497   count = ms->Sequence[index].GlyphCount;
    498   s     = ms->Sequence[index].Substitute;
    499 
    500   if ( ADD_String( buffer, 1, count, s, 0xFFFF, 0xFFFF ) )
    501     return error;
    502 
    503   if ( gdef && gdef->NewGlyphClasses )
    504   {
    505     /* this is a guess only ... */
    506 
    507     if ( property == HB_GDEF_LIGATURE )
    508       property = HB_GDEF_BASE_GLYPH;
    509 
    510     for ( n = 0; n < count; n++ )
    511     {
    512       error = _HB_GDEF_Add_Glyph_Property( gdef, s[n], property );
    513       if ( error && error != HB_Err_Not_Covered )
    514 	return error;
    515     }
    516   }
    517 
    518   return HB_Err_Ok;
    519 }
    520 
    521 
    522 /* LookupType 3 */
    523 
    524 /* AlternateSet */
    525 
    526 static HB_Error  Load_AlternateSet( HB_AlternateSet*  as,
    527 				    HB_Stream          stream )
    528 {
    529   HB_Error error;
    530 
    531   HB_UShort n, count;
    532   HB_UShort*  a;
    533 
    534 
    535   if ( ACCESS_Frame( 2L ) )
    536     return error;
    537 
    538   count = as->GlyphCount = GET_UShort();
    539 
    540   FORGET_Frame();
    541 
    542   as->Alternate = NULL;
    543 
    544   if ( ALLOC_ARRAY( as->Alternate, count, HB_UShort ) )
    545     return error;
    546 
    547   a = as->Alternate;
    548 
    549   if ( ACCESS_Frame( count * 2L ) )
    550   {
    551     FREE( a );
    552     return error;
    553   }
    554 
    555   for ( n = 0; n < count; n++ )
    556     a[n] = GET_UShort();
    557 
    558   FORGET_Frame();
    559 
    560   return HB_Err_Ok;
    561 }
    562 
    563 
    564 static void  Free_AlternateSet( HB_AlternateSet*  as )
    565 {
    566   FREE( as->Alternate );
    567 }
    568 
    569 
    570 /* AlternateSubstFormat1 */
    571 
    572 static HB_Error  Load_AlternateSubst( HB_GSUB_SubTable* st,
    573 				      HB_Stream         stream )
    574 {
    575   HB_Error error;
    576   HB_AlternateSubst* as = &st->alternate;
    577 
    578   HB_UShort          n = 0, m, count;
    579   HB_UInt           cur_offset, new_offset, base_offset;
    580 
    581   HB_AlternateSet*  aset;
    582 
    583 
    584   base_offset = FILE_Pos();
    585 
    586   if ( ACCESS_Frame( 4L ) )
    587     return error;
    588 
    589   as->SubstFormat = GET_UShort();             /* should be 1 */
    590   new_offset      = GET_UShort() + base_offset;
    591 
    592   FORGET_Frame();
    593 
    594   cur_offset = FILE_Pos();
    595   if ( FILE_Seek( new_offset ) ||
    596        ( error = _HB_OPEN_Load_Coverage( &as->Coverage, stream ) ) != HB_Err_Ok )
    597     return error;
    598   (void)FILE_Seek( cur_offset );
    599 
    600   if ( ACCESS_Frame( 2L ) )
    601     goto Fail2;
    602 
    603   count = as->AlternateSetCount = GET_UShort();
    604 
    605   FORGET_Frame();
    606 
    607   as->AlternateSet = NULL;
    608 
    609   if ( ALLOC_ARRAY( as->AlternateSet, count, HB_AlternateSet ) )
    610     goto Fail2;
    611 
    612   aset = as->AlternateSet;
    613 
    614   for ( n = 0; n < count; n++ )
    615   {
    616     if ( ACCESS_Frame( 2L ) )
    617       goto Fail1;
    618 
    619     new_offset = GET_UShort() + base_offset;
    620 
    621     FORGET_Frame();
    622 
    623     cur_offset = FILE_Pos();
    624     if ( FILE_Seek( new_offset ) ||
    625 	 ( error = Load_AlternateSet( &aset[n], stream ) ) != HB_Err_Ok )
    626       goto Fail1;
    627     (void)FILE_Seek( cur_offset );
    628   }
    629 
    630   return HB_Err_Ok;
    631 
    632 Fail1:
    633   for ( m = 0; m < n; m++ )
    634     Free_AlternateSet( &aset[m] );
    635 
    636   FREE( aset );
    637 
    638 Fail2:
    639   _HB_OPEN_Free_Coverage( &as->Coverage );
    640   return error;
    641 }
    642 
    643 
    644 static void  Free_AlternateSubst( HB_GSUB_SubTable* st )
    645 {
    646   HB_UShort          n, count;
    647   HB_AlternateSubst* as = &st->alternate;
    648 
    649   HB_AlternateSet*  aset;
    650 
    651 
    652   if ( as->AlternateSet )
    653   {
    654     count = as->AlternateSetCount;
    655     aset  = as->AlternateSet;
    656 
    657     for ( n = 0; n < count; n++ )
    658       Free_AlternateSet( &aset[n] );
    659 
    660     FREE( aset );
    661   }
    662 
    663   _HB_OPEN_Free_Coverage( &as->Coverage );
    664 }
    665 
    666 
    667 static HB_Error  Lookup_AlternateSubst( HB_GSUBHeader*    gsub,
    668 					HB_GSUB_SubTable* st,
    669 					HB_Buffer         buffer,
    670 					HB_UShort          flags,
    671 					HB_UShort          context_length,
    672 					int                nesting_level )
    673 {
    674   HB_Error          error;
    675   HB_UShort         index, value, alt_index, property;
    676   HB_AlternateSubst* as = &st->alternate;
    677   HB_GDEFHeader*     gdef = gsub->gdef;
    678   HB_AlternateSet  aset;
    679 
    680   HB_UNUSED(nesting_level);
    681 
    682   if ( context_length != 0xFFFF && context_length < 1 )
    683     return HB_Err_Not_Covered;
    684 
    685   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
    686     return error;
    687 
    688   error = _HB_OPEN_Coverage_Index( &as->Coverage, IN_CURGLYPH(), &index );
    689   if ( error )
    690     return error;
    691 
    692   aset = as->AlternateSet[index];
    693 
    694   /* we use a user-defined callback function to get the alternate index */
    695 
    696   if ( gsub->altfunc )
    697     alt_index = (gsub->altfunc)( buffer->out_pos, IN_CURGLYPH(),
    698 				 aset.GlyphCount, aset.Alternate,
    699 				 gsub->data );
    700   else
    701     alt_index = 0;
    702 
    703   value = aset.Alternate[alt_index];
    704   if ( REPLACE_Glyph( buffer, value, nesting_level ) )
    705     return error;
    706 
    707   if ( gdef && gdef->NewGlyphClasses )
    708   {
    709     /* we inherit the old glyph class to the substituted glyph */
    710 
    711     error = _HB_GDEF_Add_Glyph_Property( gdef, value, property );
    712     if ( error && error != HB_Err_Not_Covered )
    713       return error;
    714   }
    715 
    716   return HB_Err_Ok;
    717 }
    718 
    719 
    720 /* LookupType 4 */
    721 
    722 /* Ligature */
    723 
    724 static HB_Error  Load_Ligature( HB_Ligature*  l,
    725 				HB_Stream      stream )
    726 {
    727   HB_Error error;
    728 
    729   HB_UShort n, count;
    730   HB_UShort*  c;
    731 
    732 
    733   if ( ACCESS_Frame( 4L ) )
    734     return error;
    735 
    736   l->LigGlyph       = GET_UShort();
    737   l->ComponentCount = GET_UShort();
    738 
    739   FORGET_Frame();
    740 
    741   l->Component = NULL;
    742 
    743   count = l->ComponentCount - 1;      /* only ComponentCount - 1 elements */
    744 
    745   if ( ALLOC_ARRAY( l->Component, count, HB_UShort ) )
    746     return error;
    747 
    748   c = l->Component;
    749 
    750   if ( ACCESS_Frame( count * 2L ) )
    751   {
    752     FREE( c );
    753     return error;
    754   }
    755 
    756   for ( n = 0; n < count; n++ )
    757     c[n] = GET_UShort();
    758 
    759   FORGET_Frame();
    760 
    761   return HB_Err_Ok;
    762 }
    763 
    764 
    765 static void  Free_Ligature( HB_Ligature*  l )
    766 {
    767   FREE( l->Component );
    768 }
    769 
    770 
    771 /* LigatureSet */
    772 
    773 static HB_Error  Load_LigatureSet( HB_LigatureSet*  ls,
    774 				   HB_Stream         stream )
    775 {
    776   HB_Error error;
    777 
    778   HB_UShort      n = 0, m, count;
    779   HB_UInt       cur_offset, new_offset, base_offset;
    780 
    781   HB_Ligature*  l;
    782 
    783 
    784   base_offset = FILE_Pos();
    785 
    786   if ( ACCESS_Frame( 2L ) )
    787     return error;
    788 
    789   count = ls->LigatureCount = GET_UShort();
    790 
    791   FORGET_Frame();
    792 
    793   ls->Ligature = NULL;
    794 
    795   if ( ALLOC_ARRAY( ls->Ligature, count, HB_Ligature ) )
    796     return error;
    797 
    798   l = ls->Ligature;
    799 
    800   for ( n = 0; n < count; n++ )
    801   {
    802     if ( ACCESS_Frame( 2L ) )
    803       goto Fail;
    804 
    805     new_offset = GET_UShort() + base_offset;
    806 
    807     FORGET_Frame();
    808 
    809     cur_offset = FILE_Pos();
    810     if ( FILE_Seek( new_offset ) ||
    811 	 ( error = Load_Ligature( &l[n], stream ) ) != HB_Err_Ok )
    812       goto Fail;
    813     (void)FILE_Seek( cur_offset );
    814   }
    815 
    816   return HB_Err_Ok;
    817 
    818 Fail:
    819   for ( m = 0; m < n; m++ )
    820     Free_Ligature( &l[m] );
    821 
    822   FREE( l );
    823   return error;
    824 }
    825 
    826 
    827 static void  Free_LigatureSet( HB_LigatureSet*  ls )
    828 {
    829   HB_UShort      n, count;
    830 
    831   HB_Ligature*  l;
    832 
    833 
    834   if ( ls->Ligature )
    835   {
    836     count = ls->LigatureCount;
    837     l     = ls->Ligature;
    838 
    839     for ( n = 0; n < count; n++ )
    840       Free_Ligature( &l[n] );
    841 
    842     FREE( l );
    843   }
    844 }
    845 
    846 
    847 /* LigatureSubstFormat1 */
    848 
    849 static HB_Error  Load_LigatureSubst( HB_GSUB_SubTable* st,
    850 				     HB_Stream         stream )
    851 {
    852   HB_Error error;
    853   HB_LigatureSubst*  ls = &st->ligature;
    854 
    855   HB_UShort         n = 0, m, count;
    856   HB_UInt          cur_offset, new_offset, base_offset;
    857 
    858   HB_LigatureSet*  lset;
    859 
    860 
    861   base_offset = FILE_Pos();
    862 
    863   if ( ACCESS_Frame( 4L ) )
    864     return error;
    865 
    866   ls->SubstFormat = GET_UShort();             /* should be 1 */
    867   new_offset      = GET_UShort() + base_offset;
    868 
    869   FORGET_Frame();
    870 
    871   cur_offset = FILE_Pos();
    872   if ( FILE_Seek( new_offset ) ||
    873        ( error = _HB_OPEN_Load_Coverage( &ls->Coverage, stream ) ) != HB_Err_Ok )
    874     return error;
    875   (void)FILE_Seek( cur_offset );
    876 
    877   if ( ACCESS_Frame( 2L ) )
    878     goto Fail2;
    879 
    880   count = ls->LigatureSetCount = GET_UShort();
    881 
    882   FORGET_Frame();
    883 
    884   ls->LigatureSet = NULL;
    885 
    886   if ( ALLOC_ARRAY( ls->LigatureSet, count, HB_LigatureSet ) )
    887     goto Fail2;
    888 
    889   lset = ls->LigatureSet;
    890 
    891   for ( n = 0; n < count; n++ )
    892   {
    893     if ( ACCESS_Frame( 2L ) )
    894       goto Fail1;
    895 
    896     new_offset = GET_UShort() + base_offset;
    897 
    898     FORGET_Frame();
    899 
    900     cur_offset = FILE_Pos();
    901     if ( FILE_Seek( new_offset ) ||
    902 	 ( error = Load_LigatureSet( &lset[n], stream ) ) != HB_Err_Ok )
    903       goto Fail1;
    904     (void)FILE_Seek( cur_offset );
    905   }
    906 
    907   return HB_Err_Ok;
    908 
    909 Fail1:
    910   for ( m = 0; m < n; m++ )
    911     Free_LigatureSet( &lset[m] );
    912 
    913   FREE( lset );
    914 
    915 Fail2:
    916   _HB_OPEN_Free_Coverage( &ls->Coverage );
    917   return error;
    918 }
    919 
    920 
    921 static void  Free_LigatureSubst( HB_GSUB_SubTable* st )
    922 {
    923   HB_UShort         n, count;
    924   HB_LigatureSubst*  ls = &st->ligature;
    925 
    926   HB_LigatureSet*  lset;
    927 
    928 
    929   if ( ls->LigatureSet )
    930   {
    931     count = ls->LigatureSetCount;
    932     lset  = ls->LigatureSet;
    933 
    934     for ( n = 0; n < count; n++ )
    935       Free_LigatureSet( &lset[n] );
    936 
    937     FREE( lset );
    938   }
    939 
    940   _HB_OPEN_Free_Coverage( &ls->Coverage );
    941 }
    942 
    943 
    944 static HB_Error  Lookup_LigatureSubst( HB_GSUBHeader*    gsub,
    945 				       HB_GSUB_SubTable* st,
    946 				       HB_Buffer         buffer,
    947 				       HB_UShort          flags,
    948 				       HB_UShort          context_length,
    949 				       int                nesting_level )
    950 {
    951   HB_UShort      index, property;
    952   HB_Error       error;
    953   HB_UShort      numlig, i, j, is_mark, first_is_mark = FALSE;
    954   HB_UShort*     c;
    955   HB_LigatureSubst*  ls = &st->ligature;
    956   HB_GDEFHeader*     gdef = gsub->gdef;
    957 
    958   HB_Ligature*  lig;
    959 
    960   HB_UNUSED(nesting_level);
    961 
    962   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
    963     return error;
    964 
    965   if ( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS )
    966     first_is_mark = TRUE;
    967 
    968   error = _HB_OPEN_Coverage_Index( &ls->Coverage, IN_CURGLYPH(), &index );
    969   if ( error )
    970     return error;
    971 
    972   if ( index >= ls->LigatureSetCount )
    973      return ERR(HB_Err_Invalid_SubTable);
    974 
    975   lig = ls->LigatureSet[index].Ligature;
    976 
    977   for ( numlig = ls->LigatureSet[index].LigatureCount;
    978 	numlig;
    979 	numlig--, lig++ )
    980   {
    981     if ( buffer->in_pos + lig->ComponentCount > buffer->in_length )
    982       goto next_ligature;               /* Not enough glyphs in input */
    983 
    984     c    = lig->Component;
    985 
    986     is_mark = first_is_mark;
    987 
    988     if ( context_length != 0xFFFF && context_length < lig->ComponentCount )
    989       break;
    990 
    991     for ( i = 1, j = buffer->in_pos + 1; i < lig->ComponentCount; i++, j++ )
    992     {
    993       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
    994       {
    995 	if ( error && error != HB_Err_Not_Covered )
    996 	  return error;
    997 
    998 	if ( j + lig->ComponentCount - i == (HB_Int)buffer->in_length )
    999 	  goto next_ligature;
   1000 	j++;
   1001       }
   1002 
   1003       if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) )
   1004 	is_mark = FALSE;
   1005 
   1006       if ( IN_GLYPH( j ) != c[i - 1] )
   1007 	goto next_ligature;
   1008     }
   1009 
   1010     if ( gdef && gdef->NewGlyphClasses )
   1011     {
   1012       /* this is just a guess ... */
   1013 
   1014       error = _HB_GDEF_Add_Glyph_Property( gdef, lig->LigGlyph,
   1015 				  is_mark ? HB_GDEF_MARK : HB_GDEF_LIGATURE );
   1016       if ( error && error != HB_Err_Not_Covered )
   1017 	return error;
   1018     }
   1019 
   1020     if ( j == buffer->in_pos + i ) /* No input glyphs skipped */
   1021     {
   1022       /* We don't use a new ligature ID if there are no skipped
   1023 	 glyphs and the ligature already has an ID.             */
   1024 
   1025       if ( IN_LIGID( buffer->in_pos ) )
   1026       {
   1027 	if ( ADD_String( buffer, i, 1, &lig->LigGlyph,
   1028 			0xFFFF, 0xFFFF ) )
   1029 	  return error;
   1030       }
   1031       else
   1032       {
   1033 	HB_UShort ligID = _hb_buffer_allocate_ligid( buffer );
   1034 	if ( ADD_String( buffer, i, 1, &lig->LigGlyph,
   1035 			0xFFFF, ligID ) )
   1036 	  return error;
   1037       }
   1038     }
   1039     else
   1040     {
   1041       HB_UShort ligID = _hb_buffer_allocate_ligid( buffer );
   1042       if ( ADD_Glyph( buffer, lig->LigGlyph, 0xFFFF, ligID ) )
   1043 	return error;
   1044 
   1045       /* Now we must do a second loop to copy the skipped glyphs to
   1046 	 `out' and assign component values to it.  We start with the
   1047 	 glyph after the first component.  Glyphs between component
   1048 	 i and i+1 belong to component i.  Together with the ligID
   1049 	 value it is later possible to check whether a specific
   1050 	 component value really belongs to a given ligature.         */
   1051 
   1052       for ( i = 0; i < lig->ComponentCount - 1; i++ )
   1053       {
   1054 	while ( CHECK_Property( gdef, IN_CURITEM(),
   1055 				flags, &property ) )
   1056 	  if ( ADD_Glyph( buffer, IN_CURGLYPH(), i, ligID ) )
   1057 	    return error;
   1058 
   1059 	(buffer->in_pos)++;
   1060       }
   1061     }
   1062 
   1063     return HB_Err_Ok;
   1064 
   1065   next_ligature:
   1066     ;
   1067   }
   1068 
   1069   return HB_Err_Not_Covered;
   1070 }
   1071 
   1072 
   1073 /* Do the actual substitution for a context substitution (either format
   1074    5 or 6).  This is only called after we've determined that the input
   1075    matches the subrule.                                                 */
   1076 
   1077 static HB_Error  Do_ContextSubst( HB_GSUBHeader*        gsub,
   1078 				  HB_UShort              GlyphCount,
   1079 				  HB_UShort              SubstCount,
   1080 				  HB_SubstLookupRecord* subst,
   1081 				  HB_Buffer             buffer,
   1082 				  int                    nesting_level )
   1083 {
   1084   HB_Error  error;
   1085   HB_UInt   i, old_pos;
   1086 
   1087 
   1088   i = 0;
   1089 
   1090   while ( i < GlyphCount )
   1091   {
   1092     if ( SubstCount && i == subst->SequenceIndex )
   1093     {
   1094       old_pos = buffer->in_pos;
   1095 
   1096       /* Do a substitution */
   1097 
   1098       error = GSUB_Do_Glyph_Lookup( gsub, subst->LookupListIndex, buffer,
   1099 				    GlyphCount, nesting_level );
   1100 
   1101       subst++;
   1102       SubstCount--;
   1103       i += buffer->in_pos - old_pos;
   1104 
   1105       if ( error == HB_Err_Not_Covered )
   1106       {
   1107 	if ( COPY_Glyph( buffer ) )
   1108 	  return error;
   1109 	i++;
   1110       }
   1111       else if ( error )
   1112 	return error;
   1113     }
   1114     else
   1115     {
   1116       /* No substitution for this index */
   1117 
   1118       if ( COPY_Glyph( buffer ) )
   1119 	return error;
   1120       i++;
   1121     }
   1122   }
   1123 
   1124   return HB_Err_Ok;
   1125 }
   1126 
   1127 
   1128 /* LookupType 5 */
   1129 
   1130 /* SubRule */
   1131 
   1132 static HB_Error  Load_SubRule( HB_SubRule*  sr,
   1133 			       HB_Stream     stream )
   1134 {
   1135   HB_Error error;
   1136 
   1137   HB_UShort               n, count;
   1138   HB_UShort*              i;
   1139 
   1140   HB_SubstLookupRecord*  slr;
   1141 
   1142 
   1143   if ( ACCESS_Frame( 4L ) )
   1144     return error;
   1145 
   1146   sr->GlyphCount = GET_UShort();
   1147   sr->SubstCount = GET_UShort();
   1148 
   1149   FORGET_Frame();
   1150 
   1151   sr->Input = NULL;
   1152 
   1153   count = sr->GlyphCount - 1;         /* only GlyphCount - 1 elements */
   1154 
   1155   if ( ALLOC_ARRAY( sr->Input, count, HB_UShort ) )
   1156     return error;
   1157 
   1158   i = sr->Input;
   1159 
   1160   if ( ACCESS_Frame( count * 2L ) )
   1161     goto Fail2;
   1162 
   1163   for ( n = 0; n < count; n++ )
   1164     i[n] = GET_UShort();
   1165 
   1166   FORGET_Frame();
   1167 
   1168   sr->SubstLookupRecord = NULL;
   1169 
   1170   count = sr->SubstCount;
   1171 
   1172   if ( ALLOC_ARRAY( sr->SubstLookupRecord, count, HB_SubstLookupRecord ) )
   1173     goto Fail2;
   1174 
   1175   slr = sr->SubstLookupRecord;
   1176 
   1177   if ( ACCESS_Frame( count * 4L ) )
   1178     goto Fail1;
   1179 
   1180   for ( n = 0; n < count; n++ )
   1181   {
   1182     slr[n].SequenceIndex   = GET_UShort();
   1183     slr[n].LookupListIndex = GET_UShort();
   1184   }
   1185 
   1186   FORGET_Frame();
   1187 
   1188   return HB_Err_Ok;
   1189 
   1190 Fail1:
   1191   FREE( slr );
   1192 
   1193 Fail2:
   1194   FREE( i );
   1195   return error;
   1196 }
   1197 
   1198 
   1199 static void  Free_SubRule( HB_SubRule*  sr )
   1200 {
   1201   FREE( sr->SubstLookupRecord );
   1202   FREE( sr->Input );
   1203 }
   1204 
   1205 
   1206 /* SubRuleSet */
   1207 
   1208 static HB_Error  Load_SubRuleSet( HB_SubRuleSet*  srs,
   1209 				  HB_Stream        stream )
   1210 {
   1211   HB_Error error;
   1212 
   1213   HB_UShort     n = 0, m, count;
   1214   HB_UInt      cur_offset, new_offset, base_offset;
   1215 
   1216   HB_SubRule*  sr;
   1217 
   1218 
   1219   base_offset = FILE_Pos();
   1220 
   1221   if ( ACCESS_Frame( 2L ) )
   1222     return error;
   1223 
   1224   count = srs->SubRuleCount = GET_UShort();
   1225 
   1226   FORGET_Frame();
   1227 
   1228   srs->SubRule = NULL;
   1229 
   1230   if ( ALLOC_ARRAY( srs->SubRule, count, HB_SubRule ) )
   1231     return error;
   1232 
   1233   sr = srs->SubRule;
   1234 
   1235   for ( n = 0; n < count; n++ )
   1236   {
   1237     if ( ACCESS_Frame( 2L ) )
   1238       goto Fail;
   1239 
   1240     new_offset = GET_UShort() + base_offset;
   1241 
   1242     FORGET_Frame();
   1243 
   1244     cur_offset = FILE_Pos();
   1245     if ( FILE_Seek( new_offset ) ||
   1246 	 ( error = Load_SubRule( &sr[n], stream ) ) != HB_Err_Ok )
   1247       goto Fail;
   1248     (void)FILE_Seek( cur_offset );
   1249   }
   1250 
   1251   return HB_Err_Ok;
   1252 
   1253 Fail:
   1254   for ( m = 0; m < n; m++ )
   1255     Free_SubRule( &sr[m] );
   1256 
   1257   FREE( sr );
   1258   return error;
   1259 }
   1260 
   1261 
   1262 static void  Free_SubRuleSet( HB_SubRuleSet*  srs )
   1263 {
   1264   HB_UShort     n, count;
   1265 
   1266   HB_SubRule*  sr;
   1267 
   1268 
   1269   if ( srs->SubRule )
   1270   {
   1271     count = srs->SubRuleCount;
   1272     sr    = srs->SubRule;
   1273 
   1274     for ( n = 0; n < count; n++ )
   1275       Free_SubRule( &sr[n] );
   1276 
   1277     FREE( sr );
   1278   }
   1279 }
   1280 
   1281 
   1282 /* ContextSubstFormat1 */
   1283 
   1284 static HB_Error  Load_ContextSubst1( HB_ContextSubstFormat1*  csf1,
   1285 				     HB_Stream                 stream )
   1286 {
   1287   HB_Error error;
   1288 
   1289   HB_UShort        n = 0, m, count;
   1290   HB_UInt         cur_offset, new_offset, base_offset;
   1291 
   1292   HB_SubRuleSet*  srs;
   1293 
   1294 
   1295   base_offset = FILE_Pos() - 2L;
   1296 
   1297   if ( ACCESS_Frame( 2L ) )
   1298     return error;
   1299 
   1300   new_offset = GET_UShort() + base_offset;
   1301 
   1302   FORGET_Frame();
   1303 
   1304   cur_offset = FILE_Pos();
   1305   if ( FILE_Seek( new_offset ) ||
   1306        ( error = _HB_OPEN_Load_Coverage( &csf1->Coverage, stream ) ) != HB_Err_Ok )
   1307     return error;
   1308   (void)FILE_Seek( cur_offset );
   1309 
   1310   if ( ACCESS_Frame( 2L ) )
   1311     goto Fail2;
   1312 
   1313   count = csf1->SubRuleSetCount = GET_UShort();
   1314 
   1315   FORGET_Frame();
   1316 
   1317   csf1->SubRuleSet = NULL;
   1318 
   1319   if ( ALLOC_ARRAY( csf1->SubRuleSet, count, HB_SubRuleSet ) )
   1320     goto Fail2;
   1321 
   1322   srs = csf1->SubRuleSet;
   1323 
   1324   for ( n = 0; n < count; n++ )
   1325   {
   1326     if ( ACCESS_Frame( 2L ) )
   1327       goto Fail1;
   1328 
   1329     new_offset = GET_UShort() + base_offset;
   1330 
   1331     FORGET_Frame();
   1332 
   1333     cur_offset = FILE_Pos();
   1334     if ( FILE_Seek( new_offset ) ||
   1335 	 ( error = Load_SubRuleSet( &srs[n], stream ) ) != HB_Err_Ok )
   1336       goto Fail1;
   1337     (void)FILE_Seek( cur_offset );
   1338   }
   1339 
   1340   return HB_Err_Ok;
   1341 
   1342 Fail1:
   1343   for ( m = 0; m < n; m++ )
   1344     Free_SubRuleSet( &srs[m] );
   1345 
   1346   FREE( srs );
   1347 
   1348 Fail2:
   1349   _HB_OPEN_Free_Coverage( &csf1->Coverage );
   1350   return error;
   1351 }
   1352 
   1353 
   1354 static void  Free_ContextSubst1( HB_ContextSubstFormat1* csf1 )
   1355 {
   1356   HB_UShort        n, count;
   1357 
   1358   HB_SubRuleSet*  srs;
   1359 
   1360 
   1361   if ( csf1->SubRuleSet )
   1362   {
   1363     count = csf1->SubRuleSetCount;
   1364     srs   = csf1->SubRuleSet;
   1365 
   1366     for ( n = 0; n < count; n++ )
   1367       Free_SubRuleSet( &srs[n] );
   1368 
   1369     FREE( srs );
   1370   }
   1371 
   1372   _HB_OPEN_Free_Coverage( &csf1->Coverage );
   1373 }
   1374 
   1375 
   1376 /* SubClassRule */
   1377 
   1378 static HB_Error  Load_SubClassRule( HB_ContextSubstFormat2*  csf2,
   1379 				    HB_SubClassRule*         scr,
   1380 				    HB_Stream                 stream )
   1381 {
   1382   HB_Error error;
   1383 
   1384   HB_UShort               n, count;
   1385 
   1386   HB_UShort*              c;
   1387   HB_SubstLookupRecord*  slr;
   1388 
   1389 
   1390   if ( ACCESS_Frame( 4L ) )
   1391     return error;
   1392 
   1393   scr->GlyphCount = GET_UShort();
   1394   scr->SubstCount = GET_UShort();
   1395 
   1396   if ( scr->GlyphCount > csf2->MaxContextLength )
   1397     csf2->MaxContextLength = scr->GlyphCount;
   1398 
   1399   FORGET_Frame();
   1400 
   1401   scr->Class = NULL;
   1402 
   1403   count = scr->GlyphCount - 1;        /* only GlyphCount - 1 elements */
   1404 
   1405   if ( ALLOC_ARRAY( scr->Class, count, HB_UShort ) )
   1406     return error;
   1407 
   1408   c = scr->Class;
   1409 
   1410   if ( ACCESS_Frame( count * 2L ) )
   1411     goto Fail2;
   1412 
   1413   for ( n = 0; n < count; n++ )
   1414     c[n] = GET_UShort();
   1415 
   1416   FORGET_Frame();
   1417 
   1418   scr->SubstLookupRecord = NULL;
   1419 
   1420   count = scr->SubstCount;
   1421 
   1422   if ( ALLOC_ARRAY( scr->SubstLookupRecord, count, HB_SubstLookupRecord ) )
   1423     goto Fail2;
   1424 
   1425   slr = scr->SubstLookupRecord;
   1426 
   1427   if ( ACCESS_Frame( count * 4L ) )
   1428     goto Fail1;
   1429 
   1430   for ( n = 0; n < count; n++ )
   1431   {
   1432     slr[n].SequenceIndex   = GET_UShort();
   1433     slr[n].LookupListIndex = GET_UShort();
   1434   }
   1435 
   1436   FORGET_Frame();
   1437 
   1438   return HB_Err_Ok;
   1439 
   1440 Fail1:
   1441   FREE( slr );
   1442 
   1443 Fail2:
   1444   FREE( c );
   1445   return error;
   1446 }
   1447 
   1448 
   1449 static void  Free_SubClassRule( HB_SubClassRule*  scr )
   1450 {
   1451   FREE( scr->SubstLookupRecord );
   1452   FREE( scr->Class );
   1453 }
   1454 
   1455 
   1456 /* SubClassSet */
   1457 
   1458 static HB_Error  Load_SubClassSet( HB_ContextSubstFormat2*  csf2,
   1459 				   HB_SubClassSet*          scs,
   1460 				   HB_Stream                 stream )
   1461 {
   1462   HB_Error error;
   1463 
   1464   HB_UShort          n = 0, m, count;
   1465   HB_UInt           cur_offset, new_offset, base_offset;
   1466 
   1467   HB_SubClassRule*  scr;
   1468 
   1469 
   1470   base_offset = FILE_Pos();
   1471 
   1472   if ( ACCESS_Frame( 2L ) )
   1473     return error;
   1474 
   1475   count = scs->SubClassRuleCount = GET_UShort();
   1476 
   1477   FORGET_Frame();
   1478 
   1479   scs->SubClassRule = NULL;
   1480 
   1481   if ( ALLOC_ARRAY( scs->SubClassRule, count, HB_SubClassRule ) )
   1482     return error;
   1483 
   1484   scr = scs->SubClassRule;
   1485 
   1486   for ( n = 0; n < count; n++ )
   1487   {
   1488     if ( ACCESS_Frame( 2L ) )
   1489       goto Fail;
   1490 
   1491     new_offset = GET_UShort() + base_offset;
   1492 
   1493     FORGET_Frame();
   1494 
   1495     cur_offset = FILE_Pos();
   1496     if ( FILE_Seek( new_offset ) ||
   1497 	 ( error = Load_SubClassRule( csf2, &scr[n],
   1498 				      stream ) ) != HB_Err_Ok )
   1499       goto Fail;
   1500     (void)FILE_Seek( cur_offset );
   1501   }
   1502 
   1503   return HB_Err_Ok;
   1504 
   1505 Fail:
   1506   for ( m = 0; m < n; m++ )
   1507     Free_SubClassRule( &scr[m] );
   1508 
   1509   FREE( scr );
   1510   return error;
   1511 }
   1512 
   1513 
   1514 static void  Free_SubClassSet( HB_SubClassSet*  scs )
   1515 {
   1516   HB_UShort          n, count;
   1517 
   1518   HB_SubClassRule*  scr;
   1519 
   1520 
   1521   if ( scs->SubClassRule )
   1522   {
   1523     count = scs->SubClassRuleCount;
   1524     scr   = scs->SubClassRule;
   1525 
   1526     for ( n = 0; n < count; n++ )
   1527       Free_SubClassRule( &scr[n] );
   1528 
   1529     FREE( scr );
   1530   }
   1531 }
   1532 
   1533 
   1534 /* ContextSubstFormat2 */
   1535 
   1536 static HB_Error  Load_ContextSubst2( HB_ContextSubstFormat2*  csf2,
   1537 				     HB_Stream                 stream )
   1538 {
   1539   HB_Error error;
   1540 
   1541   HB_UShort         n = 0, m, count;
   1542   HB_UInt          cur_offset, new_offset, base_offset;
   1543 
   1544   HB_SubClassSet*  scs;
   1545 
   1546 
   1547   base_offset = FILE_Pos() - 2;
   1548 
   1549   if ( ACCESS_Frame( 2L ) )
   1550     return error;
   1551 
   1552   new_offset = GET_UShort() + base_offset;
   1553 
   1554   FORGET_Frame();
   1555 
   1556   cur_offset = FILE_Pos();
   1557   if ( FILE_Seek( new_offset ) ||
   1558        ( error = _HB_OPEN_Load_Coverage( &csf2->Coverage, stream ) ) != HB_Err_Ok )
   1559     return error;
   1560   (void)FILE_Seek( cur_offset );
   1561 
   1562   if ( ACCESS_Frame( 4L ) )
   1563     goto Fail3;
   1564 
   1565   new_offset = GET_UShort() + base_offset;
   1566 
   1567   /* `SubClassSetCount' is the upper limit for class values, thus we
   1568      read it now to make an additional safety check.                 */
   1569 
   1570   count = csf2->SubClassSetCount = GET_UShort();
   1571 
   1572   FORGET_Frame();
   1573 
   1574   cur_offset = FILE_Pos();
   1575   if ( FILE_Seek( new_offset ) ||
   1576        ( error = _HB_OPEN_Load_ClassDefinition( &csf2->ClassDef, count,
   1577 				       stream ) ) != HB_Err_Ok )
   1578     goto Fail3;
   1579   (void)FILE_Seek( cur_offset );
   1580 
   1581   csf2->SubClassSet      = NULL;
   1582   csf2->MaxContextLength = 0;
   1583 
   1584   if ( ALLOC_ARRAY( csf2->SubClassSet, count, HB_SubClassSet ) )
   1585     goto Fail2;
   1586 
   1587   scs = csf2->SubClassSet;
   1588 
   1589   for ( n = 0; n < count; n++ )
   1590   {
   1591     if ( ACCESS_Frame( 2L ) )
   1592       goto Fail1;
   1593 
   1594     new_offset = GET_UShort() + base_offset;
   1595 
   1596     FORGET_Frame();
   1597 
   1598     if ( new_offset != base_offset )      /* not a NULL offset */
   1599     {
   1600       cur_offset = FILE_Pos();
   1601       if ( FILE_Seek( new_offset ) ||
   1602 	   ( error = Load_SubClassSet( csf2, &scs[n],
   1603 				       stream ) ) != HB_Err_Ok )
   1604 	goto Fail1;
   1605       (void)FILE_Seek( cur_offset );
   1606     }
   1607     else
   1608     {
   1609       /* we create a SubClassSet table with no entries */
   1610 
   1611       csf2->SubClassSet[n].SubClassRuleCount = 0;
   1612       csf2->SubClassSet[n].SubClassRule      = NULL;
   1613     }
   1614   }
   1615 
   1616   return HB_Err_Ok;
   1617 
   1618 Fail1:
   1619   for ( m = 0; m < n; m++ )
   1620     Free_SubClassSet( &scs[m] );
   1621 
   1622   FREE( scs );
   1623 
   1624 Fail2:
   1625   _HB_OPEN_Free_ClassDefinition( &csf2->ClassDef );
   1626 
   1627 Fail3:
   1628   _HB_OPEN_Free_Coverage( &csf2->Coverage );
   1629   return error;
   1630 }
   1631 
   1632 
   1633 static void  Free_ContextSubst2( HB_ContextSubstFormat2*  csf2 )
   1634 {
   1635   HB_UShort         n, count;
   1636 
   1637   HB_SubClassSet*  scs;
   1638 
   1639 
   1640   if ( csf2->SubClassSet )
   1641   {
   1642     count = csf2->SubClassSetCount;
   1643     scs   = csf2->SubClassSet;
   1644 
   1645     for ( n = 0; n < count; n++ )
   1646       Free_SubClassSet( &scs[n] );
   1647 
   1648     FREE( scs );
   1649   }
   1650 
   1651   _HB_OPEN_Free_ClassDefinition( &csf2->ClassDef );
   1652   _HB_OPEN_Free_Coverage( &csf2->Coverage );
   1653 }
   1654 
   1655 
   1656 /* ContextSubstFormat3 */
   1657 
   1658 static HB_Error  Load_ContextSubst3( HB_ContextSubstFormat3*  csf3,
   1659 				     HB_Stream                 stream )
   1660 {
   1661   HB_Error error;
   1662 
   1663   HB_UShort               n = 0, m, count;
   1664   HB_UInt                cur_offset, new_offset, base_offset;
   1665 
   1666   HB_Coverage*           c;
   1667   HB_SubstLookupRecord*  slr;
   1668 
   1669 
   1670   base_offset = FILE_Pos() - 2L;
   1671 
   1672   if ( ACCESS_Frame( 4L ) )
   1673     return error;
   1674 
   1675   csf3->GlyphCount = GET_UShort();
   1676   csf3->SubstCount = GET_UShort();
   1677 
   1678   FORGET_Frame();
   1679 
   1680   csf3->Coverage = NULL;
   1681 
   1682   count = csf3->GlyphCount;
   1683 
   1684   if ( ALLOC_ARRAY( csf3->Coverage, count, HB_Coverage ) )
   1685     return error;
   1686 
   1687   c = csf3->Coverage;
   1688 
   1689   for ( n = 0; n < count; n++ )
   1690   {
   1691     if ( ACCESS_Frame( 2L ) )
   1692       goto Fail2;
   1693 
   1694     new_offset = GET_UShort() + base_offset;
   1695 
   1696     FORGET_Frame();
   1697 
   1698     cur_offset = FILE_Pos();
   1699     if ( FILE_Seek( new_offset ) ||
   1700 	 ( error = _HB_OPEN_Load_Coverage( &c[n], stream ) ) != HB_Err_Ok )
   1701       goto Fail2;
   1702     (void)FILE_Seek( cur_offset );
   1703   }
   1704 
   1705   csf3->SubstLookupRecord = NULL;
   1706 
   1707   count = csf3->SubstCount;
   1708 
   1709   if ( ALLOC_ARRAY( csf3->SubstLookupRecord, count,
   1710 		    HB_SubstLookupRecord ) )
   1711     goto Fail2;
   1712 
   1713   slr = csf3->SubstLookupRecord;
   1714 
   1715   if ( ACCESS_Frame( count * 4L ) )
   1716     goto Fail1;
   1717 
   1718   for ( n = 0; n < count; n++ )
   1719   {
   1720     slr[n].SequenceIndex   = GET_UShort();
   1721     slr[n].LookupListIndex = GET_UShort();
   1722   }
   1723 
   1724   FORGET_Frame();
   1725 
   1726   return HB_Err_Ok;
   1727 
   1728 Fail1:
   1729   FREE( slr );
   1730 
   1731 Fail2:
   1732   for ( m = 0; m < n; m++ )
   1733     _HB_OPEN_Free_Coverage( &c[m] );
   1734 
   1735   FREE( c );
   1736   return error;
   1737 }
   1738 
   1739 
   1740 static void  Free_ContextSubst3( HB_ContextSubstFormat3*  csf3 )
   1741 {
   1742   HB_UShort      n, count;
   1743 
   1744   HB_Coverage*  c;
   1745 
   1746 
   1747   FREE( csf3->SubstLookupRecord );
   1748 
   1749   if ( csf3->Coverage )
   1750   {
   1751     count = csf3->GlyphCount;
   1752     c     = csf3->Coverage;
   1753 
   1754     for ( n = 0; n < count; n++ )
   1755       _HB_OPEN_Free_Coverage( &c[n] );
   1756 
   1757     FREE( c );
   1758   }
   1759 }
   1760 
   1761 
   1762 /* ContextSubst */
   1763 
   1764 static HB_Error  Load_ContextSubst( HB_GSUB_SubTable* st,
   1765 				    HB_Stream         stream )
   1766 {
   1767   HB_Error error;
   1768   HB_ContextSubst*  cs = &st->context;
   1769 
   1770 
   1771   if ( ACCESS_Frame( 2L ) )
   1772     return error;
   1773 
   1774   cs->SubstFormat = GET_UShort();
   1775 
   1776   FORGET_Frame();
   1777 
   1778   switch ( cs->SubstFormat )
   1779   {
   1780   case 1:  return Load_ContextSubst1( &cs->csf.csf1, stream );
   1781   case 2:  return Load_ContextSubst2( &cs->csf.csf2, stream );
   1782   case 3:  return Load_ContextSubst3( &cs->csf.csf3, stream );
   1783   default: return ERR(HB_Err_Invalid_SubTable_Format);
   1784   }
   1785 
   1786   return HB_Err_Ok;               /* never reached */
   1787 }
   1788 
   1789 
   1790 static void  Free_ContextSubst( HB_GSUB_SubTable* st )
   1791 {
   1792   HB_ContextSubst*  cs = &st->context;
   1793 
   1794   switch ( cs->SubstFormat )
   1795   {
   1796   case 1:  Free_ContextSubst1( &cs->csf.csf1 ); break;
   1797   case 2:  Free_ContextSubst2( &cs->csf.csf2 ); break;
   1798   case 3:  Free_ContextSubst3( &cs->csf.csf3 ); break;
   1799   default:						break;
   1800   }
   1801 }
   1802 
   1803 
   1804 static HB_Error  Lookup_ContextSubst1( HB_GSUBHeader*          gsub,
   1805 				       HB_ContextSubstFormat1* csf1,
   1806 				       HB_Buffer               buffer,
   1807 				       HB_UShort                flags,
   1808 				       HB_UShort                context_length,
   1809 				       int                      nesting_level )
   1810 {
   1811   HB_UShort        index, property;
   1812   HB_UShort        i, j, k, numsr;
   1813   HB_Error         error;
   1814 
   1815   HB_SubRule*     sr;
   1816   HB_GDEFHeader*  gdef;
   1817 
   1818 
   1819   gdef = gsub->gdef;
   1820 
   1821   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   1822     return error;
   1823 
   1824   error = _HB_OPEN_Coverage_Index( &csf1->Coverage, IN_CURGLYPH(), &index );
   1825   if ( error )
   1826     return error;
   1827 
   1828   sr    = csf1->SubRuleSet[index].SubRule;
   1829   numsr = csf1->SubRuleSet[index].SubRuleCount;
   1830 
   1831   for ( k = 0; k < numsr; k++ )
   1832   {
   1833     if ( context_length != 0xFFFF && context_length < sr[k].GlyphCount )
   1834       goto next_subrule;
   1835 
   1836     if ( buffer->in_pos + sr[k].GlyphCount > buffer->in_length )
   1837       goto next_subrule;                        /* context is too long */
   1838 
   1839     for ( i = 1, j = buffer->in_pos + 1; i < sr[k].GlyphCount; i++, j++ )
   1840     {
   1841       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   1842       {
   1843 	if ( error && error != HB_Err_Not_Covered )
   1844 	  return error;
   1845 
   1846 	if ( j + sr[k].GlyphCount - i == (HB_Int)buffer->in_length )
   1847 	  goto next_subrule;
   1848 	j++;
   1849       }
   1850 
   1851       if ( IN_GLYPH( j ) != sr[k].Input[i - 1] )
   1852 	goto next_subrule;
   1853     }
   1854 
   1855     return Do_ContextSubst( gsub, sr[k].GlyphCount,
   1856 			    sr[k].SubstCount, sr[k].SubstLookupRecord,
   1857 			    buffer,
   1858 			    nesting_level );
   1859   next_subrule:
   1860     ;
   1861   }
   1862 
   1863   return HB_Err_Not_Covered;
   1864 }
   1865 
   1866 
   1867 static HB_Error  Lookup_ContextSubst2( HB_GSUBHeader*          gsub,
   1868 				       HB_ContextSubstFormat2* csf2,
   1869 				       HB_Buffer               buffer,
   1870 				       HB_UShort                flags,
   1871 				       HB_UShort                context_length,
   1872 				       int                      nesting_level )
   1873 {
   1874   HB_UShort          index, property;
   1875   HB_Error           error;
   1876   HB_UShort          i, j, k, known_classes;
   1877 
   1878   HB_UShort*         classes;
   1879   HB_UShort*         cl;
   1880 
   1881   HB_SubClassSet*   scs;
   1882   HB_SubClassRule*  sr;
   1883   HB_GDEFHeader*    gdef;
   1884 
   1885 
   1886   gdef = gsub->gdef;
   1887 
   1888   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   1889     return error;
   1890 
   1891   /* Note: The coverage table in format 2 doesn't give an index into
   1892 	   anything.  It just lets us know whether or not we need to
   1893 	   do any lookup at all.                                     */
   1894 
   1895   error = _HB_OPEN_Coverage_Index( &csf2->Coverage, IN_CURGLYPH(), &index );
   1896   if ( error )
   1897     return error;
   1898 
   1899   if (csf2->MaxContextLength < 1)
   1900     return HB_Err_Not_Covered;
   1901 
   1902   if ( ALLOC_ARRAY( classes, csf2->MaxContextLength, HB_UShort ) )
   1903     return error;
   1904 
   1905   error = _HB_OPEN_Get_Class( &csf2->ClassDef, IN_CURGLYPH(),
   1906 		     &classes[0], NULL );
   1907   if ( error && error != HB_Err_Not_Covered )
   1908     goto End;
   1909   known_classes = 0;
   1910 
   1911   scs = &csf2->SubClassSet[classes[0]];
   1912   if ( !scs )
   1913   {
   1914     error = ERR(HB_Err_Invalid_SubTable);
   1915     goto End;
   1916   }
   1917 
   1918   for ( k = 0; k < scs->SubClassRuleCount; k++ )
   1919   {
   1920     sr  = &scs->SubClassRule[k];
   1921 
   1922     if ( context_length != 0xFFFF && context_length < sr->GlyphCount )
   1923       goto next_subclassrule;
   1924 
   1925     if ( buffer->in_pos + sr->GlyphCount > buffer->in_length )
   1926       goto next_subclassrule;                      /* context is too long */
   1927 
   1928     cl   = sr->Class;
   1929 
   1930     /* Start at 1 because [0] is implied */
   1931 
   1932     for ( i = 1, j = buffer->in_pos + 1; i < sr->GlyphCount; i++, j++ )
   1933     {
   1934       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   1935       {
   1936 	if ( error && error != HB_Err_Not_Covered )
   1937 	  goto End;
   1938 
   1939 	if ( j + sr->GlyphCount - i < (HB_Int)buffer->in_length )
   1940 	  goto next_subclassrule;
   1941 	j++;
   1942       }
   1943 
   1944       if ( i > known_classes )
   1945       {
   1946 	/* Keeps us from having to do this for each rule */
   1947 
   1948 	error = _HB_OPEN_Get_Class( &csf2->ClassDef, IN_GLYPH( j ), &classes[i], NULL );
   1949 	if ( error && error != HB_Err_Not_Covered )
   1950 	  goto End;
   1951 	known_classes = i;
   1952       }
   1953 
   1954       if ( cl[i - 1] != classes[i] )
   1955 	goto next_subclassrule;
   1956     }
   1957 
   1958     error = Do_ContextSubst( gsub, sr->GlyphCount,
   1959 			     sr->SubstCount, sr->SubstLookupRecord,
   1960 			     buffer,
   1961 			     nesting_level );
   1962     goto End;
   1963 
   1964   next_subclassrule:
   1965     ;
   1966   }
   1967 
   1968   error = HB_Err_Not_Covered;
   1969 
   1970 End:
   1971   FREE( classes );
   1972   return error;
   1973 }
   1974 
   1975 
   1976 static HB_Error  Lookup_ContextSubst3( HB_GSUBHeader*          gsub,
   1977 				       HB_ContextSubstFormat3* csf3,
   1978 				       HB_Buffer               buffer,
   1979 				       HB_UShort                flags,
   1980 				       HB_UShort                context_length,
   1981 				       int                      nesting_level )
   1982 {
   1983   HB_Error         error;
   1984   HB_UShort        index, i, j, property;
   1985 
   1986   HB_Coverage*    c;
   1987   HB_GDEFHeader*  gdef;
   1988 
   1989 
   1990   gdef = gsub->gdef;
   1991 
   1992   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   1993     return error;
   1994 
   1995   if ( context_length != 0xFFFF && context_length < csf3->GlyphCount )
   1996     return HB_Err_Not_Covered;
   1997 
   1998   if ( buffer->in_pos + csf3->GlyphCount > buffer->in_length )
   1999     return HB_Err_Not_Covered;         /* context is too long */
   2000 
   2001   c    = csf3->Coverage;
   2002 
   2003   for ( i = 1, j = buffer->in_pos + 1; i < csf3->GlyphCount; i++, j++ )
   2004   {
   2005     while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   2006     {
   2007       if ( error && error != HB_Err_Not_Covered )
   2008 	return error;
   2009 
   2010       if ( j + csf3->GlyphCount - i == (HB_Int)buffer->in_length )
   2011 	return HB_Err_Not_Covered;
   2012       j++;
   2013     }
   2014 
   2015     error = _HB_OPEN_Coverage_Index( &c[i], IN_GLYPH( j ), &index );
   2016     if ( error )
   2017       return error;
   2018   }
   2019 
   2020   return Do_ContextSubst( gsub, csf3->GlyphCount,
   2021 			  csf3->SubstCount, csf3->SubstLookupRecord,
   2022 			  buffer,
   2023 			  nesting_level );
   2024 }
   2025 
   2026 
   2027 static HB_Error  Lookup_ContextSubst( HB_GSUBHeader*    gsub,
   2028 				      HB_GSUB_SubTable* st,
   2029 				      HB_Buffer         buffer,
   2030 				      HB_UShort          flags,
   2031 				      HB_UShort          context_length,
   2032 				      int                nesting_level )
   2033 {
   2034   HB_ContextSubst*  cs = &st->context;
   2035 
   2036   switch ( cs->SubstFormat )
   2037   {
   2038   case 1:  return Lookup_ContextSubst1( gsub, &cs->csf.csf1, buffer, flags, context_length, nesting_level );
   2039   case 2:  return Lookup_ContextSubst2( gsub, &cs->csf.csf2, buffer, flags, context_length, nesting_level );
   2040   case 3:  return Lookup_ContextSubst3( gsub, &cs->csf.csf3, buffer, flags, context_length, nesting_level );
   2041   default: return ERR(HB_Err_Invalid_SubTable_Format);
   2042   }
   2043 
   2044   return HB_Err_Ok;               /* never reached */
   2045 }
   2046 
   2047 
   2048 /* LookupType 6 */
   2049 
   2050 /* ChainSubRule */
   2051 
   2052 static HB_Error  Load_ChainSubRule( HB_ChainSubRule*  csr,
   2053 				    HB_Stream          stream )
   2054 {
   2055   HB_Error error;
   2056 
   2057   HB_UShort               n, count;
   2058   HB_UShort*              b;
   2059   HB_UShort*              i;
   2060   HB_UShort*              l;
   2061 
   2062   HB_SubstLookupRecord*  slr;
   2063 
   2064 
   2065   if ( ACCESS_Frame( 2L ) )
   2066     return error;
   2067 
   2068   csr->BacktrackGlyphCount = GET_UShort();
   2069 
   2070   FORGET_Frame();
   2071 
   2072   csr->Backtrack = NULL;
   2073 
   2074   count = csr->BacktrackGlyphCount;
   2075 
   2076   if ( ALLOC_ARRAY( csr->Backtrack, count, HB_UShort ) )
   2077     return error;
   2078 
   2079   b = csr->Backtrack;
   2080 
   2081   if ( ACCESS_Frame( count * 2L ) )
   2082     goto Fail4;
   2083 
   2084   for ( n = 0; n < count; n++ )
   2085     b[n] = GET_UShort();
   2086 
   2087   FORGET_Frame();
   2088 
   2089   if ( ACCESS_Frame( 2L ) )
   2090     goto Fail4;
   2091 
   2092   csr->InputGlyphCount = GET_UShort();
   2093 
   2094   FORGET_Frame();
   2095 
   2096   csr->Input = NULL;
   2097 
   2098   count = csr->InputGlyphCount - 1;  /* only InputGlyphCount - 1 elements */
   2099 
   2100   if ( ALLOC_ARRAY( csr->Input, count, HB_UShort ) )
   2101     goto Fail4;
   2102 
   2103   i = csr->Input;
   2104 
   2105   if ( ACCESS_Frame( count * 2L ) )
   2106     goto Fail3;
   2107 
   2108   for ( n = 0; n < count; n++ )
   2109     i[n] = GET_UShort();
   2110 
   2111   FORGET_Frame();
   2112 
   2113   if ( ACCESS_Frame( 2L ) )
   2114     goto Fail3;
   2115 
   2116   csr->LookaheadGlyphCount = GET_UShort();
   2117 
   2118   FORGET_Frame();
   2119 
   2120   csr->Lookahead = NULL;
   2121 
   2122   count = csr->LookaheadGlyphCount;
   2123 
   2124   if ( ALLOC_ARRAY( csr->Lookahead, count, HB_UShort ) )
   2125     goto Fail3;
   2126 
   2127   l = csr->Lookahead;
   2128 
   2129   if ( ACCESS_Frame( count * 2L ) )
   2130     goto Fail2;
   2131 
   2132   for ( n = 0; n < count; n++ )
   2133     l[n] = GET_UShort();
   2134 
   2135   FORGET_Frame();
   2136 
   2137   if ( ACCESS_Frame( 2L ) )
   2138     goto Fail2;
   2139 
   2140   csr->SubstCount = GET_UShort();
   2141 
   2142   FORGET_Frame();
   2143 
   2144   csr->SubstLookupRecord = NULL;
   2145 
   2146   count = csr->SubstCount;
   2147 
   2148   if ( ALLOC_ARRAY( csr->SubstLookupRecord, count, HB_SubstLookupRecord ) )
   2149     goto Fail2;
   2150 
   2151   slr = csr->SubstLookupRecord;
   2152 
   2153   if ( ACCESS_Frame( count * 4L ) )
   2154     goto Fail1;
   2155 
   2156   for ( n = 0; n < count; n++ )
   2157   {
   2158     slr[n].SequenceIndex   = GET_UShort();
   2159     slr[n].LookupListIndex = GET_UShort();
   2160   }
   2161 
   2162   FORGET_Frame();
   2163 
   2164   return HB_Err_Ok;
   2165 
   2166 Fail1:
   2167   FREE( slr );
   2168 
   2169 Fail2:
   2170   FREE( l );
   2171 
   2172 Fail3:
   2173   FREE( i );
   2174 
   2175 Fail4:
   2176   FREE( b );
   2177   return error;
   2178 }
   2179 
   2180 
   2181 static void  Free_ChainSubRule( HB_ChainSubRule*  csr )
   2182 {
   2183   FREE( csr->SubstLookupRecord );
   2184   FREE( csr->Lookahead );
   2185   FREE( csr->Input );
   2186   FREE( csr->Backtrack );
   2187 }
   2188 
   2189 
   2190 /* ChainSubRuleSet */
   2191 
   2192 static HB_Error  Load_ChainSubRuleSet( HB_ChainSubRuleSet*  csrs,
   2193 				       HB_Stream             stream )
   2194 {
   2195   HB_Error error;
   2196 
   2197   HB_UShort          n = 0, m, count;
   2198   HB_UInt           cur_offset, new_offset, base_offset;
   2199 
   2200   HB_ChainSubRule*  csr;
   2201 
   2202 
   2203   base_offset = FILE_Pos();
   2204 
   2205   if ( ACCESS_Frame( 2L ) )
   2206     return error;
   2207 
   2208   count = csrs->ChainSubRuleCount = GET_UShort();
   2209 
   2210   FORGET_Frame();
   2211 
   2212   csrs->ChainSubRule = NULL;
   2213 
   2214   if ( ALLOC_ARRAY( csrs->ChainSubRule, count, HB_ChainSubRule ) )
   2215     return error;
   2216 
   2217   csr = csrs->ChainSubRule;
   2218 
   2219   for ( n = 0; n < count; n++ )
   2220   {
   2221     if ( ACCESS_Frame( 2L ) )
   2222       goto Fail;
   2223 
   2224     new_offset = GET_UShort() + base_offset;
   2225 
   2226     FORGET_Frame();
   2227 
   2228     cur_offset = FILE_Pos();
   2229     if ( FILE_Seek( new_offset ) ||
   2230 	 ( error = Load_ChainSubRule( &csr[n], stream ) ) != HB_Err_Ok )
   2231       goto Fail;
   2232     (void)FILE_Seek( cur_offset );
   2233   }
   2234 
   2235   return HB_Err_Ok;
   2236 
   2237 Fail:
   2238   for ( m = 0; m < n; m++ )
   2239     Free_ChainSubRule( &csr[m] );
   2240 
   2241   FREE( csr );
   2242   return error;
   2243 }
   2244 
   2245 
   2246 static void  Free_ChainSubRuleSet( HB_ChainSubRuleSet*  csrs )
   2247 {
   2248   HB_UShort          n, count;
   2249 
   2250   HB_ChainSubRule*  csr;
   2251 
   2252 
   2253   if ( csrs->ChainSubRule )
   2254   {
   2255     count = csrs->ChainSubRuleCount;
   2256     csr   = csrs->ChainSubRule;
   2257 
   2258     for ( n = 0; n < count; n++ )
   2259       Free_ChainSubRule( &csr[n] );
   2260 
   2261     FREE( csr );
   2262   }
   2263 }
   2264 
   2265 
   2266 /* ChainContextSubstFormat1 */
   2267 
   2268 static HB_Error  Load_ChainContextSubst1(
   2269 		   HB_ChainContextSubstFormat1*  ccsf1,
   2270 		   HB_Stream                      stream )
   2271 {
   2272   HB_Error error;
   2273 
   2274   HB_UShort             n = 0, m, count;
   2275   HB_UInt              cur_offset, new_offset, base_offset;
   2276 
   2277   HB_ChainSubRuleSet*  csrs;
   2278 
   2279 
   2280   base_offset = FILE_Pos() - 2L;
   2281 
   2282   if ( ACCESS_Frame( 2L ) )
   2283     return error;
   2284 
   2285   new_offset = GET_UShort() + base_offset;
   2286 
   2287   FORGET_Frame();
   2288 
   2289   cur_offset = FILE_Pos();
   2290   if ( FILE_Seek( new_offset ) ||
   2291        ( error = _HB_OPEN_Load_Coverage( &ccsf1->Coverage, stream ) ) != HB_Err_Ok )
   2292     return error;
   2293   (void)FILE_Seek( cur_offset );
   2294 
   2295   if ( ACCESS_Frame( 2L ) )
   2296     goto Fail2;
   2297 
   2298   count = ccsf1->ChainSubRuleSetCount = GET_UShort();
   2299 
   2300   FORGET_Frame();
   2301 
   2302   ccsf1->ChainSubRuleSet = NULL;
   2303 
   2304   if ( ALLOC_ARRAY( ccsf1->ChainSubRuleSet, count, HB_ChainSubRuleSet ) )
   2305     goto Fail2;
   2306 
   2307   csrs = ccsf1->ChainSubRuleSet;
   2308 
   2309   for ( n = 0; n < count; n++ )
   2310   {
   2311     if ( ACCESS_Frame( 2L ) )
   2312       goto Fail1;
   2313 
   2314     new_offset = GET_UShort() + base_offset;
   2315 
   2316     FORGET_Frame();
   2317 
   2318     cur_offset = FILE_Pos();
   2319     if ( FILE_Seek( new_offset ) ||
   2320 	 ( error = Load_ChainSubRuleSet( &csrs[n], stream ) ) != HB_Err_Ok )
   2321       goto Fail1;
   2322     (void)FILE_Seek( cur_offset );
   2323   }
   2324 
   2325   return HB_Err_Ok;
   2326 
   2327 Fail1:
   2328   for ( m = 0; m < n; m++ )
   2329     Free_ChainSubRuleSet( &csrs[m] );
   2330 
   2331   FREE( csrs );
   2332 
   2333 Fail2:
   2334   _HB_OPEN_Free_Coverage( &ccsf1->Coverage );
   2335   return error;
   2336 }
   2337 
   2338 
   2339 static void  Free_ChainContextSubst1( HB_ChainContextSubstFormat1*  ccsf1 )
   2340 {
   2341   HB_UShort             n, count;
   2342 
   2343   HB_ChainSubRuleSet*  csrs;
   2344 
   2345 
   2346   if ( ccsf1->ChainSubRuleSet )
   2347   {
   2348     count = ccsf1->ChainSubRuleSetCount;
   2349     csrs  = ccsf1->ChainSubRuleSet;
   2350 
   2351     for ( n = 0; n < count; n++ )
   2352       Free_ChainSubRuleSet( &csrs[n] );
   2353 
   2354     FREE( csrs );
   2355   }
   2356 
   2357   _HB_OPEN_Free_Coverage( &ccsf1->Coverage );
   2358 }
   2359 
   2360 
   2361 /* ChainSubClassRule */
   2362 
   2363 static HB_Error  Load_ChainSubClassRule(
   2364 		   HB_ChainContextSubstFormat2*  ccsf2,
   2365 		   HB_ChainSubClassRule*         cscr,
   2366 		   HB_Stream                      stream )
   2367 {
   2368   HB_Error error;
   2369 
   2370   HB_UShort               n, count;
   2371 
   2372   HB_UShort*              b;
   2373   HB_UShort*              i;
   2374   HB_UShort*              l;
   2375   HB_SubstLookupRecord*  slr;
   2376 
   2377 
   2378   if ( ACCESS_Frame( 2L ) )
   2379     return error;
   2380 
   2381   cscr->BacktrackGlyphCount = GET_UShort();
   2382 
   2383   FORGET_Frame();
   2384 
   2385   if ( cscr->BacktrackGlyphCount > ccsf2->MaxBacktrackLength )
   2386     ccsf2->MaxBacktrackLength = cscr->BacktrackGlyphCount;
   2387 
   2388   cscr->Backtrack = NULL;
   2389 
   2390   count = cscr->BacktrackGlyphCount;
   2391 
   2392   if ( ALLOC_ARRAY( cscr->Backtrack, count, HB_UShort ) )
   2393     return error;
   2394 
   2395   b = cscr->Backtrack;
   2396 
   2397   if ( ACCESS_Frame( count * 2L ) )
   2398     goto Fail4;
   2399 
   2400   for ( n = 0; n < count; n++ )
   2401     b[n] = GET_UShort();
   2402 
   2403   FORGET_Frame();
   2404 
   2405   if ( ACCESS_Frame( 2L ) )
   2406     goto Fail4;
   2407 
   2408   cscr->InputGlyphCount = GET_UShort();
   2409 
   2410   FORGET_Frame();
   2411 
   2412   if ( cscr->InputGlyphCount > ccsf2->MaxInputLength )
   2413     ccsf2->MaxInputLength = cscr->InputGlyphCount;
   2414 
   2415   cscr->Input = NULL;
   2416 
   2417   count = cscr->InputGlyphCount - 1; /* only InputGlyphCount - 1 elements */
   2418 
   2419   if ( ALLOC_ARRAY( cscr->Input, count, HB_UShort ) )
   2420     goto Fail4;
   2421 
   2422   i = cscr->Input;
   2423 
   2424   if ( ACCESS_Frame( count * 2L ) )
   2425     goto Fail3;
   2426 
   2427   for ( n = 0; n < count; n++ )
   2428     i[n] = GET_UShort();
   2429 
   2430   FORGET_Frame();
   2431 
   2432   if ( ACCESS_Frame( 2L ) )
   2433     goto Fail3;
   2434 
   2435   cscr->LookaheadGlyphCount = GET_UShort();
   2436 
   2437   FORGET_Frame();
   2438 
   2439   if ( cscr->LookaheadGlyphCount > ccsf2->MaxLookaheadLength )
   2440     ccsf2->MaxLookaheadLength = cscr->LookaheadGlyphCount;
   2441 
   2442   cscr->Lookahead = NULL;
   2443 
   2444   count = cscr->LookaheadGlyphCount;
   2445 
   2446   if ( ALLOC_ARRAY( cscr->Lookahead, count, HB_UShort ) )
   2447     goto Fail3;
   2448 
   2449   l = cscr->Lookahead;
   2450 
   2451   if ( ACCESS_Frame( count * 2L ) )
   2452     goto Fail2;
   2453 
   2454   for ( n = 0; n < count; n++ )
   2455     l[n] = GET_UShort();
   2456 
   2457   FORGET_Frame();
   2458 
   2459   if ( ACCESS_Frame( 2L ) )
   2460     goto Fail2;
   2461 
   2462   cscr->SubstCount = GET_UShort();
   2463 
   2464   FORGET_Frame();
   2465 
   2466   cscr->SubstLookupRecord = NULL;
   2467 
   2468   count = cscr->SubstCount;
   2469 
   2470   if ( ALLOC_ARRAY( cscr->SubstLookupRecord, count,
   2471 		    HB_SubstLookupRecord ) )
   2472     goto Fail2;
   2473 
   2474   slr = cscr->SubstLookupRecord;
   2475 
   2476   if ( ACCESS_Frame( count * 4L ) )
   2477     goto Fail1;
   2478 
   2479   for ( n = 0; n < count; n++ )
   2480   {
   2481     slr[n].SequenceIndex   = GET_UShort();
   2482     slr[n].LookupListIndex = GET_UShort();
   2483   }
   2484 
   2485   FORGET_Frame();
   2486 
   2487   return HB_Err_Ok;
   2488 
   2489 Fail1:
   2490   FREE( slr );
   2491 
   2492 Fail2:
   2493   FREE( l );
   2494 
   2495 Fail3:
   2496   FREE( i );
   2497 
   2498 Fail4:
   2499   FREE( b );
   2500   return error;
   2501 }
   2502 
   2503 
   2504 static void  Free_ChainSubClassRule( HB_ChainSubClassRule*  cscr )
   2505 {
   2506   FREE( cscr->SubstLookupRecord );
   2507   FREE( cscr->Lookahead );
   2508   FREE( cscr->Input );
   2509   FREE( cscr->Backtrack );
   2510 }
   2511 
   2512 
   2513 /* SubClassSet */
   2514 
   2515 static HB_Error  Load_ChainSubClassSet(
   2516 		   HB_ChainContextSubstFormat2*  ccsf2,
   2517 		   HB_ChainSubClassSet*          cscs,
   2518 		   HB_Stream                      stream )
   2519 {
   2520   HB_Error error;
   2521 
   2522   HB_UShort               n = 0, m, count;
   2523   HB_UInt                cur_offset, new_offset, base_offset;
   2524 
   2525   HB_ChainSubClassRule*  cscr;
   2526 
   2527 
   2528   base_offset = FILE_Pos();
   2529 
   2530   if ( ACCESS_Frame( 2L ) )
   2531     return error;
   2532 
   2533   count = cscs->ChainSubClassRuleCount = GET_UShort();
   2534 
   2535   FORGET_Frame();
   2536 
   2537   cscs->ChainSubClassRule = NULL;
   2538 
   2539   if ( ALLOC_ARRAY( cscs->ChainSubClassRule, count,
   2540 		    HB_ChainSubClassRule ) )
   2541     return error;
   2542 
   2543   cscr = cscs->ChainSubClassRule;
   2544 
   2545   for ( n = 0; n < count; n++ )
   2546   {
   2547     if ( ACCESS_Frame( 2L ) )
   2548       goto Fail;
   2549 
   2550     new_offset = GET_UShort() + base_offset;
   2551 
   2552     FORGET_Frame();
   2553 
   2554     cur_offset = FILE_Pos();
   2555     if ( FILE_Seek( new_offset ) ||
   2556 	 ( error = Load_ChainSubClassRule( ccsf2, &cscr[n],
   2557 					   stream ) ) != HB_Err_Ok )
   2558       goto Fail;
   2559     (void)FILE_Seek( cur_offset );
   2560   }
   2561 
   2562   return HB_Err_Ok;
   2563 
   2564 Fail:
   2565   for ( m = 0; m < n; m++ )
   2566     Free_ChainSubClassRule( &cscr[m] );
   2567 
   2568   FREE( cscr );
   2569   return error;
   2570 }
   2571 
   2572 
   2573 static void  Free_ChainSubClassSet( HB_ChainSubClassSet*  cscs )
   2574 {
   2575   HB_UShort               n, count;
   2576 
   2577   HB_ChainSubClassRule*  cscr;
   2578 
   2579 
   2580   if ( cscs->ChainSubClassRule )
   2581   {
   2582     count = cscs->ChainSubClassRuleCount;
   2583     cscr  = cscs->ChainSubClassRule;
   2584 
   2585     for ( n = 0; n < count; n++ )
   2586       Free_ChainSubClassRule( &cscr[n] );
   2587 
   2588     FREE( cscr );
   2589   }
   2590 }
   2591 
   2592 
   2593 /* ChainContextSubstFormat2 */
   2594 
   2595 static HB_Error  Load_ChainContextSubst2(
   2596 		   HB_ChainContextSubstFormat2*  ccsf2,
   2597 		   HB_Stream                      stream )
   2598 {
   2599   HB_Error error;
   2600 
   2601   HB_UShort              n = 0, m, count;
   2602   HB_UInt               cur_offset, new_offset, base_offset;
   2603   HB_UInt               backtrack_offset, input_offset, lookahead_offset;
   2604 
   2605   HB_ChainSubClassSet*  cscs;
   2606 
   2607 
   2608   base_offset = FILE_Pos() - 2;
   2609 
   2610   if ( ACCESS_Frame( 2L ) )
   2611     return error;
   2612 
   2613   new_offset = GET_UShort() + base_offset;
   2614 
   2615   FORGET_Frame();
   2616 
   2617   cur_offset = FILE_Pos();
   2618   if ( FILE_Seek( new_offset ) ||
   2619        ( error = _HB_OPEN_Load_Coverage( &ccsf2->Coverage, stream ) ) != HB_Err_Ok )
   2620     return error;
   2621   (void)FILE_Seek( cur_offset );
   2622 
   2623   if ( ACCESS_Frame( 8L ) )
   2624     goto Fail5;
   2625 
   2626   backtrack_offset = GET_UShort();
   2627   input_offset     = GET_UShort();
   2628   lookahead_offset = GET_UShort();
   2629 
   2630   /* `ChainSubClassSetCount' is the upper limit for input class values,
   2631      thus we read it now to make an additional safety check. No limit
   2632      is known or needed for the other two class definitions          */
   2633 
   2634   count = ccsf2->ChainSubClassSetCount = GET_UShort();
   2635 
   2636   FORGET_Frame();
   2637 
   2638   if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccsf2->BacktrackClassDef, 65535,
   2639 						       backtrack_offset, base_offset,
   2640 						       stream ) ) != HB_Err_Ok )
   2641       goto Fail5;
   2642 
   2643   if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccsf2->InputClassDef, count,
   2644 						       input_offset, base_offset,
   2645 						       stream ) ) != HB_Err_Ok )
   2646       goto Fail4;
   2647   if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccsf2->LookaheadClassDef, 65535,
   2648 						       lookahead_offset, base_offset,
   2649 						       stream ) ) != HB_Err_Ok )
   2650     goto Fail3;
   2651 
   2652   ccsf2->ChainSubClassSet   = NULL;
   2653   ccsf2->MaxBacktrackLength = 0;
   2654   ccsf2->MaxInputLength     = 0;
   2655   ccsf2->MaxLookaheadLength = 0;
   2656 
   2657   if ( ALLOC_ARRAY( ccsf2->ChainSubClassSet, count, HB_ChainSubClassSet ) )
   2658     goto Fail2;
   2659 
   2660   cscs = ccsf2->ChainSubClassSet;
   2661 
   2662   for ( n = 0; n < count; n++ )
   2663   {
   2664     if ( ACCESS_Frame( 2L ) )
   2665       goto Fail1;
   2666 
   2667     new_offset = GET_UShort() + base_offset;
   2668 
   2669     FORGET_Frame();
   2670 
   2671     if ( new_offset != base_offset )      /* not a NULL offset */
   2672     {
   2673       cur_offset = FILE_Pos();
   2674       if ( FILE_Seek( new_offset ) ||
   2675 	   ( error = Load_ChainSubClassSet( ccsf2, &cscs[n],
   2676 					    stream ) ) != HB_Err_Ok )
   2677 	goto Fail1;
   2678       (void)FILE_Seek( cur_offset );
   2679     }
   2680     else
   2681     {
   2682       /* we create a ChainSubClassSet table with no entries */
   2683 
   2684       ccsf2->ChainSubClassSet[n].ChainSubClassRuleCount = 0;
   2685       ccsf2->ChainSubClassSet[n].ChainSubClassRule      = NULL;
   2686     }
   2687   }
   2688 
   2689   return HB_Err_Ok;
   2690 
   2691 Fail1:
   2692   for ( m = 0; m < n; m++ )
   2693     Free_ChainSubClassSet( &cscs[m] );
   2694 
   2695   FREE( cscs );
   2696 
   2697 Fail2:
   2698   _HB_OPEN_Free_ClassDefinition( &ccsf2->LookaheadClassDef );
   2699 
   2700 Fail3:
   2701   _HB_OPEN_Free_ClassDefinition( &ccsf2->InputClassDef );
   2702 
   2703 Fail4:
   2704   _HB_OPEN_Free_ClassDefinition( &ccsf2->BacktrackClassDef );
   2705 
   2706 Fail5:
   2707   _HB_OPEN_Free_Coverage( &ccsf2->Coverage );
   2708   return error;
   2709 }
   2710 
   2711 
   2712 static void  Free_ChainContextSubst2( HB_ChainContextSubstFormat2*  ccsf2 )
   2713 {
   2714   HB_UShort              n, count;
   2715 
   2716   HB_ChainSubClassSet*  cscs;
   2717 
   2718 
   2719   if ( ccsf2->ChainSubClassSet )
   2720   {
   2721     count = ccsf2->ChainSubClassSetCount;
   2722     cscs  = ccsf2->ChainSubClassSet;
   2723 
   2724     for ( n = 0; n < count; n++ )
   2725       Free_ChainSubClassSet( &cscs[n] );
   2726 
   2727     FREE( cscs );
   2728   }
   2729 
   2730   _HB_OPEN_Free_ClassDefinition( &ccsf2->LookaheadClassDef );
   2731   _HB_OPEN_Free_ClassDefinition( &ccsf2->InputClassDef );
   2732   _HB_OPEN_Free_ClassDefinition( &ccsf2->BacktrackClassDef );
   2733 
   2734   _HB_OPEN_Free_Coverage( &ccsf2->Coverage );
   2735 }
   2736 
   2737 
   2738 /* ChainContextSubstFormat3 */
   2739 
   2740 static HB_Error  Load_ChainContextSubst3(
   2741 		   HB_ChainContextSubstFormat3*  ccsf3,
   2742 		   HB_Stream                      stream )
   2743 {
   2744   HB_Error error;
   2745 
   2746   HB_UShort               n, nb = 0, ni =0, nl = 0, m, count;
   2747   HB_UShort               backtrack_count, input_count, lookahead_count;
   2748   HB_UInt                cur_offset, new_offset, base_offset;
   2749 
   2750   HB_Coverage*           b;
   2751   HB_Coverage*           i;
   2752   HB_Coverage*           l;
   2753   HB_SubstLookupRecord*  slr;
   2754 
   2755 
   2756   base_offset = FILE_Pos() - 2L;
   2757 
   2758   if ( ACCESS_Frame( 2L ) )
   2759     return error;
   2760 
   2761   ccsf3->BacktrackGlyphCount = GET_UShort();
   2762 
   2763   FORGET_Frame();
   2764 
   2765   ccsf3->BacktrackCoverage = NULL;
   2766 
   2767   backtrack_count = ccsf3->BacktrackGlyphCount;
   2768 
   2769   if ( ALLOC_ARRAY( ccsf3->BacktrackCoverage, backtrack_count,
   2770 		    HB_Coverage ) )
   2771     return error;
   2772 
   2773   b = ccsf3->BacktrackCoverage;
   2774 
   2775   for ( nb = 0; nb < backtrack_count; nb++ )
   2776   {
   2777     if ( ACCESS_Frame( 2L ) )
   2778       goto Fail4;
   2779 
   2780     new_offset = GET_UShort() + base_offset;
   2781 
   2782     FORGET_Frame();
   2783 
   2784     cur_offset = FILE_Pos();
   2785     if ( FILE_Seek( new_offset ) ||
   2786 	 ( error = _HB_OPEN_Load_Coverage( &b[nb], stream ) ) != HB_Err_Ok )
   2787       goto Fail4;
   2788     (void)FILE_Seek( cur_offset );
   2789   }
   2790 
   2791   if ( ACCESS_Frame( 2L ) )
   2792     goto Fail4;
   2793 
   2794   ccsf3->InputGlyphCount = GET_UShort();
   2795 
   2796   FORGET_Frame();
   2797 
   2798   ccsf3->InputCoverage = NULL;
   2799 
   2800   input_count = ccsf3->InputGlyphCount;
   2801 
   2802   if ( ALLOC_ARRAY( ccsf3->InputCoverage, input_count, HB_Coverage ) )
   2803     goto Fail4;
   2804 
   2805   i = ccsf3->InputCoverage;
   2806 
   2807   for ( ni = 0; ni < input_count; ni++ )
   2808   {
   2809     if ( ACCESS_Frame( 2L ) )
   2810       goto Fail3;
   2811 
   2812     new_offset = GET_UShort() + base_offset;
   2813 
   2814     FORGET_Frame();
   2815 
   2816     cur_offset = FILE_Pos();
   2817     if ( FILE_Seek( new_offset ) ||
   2818 	 ( error = _HB_OPEN_Load_Coverage( &i[ni], stream ) ) != HB_Err_Ok )
   2819       goto Fail3;
   2820     (void)FILE_Seek( cur_offset );
   2821   }
   2822 
   2823   if ( ACCESS_Frame( 2L ) )
   2824     goto Fail3;
   2825 
   2826   ccsf3->LookaheadGlyphCount = GET_UShort();
   2827 
   2828   FORGET_Frame();
   2829 
   2830   ccsf3->LookaheadCoverage = NULL;
   2831 
   2832   lookahead_count = ccsf3->LookaheadGlyphCount;
   2833 
   2834   if ( ALLOC_ARRAY( ccsf3->LookaheadCoverage, lookahead_count,
   2835 		    HB_Coverage ) )
   2836     goto Fail3;
   2837 
   2838   l = ccsf3->LookaheadCoverage;
   2839 
   2840   for ( nl = 0; nl < lookahead_count; nl++ )
   2841   {
   2842     if ( ACCESS_Frame( 2L ) )
   2843       goto Fail2;
   2844 
   2845     new_offset = GET_UShort() + base_offset;
   2846 
   2847     FORGET_Frame();
   2848 
   2849     cur_offset = FILE_Pos();
   2850     if ( FILE_Seek( new_offset ) ||
   2851 	 ( error = _HB_OPEN_Load_Coverage( &l[nl], stream ) ) != HB_Err_Ok )
   2852       goto Fail2;
   2853     (void)FILE_Seek( cur_offset );
   2854   }
   2855 
   2856   if ( ACCESS_Frame( 2L ) )
   2857     goto Fail2;
   2858 
   2859   ccsf3->SubstCount = GET_UShort();
   2860 
   2861   FORGET_Frame();
   2862 
   2863   ccsf3->SubstLookupRecord = NULL;
   2864 
   2865   count = ccsf3->SubstCount;
   2866 
   2867   if ( ALLOC_ARRAY( ccsf3->SubstLookupRecord, count,
   2868 		    HB_SubstLookupRecord ) )
   2869     goto Fail2;
   2870 
   2871   slr = ccsf3->SubstLookupRecord;
   2872 
   2873   if ( ACCESS_Frame( count * 4L ) )
   2874     goto Fail1;
   2875 
   2876   for ( n = 0; n < count; n++ )
   2877   {
   2878     slr[n].SequenceIndex   = GET_UShort();
   2879     slr[n].LookupListIndex = GET_UShort();
   2880   }
   2881 
   2882   FORGET_Frame();
   2883 
   2884   return HB_Err_Ok;
   2885 
   2886 Fail1:
   2887   FREE( slr );
   2888 
   2889 Fail2:
   2890   for ( m = 0; m < nl; m++ )
   2891     _HB_OPEN_Free_Coverage( &l[m] );
   2892 
   2893   FREE( l );
   2894 
   2895 Fail3:
   2896   for ( m = 0; m < ni; m++ )
   2897     _HB_OPEN_Free_Coverage( &i[m] );
   2898 
   2899   FREE( i );
   2900 
   2901 Fail4:
   2902   for ( m = 0; m < nb; m++ )
   2903     _HB_OPEN_Free_Coverage( &b[m] );
   2904 
   2905   FREE( b );
   2906   return error;
   2907 }
   2908 
   2909 
   2910 static void  Free_ChainContextSubst3( HB_ChainContextSubstFormat3*  ccsf3 )
   2911 {
   2912   HB_UShort      n, count;
   2913 
   2914   HB_Coverage*  c;
   2915 
   2916 
   2917   FREE( ccsf3->SubstLookupRecord );
   2918 
   2919   if ( ccsf3->LookaheadCoverage )
   2920   {
   2921     count = ccsf3->LookaheadGlyphCount;
   2922     c     = ccsf3->LookaheadCoverage;
   2923 
   2924     for ( n = 0; n < count; n++ )
   2925       _HB_OPEN_Free_Coverage( &c[n] );
   2926 
   2927     FREE( c );
   2928   }
   2929 
   2930   if ( ccsf3->InputCoverage )
   2931   {
   2932     count = ccsf3->InputGlyphCount;
   2933     c     = ccsf3->InputCoverage;
   2934 
   2935     for ( n = 0; n < count; n++ )
   2936       _HB_OPEN_Free_Coverage( &c[n] );
   2937 
   2938     FREE( c );
   2939   }
   2940 
   2941   if ( ccsf3->BacktrackCoverage )
   2942   {
   2943     count = ccsf3->BacktrackGlyphCount;
   2944     c     = ccsf3->BacktrackCoverage;
   2945 
   2946     for ( n = 0; n < count; n++ )
   2947       _HB_OPEN_Free_Coverage( &c[n] );
   2948 
   2949     FREE( c );
   2950   }
   2951 }
   2952 
   2953 
   2954 /* ChainContextSubst */
   2955 
   2956 static HB_Error  Load_ChainContextSubst( HB_GSUB_SubTable* st,
   2957 					 HB_Stream         stream )
   2958 {
   2959   HB_Error error;
   2960   HB_ChainContextSubst*  ccs = &st->chain;
   2961 
   2962   if ( ACCESS_Frame( 2L ) )
   2963     return error;
   2964 
   2965   ccs->SubstFormat = GET_UShort();
   2966 
   2967   FORGET_Frame();
   2968 
   2969   switch ( ccs->SubstFormat ) {
   2970     case 1:  return Load_ChainContextSubst1( &ccs->ccsf.ccsf1, stream );
   2971     case 2:  return Load_ChainContextSubst2( &ccs->ccsf.ccsf2, stream );
   2972     case 3:  return Load_ChainContextSubst3( &ccs->ccsf.ccsf3, stream );
   2973     default: return ERR(HB_Err_Invalid_SubTable_Format);
   2974   }
   2975 
   2976   return HB_Err_Ok;               /* never reached */
   2977 }
   2978 
   2979 
   2980 static void  Free_ChainContextSubst( HB_GSUB_SubTable* st )
   2981 {
   2982   HB_ChainContextSubst*  ccs = &st->chain;
   2983 
   2984   switch ( ccs->SubstFormat ) {
   2985     case 1:  Free_ChainContextSubst1( &ccs->ccsf.ccsf1 ); break;
   2986     case 2:  Free_ChainContextSubst2( &ccs->ccsf.ccsf2 ); break;
   2987     case 3:  Free_ChainContextSubst3( &ccs->ccsf.ccsf3 ); break;
   2988     default:							  break;
   2989   }
   2990 }
   2991 
   2992 
   2993 static HB_Error  Lookup_ChainContextSubst1( HB_GSUBHeader*               gsub,
   2994 					    HB_ChainContextSubstFormat1* ccsf1,
   2995 					    HB_Buffer                    buffer,
   2996 					    HB_UShort                     flags,
   2997 					    HB_UShort                     context_length,
   2998 					    int                           nesting_level )
   2999 {
   3000   HB_UShort          index, property;
   3001   HB_UShort          i, j, k, num_csr;
   3002   HB_UShort          bgc, igc, lgc;
   3003   HB_Error           error;
   3004 
   3005   HB_ChainSubRule*  csr;
   3006   HB_ChainSubRule   curr_csr;
   3007   HB_GDEFHeader*    gdef;
   3008 
   3009 
   3010   gdef = gsub->gdef;
   3011 
   3012   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   3013     return error;
   3014 
   3015   error = _HB_OPEN_Coverage_Index( &ccsf1->Coverage, IN_CURGLYPH(), &index );
   3016   if ( error )
   3017     return error;
   3018 
   3019   csr     = ccsf1->ChainSubRuleSet[index].ChainSubRule;
   3020   num_csr = ccsf1->ChainSubRuleSet[index].ChainSubRuleCount;
   3021 
   3022   for ( k = 0; k < num_csr; k++ )
   3023   {
   3024     curr_csr = csr[k];
   3025     bgc      = curr_csr.BacktrackGlyphCount;
   3026     igc      = curr_csr.InputGlyphCount;
   3027     lgc      = curr_csr.LookaheadGlyphCount;
   3028 
   3029     if ( context_length != 0xFFFF && context_length < igc )
   3030       goto next_chainsubrule;
   3031 
   3032     /* check whether context is too long; it is a first guess only */
   3033 
   3034     if ( bgc > buffer->out_pos || buffer->in_pos + igc + lgc > buffer->in_length )
   3035       goto next_chainsubrule;
   3036 
   3037     if ( bgc )
   3038     {
   3039       /* since we don't know in advance the number of glyphs to inspect,
   3040 	 we search backwards for matches in the backtrack glyph array    */
   3041 
   3042       for ( i = 0, j = buffer->out_pos - 1; i < bgc; i++, j-- )
   3043       {
   3044 	while ( CHECK_Property( gdef, OUT_ITEM( j ), flags, &property ) )
   3045 	{
   3046 	  if ( error && error != HB_Err_Not_Covered )
   3047 	    return error;
   3048 
   3049 	  if ( j + 1 == bgc - i )
   3050 	    goto next_chainsubrule;
   3051 	  j--;
   3052 	}
   3053 
   3054 	/* In OpenType 1.3, it is undefined whether the offsets of
   3055 	   backtrack glyphs is in logical order or not.  Version 1.4
   3056 	   will clarify this:
   3057 
   3058 	     Logical order -      a  b  c  d  e  f  g  h  i  j
   3059 					      i
   3060 	     Input offsets -                  0  1
   3061 	     Backtrack offsets -  3  2  1  0
   3062 	     Lookahead offsets -                    0  1  2  3           */
   3063 
   3064 	if ( OUT_GLYPH( j ) != curr_csr.Backtrack[i] )
   3065 	  goto next_chainsubrule;
   3066       }
   3067     }
   3068 
   3069     /* Start at 1 because [0] is implied */
   3070 
   3071     for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ )
   3072     {
   3073       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3074       {
   3075 	if ( error && error != HB_Err_Not_Covered )
   3076 	  return error;
   3077 
   3078 	if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
   3079 	  goto next_chainsubrule;
   3080 	j++;
   3081       }
   3082 
   3083       if ( IN_GLYPH( j ) != curr_csr.Input[i - 1] )
   3084 	  goto next_chainsubrule;
   3085     }
   3086 
   3087     /* we are starting to check for lookahead glyphs right after the
   3088        last context glyph                                            */
   3089 
   3090     for ( i = 0; i < lgc; i++, j++ )
   3091     {
   3092       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3093       {
   3094 	if ( error && error != HB_Err_Not_Covered )
   3095 	  return error;
   3096 
   3097 	if ( j + lgc - i == (HB_Int)buffer->in_length )
   3098 	  goto next_chainsubrule;
   3099 	j++;
   3100       }
   3101 
   3102       if ( IN_GLYPH( j ) != curr_csr.Lookahead[i] )
   3103 	goto next_chainsubrule;
   3104     }
   3105 
   3106     return Do_ContextSubst( gsub, igc,
   3107 			    curr_csr.SubstCount,
   3108 			    curr_csr.SubstLookupRecord,
   3109 			    buffer,
   3110 			    nesting_level );
   3111 
   3112   next_chainsubrule:
   3113     ;
   3114   }
   3115 
   3116   return HB_Err_Not_Covered;
   3117 }
   3118 
   3119 
   3120 static HB_Error  Lookup_ChainContextSubst2( HB_GSUBHeader*               gsub,
   3121 					    HB_ChainContextSubstFormat2* ccsf2,
   3122 					    HB_Buffer                    buffer,
   3123 					    HB_UShort                     flags,
   3124 					    HB_UShort                     context_length,
   3125 					    int                           nesting_level )
   3126 {
   3127   HB_UShort              index, property;
   3128   HB_Error               error;
   3129   HB_UShort              i, j, k;
   3130   HB_UShort              bgc, igc, lgc;
   3131   HB_UShort              known_backtrack_classes,
   3132 			 known_input_classes,
   3133 			 known_lookahead_classes;
   3134 
   3135   HB_UShort*             backtrack_classes;
   3136   HB_UShort*             input_classes;
   3137   HB_UShort*             lookahead_classes;
   3138 
   3139   HB_UShort*             bc;
   3140   HB_UShort*             ic;
   3141   HB_UShort*             lc;
   3142 
   3143   HB_ChainSubClassSet*  cscs;
   3144   HB_ChainSubClassRule  ccsr;
   3145   HB_GDEFHeader*        gdef;
   3146 
   3147 
   3148   gdef = gsub->gdef;
   3149 
   3150   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   3151     return error;
   3152 
   3153   /* Note: The coverage table in format 2 doesn't give an index into
   3154 	   anything.  It just lets us know whether or not we need to
   3155 	   do any lookup at all.                                     */
   3156 
   3157   error = _HB_OPEN_Coverage_Index( &ccsf2->Coverage, IN_CURGLYPH(), &index );
   3158   if ( error )
   3159     return error;
   3160 
   3161   if (ccsf2->MaxInputLength < 1)
   3162     return HB_Err_Not_Covered;
   3163 
   3164   if ( ALLOC_ARRAY( backtrack_classes, ccsf2->MaxBacktrackLength, HB_UShort ) )
   3165     return error;
   3166   known_backtrack_classes = 0;
   3167 
   3168   if ( ALLOC_ARRAY( input_classes, ccsf2->MaxInputLength, HB_UShort ) )
   3169     goto End3;
   3170   known_input_classes = 1;
   3171 
   3172   if ( ALLOC_ARRAY( lookahead_classes, ccsf2->MaxLookaheadLength, HB_UShort ) )
   3173     goto End2;
   3174   known_lookahead_classes = 0;
   3175 
   3176   error = _HB_OPEN_Get_Class( &ccsf2->InputClassDef, IN_CURGLYPH(),
   3177 		     &input_classes[0], NULL );
   3178   if ( error && error != HB_Err_Not_Covered )
   3179     goto End1;
   3180 
   3181   cscs = &ccsf2->ChainSubClassSet[input_classes[0]];
   3182   if ( !cscs )
   3183   {
   3184     error = ERR(HB_Err_Invalid_SubTable);
   3185     goto End1;
   3186   }
   3187 
   3188   for ( k = 0; k < cscs->ChainSubClassRuleCount; k++ )
   3189   {
   3190     ccsr = cscs->ChainSubClassRule[k];
   3191     bgc  = ccsr.BacktrackGlyphCount;
   3192     igc  = ccsr.InputGlyphCount;
   3193     lgc  = ccsr.LookaheadGlyphCount;
   3194 
   3195     if ( context_length != 0xFFFF && context_length < igc )
   3196       goto next_chainsubclassrule;
   3197 
   3198     /* check whether context is too long; it is a first guess only */
   3199 
   3200     if ( bgc > buffer->out_pos || buffer->in_pos + igc + lgc > buffer->in_length )
   3201       goto next_chainsubclassrule;
   3202 
   3203     if ( bgc )
   3204     {
   3205       /* Since we don't know in advance the number of glyphs to inspect,
   3206 	 we search backwards for matches in the backtrack glyph array.
   3207 	 Note that `known_backtrack_classes' starts at index 0.         */
   3208 
   3209       bc       = ccsr.Backtrack;
   3210 
   3211       for ( i = 0, j = buffer->out_pos - 1; i < bgc; i++, j-- )
   3212       {
   3213 	while ( CHECK_Property( gdef, OUT_ITEM( j ), flags, &property ) )
   3214 	{
   3215 	  if ( error && error != HB_Err_Not_Covered )
   3216 	    goto End1;
   3217 
   3218 	  if ( j + 1 == bgc - i )
   3219 	    goto next_chainsubclassrule;
   3220 	  j--;
   3221 	}
   3222 
   3223 	if ( i >= known_backtrack_classes )
   3224 	{
   3225 	  /* Keeps us from having to do this for each rule */
   3226 
   3227 	  error = _HB_OPEN_Get_Class( &ccsf2->BacktrackClassDef, OUT_GLYPH( j ),
   3228 			     &backtrack_classes[i], NULL );
   3229 	  if ( error && error != HB_Err_Not_Covered )
   3230 	    goto End1;
   3231 	  known_backtrack_classes = i;
   3232 	}
   3233 
   3234 	if ( bc[i] != backtrack_classes[i] )
   3235 	  goto next_chainsubclassrule;
   3236       }
   3237     }
   3238 
   3239     ic       = ccsr.Input;
   3240 
   3241     /* Start at 1 because [0] is implied */
   3242 
   3243     for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ )
   3244     {
   3245       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3246       {
   3247 	if ( error && error != HB_Err_Not_Covered )
   3248 	  goto End1;
   3249 
   3250 	if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
   3251 	  goto next_chainsubclassrule;
   3252 	j++;
   3253       }
   3254 
   3255       if ( i >= known_input_classes )
   3256       {
   3257 	error = _HB_OPEN_Get_Class( &ccsf2->InputClassDef, IN_GLYPH( j ),
   3258 			   &input_classes[i], NULL );
   3259 	if ( error && error != HB_Err_Not_Covered )
   3260 	  goto End1;
   3261 	known_input_classes = i;
   3262       }
   3263 
   3264       if ( ic[i - 1] != input_classes[i] )
   3265 	goto next_chainsubclassrule;
   3266     }
   3267 
   3268     /* we are starting to check for lookahead glyphs right after the
   3269        last context glyph                                            */
   3270 
   3271     lc       = ccsr.Lookahead;
   3272 
   3273     for ( i = 0; i < lgc; i++, j++ )
   3274     {
   3275       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3276       {
   3277 	if ( error && error != HB_Err_Not_Covered )
   3278 	  goto End1;
   3279 
   3280 	if ( j + lgc - i == (HB_Int)buffer->in_length )
   3281 	  goto next_chainsubclassrule;
   3282 	j++;
   3283       }
   3284 
   3285       if ( i >= known_lookahead_classes )
   3286       {
   3287 	error = _HB_OPEN_Get_Class( &ccsf2->LookaheadClassDef, IN_GLYPH( j ),
   3288 			   &lookahead_classes[i], NULL );
   3289 	if ( error && error != HB_Err_Not_Covered )
   3290 	  goto End1;
   3291 	known_lookahead_classes = i;
   3292       }
   3293 
   3294       if ( lc[i] != lookahead_classes[i] )
   3295 	goto next_chainsubclassrule;
   3296     }
   3297 
   3298     error = Do_ContextSubst( gsub, igc,
   3299 			     ccsr.SubstCount,
   3300 			     ccsr.SubstLookupRecord,
   3301 			     buffer,
   3302 			     nesting_level );
   3303     goto End1;
   3304 
   3305   next_chainsubclassrule:
   3306     ;
   3307   }
   3308 
   3309   error = HB_Err_Not_Covered;
   3310 
   3311 End1:
   3312   FREE( lookahead_classes );
   3313 
   3314 End2:
   3315   FREE( input_classes );
   3316 
   3317 End3:
   3318   FREE( backtrack_classes );
   3319   return error;
   3320 }
   3321 
   3322 
   3323 static HB_Error  Lookup_ChainContextSubst3( HB_GSUBHeader*               gsub,
   3324 					    HB_ChainContextSubstFormat3* ccsf3,
   3325 					    HB_Buffer                    buffer,
   3326 					    HB_UShort                     flags,
   3327 					    HB_UShort                     context_length,
   3328 					    int                           nesting_level )
   3329 {
   3330   HB_UShort        index, i, j, property;
   3331   HB_UShort        bgc, igc, lgc;
   3332   HB_Error         error;
   3333 
   3334   HB_Coverage*    bc;
   3335   HB_Coverage*    ic;
   3336   HB_Coverage*    lc;
   3337   HB_GDEFHeader*  gdef;
   3338 
   3339 
   3340   gdef = gsub->gdef;
   3341 
   3342   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   3343     return error;
   3344 
   3345   bgc = ccsf3->BacktrackGlyphCount;
   3346   igc = ccsf3->InputGlyphCount;
   3347   lgc = ccsf3->LookaheadGlyphCount;
   3348 
   3349   if ( context_length != 0xFFFF && context_length < igc )
   3350     return HB_Err_Not_Covered;
   3351 
   3352   /* check whether context is too long; it is a first guess only */
   3353 
   3354   if ( bgc > buffer->out_pos || buffer->in_pos + igc + lgc > buffer->in_length )
   3355     return HB_Err_Not_Covered;
   3356 
   3357   if ( bgc )
   3358   {
   3359     /* Since we don't know in advance the number of glyphs to inspect,
   3360        we search backwards for matches in the backtrack glyph array    */
   3361 
   3362     bc       = ccsf3->BacktrackCoverage;
   3363 
   3364     for ( i = 0, j = buffer->out_pos - 1; i < bgc; i++, j-- )
   3365     {
   3366       while ( CHECK_Property( gdef, OUT_ITEM( j ), flags, &property ) )
   3367       {
   3368 	if ( error && error != HB_Err_Not_Covered )
   3369 	  return error;
   3370 
   3371 	if ( j + 1 == bgc - i )
   3372 	  return HB_Err_Not_Covered;
   3373 	j--;
   3374       }
   3375 
   3376       error = _HB_OPEN_Coverage_Index( &bc[i], OUT_GLYPH( j ), &index );
   3377       if ( error )
   3378 	return error;
   3379     }
   3380   }
   3381 
   3382   ic       = ccsf3->InputCoverage;
   3383 
   3384   for ( i = 0, j = buffer->in_pos; i < igc; i++, j++ )
   3385   {
   3386     /* We already called CHECK_Property for IN_GLYPH( buffer->in_pos ) */
   3387     while ( j > buffer->in_pos && CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3388     {
   3389       if ( error && error != HB_Err_Not_Covered )
   3390 	return error;
   3391 
   3392       if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
   3393 	return HB_Err_Not_Covered;
   3394       j++;
   3395     }
   3396 
   3397     error = _HB_OPEN_Coverage_Index( &ic[i], IN_GLYPH( j ), &index );
   3398     if ( error )
   3399       return error;
   3400   }
   3401 
   3402   /* we are starting for lookahead glyphs right after the last context
   3403      glyph                                                             */
   3404 
   3405   lc       = ccsf3->LookaheadCoverage;
   3406 
   3407   for ( i = 0; i < lgc; i++, j++ )
   3408   {
   3409     while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3410     {
   3411       if ( error && error != HB_Err_Not_Covered )
   3412 	return error;
   3413 
   3414       if ( j + lgc - i == (HB_Int)buffer->in_length )
   3415 	return HB_Err_Not_Covered;
   3416       j++;
   3417     }
   3418 
   3419     error = _HB_OPEN_Coverage_Index( &lc[i], IN_GLYPH( j ), &index );
   3420     if ( error )
   3421       return error;
   3422   }
   3423 
   3424   return Do_ContextSubst( gsub, igc,
   3425 			  ccsf3->SubstCount,
   3426 			  ccsf3->SubstLookupRecord,
   3427 			  buffer,
   3428 			  nesting_level );
   3429 }
   3430 
   3431 
   3432 static HB_Error  Lookup_ChainContextSubst( HB_GSUBHeader*    gsub,
   3433 					   HB_GSUB_SubTable* st,
   3434 					   HB_Buffer         buffer,
   3435 					   HB_UShort          flags,
   3436 					   HB_UShort          context_length,
   3437 					   int                nesting_level )
   3438 {
   3439   HB_ChainContextSubst*  ccs = &st->chain;
   3440 
   3441   switch ( ccs->SubstFormat ) {
   3442     case 1:  return Lookup_ChainContextSubst1( gsub, &ccs->ccsf.ccsf1, buffer, flags, context_length, nesting_level );
   3443     case 2:  return Lookup_ChainContextSubst2( gsub, &ccs->ccsf.ccsf2, buffer, flags, context_length, nesting_level );
   3444     case 3:  return Lookup_ChainContextSubst3( gsub, &ccs->ccsf.ccsf3, buffer, flags, context_length, nesting_level );
   3445     default: return ERR(HB_Err_Invalid_SubTable_Format);
   3446   }
   3447 }
   3448 
   3449 
   3450 static HB_Error  Load_ReverseChainContextSubst( HB_GSUB_SubTable* st,
   3451 					        HB_Stream         stream )
   3452 {
   3453   HB_Error error;
   3454   HB_ReverseChainContextSubst*  rccs = &st->reverse;
   3455 
   3456   HB_UShort               m, count;
   3457 
   3458   HB_UShort               nb = 0, nl = 0, n;
   3459   HB_UShort               backtrack_count, lookahead_count;
   3460   HB_UInt                cur_offset, new_offset, base_offset;
   3461 
   3462   HB_Coverage*           b;
   3463   HB_Coverage*           l;
   3464   HB_UShort*              sub;
   3465 
   3466   base_offset = FILE_Pos();
   3467 
   3468   if ( ACCESS_Frame( 2L ) )
   3469     return error;
   3470 
   3471   rccs->SubstFormat = GET_UShort();
   3472 
   3473   if ( rccs->SubstFormat != 1 )
   3474     return ERR(HB_Err_Invalid_SubTable_Format);
   3475 
   3476   FORGET_Frame();
   3477 
   3478   if ( ACCESS_Frame( 2L ) )
   3479     return error;
   3480 
   3481   new_offset = GET_UShort() + base_offset;
   3482 
   3483   FORGET_Frame();
   3484 
   3485   cur_offset = FILE_Pos();
   3486   if ( FILE_Seek( new_offset ) ||
   3487        ( error = _HB_OPEN_Load_Coverage( &rccs->Coverage, stream ) ) != HB_Err_Ok )
   3488     return error;
   3489   (void)FILE_Seek( cur_offset );
   3490 
   3491 
   3492   if ( ACCESS_Frame( 2L ) )
   3493     goto Fail4;
   3494 
   3495   rccs->BacktrackGlyphCount = GET_UShort();
   3496 
   3497   FORGET_Frame();
   3498 
   3499   rccs->BacktrackCoverage = NULL;
   3500 
   3501   backtrack_count = rccs->BacktrackGlyphCount;
   3502 
   3503   if ( ALLOC_ARRAY( rccs->BacktrackCoverage, backtrack_count,
   3504 		    HB_Coverage ) )
   3505     goto Fail4;
   3506 
   3507   b = rccs->BacktrackCoverage;
   3508 
   3509   for ( nb = 0; nb < backtrack_count; nb++ )
   3510   {
   3511     if ( ACCESS_Frame( 2L ) )
   3512       goto Fail3;
   3513 
   3514     new_offset = GET_UShort() + base_offset;
   3515 
   3516     FORGET_Frame();
   3517 
   3518     cur_offset = FILE_Pos();
   3519     if ( FILE_Seek( new_offset ) ||
   3520 	 ( error = _HB_OPEN_Load_Coverage( &b[nb], stream ) ) != HB_Err_Ok )
   3521       goto Fail3;
   3522     (void)FILE_Seek( cur_offset );
   3523   }
   3524 
   3525 
   3526   if ( ACCESS_Frame( 2L ) )
   3527     goto Fail3;
   3528 
   3529   rccs->LookaheadGlyphCount = GET_UShort();
   3530 
   3531   FORGET_Frame();
   3532 
   3533   rccs->LookaheadCoverage = NULL;
   3534 
   3535   lookahead_count = rccs->LookaheadGlyphCount;
   3536 
   3537   if ( ALLOC_ARRAY( rccs->LookaheadCoverage, lookahead_count,
   3538 		    HB_Coverage ) )
   3539     goto Fail3;
   3540 
   3541   l = rccs->LookaheadCoverage;
   3542 
   3543   for ( nl = 0; nl < lookahead_count; nl++ )
   3544   {
   3545     if ( ACCESS_Frame( 2L ) )
   3546       goto Fail2;
   3547 
   3548     new_offset = GET_UShort() + base_offset;
   3549 
   3550     FORGET_Frame();
   3551 
   3552     cur_offset = FILE_Pos();
   3553     if ( FILE_Seek( new_offset ) ||
   3554 	 ( error = _HB_OPEN_Load_Coverage( &l[nl], stream ) ) != HB_Err_Ok )
   3555       goto Fail2;
   3556     (void)FILE_Seek( cur_offset );
   3557   }
   3558 
   3559   if ( ACCESS_Frame( 2L ) )
   3560     goto Fail2;
   3561 
   3562   rccs->GlyphCount = GET_UShort();
   3563 
   3564   FORGET_Frame();
   3565 
   3566   rccs->Substitute = NULL;
   3567 
   3568   count = rccs->GlyphCount;
   3569 
   3570   if ( ALLOC_ARRAY( rccs->Substitute, count,
   3571 		    HB_UShort ) )
   3572     goto Fail2;
   3573 
   3574   sub = rccs->Substitute;
   3575 
   3576   if ( ACCESS_Frame( count * 2L ) )
   3577     goto Fail1;
   3578 
   3579   for ( n = 0; n < count; n++ )
   3580     sub[n] = GET_UShort();
   3581 
   3582   FORGET_Frame();
   3583 
   3584   return HB_Err_Ok;
   3585 
   3586 Fail1:
   3587   FREE( sub );
   3588 
   3589 Fail2:
   3590   for ( m = 0; m < nl; m++ )
   3591     _HB_OPEN_Free_Coverage( &l[m] );
   3592 
   3593   FREE( l );
   3594 
   3595 Fail3:
   3596   for ( m = 0; m < nb; m++ )
   3597     _HB_OPEN_Free_Coverage( &b[m] );
   3598 
   3599   FREE( b );
   3600 
   3601 Fail4:
   3602   _HB_OPEN_Free_Coverage( &rccs->Coverage );
   3603   return error;
   3604 }
   3605 
   3606 
   3607 static void  Free_ReverseChainContextSubst( HB_GSUB_SubTable* st )
   3608 {
   3609   HB_UShort      n, count;
   3610   HB_ReverseChainContextSubst*  rccs = &st->reverse;
   3611 
   3612   HB_Coverage*  c;
   3613 
   3614   _HB_OPEN_Free_Coverage( &rccs->Coverage );
   3615 
   3616   if ( rccs->LookaheadCoverage )
   3617   {
   3618     count = rccs->LookaheadGlyphCount;
   3619     c     = rccs->LookaheadCoverage;
   3620 
   3621     for ( n = 0; n < count; n++ )
   3622       _HB_OPEN_Free_Coverage( &c[n] );
   3623 
   3624     FREE( c );
   3625   }
   3626 
   3627   if ( rccs->BacktrackCoverage )
   3628   {
   3629     count = rccs->BacktrackGlyphCount;
   3630     c     = rccs->BacktrackCoverage;
   3631 
   3632     for ( n = 0; n < count; n++ )
   3633       _HB_OPEN_Free_Coverage( &c[n] );
   3634 
   3635     FREE( c );
   3636   }
   3637 
   3638   FREE ( rccs->Substitute );
   3639 }
   3640 
   3641 
   3642 static HB_Error  Lookup_ReverseChainContextSubst( HB_GSUBHeader*    gsub,
   3643 						  HB_GSUB_SubTable* st,
   3644 						  HB_Buffer         buffer,
   3645 						  HB_UShort          flags,
   3646 						  HB_UShort         context_length,
   3647 						  int               nesting_level )
   3648 {
   3649   HB_UShort        index, input_index, i, j, property;
   3650   HB_UShort        bgc, lgc;
   3651   HB_Error         error;
   3652 
   3653   HB_ReverseChainContextSubst*  rccs = &st->reverse;
   3654   HB_Coverage*    bc;
   3655   HB_Coverage*    lc;
   3656   HB_GDEFHeader*  gdef;
   3657 
   3658   if ( nesting_level != 1 || context_length != 0xFFFF )
   3659     return HB_Err_Not_Covered;
   3660 
   3661   gdef = gsub->gdef;
   3662 
   3663   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
   3664     return error;
   3665 
   3666   bgc = rccs->BacktrackGlyphCount;
   3667   lgc = rccs->LookaheadGlyphCount;
   3668 
   3669   /* check whether context is too long; it is a first guess only */
   3670 
   3671   if ( bgc > buffer->in_pos || buffer->in_pos + 1 + lgc > buffer->in_length )
   3672     return HB_Err_Not_Covered;
   3673 
   3674   if ( bgc )
   3675   {
   3676     /* Since we don't know in advance the number of glyphs to inspect,
   3677        we search backwards for matches in the backtrack glyph array    */
   3678 
   3679     bc       = rccs->BacktrackCoverage;
   3680 
   3681     for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- )
   3682     {
   3683       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3684       {
   3685 	if ( error && error != HB_Err_Not_Covered )
   3686 	  return error;
   3687 
   3688 	if ( j + 1 == bgc - i )
   3689 	  return HB_Err_Not_Covered;
   3690 	j--;
   3691       }
   3692 
   3693       error = _HB_OPEN_Coverage_Index( &bc[i], IN_GLYPH( j ), &index );
   3694       if ( error )
   3695 	return error;
   3696     }
   3697   }
   3698 
   3699   j = buffer->in_pos;
   3700 
   3701   error = _HB_OPEN_Coverage_Index( &rccs->Coverage, IN_GLYPH( j ), &input_index );
   3702   if ( error )
   3703       return error;
   3704 
   3705   lc       = rccs->LookaheadCoverage;
   3706 
   3707   for ( i = 0, j = buffer->in_pos + 1; i < lgc; i++, j++ )
   3708   {
   3709     while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
   3710     {
   3711       if ( error && error != HB_Err_Not_Covered )
   3712 	return error;
   3713 
   3714       if ( j + lgc - i == (HB_Int)buffer->in_length )
   3715 	return HB_Err_Not_Covered;
   3716       j++;
   3717     }
   3718 
   3719     error = _HB_OPEN_Coverage_Index( &lc[i], IN_GLYPH( j ), &index );
   3720     if ( error )
   3721       return error;
   3722   }
   3723 
   3724   IN_CURGLYPH() = rccs->Substitute[input_index];
   3725   buffer->in_pos--; /* Reverse! */
   3726 
   3727   return error;
   3728 }
   3729 
   3730 
   3731 
   3732 /***********
   3733  * GSUB API
   3734  ***********/
   3735 
   3736 
   3737 
   3738 HB_Error  HB_GSUB_Select_Script( HB_GSUBHeader*  gsub,
   3739 				 HB_UInt         script_tag,
   3740 				 HB_UShort*       script_index )
   3741 {
   3742   HB_UShort          n;
   3743 
   3744   HB_ScriptList*    sl;
   3745   HB_ScriptRecord*  sr;
   3746 
   3747 
   3748   if ( !gsub || !script_index )
   3749     return ERR(HB_Err_Invalid_Argument);
   3750 
   3751   sl = &gsub->ScriptList;
   3752   sr = sl->ScriptRecord;
   3753 
   3754   for ( n = 0; n < sl->ScriptCount; n++ )
   3755     if ( script_tag == sr[n].ScriptTag )
   3756     {
   3757       *script_index = n;
   3758 
   3759       return HB_Err_Ok;
   3760     }
   3761 
   3762   return HB_Err_Not_Covered;
   3763 }
   3764 
   3765 
   3766 
   3767 HB_Error  HB_GSUB_Select_Language( HB_GSUBHeader*  gsub,
   3768 				   HB_UInt         language_tag,
   3769 				   HB_UShort        script_index,
   3770 				   HB_UShort*       language_index,
   3771 				   HB_UShort*       req_feature_index )
   3772 {
   3773   HB_UShort           n;
   3774 
   3775   HB_ScriptList*     sl;
   3776   HB_ScriptRecord*   sr;
   3777   HB_ScriptTable*    s;
   3778   HB_LangSysRecord*  lsr;
   3779 
   3780 
   3781   if ( !gsub || !language_index || !req_feature_index )
   3782     return ERR(HB_Err_Invalid_Argument);
   3783 
   3784   sl = &gsub->ScriptList;
   3785   sr = sl->ScriptRecord;
   3786 
   3787   if ( script_index >= sl->ScriptCount )
   3788     return ERR(HB_Err_Invalid_Argument);
   3789 
   3790   s   = &sr[script_index].Script;
   3791   lsr = s->LangSysRecord;
   3792 
   3793   for ( n = 0; n < s->LangSysCount; n++ )
   3794     if ( language_tag == lsr[n].LangSysTag )
   3795     {
   3796       *language_index = n;
   3797       *req_feature_index = lsr[n].LangSys.ReqFeatureIndex;
   3798 
   3799       return HB_Err_Ok;
   3800     }
   3801 
   3802   return HB_Err_Not_Covered;
   3803 }
   3804 
   3805 
   3806 /* selecting 0xFFFF for language_index asks for the values of the
   3807    default language (DefaultLangSys)                              */
   3808 
   3809 
   3810 HB_Error  HB_GSUB_Select_Feature( HB_GSUBHeader*  gsub,
   3811 				  HB_UInt         feature_tag,
   3812 				  HB_UShort        script_index,
   3813 				  HB_UShort        language_index,
   3814 				  HB_UShort*       feature_index )
   3815 {
   3816   HB_UShort           n;
   3817 
   3818   HB_ScriptList*     sl;
   3819   HB_ScriptRecord*   sr;
   3820   HB_ScriptTable*    s;
   3821   HB_LangSysRecord*  lsr;
   3822   HB_LangSys*        ls;
   3823   HB_UShort*          fi;
   3824 
   3825   HB_FeatureList*    fl;
   3826   HB_FeatureRecord*  fr;
   3827 
   3828 
   3829   if ( !gsub || !feature_index )
   3830     return ERR(HB_Err_Invalid_Argument);
   3831 
   3832   sl = &gsub->ScriptList;
   3833   sr = sl->ScriptRecord;
   3834 
   3835   fl = &gsub->FeatureList;
   3836   fr = fl->FeatureRecord;
   3837 
   3838   if ( script_index >= sl->ScriptCount )
   3839     return ERR(HB_Err_Invalid_Argument);
   3840 
   3841   s   = &sr[script_index].Script;
   3842   lsr = s->LangSysRecord;
   3843 
   3844   if ( language_index == 0xFFFF )
   3845     ls = &s->DefaultLangSys;
   3846   else
   3847   {
   3848     if ( language_index >= s->LangSysCount )
   3849       return ERR(HB_Err_Invalid_Argument);
   3850 
   3851     ls = &lsr[language_index].LangSys;
   3852   }
   3853 
   3854   fi = ls->FeatureIndex;
   3855 
   3856   for ( n = 0; n < ls->FeatureCount; n++ )
   3857   {
   3858     if ( fi[n] >= fl->FeatureCount )
   3859       return ERR(HB_Err_Invalid_SubTable_Format);
   3860 
   3861     if ( feature_tag == fr[fi[n]].FeatureTag )
   3862     {
   3863       *feature_index = fi[n];
   3864 
   3865       return HB_Err_Ok;
   3866     }
   3867   }
   3868 
   3869   return HB_Err_Not_Covered;
   3870 }
   3871 
   3872 
   3873 /* The next three functions return a null-terminated list */
   3874 
   3875 
   3876 HB_Error  HB_GSUB_Query_Scripts( HB_GSUBHeader*  gsub,
   3877 				 HB_UInt**       script_tag_list )
   3878 {
   3879   HB_UShort          n;
   3880   HB_Error           error;
   3881   HB_UInt*          stl;
   3882 
   3883   HB_ScriptList*    sl;
   3884   HB_ScriptRecord*  sr;
   3885 
   3886 
   3887   if ( !gsub || !script_tag_list )
   3888     return ERR(HB_Err_Invalid_Argument);
   3889 
   3890   sl = &gsub->ScriptList;
   3891   sr = sl->ScriptRecord;
   3892 
   3893   if ( ALLOC_ARRAY( stl, sl->ScriptCount + 1, HB_UInt ) )
   3894     return error;
   3895 
   3896   for ( n = 0; n < sl->ScriptCount; n++ )
   3897     stl[n] = sr[n].ScriptTag;
   3898   stl[n] = 0;
   3899 
   3900   *script_tag_list = stl;
   3901 
   3902   return HB_Err_Ok;
   3903 }
   3904 
   3905 
   3906 
   3907 HB_Error  HB_GSUB_Query_Languages( HB_GSUBHeader*  gsub,
   3908 				   HB_UShort        script_index,
   3909 				   HB_UInt**       language_tag_list )
   3910 {
   3911   HB_UShort           n;
   3912   HB_Error            error;
   3913   HB_UInt*           ltl;
   3914 
   3915   HB_ScriptList*     sl;
   3916   HB_ScriptRecord*   sr;
   3917   HB_ScriptTable*    s;
   3918   HB_LangSysRecord*  lsr;
   3919 
   3920 
   3921   if ( !gsub || !language_tag_list )
   3922     return ERR(HB_Err_Invalid_Argument);
   3923 
   3924   sl = &gsub->ScriptList;
   3925   sr = sl->ScriptRecord;
   3926 
   3927   if ( script_index >= sl->ScriptCount )
   3928     return ERR(HB_Err_Invalid_Argument);
   3929 
   3930   s   = &sr[script_index].Script;
   3931   lsr = s->LangSysRecord;
   3932 
   3933   if ( ALLOC_ARRAY( ltl, s->LangSysCount + 1, HB_UInt ) )
   3934     return error;
   3935 
   3936   for ( n = 0; n < s->LangSysCount; n++ )
   3937     ltl[n] = lsr[n].LangSysTag;
   3938   ltl[n] = 0;
   3939 
   3940   *language_tag_list = ltl;
   3941 
   3942   return HB_Err_Ok;
   3943 }
   3944 
   3945 
   3946 /* selecting 0xFFFF for language_index asks for the values of the
   3947    default language (DefaultLangSys)                              */
   3948 
   3949 
   3950 HB_Error  HB_GSUB_Query_Features( HB_GSUBHeader*  gsub,
   3951 				  HB_UShort        script_index,
   3952 				  HB_UShort        language_index,
   3953 				  HB_UInt**       feature_tag_list )
   3954 {
   3955   HB_UShort           n;
   3956   HB_Error            error;
   3957   HB_UInt*           ftl;
   3958 
   3959   HB_ScriptList*     sl;
   3960   HB_ScriptRecord*   sr;
   3961   HB_ScriptTable*    s;
   3962   HB_LangSysRecord*  lsr;
   3963   HB_LangSys*        ls;
   3964   HB_UShort*          fi;
   3965 
   3966   HB_FeatureList*    fl;
   3967   HB_FeatureRecord*  fr;
   3968 
   3969 
   3970   if ( !gsub || !feature_tag_list )
   3971     return ERR(HB_Err_Invalid_Argument);
   3972 
   3973   sl = &gsub->ScriptList;
   3974   sr = sl->ScriptRecord;
   3975 
   3976   fl = &gsub->FeatureList;
   3977   fr = fl->FeatureRecord;
   3978 
   3979   if ( script_index >= sl->ScriptCount )
   3980     return ERR(HB_Err_Invalid_Argument);
   3981 
   3982   s   = &sr[script_index].Script;
   3983   lsr = s->LangSysRecord;
   3984 
   3985   if ( language_index == 0xFFFF )
   3986     ls = &s->DefaultLangSys;
   3987   else
   3988   {
   3989     if ( language_index >= s->LangSysCount )
   3990       return ERR(HB_Err_Invalid_Argument);
   3991 
   3992     ls = &lsr[language_index].LangSys;
   3993   }
   3994 
   3995   fi = ls->FeatureIndex;
   3996 
   3997   if ( ALLOC_ARRAY( ftl, ls->FeatureCount + 1, HB_UInt ) )
   3998     return error;
   3999 
   4000   for ( n = 0; n < ls->FeatureCount; n++ )
   4001   {
   4002     if ( fi[n] >= fl->FeatureCount )
   4003     {
   4004       FREE( ftl );
   4005       return ERR(HB_Err_Invalid_SubTable_Format);
   4006     }
   4007     ftl[n] = fr[fi[n]].FeatureTag;
   4008   }
   4009   ftl[n] = 0;
   4010 
   4011   *feature_tag_list = ftl;
   4012 
   4013   return HB_Err_Ok;
   4014 }
   4015 
   4016 
   4017 /* Do an individual subtable lookup.  Returns HB_Err_Ok if substitution
   4018    has been done, or HB_Err_Not_Covered if not.                        */
   4019 static HB_Error  GSUB_Do_Glyph_Lookup( HB_GSUBHeader* gsub,
   4020 				       HB_UShort       lookup_index,
   4021 				       HB_Buffer      buffer,
   4022 				       HB_UShort       context_length,
   4023 				       int             nesting_level )
   4024 {
   4025   HB_Error               error = HB_Err_Not_Covered;
   4026   HB_UShort              i, flags, lookup_count;
   4027   HB_Lookup*             lo;
   4028   int                    lookup_type;
   4029 
   4030   nesting_level++;
   4031 
   4032   if ( nesting_level > HB_MAX_NESTING_LEVEL )
   4033     return ERR(HB_Err_Not_Covered); /* ERR() call intended */
   4034 
   4035   lookup_count = gsub->LookupList.LookupCount;
   4036   if (lookup_index >= lookup_count)
   4037     return error;
   4038 
   4039   lo    = &gsub->LookupList.Lookup[lookup_index];
   4040   flags = lo->LookupFlag;
   4041   lookup_type = lo->LookupType;
   4042 
   4043   for ( i = 0; i < lo->SubTableCount; i++ )
   4044   {
   4045     HB_GSUB_SubTable *st = &lo->SubTable[i].st.gsub;
   4046 
   4047     switch (lookup_type) {
   4048       case HB_GSUB_LOOKUP_SINGLE:
   4049 	error = Lookup_SingleSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4050       case HB_GSUB_LOOKUP_MULTIPLE:
   4051 	error = Lookup_MultipleSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4052       case HB_GSUB_LOOKUP_ALTERNATE:
   4053 	error = Lookup_AlternateSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4054       case HB_GSUB_LOOKUP_LIGATURE:
   4055 	error = Lookup_LigatureSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4056       case HB_GSUB_LOOKUP_CONTEXT:
   4057 	error = Lookup_ContextSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4058       case HB_GSUB_LOOKUP_CHAIN:
   4059 	error = Lookup_ChainContextSubst	( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4060     /*case HB_GSUB_LOOKUP_EXTENSION:
   4061 	error = Lookup_ExtensionSubst		( gsub, st, buffer, flags, context_length, nesting_level ); break;*/
   4062       case HB_GSUB_LOOKUP_REVERSE_CHAIN:
   4063 	error = Lookup_ReverseChainContextSubst	( gsub, st, buffer, flags, context_length, nesting_level ); break;
   4064       default:
   4065 	error = HB_Err_Not_Covered;
   4066     };
   4067 
   4068     /* Check whether we have a successful substitution or an error other
   4069        than HB_Err_Not_Covered                                          */
   4070     if ( error != HB_Err_Not_Covered )
   4071       return error;
   4072   }
   4073 
   4074   return HB_Err_Not_Covered;
   4075 }
   4076 
   4077 
   4078 HB_INTERNAL HB_Error
   4079 _HB_GSUB_Load_SubTable( HB_GSUB_SubTable* st,
   4080 			HB_Stream         stream,
   4081 			HB_UShort         lookup_type )
   4082 {
   4083   switch (lookup_type) {
   4084     case HB_GSUB_LOOKUP_SINGLE:		return Load_SingleSubst			( st, stream );
   4085     case HB_GSUB_LOOKUP_MULTIPLE:	return Load_MultipleSubst		( st, stream );
   4086     case HB_GSUB_LOOKUP_ALTERNATE:	return Load_AlternateSubst		( st, stream );
   4087     case HB_GSUB_LOOKUP_LIGATURE:	return Load_LigatureSubst		( st, stream );
   4088     case HB_GSUB_LOOKUP_CONTEXT:	return Load_ContextSubst		( st, stream );
   4089     case HB_GSUB_LOOKUP_CHAIN:		return Load_ChainContextSubst		( st, stream );
   4090   /*case HB_GSUB_LOOKUP_EXTENSION:	return Load_ExtensionSubst		( st, stream );*/
   4091     case HB_GSUB_LOOKUP_REVERSE_CHAIN:	return Load_ReverseChainContextSubst	( st, stream );
   4092     default:				return ERR(HB_Err_Invalid_SubTable_Format);
   4093   };
   4094 }
   4095 
   4096 
   4097 HB_INTERNAL void
   4098 _HB_GSUB_Free_SubTable( HB_GSUB_SubTable* st,
   4099 			HB_UShort         lookup_type )
   4100 {
   4101   switch ( lookup_type ) {
   4102     case HB_GSUB_LOOKUP_SINGLE:		Free_SingleSubst		( st ); return;
   4103     case HB_GSUB_LOOKUP_MULTIPLE:	Free_MultipleSubst		( st ); return;
   4104     case HB_GSUB_LOOKUP_ALTERNATE:	Free_AlternateSubst		( st ); return;
   4105     case HB_GSUB_LOOKUP_LIGATURE:	Free_LigatureSubst		( st ); return;
   4106     case HB_GSUB_LOOKUP_CONTEXT:	Free_ContextSubst		( st ); return;
   4107     case HB_GSUB_LOOKUP_CHAIN:		Free_ChainContextSubst		( st ); return;
   4108   /*case HB_GSUB_LOOKUP_EXTENSION:	Free_ExtensionSubst		( st ); return;*/
   4109     case HB_GSUB_LOOKUP_REVERSE_CHAIN:	Free_ReverseChainContextSubst	( st ); return;
   4110     default:									return;
   4111   };
   4112 }
   4113 
   4114 
   4115 
   4116 /* apply one lookup to the input string object */
   4117 
   4118 static HB_Error  GSUB_Do_String_Lookup( HB_GSUBHeader*   gsub,
   4119 				   HB_UShort         lookup_index,
   4120 				   HB_Buffer        buffer )
   4121 {
   4122   HB_Error  error, retError = HB_Err_Not_Covered;
   4123 
   4124   HB_UInt*  properties = gsub->LookupList.Properties;
   4125   int       lookup_type = gsub->LookupList.Lookup[lookup_index].LookupType;
   4126 
   4127   const int       nesting_level = 0;
   4128   /* 0xFFFF indicates that we don't have a context length yet */
   4129   const HB_UShort context_length = 0xFFFF;
   4130 
   4131   switch (lookup_type) {
   4132 
   4133     case HB_GSUB_LOOKUP_SINGLE:
   4134     case HB_GSUB_LOOKUP_MULTIPLE:
   4135     case HB_GSUB_LOOKUP_ALTERNATE:
   4136     case HB_GSUB_LOOKUP_LIGATURE:
   4137     case HB_GSUB_LOOKUP_CONTEXT:
   4138     case HB_GSUB_LOOKUP_CHAIN:
   4139       /* in/out forward substitution (implemented lazy) */
   4140 
   4141       _hb_buffer_clear_output ( buffer );
   4142       buffer->in_pos = 0;
   4143   while ( buffer->in_pos < buffer->in_length )
   4144   {
   4145     if ( ~IN_PROPERTIES( buffer->in_pos ) & properties[lookup_index] )
   4146     {
   4147 	  error = GSUB_Do_Glyph_Lookup( gsub, lookup_index, buffer, context_length, nesting_level );
   4148       if ( error )
   4149       {
   4150 	if ( error != HB_Err_Not_Covered )
   4151 	  return error;
   4152       }
   4153       else
   4154 	retError = error;
   4155     }
   4156     else
   4157       error = HB_Err_Not_Covered;
   4158 
   4159     if ( error == HB_Err_Not_Covered )
   4160 	  if ( COPY_Glyph ( buffer ) )
   4161 	return error;
   4162   }
   4163       /* we shouldn't swap if error occurred.
   4164        *
   4165        * also don't swap if nothing changed (ie HB_Err_Not_Covered).
   4166        * shouldn't matter in that case though.
   4167        */
   4168       if ( retError == HB_Err_Ok )
   4169 	_hb_buffer_swap( buffer );
   4170 
   4171   return retError;
   4172 
   4173     case HB_GSUB_LOOKUP_REVERSE_CHAIN:
   4174       /* in-place backward substitution */
   4175 
   4176       buffer->in_pos = buffer->in_length - 1;
   4177     do
   4178     {
   4179       if ( ~IN_PROPERTIES( buffer->in_pos ) & properties[lookup_index] )
   4180 	{
   4181 	  error = GSUB_Do_Glyph_Lookup( gsub, lookup_index, buffer, context_length, nesting_level );
   4182 	  if ( error )
   4183 	    {
   4184 	      if ( error != HB_Err_Not_Covered )
   4185 		return error;
   4186 	    }
   4187 	  else
   4188 	    retError = error;
   4189 	}
   4190 	else
   4191 	  error = HB_Err_Not_Covered;
   4192 
   4193 	if ( error == HB_Err_Not_Covered )
   4194 	  buffer->in_pos--;
   4195       }
   4196       while ((HB_Int) buffer->in_pos >= 0);
   4197 
   4198       return retError;
   4199 
   4200   /*case HB_GSUB_LOOKUP_EXTENSION:*/
   4201     default:
   4202   return retError;
   4203   };
   4204 }
   4205 
   4206 
   4207 HB_Error  HB_GSUB_Add_Feature( HB_GSUBHeader*  gsub,
   4208 			       HB_UShort        feature_index,
   4209 			       HB_UInt          property )
   4210 {
   4211   HB_UShort    i;
   4212 
   4213   HB_Feature  feature;
   4214   HB_UInt*     properties;
   4215   HB_UShort*   index;
   4216   HB_UShort    lookup_count;
   4217 
   4218   /* Each feature can only be added once */
   4219 
   4220   if ( !gsub ||
   4221        feature_index >= gsub->FeatureList.FeatureCount ||
   4222        gsub->FeatureList.ApplyCount == gsub->FeatureList.FeatureCount )
   4223     return ERR(HB_Err_Invalid_Argument);
   4224 
   4225   gsub->FeatureList.ApplyOrder[gsub->FeatureList.ApplyCount++] = feature_index;
   4226 
   4227   properties = gsub->LookupList.Properties;
   4228 
   4229   feature = gsub->FeatureList.FeatureRecord[feature_index].Feature;
   4230   index   = feature.LookupListIndex;
   4231   lookup_count = gsub->LookupList.LookupCount;
   4232 
   4233   for ( i = 0; i < feature.LookupListCount; i++ )
   4234   {
   4235     HB_UShort lookup_index = index[i];
   4236     if (lookup_index < lookup_count)
   4237       properties[lookup_index] |= property;
   4238   }
   4239 
   4240   return HB_Err_Ok;
   4241 }
   4242 
   4243 
   4244 
   4245 HB_Error  HB_GSUB_Clear_Features( HB_GSUBHeader*  gsub )
   4246 {
   4247   HB_UShort i;
   4248 
   4249   HB_UInt*  properties;
   4250 
   4251 
   4252   if ( !gsub )
   4253     return ERR(HB_Err_Invalid_Argument);
   4254 
   4255   gsub->FeatureList.ApplyCount = 0;
   4256 
   4257   properties = gsub->LookupList.Properties;
   4258 
   4259   for ( i = 0; i < gsub->LookupList.LookupCount; i++ )
   4260     properties[i] = 0;
   4261 
   4262   return HB_Err_Ok;
   4263 }
   4264 
   4265 
   4266 
   4267 HB_Error  HB_GSUB_Register_Alternate_Function( HB_GSUBHeader*  gsub,
   4268 					       HB_AltFunction  altfunc,
   4269 					       void*            data )
   4270 {
   4271   if ( !gsub )
   4272     return ERR(HB_Err_Invalid_Argument);
   4273 
   4274   gsub->altfunc = altfunc;
   4275   gsub->data    = data;
   4276 
   4277   return HB_Err_Ok;
   4278 }
   4279 
   4280 /* returns error if one happened, otherwise returns HB_Err_Not_Covered if no
   4281  * feature were applied, or HB_Err_Ok otherwise.
   4282  */
   4283 HB_Error  HB_GSUB_Apply_String( HB_GSUBHeader*   gsub,
   4284 				HB_Buffer        buffer )
   4285 {
   4286   HB_Error          error, retError = HB_Err_Not_Covered;
   4287   int               i, j, lookup_count, num_features;
   4288 
   4289   if ( !gsub ||
   4290        !buffer)
   4291     return ERR(HB_Err_Invalid_Argument);
   4292 
   4293   if ( buffer->in_length == 0 )
   4294     return retError;
   4295 
   4296   lookup_count = gsub->LookupList.LookupCount;
   4297   num_features = gsub->FeatureList.ApplyCount;
   4298 
   4299   for ( i = 0; i < num_features; i++)
   4300   {
   4301     HB_UShort  feature_index = gsub->FeatureList.ApplyOrder[i];
   4302     HB_Feature feature = gsub->FeatureList.FeatureRecord[feature_index].Feature;
   4303 
   4304     for ( j = 0; j < feature.LookupListCount; j++ )
   4305     {
   4306       HB_UShort         lookup_index = feature.LookupListIndex[j];
   4307 
   4308       /* Skip nonexistant lookups */
   4309       if (lookup_index >= lookup_count)
   4310        continue;
   4311 
   4312 	error = GSUB_Do_String_Lookup( gsub, lookup_index, buffer );
   4313       if ( error )
   4314       {
   4315 	if ( error != HB_Err_Not_Covered )
   4316 	  return error;
   4317       }
   4318       else
   4319 	retError = error;
   4320     }
   4321   }
   4322 
   4323   error = retError;
   4324 
   4325   return error;
   4326 }
   4327 
   4328 
   4329 /* END */
   4330