src/hb-old/harfbuzz-gsub.c

   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 */