src/hb-old/harfbuzz-gpos.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-gpos-private.h"
  31 #include "harfbuzz-open-private.h"
  32 #include "harfbuzz-gdef-private.h"
  33 #include "harfbuzz-shaper.h"
  34
  35 struct  GPOS_Instance_
  36 {
  37   HB_GPOSHeader*  gpos;
  38   HB_Font          font;
  39   HB_Bool          dvi;
  40   HB_UShort        load_flags;  /* how the glyph should be loaded */
  41   HB_Bool          r2l;
  42
  43   HB_UShort        last;        /* the last valid glyph -- used
  44                                    with cursive positioning     */
  45   HB_Fixed           anchor_x;    /* the coordinates of the anchor point */
  46   HB_Fixed           anchor_y;    /* of the last valid glyph             */
  47 };
  48
  49 typedef struct GPOS_Instance_  GPOS_Instance;
  50
  51
  52 static HB_Error  GPOS_Do_Glyph_Lookup( GPOS_Instance*    gpi,
  53                                        HB_UShort         lookup_index,
  54                                        HB_Buffer        buffer,
  55                                        HB_UShort         context_length,
  56                                        int               nesting_level );
  57
  58
  59
  60 #ifdef HB_SUPPORT_MULTIPLE_MASTER
  61 /* the client application must replace this with something more
  62    meaningful if multiple master fonts are to be supported.     */
  63
  64 static HB_Error  default_mmfunc( HB_Font      font,
  65                                  HB_UShort    metric_id,
  66                                  HB_Fixed*      metric_value,
  67                                  void*        data )
  68 {
  69   HB_UNUSED(font);
  70   HB_UNUSED(metric_id);
  71   HB_UNUSED(metric_value);
  72   HB_UNUSED(data);
  73   return ERR(HB_Err_Not_Covered); /* ERR() call intended */
  74 }
  75 #endif
  76
  77
  78
  79 HB_Error  HB_Load_GPOS_Table( HB_Stream stream,
  80                               HB_GPOSHeader** retptr,
  81                               HB_GDEFHeader*  gdef,
  82                               HB_Stream       gdefStream )
  83 {
  84   HB_UInt         cur_offset, new_offset, base_offset;
  85
  86   HB_GPOSHeader*  gpos;
  87
  88   HB_Error   error;
  89
  90
  91   if ( !retptr )
  92     return ERR(HB_Err_Invalid_Argument);
  93
  94   if ( GOTO_Table( TTAG_GPOS ) )
  95     return error;
  96
  97   base_offset = FILE_Pos();
  98
  99   if ( ALLOC ( gpos, sizeof( *gpos ) ) )
 100     return error;
 101
 102 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 103   gpos->mmfunc = default_mmfunc;
 104 #endif
 105
 106   /* skip version */
 107
 108   if ( FILE_Seek( base_offset + 4L ) ||
 109        ACCESS_Frame( 2L ) )
 110     goto Fail4;
 111
 112   new_offset = GET_UShort() + base_offset;
 113
 114   FORGET_Frame();
 115
 116   cur_offset = FILE_Pos();
 117   if ( FILE_Seek( new_offset ) ||
 118        ( error = _HB_OPEN_Load_ScriptList( &gpos->ScriptList,
 119                                   stream ) ) != HB_Err_Ok )
 120     goto Fail4;
 121   (void)FILE_Seek( cur_offset );
 122
 123   if ( ACCESS_Frame( 2L ) )
 124     goto Fail3;
 125
 126   new_offset = GET_UShort() + base_offset;
 127
 128   FORGET_Frame();
 129
 130   cur_offset = FILE_Pos();
 131   if ( FILE_Seek( new_offset ) ||
 132        ( error = _HB_OPEN_Load_FeatureList( &gpos->FeatureList,
 133                                    stream ) ) != HB_Err_Ok )
 134     goto Fail3;
 135   (void)FILE_Seek( cur_offset );
 136
 137   if ( ACCESS_Frame( 2L ) )
 138     goto Fail2;
 139
 140   new_offset = GET_UShort() + base_offset;
 141
 142   FORGET_Frame();
 143
 144   cur_offset = FILE_Pos();
 145   if ( FILE_Seek( new_offset ) ||
 146        ( error = _HB_OPEN_Load_LookupList( &gpos->LookupList,
 147                                   stream, HB_Type_GPOS ) ) != HB_Err_Ok )
 148     goto Fail2;
 149
 150   gpos->gdef = gdef;      /* can be NULL */
 151
 152   if ( ( error =  _HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( gdef, gdefStream,
 153                                                                      gpos->LookupList.Lookup,
 154                                                                      gpos->LookupList.LookupCount ) ) )
 155     goto Fail1;
 156
 157   *retptr = gpos;
 158
 159   return HB_Err_Ok;
 160
 161 Fail1:
 162   _HB_OPEN_Free_LookupList( &gpos->LookupList, HB_Type_GPOS );
 163
 164 Fail2:
 165   _HB_OPEN_Free_FeatureList( &gpos->FeatureList );
 166
 167 Fail3:
 168   _HB_OPEN_Free_ScriptList( &gpos->ScriptList );
 169
 170 Fail4:
 171   FREE( gpos );
 172
 173   return error;
 174 }
 175
 176
 177 HB_Error  HB_Done_GPOS_Table( HB_GPOSHeader* gpos )
 178 {
 179   _HB_OPEN_Free_LookupList( &gpos->LookupList, HB_Type_GPOS );
 180   _HB_OPEN_Free_FeatureList( &gpos->FeatureList );
 181   _HB_OPEN_Free_ScriptList( &gpos->ScriptList );
 182
 183   FREE( gpos );
 184
 185   return HB_Err_Ok;
 186 }
 187
 188
 189 /*****************************
 190  * SubTable related functions
 191  *****************************/
 192
 193 /* shared tables */
 194
 195 /* ValueRecord */
 196
 197 /* There is a subtle difference in the specs between a `table' and a
 198    `record' -- offsets for device tables in ValueRecords are taken from
 199    the parent table and not the parent record.                          */
 200
 201 static HB_Error  Load_ValueRecord( HB_ValueRecord*  vr,
 202                                    HB_UShort         format,
 203                                    HB_UInt          base_offset,
 204                                    HB_Stream         stream )
 205 {
 206   HB_Error  error;
 207
 208   HB_UInt cur_offset, new_offset;
 209
 210
 211   if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT )
 212   {
 213     if ( ACCESS_Frame( 2L ) )
 214       return error;
 215
 216     vr->XPlacement = GET_Short();
 217
 218     FORGET_Frame();
 219   }
 220   else
 221     vr->XPlacement = 0;
 222
 223   if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT )
 224   {
 225     if ( ACCESS_Frame( 2L ) )
 226       return error;
 227
 228     vr->YPlacement = GET_Short();
 229
 230     FORGET_Frame();
 231   }
 232   else
 233     vr->YPlacement = 0;
 234
 235   if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE )
 236   {
 237     if ( ACCESS_Frame( 2L ) )
 238       return error;
 239
 240     vr->XAdvance = GET_Short();
 241
 242     FORGET_Frame();
 243   }
 244   else
 245     vr->XAdvance = 0;
 246
 247   if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE )
 248   {
 249     if ( ACCESS_Frame( 2L ) )
 250       return error;
 251
 252     vr->YAdvance = GET_Short();
 253
 254     FORGET_Frame();
 255   }
 256   else
 257     vr->YAdvance = 0;
 258
 259   if ( format & HB_GPOS_FORMAT_HAVE_DEVICE_TABLES )
 260   {
 261     if ( ALLOC_ARRAY( vr->DeviceTables, 4, HB_Device ) )
 262       return error;
 263     vr->DeviceTables[VR_X_ADVANCE_DEVICE] = 0;
 264     vr->DeviceTables[VR_Y_ADVANCE_DEVICE] = 0;
 265     vr->DeviceTables[VR_X_PLACEMENT_DEVICE] = 0;
 266     vr->DeviceTables[VR_Y_PLACEMENT_DEVICE] = 0;
 267   }
 268   else
 269   {
 270     vr->DeviceTables = 0;
 271   }
 272
 273   if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE )
 274   {
 275     if ( ACCESS_Frame( 2L ) )
 276       goto Fail4;
 277
 278     new_offset = GET_UShort();
 279
 280     FORGET_Frame();
 281
 282     if ( new_offset )
 283     {
 284       new_offset += base_offset;
 285
 286       cur_offset = FILE_Pos();
 287       if ( FILE_Seek( new_offset ) ||
 288            ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_X_PLACEMENT_DEVICE],
 289                                   stream ) ) != HB_Err_Ok )
 290        goto Fail4;
 291       (void)FILE_Seek( cur_offset );
 292     }
 293   }
 294
 295   if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE )
 296   {
 297     if ( ACCESS_Frame( 2L ) )
 298       goto Fail3;
 299
 300     new_offset = GET_UShort();
 301
 302     FORGET_Frame();
 303
 304     if ( new_offset )
 305     {
 306       new_offset += base_offset;
 307
 308       cur_offset = FILE_Pos();
 309       if ( FILE_Seek( new_offset ) ||
 310            ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_Y_PLACEMENT_DEVICE],
 311                                   stream ) ) != HB_Err_Ok )
 312         goto Fail3;
 313       (void)FILE_Seek( cur_offset );
 314     }
 315   }
 316
 317   if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE )
 318   {
 319     if ( ACCESS_Frame( 2L ) )
 320       goto Fail2;
 321
 322     new_offset = GET_UShort();
 323
 324     FORGET_Frame();
 325
 326     if ( new_offset )
 327     {
 328       new_offset += base_offset;
 329
 330       cur_offset = FILE_Pos();
 331       if ( FILE_Seek( new_offset ) ||
 332            ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_X_ADVANCE_DEVICE],
 333                                   stream ) ) != HB_Err_Ok )
 334         goto Fail2;
 335       (void)FILE_Seek( cur_offset );
 336     }
 337   }
 338
 339   if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE )
 340   {
 341     if ( ACCESS_Frame( 2L ) )
 342       goto Fail1;
 343
 344     new_offset = GET_UShort();
 345
 346     FORGET_Frame();
 347
 348     if ( new_offset )
 349     {
 350       new_offset += base_offset;
 351
 352       cur_offset = FILE_Pos();
 353       if ( FILE_Seek( new_offset ) ||
 354            ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_Y_ADVANCE_DEVICE],
 355                                   stream ) ) != HB_Err_Ok )
 356         goto Fail1;
 357       (void)FILE_Seek( cur_offset );
 358     }
 359   }
 360
 361   if ( format & HB_GPOS_FORMAT_HAVE_X_ID_PLACEMENT )
 362   {
 363     if ( ACCESS_Frame( 2L ) )
 364       goto Fail1;
 365
 366 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 367     vr->XIdPlacement = GET_UShort();
 368 #else
 369     (void) GET_UShort();
 370 #endif
 371
 372     FORGET_Frame();
 373   }
 374 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 375   else
 376     vr->XIdPlacement = 0;
 377 #endif
 378
 379   if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_PLACEMENT )
 380   {
 381     if ( ACCESS_Frame( 2L ) )
 382       goto Fail1;
 383
 384 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 385     vr->YIdPlacement = GET_UShort();
 386 #else
 387     (void) GET_UShort();
 388 #endif
 389
 390     FORGET_Frame();
 391   }
 392 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 393   else
 394     vr->YIdPlacement = 0;
 395 #endif
 396
 397   if ( format & HB_GPOS_FORMAT_HAVE_X_ID_ADVANCE )
 398   {
 399     if ( ACCESS_Frame( 2L ) )
 400       goto Fail1;
 401
 402 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 403     vr->XIdAdvance = GET_UShort();
 404 #else
 405     (void) GET_UShort();
 406 #endif
 407
 408     FORGET_Frame();
 409   }
 410 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 411   else
 412     vr->XIdAdvance = 0;
 413 #endif
 414
 415   if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_ADVANCE )
 416   {
 417     if ( ACCESS_Frame( 2L ) )
 418       goto Fail1;
 419
 420 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 421     vr->YIdAdvance = GET_UShort();
 422 #else
 423     (void) GET_UShort();
 424 #endif
 425
 426     FORGET_Frame();
 427   }
 428 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 429   else
 430     vr->YIdAdvance = 0;
 431 #endif
 432
 433   return HB_Err_Ok;
 434
 435 Fail1:
 436   if ( vr->DeviceTables )
 437     _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_ADVANCE_DEVICE] );
 438
 439 Fail2:
 440   if ( vr->DeviceTables )
 441     _HB_OPEN_Free_Device( vr->DeviceTables[VR_X_ADVANCE_DEVICE] );
 442
 443 Fail3:
 444   if ( vr->DeviceTables )
 445     _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_PLACEMENT_DEVICE] );
 446
 447 Fail4:
 448   FREE( vr->DeviceTables );
 449   return error;
 450 }
 451
 452
 453 static void  Free_ValueRecord( HB_ValueRecord*  vr,
 454                                HB_UShort         format )
 455 {
 456   if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE )
 457     _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_ADVANCE_DEVICE] );
 458   if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE )
 459     _HB_OPEN_Free_Device( vr->DeviceTables[VR_X_ADVANCE_DEVICE] );
 460   if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE )
 461     _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_PLACEMENT_DEVICE] );
 462   if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE )
 463     _HB_OPEN_Free_Device( vr->DeviceTables[VR_X_PLACEMENT_DEVICE] );
 464   FREE( vr->DeviceTables );
 465 }
 466
 467
 468 static HB_Error  Get_ValueRecord( GPOS_Instance*    gpi,
 469                                   HB_ValueRecord*  vr,
 470                                   HB_UShort         format,
 471                                   HB_Position      gd )
 472 {
 473   HB_Short         pixel_value;
 474   HB_Error         error = HB_Err_Ok;
 475 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 476   HB_GPOSHeader*  gpos = gpi->gpos;
 477   HB_Fixed           value;
 478 #endif
 479
 480   HB_UShort  x_ppem, y_ppem;
 481   HB_16Dot16   x_scale, y_scale;
 482
 483
 484   if ( !format )
 485     return HB_Err_Ok;
 486
 487   x_ppem  = gpi->font->x_ppem;
 488   y_ppem  = gpi->font->y_ppem;
 489   x_scale = gpi->font->x_scale;
 490   y_scale = gpi->font->y_scale;
 491
 492   /* design units -> fractional pixel */
 493
 494   if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT )
 495     gd->x_pos += x_scale * vr->XPlacement / 0x10000;
 496   if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT )
 497     gd->y_pos += y_scale * vr->YPlacement / 0x10000;
 498   if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE )
 499     gd->x_advance += x_scale * vr->XAdvance / 0x10000;
 500   if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE )
 501     gd->y_advance += y_scale * vr->YAdvance / 0x10000;
 502
 503   if ( !gpi->dvi )
 504   {
 505     /* pixel -> fractional pixel */
 506
 507     if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE )
 508     {
 509       _HB_OPEN_Get_Device( vr->DeviceTables[VR_X_PLACEMENT_DEVICE], x_ppem, &pixel_value );
 510       gd->x_pos += pixel_value << 6;
 511     }
 512     if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE )
 513     {
 514       _HB_OPEN_Get_Device( vr->DeviceTables[VR_Y_PLACEMENT_DEVICE], y_ppem, &pixel_value );
 515       gd->y_pos += pixel_value << 6;
 516     }
 517     if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE )
 518     {
 519       _HB_OPEN_Get_Device( vr->DeviceTables[VR_X_ADVANCE_DEVICE], x_ppem, &pixel_value );
 520       gd->x_advance += pixel_value << 6;
 521     }
 522     if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE )
 523     {
 524       _HB_OPEN_Get_Device( vr->DeviceTables[VR_Y_ADVANCE_DEVICE], y_ppem, &pixel_value );
 525       gd->y_advance += pixel_value << 6;
 526     }
 527   }
 528
 529 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 530   /* values returned from mmfunc() are already in fractional pixels */
 531
 532   if ( format & HB_GPOS_FORMAT_HAVE_X_ID_PLACEMENT )
 533   {
 534     error = (gpos->mmfunc)( gpi->font, vr->XIdPlacement,
 535                             &value, gpos->data );
 536     if ( error )
 537       return error;
 538     gd->x_pos += value;
 539   }
 540   if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_PLACEMENT )
 541   {
 542     error = (gpos->mmfunc)( gpi->font, vr->YIdPlacement,
 543                             &value, gpos->data );
 544     if ( error )
 545       return error;
 546     gd->y_pos += value;
 547   }
 548   if ( format & HB_GPOS_FORMAT_HAVE_X_ID_ADVANCE )
 549   {
 550     error = (gpos->mmfunc)( gpi->font, vr->XIdAdvance,
 551                             &value, gpos->data );
 552     if ( error )
 553       return error;
 554     gd->x_advance += value;
 555   }
 556   if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_ADVANCE )
 557   {
 558     error = (gpos->mmfunc)( gpi->font, vr->YIdAdvance,
 559                             &value, gpos->data );
 560     if ( error )
 561       return error;
 562     gd->y_advance += value;
 563   }
 564 #endif
 565
 566   return error;
 567 }
 568
 569
 570 /* AnchorFormat1 */
 571 /* AnchorFormat2 */
 572 /* AnchorFormat3 */
 573 /* AnchorFormat4 */
 574
 575 static HB_Error  Load_Anchor( HB_Anchor*  an,
 576                               HB_Stream    stream )
 577 {
 578   HB_Error  error;
 579
 580   HB_UInt cur_offset, new_offset, base_offset;
 581
 582
 583   base_offset = FILE_Pos();
 584
 585   if ( ACCESS_Frame( 2L ) )
 586     return error;
 587
 588   an->PosFormat = GET_UShort();
 589
 590   FORGET_Frame();
 591
 592   switch ( an->PosFormat )
 593   {
 594   case 1:
 595     if ( ACCESS_Frame( 4L ) )
 596       return error;
 597
 598     an->af.af1.XCoordinate = GET_Short();
 599     an->af.af1.YCoordinate = GET_Short();
 600
 601     FORGET_Frame();
 602     break;
 603
 604   case 2:
 605     if ( ACCESS_Frame( 6L ) )
 606       return error;
 607
 608     an->af.af2.XCoordinate = GET_Short();
 609     an->af.af2.YCoordinate = GET_Short();
 610     an->af.af2.AnchorPoint = GET_UShort();
 611
 612     FORGET_Frame();
 613     break;
 614
 615   case 3:
 616     if ( ACCESS_Frame( 6L ) )
 617       return error;
 618
 619     an->af.af3.XCoordinate = GET_Short();
 620     an->af.af3.YCoordinate = GET_Short();
 621
 622     new_offset = GET_UShort();
 623
 624     FORGET_Frame();
 625
 626     if ( new_offset )
 627     {
 628       if ( ALLOC_ARRAY( an->af.af3.DeviceTables, 2, HB_Device ) )
 629         return error;
 630
 631       an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] = 0;
 632       an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE] = 0;
 633
 634       new_offset += base_offset;
 635
 636       cur_offset = FILE_Pos();
 637       if ( FILE_Seek( new_offset ) ||
 638            ( error = _HB_OPEN_Load_Device( &an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE],
 639                                   stream ) ) != HB_Err_Ok )
 640         goto Fail2;
 641       (void)FILE_Seek( cur_offset );
 642     }
 643
 644     if ( ACCESS_Frame( 2L ) )
 645       goto Fail;
 646
 647     new_offset = GET_UShort();
 648
 649     FORGET_Frame();
 650
 651     if ( new_offset )
 652     {
 653       if ( !an->af.af3.DeviceTables )
 654       {
 655         if ( ALLOC_ARRAY( an->af.af3.DeviceTables, 2, HB_Device ) )
 656           return error;
 657
 658         an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] = 0;
 659         an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE] = 0;
 660       }
 661
 662       new_offset += base_offset;
 663
 664       cur_offset = FILE_Pos();
 665       if ( FILE_Seek( new_offset ) ||
 666            ( error = _HB_OPEN_Load_Device( &an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE],
 667                                   stream ) ) != HB_Err_Ok )
 668         goto Fail;
 669       (void)FILE_Seek( cur_offset );
 670     }
 671     break;
 672
 673   case 4:
 674     if ( ACCESS_Frame( 4L ) )
 675       return error;
 676
 677 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 678     an->af.af4.XIdAnchor = GET_UShort();
 679     an->af.af4.YIdAnchor = GET_UShort();
 680 #else
 681     (void) GET_UShort();
 682     (void) GET_UShort();
 683 #endif
 684
 685     FORGET_Frame();
 686     break;
 687
 688   default:
 689     return ERR(HB_Err_Invalid_SubTable_Format);
 690   }
 691
 692   return HB_Err_Ok;
 693
 694 Fail:
 695   if ( an->af.af3.DeviceTables )
 696     _HB_OPEN_Free_Device( an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] );
 697
 698 Fail2:
 699   FREE( an->af.af3.DeviceTables );
 700   return error;
 701 }
 702
 703
 704 static void  Free_Anchor( HB_Anchor*  an)
 705 {
 706   if ( an->PosFormat == 3 && an->af.af3.DeviceTables )
 707   {
 708     _HB_OPEN_Free_Device( an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] );
 709     _HB_OPEN_Free_Device( an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE] );
 710     FREE( an->af.af3.DeviceTables );
 711   }
 712 }
 713
 714
 715 static HB_Error  Get_Anchor( GPOS_Instance*   gpi,
 716                              HB_Anchor*      an,
 717                              HB_UShort        glyph_index,
 718                              HB_Fixed*          x_value,
 719                              HB_Fixed*          y_value )
 720 {
 721   HB_Error  error = HB_Err_Ok;
 722
 723 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 724   HB_GPOSHeader*  gpos = gpi->gpos;
 725 #endif
 726   HB_UShort        ap;
 727
 728   HB_Short         pixel_value;
 729
 730   HB_UShort        x_ppem, y_ppem;
 731   HB_16Dot16         x_scale, y_scale;
 732
 733
 734   x_ppem  = gpi->font->x_ppem;
 735   y_ppem  = gpi->font->y_ppem;
 736   x_scale = gpi->font->x_scale;
 737   y_scale = gpi->font->y_scale;
 738
 739   switch ( an->PosFormat )
 740   {
 741   case 0:
 742     /* The special case of an empty AnchorTable */
 743   default:
 744
 745     return HB_Err_Not_Covered;
 746
 747   case 1:
 748     *x_value = x_scale * an->af.af1.XCoordinate / 0x10000;
 749     *y_value = y_scale * an->af.af1.YCoordinate / 0x10000;
 750     break;
 751
 752   case 2:
 753     if ( !gpi->dvi )
 754     {
 755       hb_uint32 n_points = 0;
 756       ap = an->af.af2.AnchorPoint;
 757       if (!gpi->font->klass->getPointInOutline)
 758           goto no_contour_point;
 759       error = gpi->font->klass->getPointInOutline(gpi->font, glyph_index, gpi->load_flags, ap, x_value, y_value, &n_points);
 760       if (error)
 761           return error;
 762       /* if n_points is set to zero, we use the design coordinate value pair.
 763        * This can happen e.g. for sbit glyphs. */
 764       if (!n_points)
 765           goto no_contour_point;
 766     }
 767     else
 768     {
 769     no_contour_point:
 770       *x_value = x_scale * an->af.af3.XCoordinate / 0x10000;
 771       *y_value = y_scale * an->af.af3.YCoordinate / 0x10000;
 772     }
 773     break;
 774
 775   case 3:
 776     if ( !gpi->dvi )
 777     {
 778       _HB_OPEN_Get_Device( an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE], x_ppem, &pixel_value );
 779       *x_value = pixel_value << 6;
 780       _HB_OPEN_Get_Device( an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE], y_ppem, &pixel_value );
 781       *y_value = pixel_value << 6;
 782     }
 783     else
 784       *x_value = *y_value = 0;
 785
 786     *x_value += x_scale * an->af.af3.XCoordinate / 0x10000;
 787     *y_value += y_scale * an->af.af3.YCoordinate / 0x10000;
 788     break;
 789
 790   case 4:
 791 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 792     error = (gpos->mmfunc)( gpi->font, an->af.af4.XIdAnchor,
 793                             x_value, gpos->data );
 794     if ( error )
 795       return error;
 796
 797     error = (gpos->mmfunc)( gpi->font, an->af.af4.YIdAnchor,
 798                             y_value, gpos->data );
 799     if ( error )
 800       return error;
 801     break;
 802 #else
 803     return ERR(HB_Err_Not_Covered);
 804 #endif
 805   }
 806
 807   return error;
 808 }
 809
 810
 811 /* MarkArray */
 812
 813 static HB_Error  Load_MarkArray ( HB_MarkArray*  ma,
 814                                   HB_Stream       stream )
 815 {
 816   HB_Error  error;
 817
 818   HB_UShort        n, m, count;
 819   HB_UInt         cur_offset, new_offset, base_offset;
 820
 821   HB_MarkRecord*  mr;
 822
 823
 824   base_offset = FILE_Pos();
 825
 826   if ( ACCESS_Frame( 2L ) )
 827     return error;
 828
 829   count = ma->MarkCount = GET_UShort();
 830
 831   FORGET_Frame();
 832
 833   ma->MarkRecord = NULL;
 834
 835   if ( ALLOC_ARRAY( ma->MarkRecord, count, HB_MarkRecord ) )
 836     return error;
 837
 838   mr = ma->MarkRecord;
 839
 840   for ( n = 0; n < count; n++ )
 841   {
 842     if ( ACCESS_Frame( 4L ) )
 843       goto Fail;
 844
 845     mr[n].Class = GET_UShort();
 846     new_offset  = GET_UShort() + base_offset;
 847
 848     FORGET_Frame();
 849
 850     cur_offset = FILE_Pos();
 851     if ( FILE_Seek( new_offset ) ||
 852          ( error = Load_Anchor( &mr[n].MarkAnchor, stream ) ) != HB_Err_Ok )
 853       goto Fail;
 854     (void)FILE_Seek( cur_offset );
 855   }
 856
 857   return HB_Err_Ok;
 858
 859 Fail:
 860   for ( m = 0; m < n; m++ )
 861     Free_Anchor( &mr[m].MarkAnchor );
 862
 863   FREE( mr );
 864   return error;
 865 }
 866
 867
 868 static void  Free_MarkArray( HB_MarkArray*  ma )
 869 {
 870   HB_UShort        n, count;
 871
 872   HB_MarkRecord*  mr;
 873
 874
 875   if ( ma->MarkRecord )
 876   {
 877     count = ma->MarkCount;
 878     mr    = ma->MarkRecord;
 879
 880     for ( n = 0; n < count; n++ )
 881       Free_Anchor( &mr[n].MarkAnchor );
 882
 883     FREE( mr );
 884   }
 885 }
 886
 887
 888 /* LookupType 1 */
 889
 890 /* SinglePosFormat1 */
 891 /* SinglePosFormat2 */
 892
 893 static HB_Error  Load_SinglePos( HB_GPOS_SubTable* st,
 894                                  HB_Stream       stream )
 895 {
 896   HB_Error  error;
 897   HB_SinglePos*   sp = &st->single;
 898
 899   HB_UShort         n, m, count, format;
 900   HB_UInt          cur_offset, new_offset, base_offset;
 901
 902   HB_ValueRecord*  vr;
 903
 904
 905   base_offset = FILE_Pos();
 906
 907   if ( ACCESS_Frame( 6L ) )
 908     return error;
 909
 910   sp->PosFormat = GET_UShort();
 911   new_offset    = GET_UShort() + base_offset;
 912
 913   format = sp->ValueFormat = GET_UShort();
 914
 915   FORGET_Frame();
 916
 917   if ( !format )
 918     return ERR(HB_Err_Invalid_SubTable);
 919
 920   cur_offset = FILE_Pos();
 921   if ( FILE_Seek( new_offset ) ||
 922        ( error = _HB_OPEN_Load_Coverage( &sp->Coverage, stream ) ) != HB_Err_Ok )
 923     return error;
 924   (void)FILE_Seek( cur_offset );
 925
 926   switch ( sp->PosFormat )
 927   {
 928   case 1:
 929     error = Load_ValueRecord( &sp->spf.spf1.Value, format,
 930                               base_offset, stream );
 931     if ( error )
 932       goto Fail2;
 933     break;
 934
 935   case 2:
 936     if ( ACCESS_Frame( 2L ) )
 937       goto Fail2;
 938
 939     count = sp->spf.spf2.ValueCount = GET_UShort();
 940
 941     FORGET_Frame();
 942
 943     sp->spf.spf2.Value = NULL;
 944
 945     if ( ALLOC_ARRAY( sp->spf.spf2.Value, count, HB_ValueRecord ) )
 946       goto Fail2;
 947
 948     vr = sp->spf.spf2.Value;
 949
 950     for ( n = 0; n < count; n++ )
 951     {
 952       error = Load_ValueRecord( &vr[n], format, base_offset, stream );
 953       if ( error )
 954         goto Fail1;
 955     }
 956     break;
 957
 958   default:
 959     return ERR(HB_Err_Invalid_SubTable_Format);
 960   }
 961
 962   return HB_Err_Ok;
 963
 964 Fail1:
 965   for ( m = 0; m < n; m++ )
 966     Free_ValueRecord( &vr[m], format );
 967
 968   FREE( vr );
 969
 970 Fail2:
 971   _HB_OPEN_Free_Coverage( &sp->Coverage );
 972   return error;
 973 }
 974
 975
 976 static void  Free_SinglePos( HB_GPOS_SubTable* st )
 977 {
 978   HB_UShort         n, count, format;
 979   HB_SinglePos*   sp = &st->single;
 980
 981   HB_ValueRecord*  v;
 982
 983
 984   format = sp->ValueFormat;
 985
 986   switch ( sp->PosFormat )
 987   {
 988   case 1:
 989     Free_ValueRecord( &sp->spf.spf1.Value, format );
 990     break;
 991
 992   case 2:
 993     if ( sp->spf.spf2.Value )
 994     {
 995       count = sp->spf.spf2.ValueCount;
 996       v     = sp->spf.spf2.Value;
 997
 998       for ( n = 0; n < count; n++ )
 999         Free_ValueRecord( &v[n], format );
1000
1001       FREE( v );
1002     }
1003     break;
1004   default:
1005     break;
1006   }
1007
1008   _HB_OPEN_Free_Coverage( &sp->Coverage );
1009 }
1010
1011 static HB_Error  Lookup_SinglePos( GPOS_Instance*    gpi,
1012                                    HB_GPOS_SubTable* st,
1013                                    HB_Buffer        buffer,
1014                                    HB_UShort         flags,
1015                                    HB_UShort         context_length,
1016                                    int               nesting_level )
1017 {
1018   HB_UShort        index, property;
1019   HB_Error         error;
1020   HB_GPOSHeader*  gpos = gpi->gpos;
1021   HB_SinglePos*   sp = &st->single;
1022
1023   HB_UNUSED(nesting_level);
1024
1025   if ( context_length != 0xFFFF && context_length < 1 )
1026     return HB_Err_Not_Covered;
1027
1028   if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) )
1029     return error;
1030
1031   error = _HB_OPEN_Coverage_Index( &sp->Coverage, IN_CURGLYPH(), &index );
1032   if ( error )
1033     return error;
1034
1035   switch ( sp->PosFormat )
1036   {
1037   case 1:
1038     error = Get_ValueRecord( gpi, &sp->spf.spf1.Value,
1039                              sp->ValueFormat, POSITION( buffer->in_pos ) );
1040     if ( error )
1041       return error;
1042     break;
1043
1044   case 2:
1045     if ( index >= sp->spf.spf2.ValueCount )
1046       return ERR(HB_Err_Invalid_SubTable);
1047     error = Get_ValueRecord( gpi, &sp->spf.spf2.Value[index],
1048                              sp->ValueFormat, POSITION( buffer->in_pos ) );
1049     if ( error )
1050       return error;
1051     break;
1052
1053   default:
1054     return ERR(HB_Err_Invalid_SubTable);
1055   }
1056
1057   (buffer->in_pos)++;
1058
1059   return HB_Err_Ok;
1060 }
1061
1062
1063 /* LookupType 2 */
1064
1065 /* PairSet */
1066
1067 static HB_Error  Load_PairSet ( HB_PairSet*  ps,
1068                                 HB_UShort     format1,
1069                                 HB_UShort     format2,
1070                                 HB_Stream     stream )
1071 {
1072   HB_Error  error;
1073
1074   HB_UShort             n, m, count;
1075   HB_UInt              base_offset;
1076
1077   HB_PairValueRecord*  pvr;
1078
1079
1080   base_offset = FILE_Pos();
1081
1082   if ( ACCESS_Frame( 2L ) )
1083     return error;
1084
1085   count = ps->PairValueCount = GET_UShort();
1086
1087   FORGET_Frame();
1088
1089   ps->PairValueRecord = NULL;
1090
1091   if ( ALLOC_ARRAY( ps->PairValueRecord, count, HB_PairValueRecord ) )
1092     return error;
1093
1094   pvr = ps->PairValueRecord;
1095
1096   for ( n = 0; n < count; n++ )
1097   {
1098     if ( ACCESS_Frame( 2L ) )
1099       goto Fail;
1100
1101     pvr[n].SecondGlyph = GET_UShort();
1102
1103     FORGET_Frame();
1104
1105     if ( format1 )
1106     {
1107       error = Load_ValueRecord( &pvr[n].Value1, format1,
1108                                 base_offset, stream );
1109       if ( error )
1110         goto Fail;
1111     }
1112     if ( format2 )
1113     {
1114       error = Load_ValueRecord( &pvr[n].Value2, format2,
1115                                 base_offset, stream );
1116       if ( error )
1117       {
1118         if ( format1 )
1119           Free_ValueRecord( &pvr[n].Value1, format1 );
1120         goto Fail;
1121       }
1122     }
1123   }
1124
1125   return HB_Err_Ok;
1126
1127 Fail:
1128   for ( m = 0; m < n; m++ )
1129   {
1130     if ( format1 )
1131       Free_ValueRecord( &pvr[m].Value1, format1 );
1132     if ( format2 )
1133       Free_ValueRecord( &pvr[m].Value2, format2 );
1134   }
1135
1136   FREE( pvr );
1137   return error;
1138 }
1139
1140
1141 static void  Free_PairSet( HB_PairSet*  ps,
1142                            HB_UShort     format1,
1143                            HB_UShort     format2 )
1144 {
1145   HB_UShort             n, count;
1146
1147   HB_PairValueRecord*  pvr;
1148
1149
1150   if ( ps->PairValueRecord )
1151   {
1152     count = ps->PairValueCount;
1153     pvr   = ps->PairValueRecord;
1154
1155     for ( n = 0; n < count; n++ )
1156     {
1157       if ( format1 )
1158         Free_ValueRecord( &pvr[n].Value1, format1 );
1159       if ( format2 )
1160         Free_ValueRecord( &pvr[n].Value2, format2 );
1161     }
1162
1163     FREE( pvr );
1164   }
1165 }
1166
1167
1168 /* PairPosFormat1 */
1169
1170 static HB_Error  Load_PairPos1( HB_PairPosFormat1*  ppf1,
1171                                 HB_UShort            format1,
1172                                 HB_UShort            format2,
1173                                 HB_Stream            stream )
1174 {
1175   HB_Error  error;
1176
1177   HB_UShort     n, m, count;
1178   HB_UInt      cur_offset, new_offset, base_offset;
1179
1180   HB_PairSet*  ps;
1181
1182
1183   base_offset = FILE_Pos() - 8L;
1184
1185   if ( ACCESS_Frame( 2L ) )
1186     return error;
1187
1188   count = ppf1->PairSetCount = GET_UShort();
1189
1190   FORGET_Frame();
1191
1192   ppf1->PairSet = NULL;
1193
1194   if ( ALLOC_ARRAY( ppf1->PairSet, count, HB_PairSet ) )
1195     return error;
1196
1197   ps = ppf1->PairSet;
1198
1199   for ( n = 0; n < count; n++ )
1200   {
1201     if ( ACCESS_Frame( 2L ) )
1202       goto Fail;
1203
1204     new_offset = GET_UShort() + base_offset;
1205
1206     FORGET_Frame();
1207
1208     cur_offset = FILE_Pos();
1209     if ( FILE_Seek( new_offset ) ||
1210          ( error = Load_PairSet( &ps[n], format1,
1211                                  format2, stream ) ) != HB_Err_Ok )
1212       goto Fail;
1213     (void)FILE_Seek( cur_offset );
1214   }
1215
1216   return HB_Err_Ok;
1217
1218 Fail:
1219   for ( m = 0; m < n; m++ )
1220     Free_PairSet( &ps[m], format1, format2 );
1221
1222   FREE( ps );
1223   return error;
1224 }
1225
1226
1227 static void  Free_PairPos1( HB_PairPosFormat1*  ppf1,
1228                             HB_UShort            format1,
1229                             HB_UShort            format2 )
1230 {
1231   HB_UShort     n, count;
1232
1233   HB_PairSet*  ps;
1234
1235
1236   if ( ppf1->PairSet )
1237   {
1238     count = ppf1->PairSetCount;
1239     ps    = ppf1->PairSet;
1240
1241     for ( n = 0; n < count; n++ )
1242       Free_PairSet( &ps[n], format1, format2 );
1243
1244     FREE( ps );
1245   }
1246 }
1247
1248
1249 /* PairPosFormat2 */
1250
1251 static HB_Error  Load_PairPos2( HB_PairPosFormat2*  ppf2,
1252                                 HB_UShort            format1,
1253                                 HB_UShort            format2,
1254                                 HB_Stream            stream )
1255 {
1256   HB_Error  error;
1257
1258   HB_UShort          m, n, k, count1, count2;
1259   HB_UInt           cur_offset, new_offset1, new_offset2, base_offset;
1260
1261   HB_Class1Record*  c1r;
1262   HB_Class2Record*  c2r;
1263
1264
1265   base_offset = FILE_Pos() - 8L;
1266
1267   if ( ACCESS_Frame( 8L ) )
1268     return error;
1269
1270   new_offset1 = GET_UShort() + base_offset;
1271   new_offset2 = GET_UShort() + base_offset;
1272
1273   /* `Class1Count' and `Class2Count' are the upper limits for class
1274      values, thus we read it now to make additional safety checks.  */
1275
1276   count1 = ppf2->Class1Count = GET_UShort();
1277   count2 = ppf2->Class2Count = GET_UShort();
1278
1279   FORGET_Frame();
1280
1281   cur_offset = FILE_Pos();
1282   if ( FILE_Seek( new_offset1 ) ||
1283        ( error = _HB_OPEN_Load_ClassDefinition( &ppf2->ClassDef1, count1,
1284                                        stream ) ) != HB_Err_Ok )
1285     return error;
1286   if ( FILE_Seek( new_offset2 ) ||
1287        ( error = _HB_OPEN_Load_ClassDefinition( &ppf2->ClassDef2, count2,
1288                                        stream ) ) != HB_Err_Ok )
1289     goto Fail3;
1290   (void)FILE_Seek( cur_offset );
1291
1292   ppf2->Class1Record = NULL;
1293
1294   if ( ALLOC_ARRAY( ppf2->Class1Record, count1, HB_Class1Record ) )
1295     goto Fail2;
1296
1297   c1r = ppf2->Class1Record;
1298
1299   for ( m = 0; m < count1; m++ )
1300   {
1301     c1r[m].Class2Record = NULL;
1302
1303     if ( ALLOC_ARRAY( c1r[m].Class2Record, count2, HB_Class2Record ) )
1304       goto Fail1;
1305
1306     c2r = c1r[m].Class2Record;
1307
1308     for ( n = 0; n < count2; n++ )
1309     {
1310       if ( format1 )
1311       {
1312         error = Load_ValueRecord( &c2r[n].Value1, format1,
1313                                   base_offset, stream );
1314         if ( error )
1315           goto Fail0;
1316       }
1317       if ( format2 )
1318       {
1319         error = Load_ValueRecord( &c2r[n].Value2, format2,
1320                                   base_offset, stream );
1321         if ( error )
1322         {
1323           if ( format1 )
1324             Free_ValueRecord( &c2r[n].Value1, format1 );
1325           goto Fail0;
1326         }
1327       }
1328     }
1329
1330     continue;
1331
1332   Fail0:
1333     for ( k = 0; k < n; k++ )
1334     {
1335       if ( format1 )
1336         Free_ValueRecord( &c2r[k].Value1, format1 );
1337       if ( format2 )
1338         Free_ValueRecord( &c2r[k].Value2, format2 );
1339     }
1340     goto Fail1;
1341   }
1342
1343   return HB_Err_Ok;
1344
1345 Fail1:
1346   for ( k = 0; k < m; k++ )
1347   {
1348     c2r = c1r[k].Class2Record;
1349
1350     for ( n = 0; n < count2; n++ )
1351     {
1352       if ( format1 )
1353         Free_ValueRecord( &c2r[n].Value1, format1 );
1354       if ( format2 )
1355         Free_ValueRecord( &c2r[n].Value2, format2 );
1356     }
1357
1358     FREE( c2r );
1359   }
1360
1361   FREE( c1r );
1362 Fail2:
1363
1364   _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef2 );
1365
1366 Fail3:
1367   _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef1 );
1368   return error;
1369 }
1370
1371
1372 static void  Free_PairPos2( HB_PairPosFormat2*  ppf2,
1373                             HB_UShort            format1,
1374                             HB_UShort            format2)
1375 {
1376   HB_UShort          m, n, count1, count2;
1377
1378   HB_Class1Record*  c1r;
1379   HB_Class2Record*  c2r;
1380
1381
1382   if ( ppf2->Class1Record )
1383   {
1384     c1r    = ppf2->Class1Record;
1385     count1 = ppf2->Class1Count;
1386     count2 = ppf2->Class2Count;
1387
1388     for ( m = 0; m < count1; m++ )
1389     {
1390       c2r = c1r[m].Class2Record;
1391
1392       for ( n = 0; n < count2; n++ )
1393       {
1394         if ( format1 )
1395           Free_ValueRecord( &c2r[n].Value1, format1 );
1396         if ( format2 )
1397           Free_ValueRecord( &c2r[n].Value2, format2 );
1398       }
1399
1400       FREE( c2r );
1401     }
1402
1403     FREE( c1r );
1404
1405     _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef2 );
1406     _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef1 );
1407   }
1408 }
1409
1410
1411 static HB_Error  Load_PairPos( HB_GPOS_SubTable* st,
1412                                HB_Stream     stream )
1413 {
1414   HB_Error  error;
1415   HB_PairPos*     pp = &st->pair;
1416
1417   HB_UShort         format1, format2;
1418   HB_UInt          cur_offset, new_offset, base_offset;
1419
1420
1421   base_offset = FILE_Pos();
1422
1423   if ( ACCESS_Frame( 8L ) )
1424     return error;
1425
1426   pp->PosFormat = GET_UShort();
1427   new_offset    = GET_UShort() + base_offset;
1428
1429   format1 = pp->ValueFormat1 = GET_UShort();
1430   format2 = pp->ValueFormat2 = GET_UShort();
1431
1432   FORGET_Frame();
1433
1434   cur_offset = FILE_Pos();
1435   if ( FILE_Seek( new_offset ) ||
1436        ( error = _HB_OPEN_Load_Coverage( &pp->Coverage, stream ) ) != HB_Err_Ok )
1437     return error;
1438   (void)FILE_Seek( cur_offset );
1439
1440   switch ( pp->PosFormat )
1441   {
1442   case 1:
1443     error = Load_PairPos1( &pp->ppf.ppf1, format1, format2, stream );
1444     if ( error )
1445       goto Fail;
1446     break;
1447
1448   case 2:
1449     error = Load_PairPos2( &pp->ppf.ppf2, format1, format2, stream );
1450     if ( error )
1451       goto Fail;
1452     break;
1453
1454   default:
1455     return ERR(HB_Err_Invalid_SubTable_Format);
1456   }
1457
1458   return HB_Err_Ok;
1459
1460 Fail:
1461   _HB_OPEN_Free_Coverage( &pp->Coverage );
1462   return error;
1463 }
1464
1465
1466 static void  Free_PairPos( HB_GPOS_SubTable* st )
1467 {
1468   HB_UShort  format1, format2;
1469   HB_PairPos*     pp = &st->pair;
1470
1471
1472   format1 = pp->ValueFormat1;
1473   format2 = pp->ValueFormat2;
1474
1475   switch ( pp->PosFormat )
1476   {
1477   case 1:
1478     Free_PairPos1( &pp->ppf.ppf1, format1, format2 );
1479     break;
1480
1481   case 2:
1482     Free_PairPos2( &pp->ppf.ppf2, format1, format2 );
1483     break;
1484
1485   default:
1486     break;
1487   }
1488
1489   _HB_OPEN_Free_Coverage( &pp->Coverage );
1490 }
1491
1492
1493 static HB_Error  Lookup_PairPos1( GPOS_Instance*       gpi,
1494                                   HB_PairPosFormat1*  ppf1,
1495                                   HB_Buffer           buffer,
1496                                   HB_UInt              first_pos,
1497                                   HB_UShort            index,
1498                                   HB_UShort            format1,
1499                                   HB_UShort            format2 )
1500 {
1501   HB_Error              error;
1502   HB_UShort             numpvr, glyph2;
1503
1504   HB_PairValueRecord*  pvr;
1505
1506
1507   if ( index >= ppf1->PairSetCount )
1508      return ERR(HB_Err_Invalid_SubTable);
1509
1510   pvr = ppf1->PairSet[index].PairValueRecord;
1511   if ( !pvr )
1512     return ERR(HB_Err_Invalid_SubTable);
1513
1514   glyph2 = IN_CURGLYPH();
1515
1516   for ( numpvr = ppf1->PairSet[index].PairValueCount;
1517         numpvr;
1518         numpvr--, pvr++ )
1519   {
1520     if ( glyph2 == pvr->SecondGlyph )
1521     {
1522       error = Get_ValueRecord( gpi, &pvr->Value1, format1,
1523                                POSITION( first_pos ) );
1524       if ( error )
1525         return error;
1526       return Get_ValueRecord( gpi, &pvr->Value2, format2,
1527                               POSITION( buffer->in_pos ) );
1528     }
1529   }
1530
1531   return HB_Err_Not_Covered;
1532 }
1533
1534
1535 static HB_Error  Lookup_PairPos2( GPOS_Instance*       gpi,
1536                                   HB_PairPosFormat2*  ppf2,
1537                                   HB_Buffer           buffer,
1538                                   HB_UInt              first_pos,
1539                                   HB_UShort            format1,
1540                                   HB_UShort            format2 )
1541 {
1542   HB_Error           error;
1543   HB_UShort          cl1 = 0, cl2 = 0; /* shut compiler up */
1544
1545   HB_Class1Record*  c1r;
1546   HB_Class2Record*  c2r;
1547
1548
1549   error = _HB_OPEN_Get_Class( &ppf2->ClassDef1, IN_GLYPH( first_pos ),
1550                      &cl1, NULL );
1551   if ( error && error != HB_Err_Not_Covered )
1552     return error;
1553   error = _HB_OPEN_Get_Class( &ppf2->ClassDef2, IN_CURGLYPH(),
1554                      &cl2, NULL );
1555   if ( error && error != HB_Err_Not_Covered )
1556     return error;
1557
1558   c1r = &ppf2->Class1Record[cl1];
1559   if ( !c1r )
1560     return ERR(HB_Err_Invalid_SubTable);
1561   c2r = &c1r->Class2Record[cl2];
1562
1563   error = Get_ValueRecord( gpi, &c2r->Value1, format1, POSITION( first_pos ) );
1564   if ( error )
1565     return error;
1566   return Get_ValueRecord( gpi, &c2r->Value2, format2, POSITION( buffer->in_pos ) );
1567 }
1568
1569
1570 static HB_Error  Lookup_PairPos( GPOS_Instance*    gpi,
1571                                  HB_GPOS_SubTable* st,
1572                                  HB_Buffer        buffer,
1573                                  HB_UShort         flags,
1574                                  HB_UShort         context_length,
1575                                  int               nesting_level )
1576 {
1577   HB_Error         error;
1578   HB_UShort        index, property;
1579   HB_UInt          first_pos;
1580   HB_GPOSHeader*  gpos = gpi->gpos;
1581   HB_PairPos*     pp = &st->pair;
1582
1583   HB_UNUSED(nesting_level);
1584
1585   if ( buffer->in_pos >= buffer->in_length - 1 )
1586     return HB_Err_Not_Covered;           /* Not enough glyphs in stream */
1587
1588   if ( context_length != 0xFFFF && context_length < 2 )
1589     return HB_Err_Not_Covered;
1590
1591   if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) )
1592     return error;
1593
1594   error = _HB_OPEN_Coverage_Index( &pp->Coverage, IN_CURGLYPH(), &index );
1595   if ( error )
1596     return error;
1597
1598   /* second glyph */
1599
1600   first_pos = buffer->in_pos;
1601   (buffer->in_pos)++;
1602
1603   while ( CHECK_Property( gpos->gdef, IN_CURITEM(),
1604                           flags, &property ) )
1605   {
1606     if ( error && error != HB_Err_Not_Covered )
1607       return error;
1608
1609     if ( buffer->in_pos == buffer->in_length )
1610       {
1611         buffer->in_pos = first_pos;
1612         return HB_Err_Not_Covered;
1613       }
1614     (buffer->in_pos)++;
1615
1616   }
1617
1618   switch ( pp->PosFormat )
1619   {
1620   case 1:
1621     error = Lookup_PairPos1( gpi, &pp->ppf.ppf1, buffer,
1622                              first_pos, index,
1623                              pp->ValueFormat1, pp->ValueFormat2 );
1624     break;
1625
1626   case 2:
1627     error = Lookup_PairPos2( gpi, &pp->ppf.ppf2, buffer, first_pos,
1628                              pp->ValueFormat1, pp->ValueFormat2 );
1629     break;
1630
1631   default:
1632     return ERR(HB_Err_Invalid_SubTable_Format);
1633   }
1634
1635   /* if we don't have coverage for the second glyph don't skip it for
1636      further lookups but reset in_pos back to the first_glyph and let
1637      the caller in Do_String_Lookup increment in_pos */
1638   if ( error == HB_Err_Not_Covered )
1639       buffer->in_pos = first_pos;
1640
1641   /* adjusting the `next' glyph */
1642
1643   if ( pp->ValueFormat2 )
1644     (buffer->in_pos)++;
1645
1646   return error;
1647 }
1648
1649
1650 /* LookupType 3 */
1651
1652 /* CursivePosFormat1 */
1653
1654 static HB_Error  Load_CursivePos( HB_GPOS_SubTable* st,
1655                                   HB_Stream        stream )
1656 {
1657   HB_Error  error;
1658   HB_CursivePos*  cp = &st->cursive;
1659
1660   HB_UShort             n, m, count;
1661   HB_UInt              cur_offset, new_offset, base_offset;
1662
1663   HB_EntryExitRecord*  eer;
1664
1665
1666   base_offset = FILE_Pos();
1667
1668   if ( ACCESS_Frame( 4L ) )
1669     return error;
1670
1671   cp->PosFormat = GET_UShort();
1672   new_offset    = GET_UShort() + base_offset;
1673
1674   FORGET_Frame();
1675
1676   cur_offset = FILE_Pos();
1677   if ( FILE_Seek( new_offset ) ||
1678        ( error = _HB_OPEN_Load_Coverage( &cp->Coverage, stream ) ) != HB_Err_Ok )
1679     return error;
1680   (void)FILE_Seek( cur_offset );
1681
1682   if ( ACCESS_Frame( 2L ) )
1683     goto Fail2;
1684
1685   count = cp->EntryExitCount = GET_UShort();
1686
1687   FORGET_Frame();
1688
1689   cp->EntryExitRecord = NULL;
1690
1691   if ( ALLOC_ARRAY( cp->EntryExitRecord, count, HB_EntryExitRecord ) )
1692     goto Fail2;
1693
1694   eer = cp->EntryExitRecord;
1695
1696   for ( n = 0; n < count; n++ )
1697   {
1698     HB_UInt entry_offset;
1699
1700     if ( ACCESS_Frame( 2L ) )
1701       return error;
1702
1703     entry_offset = new_offset = GET_UShort();
1704
1705     FORGET_Frame();
1706
1707     if ( new_offset )
1708     {
1709       new_offset += base_offset;
1710
1711       cur_offset = FILE_Pos();
1712       if ( FILE_Seek( new_offset ) ||
1713            ( error = Load_Anchor( &eer[n].EntryAnchor,
1714                                   stream ) ) != HB_Err_Ok )
1715         goto Fail1;
1716       (void)FILE_Seek( cur_offset );
1717     }
1718     else
1719       eer[n].EntryAnchor.PosFormat   = 0;
1720
1721     if ( ACCESS_Frame( 2L ) )
1722       return error;
1723
1724     new_offset = GET_UShort();
1725
1726     FORGET_Frame();
1727
1728     if ( new_offset )
1729     {
1730       new_offset += base_offset;
1731
1732       cur_offset = FILE_Pos();
1733       if ( FILE_Seek( new_offset ) ||
1734            ( error = Load_Anchor( &eer[n].ExitAnchor,
1735                                   stream ) ) != HB_Err_Ok )
1736       {
1737         if ( entry_offset )
1738           Free_Anchor( &eer[n].EntryAnchor );
1739         goto Fail1;
1740       }
1741       (void)FILE_Seek( cur_offset );
1742     }
1743     else
1744       eer[n].ExitAnchor.PosFormat   = 0;
1745   }
1746
1747   return HB_Err_Ok;
1748
1749 Fail1:
1750   for ( m = 0; m < n; m++ )
1751   {
1752     Free_Anchor( &eer[m].EntryAnchor );
1753     Free_Anchor( &eer[m].ExitAnchor );
1754   }
1755
1756   FREE( eer );
1757
1758 Fail2:
1759   _HB_OPEN_Free_Coverage( &cp->Coverage );
1760   return error;
1761 }
1762
1763
1764 static void  Free_CursivePos( HB_GPOS_SubTable* st )
1765 {
1766   HB_UShort             n, count;
1767   HB_CursivePos*  cp = &st->cursive;
1768
1769   HB_EntryExitRecord*  eer;
1770
1771
1772   if ( cp->EntryExitRecord )
1773   {
1774     count = cp->EntryExitCount;
1775     eer   = cp->EntryExitRecord;
1776
1777     for ( n = 0; n < count; n++ )
1778     {
1779       Free_Anchor( &eer[n].EntryAnchor );
1780       Free_Anchor( &eer[n].ExitAnchor );
1781     }
1782
1783     FREE( eer );
1784   }
1785
1786   _HB_OPEN_Free_Coverage( &cp->Coverage );
1787 }
1788
1789
1790 static HB_Error  Lookup_CursivePos( GPOS_Instance*    gpi,
1791                                     HB_GPOS_SubTable* st,
1792                                     HB_Buffer        buffer,
1793                                     HB_UShort         flags,
1794                                     HB_UShort         context_length,
1795                                     int               nesting_level )
1796 {
1797   HB_UShort        index, property;
1798   HB_Error         error;
1799   HB_GPOSHeader*  gpos = gpi->gpos;
1800   HB_CursivePos*  cp = &st->cursive;
1801
1802   HB_EntryExitRecord*  eer;
1803   HB_Fixed                entry_x, entry_y;
1804   HB_Fixed                exit_x, exit_y;
1805
1806   HB_UNUSED(nesting_level);
1807
1808   if ( context_length != 0xFFFF && context_length < 1 )
1809   {
1810     gpi->last = 0xFFFF;
1811     return HB_Err_Not_Covered;
1812   }
1813
1814   /* Glyphs not having the right GDEF properties will be ignored, i.e.,
1815      gpi->last won't be reset (contrary to user defined properties). */
1816
1817   if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) )
1818     return error;
1819
1820   /* We don't handle mark glyphs here.  According to Andrei, this isn't
1821      possible, but who knows...                                         */
1822
1823   if ( property == HB_GDEF_MARK )
1824   {
1825     gpi->last = 0xFFFF;
1826     return HB_Err_Not_Covered;
1827   }
1828
1829   error = _HB_OPEN_Coverage_Index( &cp->Coverage, IN_CURGLYPH(), &index );
1830   if ( error )
1831   {
1832     gpi->last = 0xFFFF;
1833     return error;
1834   }
1835
1836   if ( index >= cp->EntryExitCount )
1837     return ERR(HB_Err_Invalid_SubTable);
1838
1839   eer = &cp->EntryExitRecord[index];
1840
1841   /* Now comes the messiest part of the whole OpenType
1842      specification.  At first glance, cursive connections seem easy
1843      to understand, but there are pitfalls!  The reason is that
1844      the specs don't mention how to compute the advance values
1845      resp. glyph offsets.  I was told it would be an omission, to
1846      be fixed in the next OpenType version...  Again many thanks to
1847      Andrei Burago <andreib@microsoft.com> for clarifications.
1848
1849      Consider the following example:
1850
1851                       |  xadv1    |
1852                        +---------+
1853                        |         |
1854                  +-----+--+ 1    |
1855                  |     | .|      |
1856                  |    0+--+------+
1857                  |   2    |
1858                  |        |
1859                 0+--------+
1860                 |  xadv2   |
1861
1862        glyph1: advance width = 12
1863                anchor point = (3,1)
1864
1865        glyph2: advance width = 11
1866                anchor point = (9,4)
1867
1868        LSB is 1 for both glyphs (so the boxes drawn above are glyph
1869        bboxes).  Writing direction is R2L; `0' denotes the glyph's
1870        coordinate origin.
1871
1872      Now the surprising part: The advance width of the *left* glyph
1873      (resp. of the *bottom* glyph) will be modified, no matter
1874      whether the writing direction is L2R or R2L (resp. T2B or
1875      B2T)!  This assymetry is caused by the fact that the glyph's
1876      coordinate origin is always the lower left corner for all
1877      writing directions.
1878
1879      Continuing the above example, we can compute the new
1880      (horizontal) advance width of glyph2 as
1881
1882        9 - 3 = 6  ,
1883
1884      and the new vertical offset of glyph2 as
1885
1886        1 - 4 = -3  .
1887
1888
1889      Vertical writing direction is far more complicated:
1890
1891      a) Assuming that we recompute the advance height of the lower glyph:
1892
1893                                   --
1894                        +---------+
1895               --       |         |
1896                  +-----+--+ 1    | yadv1
1897                  |     | .|      |
1898            yadv2 |    0+--+------+        -- BSB1  --
1899                  |   2    |       --      --        y_offset
1900                  |        |
1901    BSB2 --      0+--------+                        --
1902         --    --
1903
1904        glyph1: advance height = 6
1905                anchor point = (3,1)
1906
1907        glyph2: advance height = 7
1908                anchor point = (9,4)
1909
1910        TSB is 1 for both glyphs; writing direction is T2B.
1911
1912
1913          BSB1     = yadv1 - (TSB1 + ymax1)
1914          BSB2     = yadv2 - (TSB2 + ymax2)
1915          y_offset = y2 - y1
1916
1917        vertical advance width of glyph2
1918          = y_offset + BSB2 - BSB1
1919          = (y2 - y1) + (yadv2 - (TSB2 + ymax2)) - (yadv1 - (TSB1 + ymax1))
1920          = y2 - y1 + yadv2 - TSB2 - ymax2 - (yadv1 - TSB1 - ymax1)
1921          = y2 - y1 + yadv2 - TSB2 - ymax2 - yadv1 + TSB1 + ymax1
1922
1923
1924      b) Assuming that we recompute the advance height of the upper glyph:
1925
1926                                   --      --
1927                        +---------+        -- TSB1
1928         --    --       |         |
1929    TSB2 --       +-----+--+ 1    | yadv1   ymax1
1930                  |     | .|      |
1931            yadv2 |    0+--+------+        --       --
1932     ymax2        |   2    |       --                y_offset
1933                  |        |
1934         --      0+--------+                        --
1935               --
1936
1937        glyph1: advance height = 6
1938                anchor point = (3,1)
1939
1940        glyph2: advance height = 7
1941                anchor point = (9,4)
1942
1943        TSB is 1 for both glyphs; writing direction is T2B.
1944
1945        y_offset = y2 - y1
1946
1947        vertical advance width of glyph2
1948          = TSB1 + ymax1 + y_offset - (TSB2 + ymax2)
1949          = TSB1 + ymax1 + y2 - y1 - TSB2 - ymax2
1950
1951
1952      Comparing a) with b) shows that b) is easier to compute.  I'll wait
1953      for a reply from Andrei to see what should really be implemented...
1954
1955      Since horizontal advance widths or vertical advance heights
1956      can be used alone but not together, no ambiguity occurs.        */
1957
1958   if ( gpi->last == 0xFFFF )
1959     goto end;
1960
1961   /* Get_Anchor() returns HB_Err_Not_Covered if there is no anchor
1962      table.                                                         */
1963
1964   error = Get_Anchor( gpi, &eer->EntryAnchor, IN_CURGLYPH(),
1965                       &entry_x, &entry_y );
1966   if ( error == HB_Err_Not_Covered )
1967     goto end;
1968   if ( error )
1969     return error;
1970
1971   if ( gpi->r2l )
1972   {
1973     POSITION( buffer->in_pos )->x_advance   = entry_x - gpi->anchor_x;
1974     POSITION( buffer->in_pos )->new_advance = TRUE;
1975   }
1976   else
1977   {
1978     POSITION( gpi->last )->x_advance   = gpi->anchor_x - entry_x;
1979     POSITION( gpi->last )->new_advance = TRUE;
1980   }
1981
1982   if ( flags & HB_LOOKUP_FLAG_RIGHT_TO_LEFT )
1983   {
1984     POSITION( gpi->last )->cursive_chain = gpi->last - buffer->in_pos;
1985     POSITION( gpi->last )->y_pos = entry_y - gpi->anchor_y;
1986   }
1987   else
1988   {
1989     POSITION( buffer->in_pos )->cursive_chain = buffer->in_pos - gpi->last;
1990     POSITION( buffer->in_pos )->y_pos = gpi->anchor_y - entry_y;
1991   }
1992
1993 end:
1994   error = Get_Anchor( gpi, &eer->ExitAnchor, IN_CURGLYPH(),
1995                       &exit_x, &exit_y );
1996   if ( error == HB_Err_Not_Covered )
1997     gpi->last = 0xFFFF;
1998   else
1999   {
2000     gpi->last     = buffer->in_pos;
2001     gpi->anchor_x = exit_x;
2002     gpi->anchor_y = exit_y;
2003   }
2004   if ( error )
2005     return error;
2006
2007   (buffer->in_pos)++;
2008
2009   return HB_Err_Ok;
2010 }
2011
2012
2013 /* LookupType 4 */
2014
2015 /* BaseArray */
2016
2017 static HB_Error  Load_BaseArray( HB_BaseArray*  ba,
2018                                  HB_UShort       num_classes,
2019                                  HB_Stream       stream )
2020 {
2021   HB_Error  error;
2022
2023   HB_UShort       m, n, count;
2024   HB_UInt         cur_offset, new_offset, base_offset;
2025
2026   HB_BaseRecord  *br;
2027   HB_Anchor      *ban, *bans;
2028
2029
2030   base_offset = FILE_Pos();
2031
2032   if ( ACCESS_Frame( 2L ) )
2033     return error;
2034
2035   count = ba->BaseCount = GET_UShort();
2036
2037   FORGET_Frame();
2038
2039   ba->BaseRecord = NULL;
2040
2041   if ( ALLOC_ARRAY( ba->BaseRecord, count, HB_BaseRecord ) )
2042     return error;
2043
2044   br = ba->BaseRecord;
2045
2046   bans = NULL;
2047
2048   if ( ALLOC_ARRAY( bans, count * num_classes, HB_Anchor ) )
2049     goto Fail;
2050
2051   for ( m = 0; m < count; m++ )
2052   {
2053     br[m].BaseAnchor = NULL;
2054
2055     ban = br[m].BaseAnchor = bans + m * num_classes;
2056
2057     for ( n = 0; n < num_classes; n++ )
2058     {
2059       if ( ACCESS_Frame( 2L ) )
2060         goto Fail;
2061
2062       new_offset = GET_UShort() + base_offset;
2063
2064       FORGET_Frame();
2065
2066       if (new_offset == base_offset) {
2067         /* XXX
2068          * Doulos SIL Regular is buggy and has zero offsets here.
2069          * Skip it
2070          */
2071         ban[n].PosFormat = 0;
2072         continue;
2073       }
2074
2075       cur_offset = FILE_Pos();
2076       if ( FILE_Seek( new_offset ) ||
2077            ( error = Load_Anchor( &ban[n], stream ) ) != HB_Err_Ok )
2078         goto Fail;
2079       (void)FILE_Seek( cur_offset );
2080     }
2081   }
2082
2083   return HB_Err_Ok;
2084
2085 Fail:
2086   FREE( bans );
2087   FREE( br );
2088   return error;
2089 }
2090
2091
2092 static void  Free_BaseArray( HB_BaseArray*  ba,
2093                              HB_UShort       num_classes )
2094 {
2095   HB_BaseRecord  *br;
2096   HB_Anchor      *bans;
2097
2098   if ( ba->BaseRecord )
2099   {
2100     br    = ba->BaseRecord;
2101
2102     if ( ba->BaseCount )
2103     {
2104       HB_UShort i, count;
2105       count = num_classes * ba->BaseCount;
2106       bans = br[0].BaseAnchor;
2107       for (i = 0; i < count; i++)
2108         Free_Anchor (&bans[i]);
2109       FREE( bans );
2110     }
2111
2112     FREE( br );
2113   }
2114 }
2115
2116
2117 /* MarkBasePosFormat1 */
2118
2119 static HB_Error  Load_MarkBasePos( HB_GPOS_SubTable* st,
2120                                    HB_Stream         stream )
2121 {
2122   HB_Error  error;
2123   HB_MarkBasePos* mbp = &st->markbase;
2124
2125   HB_UInt  cur_offset, new_offset, base_offset;
2126
2127
2128   base_offset = FILE_Pos();
2129
2130   if ( ACCESS_Frame( 4L ) )
2131     return error;
2132
2133   mbp->PosFormat = GET_UShort();
2134   new_offset     = GET_UShort() + base_offset;
2135
2136   FORGET_Frame();
2137
2138   if (mbp->PosFormat != 1)
2139     return ERR(HB_Err_Invalid_SubTable_Format);
2140
2141   cur_offset = FILE_Pos();
2142   if ( FILE_Seek( new_offset ) ||
2143        ( error = _HB_OPEN_Load_Coverage( &mbp->MarkCoverage, stream ) ) != HB_Err_Ok )
2144     return error;
2145   (void)FILE_Seek( cur_offset );
2146
2147   if ( ACCESS_Frame( 2L ) )
2148     goto Fail3;
2149
2150   new_offset = GET_UShort() + base_offset;
2151
2152   FORGET_Frame();
2153
2154   cur_offset = FILE_Pos();
2155   if ( FILE_Seek( new_offset ) ||
2156        ( error = _HB_OPEN_Load_Coverage( &mbp->BaseCoverage, stream ) ) != HB_Err_Ok )
2157     goto Fail3;
2158   (void)FILE_Seek( cur_offset );
2159
2160   if ( ACCESS_Frame( 4L ) )
2161     goto Fail2;
2162
2163   mbp->ClassCount = GET_UShort();
2164   new_offset      = GET_UShort() + base_offset;
2165
2166   FORGET_Frame();
2167
2168   cur_offset = FILE_Pos();
2169   if ( FILE_Seek( new_offset ) ||
2170        ( error = Load_MarkArray( &mbp->MarkArray, stream ) ) != HB_Err_Ok )
2171     goto Fail2;
2172   (void)FILE_Seek( cur_offset );
2173
2174   if ( ACCESS_Frame( 2L ) )
2175     goto Fail1;
2176
2177   new_offset = GET_UShort() + base_offset;
2178
2179   FORGET_Frame();
2180
2181   cur_offset = FILE_Pos();
2182   if ( FILE_Seek( new_offset ) ||
2183        ( error = Load_BaseArray( &mbp->BaseArray, mbp->ClassCount,
2184                                  stream ) ) != HB_Err_Ok )
2185     goto Fail1;
2186
2187   return HB_Err_Ok;
2188
2189 Fail1:
2190   Free_MarkArray( &mbp->MarkArray );
2191
2192 Fail2:
2193   _HB_OPEN_Free_Coverage( &mbp->BaseCoverage );
2194
2195 Fail3:
2196   _HB_OPEN_Free_Coverage( &mbp->MarkCoverage );
2197   return error;
2198 }
2199
2200
2201 static void  Free_MarkBasePos( HB_GPOS_SubTable* st )
2202 {
2203   HB_MarkBasePos* mbp = &st->markbase;
2204
2205   Free_BaseArray( &mbp->BaseArray, mbp->ClassCount );
2206   Free_MarkArray( &mbp->MarkArray );
2207   _HB_OPEN_Free_Coverage( &mbp->BaseCoverage );
2208   _HB_OPEN_Free_Coverage( &mbp->MarkCoverage );
2209 }
2210
2211
2212 static HB_Error  Lookup_MarkBasePos( GPOS_Instance*    gpi,
2213                                      HB_GPOS_SubTable* st,
2214                                      HB_Buffer        buffer,
2215                                      HB_UShort         flags,
2216                                      HB_UShort         context_length,
2217                                      int               nesting_level )
2218 {
2219   HB_UShort        i, j, mark_index, base_index, property, class;
2220   HB_Fixed           x_mark_value, y_mark_value, x_base_value, y_base_value;
2221   HB_Error         error;
2222   HB_GPOSHeader*  gpos = gpi->gpos;
2223   HB_MarkBasePos* mbp = &st->markbase;
2224
2225   HB_MarkArray*   ma;
2226   HB_BaseArray*   ba;
2227   HB_BaseRecord*  br;
2228   HB_Anchor*      mark_anchor;
2229   HB_Anchor*      base_anchor;
2230
2231   HB_Position     o;
2232
2233   HB_UNUSED(nesting_level);
2234
2235   if ( context_length != 0xFFFF && context_length < 1 )
2236     return HB_Err_Not_Covered;
2237
2238   if ( flags & HB_LOOKUP_FLAG_IGNORE_BASE_GLYPHS )
2239     return HB_Err_Not_Covered;
2240
2241   if ( CHECK_Property( gpos->gdef, IN_CURITEM(),
2242                        flags, &property ) )
2243     return error;
2244
2245   error = _HB_OPEN_Coverage_Index( &mbp->MarkCoverage, IN_CURGLYPH(),
2246                           &mark_index );
2247   if ( error )
2248     return error;
2249
2250   /* now we search backwards for a non-mark glyph */
2251
2252   i = 1;
2253   j = buffer->in_pos - 1;
2254
2255   while ( i <= buffer->in_pos )
2256   {
2257     error = HB_GDEF_Get_Glyph_Property( gpos->gdef, IN_GLYPH( j ),
2258                                         &property );
2259     if ( error )
2260       return error;
2261
2262     if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) )
2263       break;
2264
2265     i++;
2266     j--;
2267   }
2268
2269   /* The following assertion is too strong -- at least for mangal.ttf. */
2270 #if 0
2271   if ( property != HB_GDEF_BASE_GLYPH )
2272     return HB_Err_Not_Covered;
2273 #endif
2274
2275   if ( i > buffer->in_pos )
2276     return HB_Err_Not_Covered;
2277
2278   error = _HB_OPEN_Coverage_Index( &mbp->BaseCoverage, IN_GLYPH( j ),
2279                           &base_index );
2280   if ( error )
2281     return error;
2282
2283   ma = &mbp->MarkArray;
2284
2285   if ( mark_index >= ma->MarkCount )
2286     return ERR(HB_Err_Invalid_SubTable);
2287
2288   class       = ma->MarkRecord[mark_index].Class;
2289   mark_anchor = &ma->MarkRecord[mark_index].MarkAnchor;
2290
2291   if ( class >= mbp->ClassCount )
2292     return ERR(HB_Err_Invalid_SubTable);
2293
2294   ba = &mbp->BaseArray;
2295
2296   if ( base_index >= ba->BaseCount )
2297     return ERR(HB_Err_Invalid_SubTable);
2298
2299   br          = &ba->BaseRecord[base_index];
2300   base_anchor = &br->BaseAnchor[class];
2301
2302   error = Get_Anchor( gpi, mark_anchor, IN_CURGLYPH(),
2303                       &x_mark_value, &y_mark_value );
2304   if ( error )
2305     return error;
2306
2307   error = Get_Anchor( gpi, base_anchor, IN_GLYPH( j ),
2308                       &x_base_value, &y_base_value );
2309   if ( error )
2310     return error;
2311
2312   /* anchor points are not cumulative */
2313
2314   o = POSITION( buffer->in_pos );
2315
2316   o->x_pos     = x_base_value - x_mark_value;
2317   o->y_pos     = y_base_value - y_mark_value;
2318   o->x_advance = 0;
2319   o->y_advance = 0;
2320   o->back      = i;
2321
2322   (buffer->in_pos)++;
2323
2324   return HB_Err_Ok;
2325 }
2326
2327
2328 /* LookupType 5 */
2329
2330 /* LigatureAttach */
2331
2332 static HB_Error  Load_LigatureAttach( HB_LigatureAttach*  lat,
2333                                       HB_UShort            num_classes,
2334                                       HB_Stream            stream )
2335 {
2336   HB_Error  error;
2337
2338   HB_UShort             m, n, k, count;
2339   HB_UInt              cur_offset, new_offset, base_offset;
2340
2341   HB_ComponentRecord*  cr;
2342   HB_Anchor*           lan;
2343
2344
2345   base_offset = FILE_Pos();
2346
2347   if ( ACCESS_Frame( 2L ) )
2348     return error;
2349
2350   count = lat->ComponentCount = GET_UShort();
2351
2352   FORGET_Frame();
2353
2354   lat->ComponentRecord = NULL;
2355
2356   if ( ALLOC_ARRAY( lat->ComponentRecord, count, HB_ComponentRecord ) )
2357     return error;
2358
2359   cr = lat->ComponentRecord;
2360
2361   for ( m = 0; m < count; m++ )
2362   {
2363     cr[m].LigatureAnchor = NULL;
2364
2365     if ( ALLOC_ARRAY( cr[m].LigatureAnchor, num_classes, HB_Anchor ) )
2366       goto Fail;
2367
2368     lan = cr[m].LigatureAnchor;
2369
2370     for ( n = 0; n < num_classes; n++ )
2371     {
2372       if ( ACCESS_Frame( 2L ) )
2373         goto Fail0;
2374
2375       new_offset = GET_UShort();
2376
2377       FORGET_Frame();
2378
2379       if ( new_offset )
2380       {
2381         new_offset += base_offset;
2382
2383         cur_offset = FILE_Pos();
2384         if ( FILE_Seek( new_offset ) ||
2385              ( error = Load_Anchor( &lan[n], stream ) ) != HB_Err_Ok )
2386           goto Fail0;
2387         (void)FILE_Seek( cur_offset );
2388       }
2389       else
2390         lan[n].PosFormat = 0;
2391     }
2392
2393     continue;
2394   Fail0:
2395     for ( k = 0; k < n; k++ )
2396       Free_Anchor( &lan[k] );
2397     goto Fail;
2398   }
2399
2400   return HB_Err_Ok;
2401
2402 Fail:
2403   for ( k = 0; k < m; k++ )
2404   {
2405     lan = cr[k].LigatureAnchor;
2406
2407     for ( n = 0; n < num_classes; n++ )
2408       Free_Anchor( &lan[n] );
2409
2410     FREE( lan );
2411   }
2412
2413   FREE( cr );
2414   return error;
2415 }
2416
2417
2418 static void  Free_LigatureAttach( HB_LigatureAttach*  lat,
2419                                   HB_UShort            num_classes )
2420 {
2421   HB_UShort        m, n, count;
2422
2423   HB_ComponentRecord*  cr;
2424   HB_Anchor*           lan;
2425
2426
2427   if ( lat->ComponentRecord )
2428   {
2429     count = lat->ComponentCount;
2430     cr    = lat->ComponentRecord;
2431
2432     for ( m = 0; m < count; m++ )
2433     {
2434       lan = cr[m].LigatureAnchor;
2435
2436       for ( n = 0; n < num_classes; n++ )
2437         Free_Anchor( &lan[n] );
2438
2439       FREE( lan );
2440     }
2441
2442     FREE( cr );
2443   }
2444 }
2445
2446
2447 /* LigatureArray */
2448
2449 static HB_Error  Load_LigatureArray( HB_LigatureArray*  la,
2450                                      HB_UShort           num_classes,
2451                                      HB_Stream           stream )
2452 {
2453   HB_Error  error;
2454
2455   HB_UShort            n, m, count;
2456   HB_UInt             cur_offset, new_offset, base_offset;
2457
2458   HB_LigatureAttach*  lat;
2459
2460
2461   base_offset = FILE_Pos();
2462
2463   if ( ACCESS_Frame( 2L ) )
2464     return error;
2465
2466   count = la->LigatureCount = GET_UShort();
2467
2468   FORGET_Frame();
2469
2470   la->LigatureAttach = NULL;
2471
2472   if ( ALLOC_ARRAY( la->LigatureAttach, count, HB_LigatureAttach ) )
2473     return error;
2474
2475   lat = la->LigatureAttach;
2476
2477   for ( n = 0; n < count; n++ )
2478   {
2479     if ( ACCESS_Frame( 2L ) )
2480       goto Fail;
2481
2482     new_offset = GET_UShort() + base_offset;
2483
2484     FORGET_Frame();
2485
2486     cur_offset = FILE_Pos();
2487     if ( FILE_Seek( new_offset ) ||
2488          ( error = Load_LigatureAttach( &lat[n], num_classes,
2489                                         stream ) ) != HB_Err_Ok )
2490       goto Fail;
2491     (void)FILE_Seek( cur_offset );
2492   }
2493
2494   return HB_Err_Ok;
2495
2496 Fail:
2497   for ( m = 0; m < n; m++ )
2498     Free_LigatureAttach( &lat[m], num_classes );
2499
2500   FREE( lat );
2501   return error;
2502 }
2503
2504
2505 static void  Free_LigatureArray( HB_LigatureArray*  la,
2506                                  HB_UShort           num_classes )
2507 {
2508   HB_UShort            n, count;
2509
2510   HB_LigatureAttach*  lat;
2511
2512
2513   if ( la->LigatureAttach )
2514   {
2515     count = la->LigatureCount;
2516     lat   = la->LigatureAttach;
2517
2518     for ( n = 0; n < count; n++ )
2519       Free_LigatureAttach( &lat[n], num_classes );
2520
2521     FREE( lat );
2522   }
2523 }
2524
2525
2526 /* MarkLigPosFormat1 */
2527
2528 static HB_Error  Load_MarkLigPos( HB_GPOS_SubTable* st,
2529                                   HB_Stream        stream )
2530 {
2531   HB_Error  error;
2532   HB_MarkLigPos*  mlp = &st->marklig;
2533
2534   HB_UInt  cur_offset, new_offset, base_offset;
2535
2536
2537   base_offset = FILE_Pos();
2538
2539   if ( ACCESS_Frame( 4L ) )
2540     return error;
2541
2542   mlp->PosFormat = GET_UShort();
2543   new_offset     = GET_UShort() + base_offset;
2544
2545   FORGET_Frame();
2546
2547   cur_offset = FILE_Pos();
2548   if ( FILE_Seek( new_offset ) ||
2549        ( error = _HB_OPEN_Load_Coverage( &mlp->MarkCoverage, stream ) ) != HB_Err_Ok )
2550     return error;
2551   (void)FILE_Seek( cur_offset );
2552
2553   if ( ACCESS_Frame( 2L ) )
2554     goto Fail3;
2555
2556   new_offset = GET_UShort() + base_offset;
2557
2558   FORGET_Frame();
2559
2560   cur_offset = FILE_Pos();
2561   if ( FILE_Seek( new_offset ) ||
2562        ( error = _HB_OPEN_Load_Coverage( &mlp->LigatureCoverage,
2563                                 stream ) ) != HB_Err_Ok )
2564     goto Fail3;
2565   (void)FILE_Seek( cur_offset );
2566
2567   if ( ACCESS_Frame( 4L ) )
2568     goto Fail2;
2569
2570   mlp->ClassCount = GET_UShort();
2571   new_offset      = GET_UShort() + base_offset;
2572
2573   FORGET_Frame();
2574
2575   cur_offset = FILE_Pos();
2576   if ( FILE_Seek( new_offset ) ||
2577        ( error = Load_MarkArray( &mlp->MarkArray, stream ) ) != HB_Err_Ok )
2578     goto Fail2;
2579   (void)FILE_Seek( cur_offset );
2580
2581   if ( ACCESS_Frame( 2L ) )
2582     goto Fail1;
2583
2584   new_offset = GET_UShort() + base_offset;
2585
2586   FORGET_Frame();
2587
2588   cur_offset = FILE_Pos();
2589   if ( FILE_Seek( new_offset ) ||
2590        ( error = Load_LigatureArray( &mlp->LigatureArray, mlp->ClassCount,
2591                                      stream ) ) != HB_Err_Ok )
2592     goto Fail1;
2593
2594   return HB_Err_Ok;
2595
2596 Fail1:
2597   Free_MarkArray( &mlp->MarkArray );
2598
2599 Fail2:
2600   _HB_OPEN_Free_Coverage( &mlp->LigatureCoverage );
2601
2602 Fail3:
2603   _HB_OPEN_Free_Coverage( &mlp->MarkCoverage );
2604   return error;
2605 }
2606
2607
2608 static void  Free_MarkLigPos( HB_GPOS_SubTable* st)
2609 {
2610   HB_MarkLigPos*  mlp = &st->marklig;
2611
2612   Free_LigatureArray( &mlp->LigatureArray, mlp->ClassCount );
2613   Free_MarkArray( &mlp->MarkArray );
2614   _HB_OPEN_Free_Coverage( &mlp->LigatureCoverage );
2615   _HB_OPEN_Free_Coverage( &mlp->MarkCoverage );
2616 }
2617
2618
2619 static HB_Error  Lookup_MarkLigPos( GPOS_Instance*    gpi,
2620                                     HB_GPOS_SubTable* st,
2621                                     HB_Buffer        buffer,
2622                                     HB_UShort         flags,
2623                                     HB_UShort         context_length,
2624                                     int               nesting_level )
2625 {
2626   HB_UShort        i, j, mark_index, lig_index, property, class;
2627   HB_UShort        mark_glyph;
2628   HB_Fixed           x_mark_value, y_mark_value, x_lig_value, y_lig_value;
2629   HB_Error         error;
2630   HB_GPOSHeader*  gpos = gpi->gpos;
2631   HB_MarkLigPos*  mlp = &st->marklig;
2632
2633   HB_MarkArray*        ma;
2634   HB_LigatureArray*    la;
2635   HB_LigatureAttach*   lat;
2636   HB_ComponentRecord*  cr;
2637   HB_UShort             comp_index;
2638   HB_Anchor*           mark_anchor;
2639   HB_Anchor*           lig_anchor;
2640
2641   HB_Position    o;
2642
2643   HB_UNUSED(nesting_level);
2644
2645   if ( context_length != 0xFFFF && context_length < 1 )
2646     return HB_Err_Not_Covered;
2647
2648   if ( flags & HB_LOOKUP_FLAG_IGNORE_LIGATURES )
2649     return HB_Err_Not_Covered;
2650
2651   mark_glyph = IN_CURGLYPH();
2652
2653   if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) )
2654     return error;
2655
2656   error = _HB_OPEN_Coverage_Index( &mlp->MarkCoverage, mark_glyph, &mark_index );
2657   if ( error )
2658     return error;
2659
2660   /* now we search backwards for a non-mark glyph */
2661
2662   i = 1;
2663   j = buffer->in_pos - 1;
2664
2665   while ( i <= buffer->in_pos )
2666   {
2667     error = HB_GDEF_Get_Glyph_Property( gpos->gdef, IN_GLYPH( j ),
2668                                         &property );
2669     if ( error )
2670       return error;
2671
2672     if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) )
2673       break;
2674
2675     i++;
2676     j--;
2677   }
2678
2679   /* Similar to Lookup_MarkBasePos(), I suspect that this assertion is
2680      too strong, thus it is commented out.                             */
2681 #if 0
2682   if ( property != HB_GDEF_LIGATURE )
2683     return HB_Err_Not_Covered;
2684 #endif
2685
2686   if ( i > buffer->in_pos )
2687     return HB_Err_Not_Covered;
2688
2689   error = _HB_OPEN_Coverage_Index( &mlp->LigatureCoverage, IN_GLYPH( j ),
2690                           &lig_index );
2691   if ( error )
2692     return error;
2693
2694   ma = &mlp->MarkArray;
2695
2696   if ( mark_index >= ma->MarkCount )
2697     return ERR(HB_Err_Invalid_SubTable);
2698
2699   class       = ma->MarkRecord[mark_index].Class;
2700   mark_anchor = &ma->MarkRecord[mark_index].MarkAnchor;
2701
2702   if ( class >= mlp->ClassCount )
2703     return ERR(HB_Err_Invalid_SubTable);
2704
2705   la = &mlp->LigatureArray;
2706
2707   if ( lig_index >= la->LigatureCount )
2708     return ERR(HB_Err_Invalid_SubTable);
2709
2710   lat = &la->LigatureAttach[lig_index];
2711
2712   /* We must now check whether the ligature ID of the current mark glyph
2713      is identical to the ligature ID of the found ligature.  If yes, we
2714      can directly use the component index.  If not, we attach the mark
2715      glyph to the last component of the ligature.                        */
2716
2717   if ( IN_LIGID( j ) == IN_LIGID( buffer->in_pos) )
2718   {
2719     comp_index = IN_COMPONENT( buffer->in_pos );
2720     if ( comp_index >= lat->ComponentCount )
2721       return HB_Err_Not_Covered;
2722   }
2723   else
2724     comp_index = lat->ComponentCount - 1;
2725
2726   cr         = &lat->ComponentRecord[comp_index];
2727   lig_anchor = &cr->LigatureAnchor[class];
2728
2729   error = Get_Anchor( gpi, mark_anchor, IN_CURGLYPH(),
2730                       &x_mark_value, &y_mark_value );
2731   if ( error )
2732     return error;
2733   error = Get_Anchor( gpi, lig_anchor, IN_GLYPH( j ),
2734                       &x_lig_value, &y_lig_value );
2735   if ( error )
2736     return error;
2737
2738   /* anchor points are not cumulative */
2739
2740   o = POSITION( buffer->in_pos );
2741
2742   o->x_pos     = x_lig_value - x_mark_value;
2743   o->y_pos     = y_lig_value - y_mark_value;
2744   o->x_advance = 0;
2745   o->y_advance = 0;
2746   o->back      = i;
2747
2748   (buffer->in_pos)++;
2749
2750   return HB_Err_Ok;
2751 }
2752
2753
2754 /* LookupType 6 */
2755
2756 /* Mark2Array */
2757
2758 static HB_Error  Load_Mark2Array( HB_Mark2Array*  m2a,
2759                                   HB_UShort        num_classes,
2760                                   HB_Stream        stream )
2761 {
2762   HB_Error  error;
2763
2764   HB_UShort        m, n, count;
2765   HB_UInt          cur_offset, new_offset, base_offset;
2766
2767   HB_Mark2Record  *m2r;
2768   HB_Anchor       *m2an, *m2ans;
2769
2770
2771   base_offset = FILE_Pos();
2772
2773   if ( ACCESS_Frame( 2L ) )
2774     return error;
2775
2776   count = m2a->Mark2Count = GET_UShort();
2777
2778   FORGET_Frame();
2779
2780   m2a->Mark2Record = NULL;
2781
2782   if ( ALLOC_ARRAY( m2a->Mark2Record, count, HB_Mark2Record ) )
2783     return error;
2784
2785   m2r = m2a->Mark2Record;
2786
2787   m2ans = NULL;
2788
2789   if ( ALLOC_ARRAY( m2ans, count * num_classes, HB_Anchor ) )
2790     goto Fail;
2791
2792   for ( m = 0; m < count; m++ )
2793   {
2794     m2an = m2r[m].Mark2Anchor = m2ans + m * num_classes;
2795
2796     for ( n = 0; n < num_classes; n++ )
2797     {
2798       if ( ACCESS_Frame( 2L ) )
2799         goto Fail;
2800
2801       new_offset = GET_UShort() + base_offset;
2802
2803       FORGET_Frame();
2804
2805       if (new_offset == base_offset) {
2806         /* Anchor table not provided.  Skip loading.
2807          * Some versions of FreeSans hit this. */
2808         m2an[n].PosFormat = 0;
2809         continue;
2810       }
2811
2812       cur_offset = FILE_Pos();
2813       if ( FILE_Seek( new_offset ) ||
2814            ( error = Load_Anchor( &m2an[n], stream ) ) != HB_Err_Ok )
2815         goto Fail;
2816       (void)FILE_Seek( cur_offset );
2817     }
2818   }
2819
2820   return HB_Err_Ok;
2821
2822 Fail:
2823   FREE( m2ans );
2824   FREE( m2r );
2825   return error;
2826 }
2827
2828
2829 static void  Free_Mark2Array( HB_Mark2Array*  m2a,
2830                               HB_UShort        num_classes )
2831 {
2832   HB_Mark2Record  *m2r;
2833   HB_Anchor       *m2ans;
2834
2835   HB_UNUSED(num_classes);
2836
2837   if ( m2a->Mark2Record )
2838   {
2839     m2r   = m2a->Mark2Record;
2840
2841     if ( m2a->Mark2Count )
2842     {
2843       m2ans = m2r[0].Mark2Anchor;
2844       FREE( m2ans );
2845     }
2846
2847     FREE( m2r );
2848   }
2849 }
2850
2851
2852 /* MarkMarkPosFormat1 */
2853
2854 static HB_Error  Load_MarkMarkPos( HB_GPOS_SubTable* st,
2855                                    HB_Stream         stream )
2856 {
2857   HB_Error  error;
2858   HB_MarkMarkPos* mmp = &st->markmark;
2859
2860   HB_UInt  cur_offset, new_offset, base_offset;
2861
2862
2863   base_offset = FILE_Pos();
2864
2865   if ( ACCESS_Frame( 4L ) )
2866     return error;
2867
2868   mmp->PosFormat = GET_UShort();
2869   new_offset     = GET_UShort() + base_offset;
2870
2871   FORGET_Frame();
2872
2873   cur_offset = FILE_Pos();
2874   if ( FILE_Seek( new_offset ) ||
2875        ( error = _HB_OPEN_Load_Coverage( &mmp->Mark1Coverage,
2876                                 stream ) ) != HB_Err_Ok )
2877     return error;
2878   (void)FILE_Seek( cur_offset );
2879
2880   if ( ACCESS_Frame( 2L ) )
2881     goto Fail3;
2882
2883   new_offset = GET_UShort() + base_offset;
2884
2885   FORGET_Frame();
2886
2887   cur_offset = FILE_Pos();
2888   if ( FILE_Seek( new_offset ) ||
2889        ( error = _HB_OPEN_Load_Coverage( &mmp->Mark2Coverage,
2890                                 stream ) ) != HB_Err_Ok )
2891     goto Fail3;
2892   (void)FILE_Seek( cur_offset );
2893
2894   if ( ACCESS_Frame( 4L ) )
2895     goto Fail2;
2896
2897   mmp->ClassCount = GET_UShort();
2898   new_offset      = GET_UShort() + base_offset;
2899
2900   FORGET_Frame();
2901
2902   cur_offset = FILE_Pos();
2903   if ( FILE_Seek( new_offset ) ||
2904        ( error = Load_MarkArray( &mmp->Mark1Array, stream ) ) != HB_Err_Ok )
2905     goto Fail2;
2906   (void)FILE_Seek( cur_offset );
2907
2908   if ( ACCESS_Frame( 2L ) )
2909     goto Fail1;
2910
2911   new_offset = GET_UShort() + base_offset;
2912
2913   FORGET_Frame();
2914
2915   cur_offset = FILE_Pos();
2916   if ( FILE_Seek( new_offset ) ||
2917        ( error = Load_Mark2Array( &mmp->Mark2Array, mmp->ClassCount,
2918                                   stream ) ) != HB_Err_Ok )
2919     goto Fail1;
2920
2921   return HB_Err_Ok;
2922
2923 Fail1:
2924   Free_MarkArray( &mmp->Mark1Array );
2925
2926 Fail2:
2927   _HB_OPEN_Free_Coverage( &mmp->Mark2Coverage );
2928
2929 Fail3:
2930   _HB_OPEN_Free_Coverage( &mmp->Mark1Coverage );
2931   return error;
2932 }
2933
2934
2935 static void  Free_MarkMarkPos( HB_GPOS_SubTable* st)
2936 {
2937   HB_MarkMarkPos* mmp = &st->markmark;
2938
2939   Free_Mark2Array( &mmp->Mark2Array, mmp->ClassCount );
2940   Free_MarkArray( &mmp->Mark1Array );
2941   _HB_OPEN_Free_Coverage( &mmp->Mark2Coverage );
2942   _HB_OPEN_Free_Coverage( &mmp->Mark1Coverage );
2943 }
2944
2945
2946 static HB_Error  Lookup_MarkMarkPos( GPOS_Instance*    gpi,
2947                                      HB_GPOS_SubTable* st,
2948                                      HB_Buffer        buffer,
2949                                      HB_UShort         flags,
2950                                      HB_UShort         context_length,
2951                                      int               nesting_level )
2952 {
2953   HB_UShort        i, j, mark1_index, mark2_index, property, class;
2954   HB_Fixed           x_mark1_value, y_mark1_value,
2955                    x_mark2_value, y_mark2_value;
2956   HB_Error         error;
2957   HB_GPOSHeader*  gpos = gpi->gpos;
2958   HB_MarkMarkPos* mmp = &st->markmark;
2959
2960   HB_MarkArray*    ma1;
2961   HB_Mark2Array*   ma2;
2962   HB_Mark2Record*  m2r;
2963   HB_Anchor*       mark1_anchor;
2964   HB_Anchor*       mark2_anchor;
2965
2966   HB_Position    o;
2967
2968   HB_UNUSED(nesting_level);
2969
2970   if ( context_length != 0xFFFF && context_length < 1 )
2971     return HB_Err_Not_Covered;
2972
2973   if ( flags & HB_LOOKUP_FLAG_IGNORE_MARKS )
2974     return HB_Err_Not_Covered;
2975
2976   if ( CHECK_Property( gpos->gdef, IN_CURITEM(),
2977                        flags, &property ) )
2978     return error;
2979
2980   error = _HB_OPEN_Coverage_Index( &mmp->Mark1Coverage, IN_CURGLYPH(),
2981                           &mark1_index );
2982   if ( error )
2983     return error;
2984
2985   /* now we search backwards for a suitable mark glyph until a non-mark
2986      glyph                                                */
2987
2988   if ( buffer->in_pos == 0 )
2989     return HB_Err_Not_Covered;
2990
2991   i = 1;
2992   j = buffer->in_pos - 1;
2993   while ( i <= buffer->in_pos )
2994   {
2995     error = HB_GDEF_Get_Glyph_Property( gpos->gdef, IN_GLYPH( j ),
2996                                         &property );
2997     if ( error )
2998       return error;
2999
3000     if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) )
3001       return HB_Err_Not_Covered;
3002
3003     if ( flags & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS )
3004     {
3005       if ( property == (flags & 0xFF00) )
3006         break;
3007     }
3008     else
3009       break;
3010
3011     i++;
3012     j--;
3013   }
3014
3015   if ( i > buffer->in_pos )
3016     return HB_Err_Not_Covered;
3017
3018   error = _HB_OPEN_Coverage_Index( &mmp->Mark2Coverage, IN_GLYPH( j ),
3019                           &mark2_index );
3020   if ( error )
3021     return error;
3022
3023   ma1 = &mmp->Mark1Array;
3024
3025   if ( mark1_index >= ma1->MarkCount )
3026     return ERR(HB_Err_Invalid_SubTable);
3027
3028   class        = ma1->MarkRecord[mark1_index].Class;
3029   mark1_anchor = &ma1->MarkRecord[mark1_index].MarkAnchor;
3030
3031   if ( class >= mmp->ClassCount )
3032     return ERR(HB_Err_Invalid_SubTable);
3033
3034   ma2 = &mmp->Mark2Array;
3035
3036   if ( mark2_index >= ma2->Mark2Count )
3037     return ERR(HB_Err_Invalid_SubTable);
3038
3039   m2r          = &ma2->Mark2Record[mark2_index];
3040   mark2_anchor = &m2r->Mark2Anchor[class];
3041
3042   error = Get_Anchor( gpi, mark1_anchor, IN_CURGLYPH(),
3043                       &x_mark1_value, &y_mark1_value );
3044   if ( error )
3045     return error;
3046   error = Get_Anchor( gpi, mark2_anchor, IN_GLYPH( j ),
3047                       &x_mark2_value, &y_mark2_value );
3048   if ( error )
3049     return error;
3050
3051   /* anchor points are not cumulative */
3052
3053   o = POSITION( buffer->in_pos );
3054
3055   o->x_pos     = x_mark2_value - x_mark1_value;
3056   o->y_pos     = y_mark2_value - y_mark1_value;
3057   o->x_advance = 0;
3058   o->y_advance = 0;
3059   o->back      = 1;
3060
3061   (buffer->in_pos)++;
3062
3063   return HB_Err_Ok;
3064 }
3065
3066
3067 /* Do the actual positioning for a context positioning (either format
3068    7 or 8).  This is only called after we've determined that the stream
3069    matches the subrule.                                                 */
3070
3071 static HB_Error  Do_ContextPos( GPOS_Instance*        gpi,
3072                                 HB_UShort             GlyphCount,
3073                                 HB_UShort             PosCount,
3074                                 HB_PosLookupRecord*  pos,
3075                                 HB_Buffer            buffer,
3076                                 int                   nesting_level )
3077 {
3078   HB_Error  error;
3079   HB_UInt   i, old_pos;
3080
3081
3082   i = 0;
3083
3084   while ( i < GlyphCount )
3085   {
3086     if ( PosCount && i == pos->SequenceIndex )
3087     {
3088       old_pos = buffer->in_pos;
3089
3090       /* Do a positioning */
3091
3092       error = GPOS_Do_Glyph_Lookup( gpi, pos->LookupListIndex, buffer,
3093                                     GlyphCount, nesting_level );
3094
3095       if ( error )
3096         return error;
3097
3098       pos++;
3099       PosCount--;
3100       i += buffer->in_pos - old_pos;
3101     }
3102     else
3103     {
3104       i++;
3105       (buffer->in_pos)++;
3106     }
3107   }
3108
3109   return HB_Err_Ok;
3110 }
3111
3112
3113 /* LookupType 7 */
3114
3115 /* PosRule */
3116
3117 static HB_Error  Load_PosRule( HB_PosRule*  pr,
3118                                HB_Stream     stream )
3119 {
3120   HB_Error  error;
3121
3122   HB_UShort             n, count;
3123   HB_UShort*            i;
3124
3125   HB_PosLookupRecord*  plr;
3126
3127
3128   if ( ACCESS_Frame( 4L ) )
3129     return error;
3130
3131   pr->GlyphCount = GET_UShort();
3132   pr->PosCount   = GET_UShort();
3133
3134   FORGET_Frame();
3135
3136   pr->Input = NULL;
3137
3138   count = pr->GlyphCount - 1;         /* only GlyphCount - 1 elements */
3139
3140   if ( ALLOC_ARRAY( pr->Input, count, HB_UShort ) )
3141     return error;
3142
3143   i = pr->Input;
3144
3145   if ( ACCESS_Frame( count * 2L ) )
3146     goto Fail2;
3147
3148   for ( n = 0; n < count; n++ )
3149     i[n] = GET_UShort();
3150
3151   FORGET_Frame();
3152
3153   pr->PosLookupRecord = NULL;
3154
3155   count = pr->PosCount;
3156
3157   if ( ALLOC_ARRAY( pr->PosLookupRecord, count, HB_PosLookupRecord ) )
3158     goto Fail2;
3159
3160   plr = pr->PosLookupRecord;
3161
3162   if ( ACCESS_Frame( count * 4L ) )
3163     goto Fail1;
3164
3165   for ( n = 0; n < count; n++ )
3166   {
3167     plr[n].SequenceIndex   = GET_UShort();
3168     plr[n].LookupListIndex = GET_UShort();
3169   }
3170
3171   FORGET_Frame();
3172
3173   return HB_Err_Ok;
3174
3175 Fail1:
3176   FREE( plr );
3177
3178 Fail2:
3179   FREE( i );
3180   return error;
3181 }
3182
3183
3184 static void  Free_PosRule( HB_PosRule*  pr )
3185 {
3186   FREE( pr->PosLookupRecord );
3187   FREE( pr->Input );
3188 }
3189
3190
3191 /* PosRuleSet */
3192
3193 static HB_Error  Load_PosRuleSet( HB_PosRuleSet*  prs,
3194                                   HB_Stream        stream )
3195 {
3196   HB_Error  error;
3197
3198   HB_UShort     n, m, count;
3199   HB_UInt      cur_offset, new_offset, base_offset;
3200
3201   HB_PosRule*  pr;
3202
3203
3204   base_offset = FILE_Pos();
3205
3206   if ( ACCESS_Frame( 2L ) )
3207     return error;
3208
3209   count = prs->PosRuleCount = GET_UShort();
3210
3211   FORGET_Frame();
3212
3213   prs->PosRule = NULL;
3214
3215   if ( ALLOC_ARRAY( prs->PosRule, count, HB_PosRule ) )
3216     return error;
3217
3218   pr = prs->PosRule;
3219
3220   for ( n = 0; n < count; n++ )
3221   {
3222     if ( ACCESS_Frame( 2L ) )
3223       goto Fail;
3224
3225     new_offset = GET_UShort() + base_offset;
3226
3227     FORGET_Frame();
3228
3229     cur_offset = FILE_Pos();
3230     if ( FILE_Seek( new_offset ) ||
3231          ( error = Load_PosRule( &pr[n], stream ) ) != HB_Err_Ok )
3232       goto Fail;
3233     (void)FILE_Seek( cur_offset );
3234   }
3235
3236   return HB_Err_Ok;
3237
3238 Fail:
3239   for ( m = 0; m < n; m++ )
3240     Free_PosRule( &pr[m] );
3241
3242   FREE( pr );
3243   return error;
3244 }
3245
3246
3247 static void  Free_PosRuleSet( HB_PosRuleSet*  prs )
3248 {
3249   HB_UShort     n, count;
3250
3251   HB_PosRule*  pr;
3252
3253
3254   if ( prs->PosRule )
3255   {
3256     count = prs->PosRuleCount;
3257     pr    = prs->PosRule;
3258
3259     for ( n = 0; n < count; n++ )
3260       Free_PosRule( &pr[n] );
3261
3262     FREE( pr );
3263   }
3264 }
3265
3266
3267 /* ContextPosFormat1 */
3268
3269 static HB_Error  Load_ContextPos1( HB_ContextPosFormat1*  cpf1,
3270                                    HB_Stream               stream )
3271 {
3272   HB_Error  error;
3273
3274   HB_UShort        n, m, count;
3275   HB_UInt         cur_offset, new_offset, base_offset;
3276
3277   HB_PosRuleSet*  prs;
3278
3279
3280   base_offset = FILE_Pos() - 2L;
3281
3282   if ( ACCESS_Frame( 2L ) )
3283     return error;
3284
3285   new_offset = GET_UShort() + base_offset;
3286
3287   FORGET_Frame();
3288
3289   cur_offset = FILE_Pos();
3290   if ( FILE_Seek( new_offset ) ||
3291        ( error = _HB_OPEN_Load_Coverage( &cpf1->Coverage, stream ) ) != HB_Err_Ok )
3292     return error;
3293   (void)FILE_Seek( cur_offset );
3294
3295   if ( ACCESS_Frame( 2L ) )
3296     goto Fail2;
3297
3298   count = cpf1->PosRuleSetCount = GET_UShort();
3299
3300   FORGET_Frame();
3301
3302   cpf1->PosRuleSet = NULL;
3303
3304   if ( ALLOC_ARRAY( cpf1->PosRuleSet, count, HB_PosRuleSet ) )
3305     goto Fail2;
3306
3307   prs = cpf1->PosRuleSet;
3308
3309   for ( n = 0; n < count; n++ )
3310   {
3311     if ( ACCESS_Frame( 2L ) )
3312       goto Fail1;
3313
3314     new_offset = GET_UShort() + base_offset;
3315
3316     FORGET_Frame();
3317
3318     cur_offset = FILE_Pos();
3319     if ( FILE_Seek( new_offset ) ||
3320          ( error = Load_PosRuleSet( &prs[n], stream ) ) != HB_Err_Ok )
3321       goto Fail1;
3322     (void)FILE_Seek( cur_offset );
3323   }
3324
3325   return HB_Err_Ok;
3326
3327 Fail1:
3328   for ( m = 0; m < n; m++ )
3329     Free_PosRuleSet( &prs[m] );
3330
3331   FREE( prs );
3332
3333 Fail2:
3334   _HB_OPEN_Free_Coverage( &cpf1->Coverage );
3335   return error;
3336 }
3337
3338
3339 static void  Free_ContextPos1( HB_ContextPosFormat1*  cpf1 )
3340 {
3341   HB_UShort        n, count;
3342
3343   HB_PosRuleSet*  prs;
3344
3345
3346   if ( cpf1->PosRuleSet )
3347   {
3348     count = cpf1->PosRuleSetCount;
3349     prs   = cpf1->PosRuleSet;
3350
3351     for ( n = 0; n < count; n++ )
3352       Free_PosRuleSet( &prs[n] );
3353
3354     FREE( prs );
3355   }
3356
3357   _HB_OPEN_Free_Coverage( &cpf1->Coverage );
3358 }
3359
3360
3361 /* PosClassRule */
3362
3363 static HB_Error  Load_PosClassRule( HB_ContextPosFormat2*  cpf2,
3364                                     HB_PosClassRule*       pcr,
3365                                     HB_Stream               stream )
3366 {
3367   HB_Error  error;
3368
3369   HB_UShort             n, count;
3370
3371   HB_UShort*            c;
3372   HB_PosLookupRecord*  plr;
3373
3374
3375   if ( ACCESS_Frame( 4L ) )
3376     return error;
3377
3378   pcr->GlyphCount = GET_UShort();
3379   pcr->PosCount   = GET_UShort();
3380
3381   FORGET_Frame();
3382
3383   if ( pcr->GlyphCount > cpf2->MaxContextLength )
3384     cpf2->MaxContextLength = pcr->GlyphCount;
3385
3386   pcr->Class = NULL;
3387
3388   count = pcr->GlyphCount - 1;        /* only GlyphCount - 1 elements */
3389
3390   if ( ALLOC_ARRAY( pcr->Class, count, HB_UShort ) )
3391     return error;
3392
3393   c = pcr->Class;
3394
3395   if ( ACCESS_Frame( count * 2L ) )
3396     goto Fail2;
3397
3398   for ( n = 0; n < count; n++ )
3399     c[n] = GET_UShort();
3400
3401   FORGET_Frame();
3402
3403   pcr->PosLookupRecord = NULL;
3404
3405   count = pcr->PosCount;
3406
3407   if ( ALLOC_ARRAY( pcr->PosLookupRecord, count, HB_PosLookupRecord ) )
3408     goto Fail2;
3409
3410   plr = pcr->PosLookupRecord;
3411
3412   if ( ACCESS_Frame( count * 4L ) )
3413     goto Fail1;
3414
3415   for ( n = 0; n < count; n++ )
3416   {
3417     plr[n].SequenceIndex   = GET_UShort();
3418     plr[n].LookupListIndex = GET_UShort();
3419   }
3420
3421   FORGET_Frame();
3422
3423   return HB_Err_Ok;
3424
3425 Fail1:
3426   FREE( plr );
3427
3428 Fail2:
3429   FREE( c );
3430   return error;
3431 }
3432
3433
3434 static void  Free_PosClassRule( HB_PosClassRule*  pcr )
3435 {
3436   FREE( pcr->PosLookupRecord );
3437   FREE( pcr->Class );
3438 }
3439
3440
3441 /* PosClassSet */
3442
3443 static HB_Error  Load_PosClassSet( HB_ContextPosFormat2*  cpf2,
3444                                    HB_PosClassSet*        pcs,
3445                                    HB_Stream               stream )
3446 {
3447   HB_Error  error;
3448
3449   HB_UShort          n, m, count;
3450   HB_UInt           cur_offset, new_offset, base_offset;
3451
3452   HB_PosClassRule*  pcr;
3453
3454
3455   base_offset = FILE_Pos();
3456
3457   if ( ACCESS_Frame( 2L ) )
3458     return error;
3459
3460   count = pcs->PosClassRuleCount = GET_UShort();
3461
3462   FORGET_Frame();
3463
3464   pcs->PosClassRule = NULL;
3465
3466   if ( ALLOC_ARRAY( pcs->PosClassRule, count, HB_PosClassRule ) )
3467     return error;
3468
3469   pcr = pcs->PosClassRule;
3470
3471   for ( n = 0; n < count; n++ )
3472   {
3473     if ( ACCESS_Frame( 2L ) )
3474       goto Fail;
3475
3476     new_offset = GET_UShort() + base_offset;
3477
3478     FORGET_Frame();
3479
3480     cur_offset = FILE_Pos();
3481     if ( FILE_Seek( new_offset ) ||
3482          ( error = Load_PosClassRule( cpf2, &pcr[n],
3483                                       stream ) ) != HB_Err_Ok )
3484       goto Fail;
3485     (void)FILE_Seek( cur_offset );
3486   }
3487
3488   return HB_Err_Ok;
3489
3490 Fail:
3491   for ( m = 0; m < n; m++ )
3492     Free_PosClassRule( &pcr[m] );
3493
3494   FREE( pcr );
3495   return error;
3496 }
3497
3498
3499 static void  Free_PosClassSet( HB_PosClassSet*  pcs )
3500 {
3501   HB_UShort          n, count;
3502
3503   HB_PosClassRule*  pcr;
3504
3505
3506   if ( pcs->PosClassRule )
3507   {
3508     count = pcs->PosClassRuleCount;
3509     pcr   = pcs->PosClassRule;
3510
3511     for ( n = 0; n < count; n++ )
3512       Free_PosClassRule( &pcr[n] );
3513
3514     FREE( pcr );
3515   }
3516 }
3517
3518
3519 /* ContextPosFormat2 */
3520
3521 static HB_Error  Load_ContextPos2( HB_ContextPosFormat2*  cpf2,
3522                                    HB_Stream               stream )
3523 {
3524   HB_Error  error;
3525
3526   HB_UShort         n, m, count;
3527   HB_UInt          cur_offset, new_offset, base_offset;
3528
3529   HB_PosClassSet*  pcs;
3530
3531
3532   base_offset = FILE_Pos() - 2;
3533
3534   if ( ACCESS_Frame( 2L ) )
3535     return error;
3536
3537   new_offset = GET_UShort() + base_offset;
3538
3539   FORGET_Frame();
3540
3541   cur_offset = FILE_Pos();
3542   if ( FILE_Seek( new_offset ) ||
3543        ( error = _HB_OPEN_Load_Coverage( &cpf2->Coverage, stream ) ) != HB_Err_Ok )
3544     return error;
3545   (void)FILE_Seek( cur_offset );
3546
3547   if ( ACCESS_Frame( 4L ) )
3548     goto Fail3;
3549
3550   new_offset = GET_UShort() + base_offset;
3551
3552   /* `PosClassSetCount' is the upper limit for class values, thus we
3553      read it now to make an additional safety check.                 */
3554
3555   count = cpf2->PosClassSetCount = GET_UShort();
3556
3557   FORGET_Frame();
3558
3559   cur_offset = FILE_Pos();
3560   if ( FILE_Seek( new_offset ) ||
3561        ( error = _HB_OPEN_Load_ClassDefinition( &cpf2->ClassDef, count,
3562                                        stream ) ) != HB_Err_Ok )
3563     goto Fail3;
3564   (void)FILE_Seek( cur_offset );
3565
3566   cpf2->PosClassSet      = NULL;
3567   cpf2->MaxContextLength = 0;
3568
3569   if ( ALLOC_ARRAY( cpf2->PosClassSet, count, HB_PosClassSet ) )
3570     goto Fail2;
3571
3572   pcs = cpf2->PosClassSet;
3573
3574   for ( n = 0; n < count; n++ )
3575   {
3576     if ( ACCESS_Frame( 2L ) )
3577       goto Fail1;
3578
3579     new_offset = GET_UShort() + base_offset;
3580
3581     FORGET_Frame();
3582
3583     if ( new_offset != base_offset )      /* not a NULL offset */
3584     {
3585       cur_offset = FILE_Pos();
3586       if ( FILE_Seek( new_offset ) ||
3587            ( error = Load_PosClassSet( cpf2, &pcs[n],
3588                                        stream ) ) != HB_Err_Ok )
3589         goto Fail1;
3590       (void)FILE_Seek( cur_offset );
3591     }
3592     else
3593     {
3594       /* we create a PosClassSet table with no entries */
3595
3596       cpf2->PosClassSet[n].PosClassRuleCount = 0;
3597       cpf2->PosClassSet[n].PosClassRule      = NULL;
3598     }
3599   }
3600
3601   return HB_Err_Ok;
3602
3603 Fail1:
3604   for ( m = 0; m < n; n++ )
3605     Free_PosClassSet( &pcs[m] );
3606
3607   FREE( pcs );
3608
3609 Fail2:
3610   _HB_OPEN_Free_ClassDefinition( &cpf2->ClassDef );
3611
3612 Fail3:
3613   _HB_OPEN_Free_Coverage( &cpf2->Coverage );
3614   return error;
3615 }
3616
3617
3618 static void  Free_ContextPos2( HB_ContextPosFormat2*  cpf2 )
3619 {
3620   HB_UShort         n, count;
3621
3622   HB_PosClassSet*  pcs;
3623
3624
3625   if ( cpf2->PosClassSet )
3626   {
3627     count = cpf2->PosClassSetCount;
3628     pcs   = cpf2->PosClassSet;
3629
3630     for ( n = 0; n < count; n++ )
3631       Free_PosClassSet( &pcs[n] );
3632
3633     FREE( pcs );
3634   }
3635
3636   _HB_OPEN_Free_ClassDefinition( &cpf2->ClassDef );
3637   _HB_OPEN_Free_Coverage( &cpf2->Coverage );
3638 }
3639
3640
3641 /* ContextPosFormat3 */
3642
3643 static HB_Error  Load_ContextPos3( HB_ContextPosFormat3*  cpf3,
3644                                    HB_Stream               stream )
3645 {
3646   HB_Error  error;
3647
3648   HB_UShort             n, count;
3649   HB_UInt              cur_offset, new_offset, base_offset;
3650
3651   HB_Coverage*         c;
3652   HB_PosLookupRecord*  plr;
3653
3654
3655   base_offset = FILE_Pos() - 2L;
3656
3657   if ( ACCESS_Frame( 4L ) )
3658     return error;
3659
3660   cpf3->GlyphCount = GET_UShort();
3661   cpf3->PosCount   = GET_UShort();
3662
3663   FORGET_Frame();
3664
3665   cpf3->Coverage = NULL;
3666
3667   count = cpf3->GlyphCount;
3668
3669   if ( ALLOC_ARRAY( cpf3->Coverage, count, HB_Coverage ) )
3670     return error;
3671
3672   c = cpf3->Coverage;
3673
3674   for ( n = 0; n < count; n++ )
3675   {
3676     if ( ACCESS_Frame( 2L ) )
3677       goto Fail2;
3678
3679     new_offset = GET_UShort() + base_offset;
3680
3681     FORGET_Frame();
3682
3683     cur_offset = FILE_Pos();
3684     if ( FILE_Seek( new_offset ) ||
3685          ( error = _HB_OPEN_Load_Coverage( &c[n], stream ) ) != HB_Err_Ok )
3686       goto Fail2;
3687     (void)FILE_Seek( cur_offset );
3688   }
3689
3690   cpf3->PosLookupRecord = NULL;
3691
3692   count = cpf3->PosCount;
3693
3694   if ( ALLOC_ARRAY( cpf3->PosLookupRecord, count, HB_PosLookupRecord ) )
3695     goto Fail2;
3696
3697   plr = cpf3->PosLookupRecord;
3698
3699   if ( ACCESS_Frame( count * 4L ) )
3700     goto Fail1;
3701
3702   for ( n = 0; n < count; n++ )
3703   {
3704     plr[n].SequenceIndex   = GET_UShort();
3705     plr[n].LookupListIndex = GET_UShort();
3706   }
3707
3708   FORGET_Frame();
3709
3710   return HB_Err_Ok;
3711
3712 Fail1:
3713   FREE( plr );
3714
3715 Fail2:
3716   for ( n = 0; n < count; n++ )
3717     _HB_OPEN_Free_Coverage( &c[n] );
3718
3719   FREE( c );
3720   return error;
3721 }
3722
3723
3724 static void  Free_ContextPos3( HB_ContextPosFormat3*  cpf3 )
3725 {
3726   HB_UShort      n, count;
3727
3728   HB_Coverage*  c;
3729
3730
3731   FREE( cpf3->PosLookupRecord );
3732
3733   if ( cpf3->Coverage )
3734   {
3735     count = cpf3->GlyphCount;
3736     c     = cpf3->Coverage;
3737
3738     for ( n = 0; n < count; n++ )
3739       _HB_OPEN_Free_Coverage( &c[n] );
3740
3741     FREE( c );
3742   }
3743 }
3744
3745
3746 /* ContextPos */
3747
3748 static HB_Error  Load_ContextPos( HB_GPOS_SubTable* st,
3749                                   HB_Stream        stream )
3750 {
3751   HB_Error  error;
3752   HB_ContextPos*   cp = &st->context;
3753
3754
3755   if ( ACCESS_Frame( 2L ) )
3756     return error;
3757
3758   cp->PosFormat = GET_UShort();
3759
3760   FORGET_Frame();
3761
3762   switch ( cp->PosFormat )
3763   {
3764   case 1:
3765     return Load_ContextPos1( &cp->cpf.cpf1, stream );
3766
3767   case 2:
3768     return Load_ContextPos2( &cp->cpf.cpf2, stream );
3769
3770   case 3:
3771     return Load_ContextPos3( &cp->cpf.cpf3, stream );
3772
3773   default:
3774     return ERR(HB_Err_Invalid_SubTable_Format);
3775   }
3776
3777   return HB_Err_Ok;               /* never reached */
3778 }
3779
3780
3781 static void  Free_ContextPos( HB_GPOS_SubTable* st )
3782 {
3783   HB_ContextPos*   cp = &st->context;
3784
3785   switch ( cp->PosFormat )
3786   {
3787   case 1:  Free_ContextPos1( &cp->cpf.cpf1 ); break;
3788   case 2:  Free_ContextPos2( &cp->cpf.cpf2 ); break;
3789   case 3:  Free_ContextPos3( &cp->cpf.cpf3 ); break;
3790   default:                                            break;
3791   }
3792 }
3793
3794
3795 static HB_Error  Lookup_ContextPos1( GPOS_Instance*          gpi,
3796                                      HB_ContextPosFormat1*  cpf1,
3797                                      HB_Buffer              buffer,
3798                                      HB_UShort               flags,
3799                                      HB_UShort               context_length,
3800                                      int                     nesting_level )
3801 {
3802   HB_UShort        index, property;
3803   HB_UShort        i, j, k, numpr;
3804   HB_Error         error;
3805   HB_GPOSHeader*  gpos = gpi->gpos;
3806
3807   HB_PosRule*     pr;
3808   HB_GDEFHeader*  gdef;
3809
3810
3811   gdef = gpos->gdef;
3812
3813   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
3814     return error;
3815
3816   error = _HB_OPEN_Coverage_Index( &cpf1->Coverage, IN_CURGLYPH(), &index );
3817   if ( error )
3818     return error;
3819
3820   pr    = cpf1->PosRuleSet[index].PosRule;
3821   numpr = cpf1->PosRuleSet[index].PosRuleCount;
3822
3823   for ( k = 0; k < numpr; k++ )
3824   {
3825     if ( context_length != 0xFFFF && context_length < pr[k].GlyphCount )
3826       goto next_posrule;
3827
3828     if ( buffer->in_pos + pr[k].GlyphCount > buffer->in_length )
3829       goto next_posrule;                       /* context is too long */
3830
3831     for ( i = 1, j = buffer->in_pos + 1; i < pr[k].GlyphCount; i++, j++ )
3832     {
3833       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
3834       {
3835         if ( error && error != HB_Err_Not_Covered )
3836           return error;
3837
3838         if ( j + pr[k].GlyphCount - i == (HB_Int)buffer->in_length )
3839           goto next_posrule;
3840         j++;
3841       }
3842
3843       if ( IN_GLYPH( j ) != pr[k].Input[i - 1] )
3844         goto next_posrule;
3845     }
3846
3847     return Do_ContextPos( gpi, pr[k].GlyphCount,
3848                           pr[k].PosCount, pr[k].PosLookupRecord,
3849                           buffer,
3850                           nesting_level );
3851
3852     next_posrule:
3853       ;
3854   }
3855
3856   return HB_Err_Not_Covered;
3857 }
3858
3859
3860 static HB_Error  Lookup_ContextPos2( GPOS_Instance*          gpi,
3861                                      HB_ContextPosFormat2*  cpf2,
3862                                      HB_Buffer              buffer,
3863                                      HB_UShort               flags,
3864                                      HB_UShort               context_length,
3865                                      int                     nesting_level )
3866 {
3867   HB_UShort          index, property;
3868   HB_Error           error;
3869   HB_UShort          i, j, k, known_classes;
3870
3871   HB_UShort*         classes;
3872   HB_UShort*         cl;
3873   HB_GPOSHeader*    gpos = gpi->gpos;
3874
3875   HB_PosClassSet*   pcs;
3876   HB_PosClassRule*  pr;
3877   HB_GDEFHeader*    gdef;
3878
3879
3880   gdef = gpos->gdef;
3881
3882   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
3883     return error;
3884
3885   /* Note: The coverage table in format 2 doesn't give an index into
3886            anything.  It just lets us know whether or not we need to
3887            do any lookup at all.                                     */
3888
3889   error = _HB_OPEN_Coverage_Index( &cpf2->Coverage, IN_CURGLYPH(), &index );
3890   if ( error )
3891     return error;
3892
3893   if (cpf2->MaxContextLength < 1)
3894     return HB_Err_Not_Covered;
3895
3896   if ( ALLOC_ARRAY( classes, cpf2->MaxContextLength, HB_UShort ) )
3897     return error;
3898
3899   error = _HB_OPEN_Get_Class( &cpf2->ClassDef, IN_CURGLYPH(),
3900                      &classes[0], NULL );
3901   if ( error && error != HB_Err_Not_Covered )
3902     goto End;
3903   known_classes = 0;
3904
3905   pcs = &cpf2->PosClassSet[classes[0]];
3906   if ( !pcs )
3907   {
3908     error = ERR(HB_Err_Invalid_SubTable);
3909     goto End;
3910   }
3911
3912   for ( k = 0; k < pcs->PosClassRuleCount; k++ )
3913   {
3914     pr = &pcs->PosClassRule[k];
3915
3916     if ( context_length != 0xFFFF && context_length < pr->GlyphCount )
3917       goto next_posclassrule;
3918
3919     if ( buffer->in_pos + pr->GlyphCount > buffer->in_length )
3920       goto next_posclassrule;                /* context is too long */
3921
3922     cl   = pr->Class;
3923
3924     /* Start at 1 because [0] is implied */
3925
3926     for ( i = 1, j = buffer->in_pos + 1; i < pr->GlyphCount; i++, j++ )
3927     {
3928       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
3929       {
3930         if ( error && error != HB_Err_Not_Covered )
3931           goto End;
3932
3933         if ( j + pr->GlyphCount - i == (HB_Int)buffer->in_length )
3934           goto next_posclassrule;
3935         j++;
3936       }
3937
3938       if ( i > known_classes )
3939       {
3940         /* Keeps us from having to do this for each rule */
3941
3942         error = _HB_OPEN_Get_Class( &cpf2->ClassDef, IN_GLYPH( j ), &classes[i], NULL );
3943         if ( error && error != HB_Err_Not_Covered )
3944           goto End;
3945         known_classes = i;
3946       }
3947
3948       if ( cl[i - 1] != classes[i] )
3949         goto next_posclassrule;
3950     }
3951
3952     error = Do_ContextPos( gpi, pr->GlyphCount,
3953                            pr->PosCount, pr->PosLookupRecord,
3954                            buffer,
3955                            nesting_level );
3956     goto End;
3957
3958   next_posclassrule:
3959     ;
3960   }
3961
3962   error = HB_Err_Not_Covered;
3963
3964 End:
3965   FREE( classes );
3966   return error;
3967 }
3968
3969
3970 static HB_Error  Lookup_ContextPos3( GPOS_Instance*          gpi,
3971                                      HB_ContextPosFormat3*  cpf3,
3972                                      HB_Buffer              buffer,
3973                                      HB_UShort               flags,
3974                                      HB_UShort               context_length,
3975                                      int                     nesting_level )
3976 {
3977   HB_Error         error;
3978   HB_UShort        index, i, j, property;
3979   HB_GPOSHeader*  gpos = gpi->gpos;
3980
3981   HB_Coverage*    c;
3982   HB_GDEFHeader*  gdef;
3983
3984
3985   gdef = gpos->gdef;
3986
3987   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
3988     return error;
3989
3990   if ( context_length != 0xFFFF && context_length < cpf3->GlyphCount )
3991     return HB_Err_Not_Covered;
3992
3993   if ( buffer->in_pos + cpf3->GlyphCount > buffer->in_length )
3994     return HB_Err_Not_Covered;         /* context is too long */
3995
3996   c    = cpf3->Coverage;
3997
3998   for ( i = 1, j = 1; i < cpf3->GlyphCount; i++, j++ )
3999   {
4000     while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
4001     {
4002       if ( error && error != HB_Err_Not_Covered )
4003         return error;
4004
4005       if ( j + cpf3->GlyphCount - i == (HB_Int)buffer->in_length )
4006         return HB_Err_Not_Covered;
4007       j++;
4008     }
4009
4010     error = _HB_OPEN_Coverage_Index( &c[i], IN_GLYPH( j ), &index );
4011     if ( error )
4012       return error;
4013   }
4014
4015   return Do_ContextPos( gpi, cpf3->GlyphCount,
4016                         cpf3->PosCount, cpf3->PosLookupRecord,
4017                         buffer,
4018                         nesting_level );
4019 }
4020
4021
4022 static HB_Error  Lookup_ContextPos( GPOS_Instance*    gpi,
4023                                     HB_GPOS_SubTable* st,
4024                                     HB_Buffer        buffer,
4025                                     HB_UShort         flags,
4026                                     HB_UShort         context_length,
4027                                     int               nesting_level )
4028 {
4029   HB_ContextPos*   cp = &st->context;
4030
4031   switch ( cp->PosFormat )
4032   {
4033   case 1:
4034     return Lookup_ContextPos1( gpi, &cp->cpf.cpf1, buffer,
4035                                flags, context_length, nesting_level );
4036
4037   case 2:
4038     return Lookup_ContextPos2( gpi, &cp->cpf.cpf2, buffer,
4039                                flags, context_length, nesting_level );
4040
4041   case 3:
4042     return Lookup_ContextPos3( gpi, &cp->cpf.cpf3, buffer,
4043                                flags, context_length, nesting_level );
4044
4045   default:
4046     return ERR(HB_Err_Invalid_SubTable_Format);
4047   }
4048
4049   return HB_Err_Ok;               /* never reached */
4050 }
4051
4052
4053 /* LookupType 8 */
4054
4055 /* ChainPosRule */
4056
4057 static HB_Error  Load_ChainPosRule( HB_ChainPosRule*  cpr,
4058                                     HB_Stream          stream )
4059 {
4060   HB_Error  error;
4061
4062   HB_UShort             n, count;
4063   HB_UShort*            b;
4064   HB_UShort*            i;
4065   HB_UShort*            l;
4066
4067   HB_PosLookupRecord*  plr;
4068
4069
4070   if ( ACCESS_Frame( 2L ) )
4071     return error;
4072
4073   cpr->BacktrackGlyphCount = GET_UShort();
4074
4075   FORGET_Frame();
4076
4077   cpr->Backtrack = NULL;
4078
4079   count = cpr->BacktrackGlyphCount;
4080
4081   if ( ALLOC_ARRAY( cpr->Backtrack, count, HB_UShort ) )
4082     return error;
4083
4084   b = cpr->Backtrack;
4085
4086   if ( ACCESS_Frame( count * 2L ) )
4087     goto Fail4;
4088
4089   for ( n = 0; n < count; n++ )
4090     b[n] = GET_UShort();
4091
4092   FORGET_Frame();
4093
4094   if ( ACCESS_Frame( 2L ) )
4095     goto Fail4;
4096
4097   cpr->InputGlyphCount = GET_UShort();
4098
4099   FORGET_Frame();
4100
4101   cpr->Input = NULL;
4102
4103   count = cpr->InputGlyphCount - 1;  /* only InputGlyphCount - 1 elements */
4104
4105   if ( ALLOC_ARRAY( cpr->Input, count, HB_UShort ) )
4106     goto Fail4;
4107
4108   i = cpr->Input;
4109
4110   if ( ACCESS_Frame( count * 2L ) )
4111     goto Fail3;
4112
4113   for ( n = 0; n < count; n++ )
4114     i[n] = GET_UShort();
4115
4116   FORGET_Frame();
4117
4118   if ( ACCESS_Frame( 2L ) )
4119     goto Fail3;
4120
4121   cpr->LookaheadGlyphCount = GET_UShort();
4122
4123   FORGET_Frame();
4124
4125   cpr->Lookahead = NULL;
4126
4127   count = cpr->LookaheadGlyphCount;
4128
4129   if ( ALLOC_ARRAY( cpr->Lookahead, count, HB_UShort ) )
4130     goto Fail3;
4131
4132   l = cpr->Lookahead;
4133
4134   if ( ACCESS_Frame( count * 2L ) )
4135     goto Fail2;
4136
4137   for ( n = 0; n < count; n++ )
4138     l[n] = GET_UShort();
4139
4140   FORGET_Frame();
4141
4142   if ( ACCESS_Frame( 2L ) )
4143     goto Fail2;
4144
4145   cpr->PosCount = GET_UShort();
4146
4147   FORGET_Frame();
4148
4149   cpr->PosLookupRecord = NULL;
4150
4151   count = cpr->PosCount;
4152
4153   if ( ALLOC_ARRAY( cpr->PosLookupRecord, count, HB_PosLookupRecord ) )
4154     goto Fail2;
4155
4156   plr = cpr->PosLookupRecord;
4157
4158   if ( ACCESS_Frame( count * 4L ) )
4159     goto Fail1;
4160
4161   for ( n = 0; n < count; n++ )
4162   {
4163     plr[n].SequenceIndex   = GET_UShort();
4164     plr[n].LookupListIndex = GET_UShort();
4165   }
4166
4167   FORGET_Frame();
4168
4169   return HB_Err_Ok;
4170
4171 Fail1:
4172   FREE( plr );
4173
4174 Fail2:
4175   FREE( l );
4176
4177 Fail3:
4178   FREE( i );
4179
4180 Fail4:
4181   FREE( b );
4182   return error;
4183 }
4184
4185
4186 static void  Free_ChainPosRule( HB_ChainPosRule*  cpr )
4187 {
4188   FREE( cpr->PosLookupRecord );
4189   FREE( cpr->Lookahead );
4190   FREE( cpr->Input );
4191   FREE( cpr->Backtrack );
4192 }
4193
4194
4195 /* ChainPosRuleSet */
4196
4197 static HB_Error  Load_ChainPosRuleSet( HB_ChainPosRuleSet*  cprs,
4198                                        HB_Stream             stream )
4199 {
4200   HB_Error  error;
4201
4202   HB_UShort          n, m, count;
4203   HB_UInt           cur_offset, new_offset, base_offset;
4204
4205   HB_ChainPosRule*  cpr;
4206
4207
4208   base_offset = FILE_Pos();
4209
4210   if ( ACCESS_Frame( 2L ) )
4211     return error;
4212
4213   count = cprs->ChainPosRuleCount = GET_UShort();
4214
4215   FORGET_Frame();
4216
4217   cprs->ChainPosRule = NULL;
4218
4219   if ( ALLOC_ARRAY( cprs->ChainPosRule, count, HB_ChainPosRule ) )
4220     return error;
4221
4222   cpr = cprs->ChainPosRule;
4223
4224   for ( n = 0; n < count; n++ )
4225   {
4226     if ( ACCESS_Frame( 2L ) )
4227       goto Fail;
4228
4229     new_offset = GET_UShort() + base_offset;
4230
4231     FORGET_Frame();
4232
4233     cur_offset = FILE_Pos();
4234     if ( FILE_Seek( new_offset ) ||
4235          ( error = Load_ChainPosRule( &cpr[n], stream ) ) != HB_Err_Ok )
4236       goto Fail;
4237     (void)FILE_Seek( cur_offset );
4238   }
4239
4240   return HB_Err_Ok;
4241
4242 Fail:
4243   for ( m = 0; m < n; m++ )
4244     Free_ChainPosRule( &cpr[m] );
4245
4246   FREE( cpr );
4247   return error;
4248 }
4249
4250
4251 static void  Free_ChainPosRuleSet( HB_ChainPosRuleSet*  cprs )
4252 {
4253   HB_UShort          n, count;
4254
4255   HB_ChainPosRule*  cpr;
4256
4257
4258   if ( cprs->ChainPosRule )
4259   {
4260     count = cprs->ChainPosRuleCount;
4261     cpr   = cprs->ChainPosRule;
4262
4263     for ( n = 0; n < count; n++ )
4264       Free_ChainPosRule( &cpr[n] );
4265
4266     FREE( cpr );
4267   }
4268 }
4269
4270
4271 /* ChainContextPosFormat1 */
4272
4273 static HB_Error  Load_ChainContextPos1( HB_ChainContextPosFormat1*  ccpf1,
4274                                         HB_Stream                    stream )
4275 {
4276   HB_Error  error;
4277
4278   HB_UShort             n, m, count;
4279   HB_UInt              cur_offset, new_offset, base_offset;
4280
4281   HB_ChainPosRuleSet*  cprs;
4282
4283
4284   base_offset = FILE_Pos() - 2L;
4285
4286   if ( ACCESS_Frame( 2L ) )
4287     return error;
4288
4289   new_offset = GET_UShort() + base_offset;
4290
4291   FORGET_Frame();
4292
4293   cur_offset = FILE_Pos();
4294   if ( FILE_Seek( new_offset ) ||
4295        ( error = _HB_OPEN_Load_Coverage( &ccpf1->Coverage, stream ) ) != HB_Err_Ok )
4296     return error;
4297   (void)FILE_Seek( cur_offset );
4298
4299   if ( ACCESS_Frame( 2L ) )
4300     goto Fail2;
4301
4302   count = ccpf1->ChainPosRuleSetCount = GET_UShort();
4303
4304   FORGET_Frame();
4305
4306   ccpf1->ChainPosRuleSet = NULL;
4307
4308   if ( ALLOC_ARRAY( ccpf1->ChainPosRuleSet, count, HB_ChainPosRuleSet ) )
4309     goto Fail2;
4310
4311   cprs = ccpf1->ChainPosRuleSet;
4312
4313   for ( n = 0; n < count; n++ )
4314   {
4315     if ( ACCESS_Frame( 2L ) )
4316       goto Fail1;
4317
4318     new_offset = GET_UShort() + base_offset;
4319
4320     FORGET_Frame();
4321
4322     cur_offset = FILE_Pos();
4323     if ( FILE_Seek( new_offset ) ||
4324          ( error = Load_ChainPosRuleSet( &cprs[n], stream ) ) != HB_Err_Ok )
4325       goto Fail1;
4326     (void)FILE_Seek( cur_offset );
4327   }
4328
4329   return HB_Err_Ok;
4330
4331 Fail1:
4332   for ( m = 0; m < n; m++ )
4333     Free_ChainPosRuleSet( &cprs[m] );
4334
4335   FREE( cprs );
4336
4337 Fail2:
4338   _HB_OPEN_Free_Coverage( &ccpf1->Coverage );
4339   return error;
4340 }
4341
4342
4343 static void  Free_ChainContextPos1( HB_ChainContextPosFormat1*  ccpf1 )
4344 {
4345   HB_UShort             n, count;
4346
4347   HB_ChainPosRuleSet*  cprs;
4348
4349
4350   if ( ccpf1->ChainPosRuleSet )
4351   {
4352     count = ccpf1->ChainPosRuleSetCount;
4353     cprs  = ccpf1->ChainPosRuleSet;
4354
4355     for ( n = 0; n < count; n++ )
4356       Free_ChainPosRuleSet( &cprs[n] );
4357
4358     FREE( cprs );
4359   }
4360
4361   _HB_OPEN_Free_Coverage( &ccpf1->Coverage );
4362 }
4363
4364
4365 /* ChainPosClassRule */
4366
4367 static HB_Error  Load_ChainPosClassRule(
4368                    HB_ChainContextPosFormat2*  ccpf2,
4369                    HB_ChainPosClassRule*       cpcr,
4370                    HB_Stream                    stream )
4371 {
4372   HB_Error  error;
4373
4374   HB_UShort             n, count;
4375
4376   HB_UShort*            b;
4377   HB_UShort*            i;
4378   HB_UShort*            l;
4379   HB_PosLookupRecord*  plr;
4380
4381
4382   if ( ACCESS_Frame( 2L ) )
4383     return error;
4384
4385   cpcr->BacktrackGlyphCount = GET_UShort();
4386
4387   FORGET_Frame();
4388
4389   if ( cpcr->BacktrackGlyphCount > ccpf2->MaxBacktrackLength )
4390     ccpf2->MaxBacktrackLength = cpcr->BacktrackGlyphCount;
4391
4392   cpcr->Backtrack = NULL;
4393
4394   count = cpcr->BacktrackGlyphCount;
4395
4396   if ( ALLOC_ARRAY( cpcr->Backtrack, count, HB_UShort ) )
4397     return error;
4398
4399   b = cpcr->Backtrack;
4400
4401   if ( ACCESS_Frame( count * 2L ) )
4402     goto Fail4;
4403
4404   for ( n = 0; n < count; n++ )
4405     b[n] = GET_UShort();
4406
4407   FORGET_Frame();
4408
4409   if ( ACCESS_Frame( 2L ) )
4410     goto Fail4;
4411
4412   cpcr->InputGlyphCount = GET_UShort();
4413
4414   if ( cpcr->InputGlyphCount > ccpf2->MaxInputLength )
4415     ccpf2->MaxInputLength = cpcr->InputGlyphCount;
4416
4417   FORGET_Frame();
4418
4419   cpcr->Input = NULL;
4420
4421   count = cpcr->InputGlyphCount - 1; /* only InputGlyphCount - 1 elements */
4422
4423   if ( ALLOC_ARRAY( cpcr->Input, count, HB_UShort ) )
4424     goto Fail4;
4425
4426   i = cpcr->Input;
4427
4428   if ( ACCESS_Frame( count * 2L ) )
4429     goto Fail3;
4430
4431   for ( n = 0; n < count; n++ )
4432     i[n] = GET_UShort();
4433
4434   FORGET_Frame();
4435
4436   if ( ACCESS_Frame( 2L ) )
4437     goto Fail3;
4438
4439   cpcr->LookaheadGlyphCount = GET_UShort();
4440
4441   FORGET_Frame();
4442
4443   if ( cpcr->LookaheadGlyphCount > ccpf2->MaxLookaheadLength )
4444     ccpf2->MaxLookaheadLength = cpcr->LookaheadGlyphCount;
4445
4446   cpcr->Lookahead = NULL;
4447
4448   count = cpcr->LookaheadGlyphCount;
4449
4450   if ( ALLOC_ARRAY( cpcr->Lookahead, count, HB_UShort ) )
4451     goto Fail3;
4452
4453   l = cpcr->Lookahead;
4454
4455   if ( ACCESS_Frame( count * 2L ) )
4456     goto Fail2;
4457
4458   for ( n = 0; n < count; n++ )
4459     l[n] = GET_UShort();
4460
4461   FORGET_Frame();
4462
4463   if ( ACCESS_Frame( 2L ) )
4464     goto Fail2;
4465
4466   cpcr->PosCount = GET_UShort();
4467
4468   FORGET_Frame();
4469
4470   cpcr->PosLookupRecord = NULL;
4471
4472   count = cpcr->PosCount;
4473
4474   if ( ALLOC_ARRAY( cpcr->PosLookupRecord, count, HB_PosLookupRecord ) )
4475     goto Fail2;
4476
4477   plr = cpcr->PosLookupRecord;
4478
4479   if ( ACCESS_Frame( count * 4L ) )
4480     goto Fail1;
4481
4482   for ( n = 0; n < count; n++ )
4483   {
4484     plr[n].SequenceIndex   = GET_UShort();
4485     plr[n].LookupListIndex = GET_UShort();
4486   }
4487
4488   FORGET_Frame();
4489
4490   return HB_Err_Ok;
4491
4492 Fail1:
4493   FREE( plr );
4494
4495 Fail2:
4496   FREE( l );
4497
4498 Fail3:
4499   FREE( i );
4500
4501 Fail4:
4502   FREE( b );
4503   return error;
4504 }
4505
4506
4507 static void  Free_ChainPosClassRule( HB_ChainPosClassRule*  cpcr )
4508 {
4509   FREE( cpcr->PosLookupRecord );
4510   FREE( cpcr->Lookahead );
4511   FREE( cpcr->Input );
4512   FREE( cpcr->Backtrack );
4513 }
4514
4515
4516 /* PosClassSet */
4517
4518 static HB_Error  Load_ChainPosClassSet(
4519                    HB_ChainContextPosFormat2*  ccpf2,
4520                    HB_ChainPosClassSet*        cpcs,
4521                    HB_Stream                    stream )
4522 {
4523   HB_Error  error;
4524
4525   HB_UShort               n, m, count;
4526   HB_UInt                cur_offset, new_offset, base_offset;
4527
4528   HB_ChainPosClassRule*  cpcr;
4529
4530
4531   base_offset = FILE_Pos();
4532
4533   if ( ACCESS_Frame( 2L ) )
4534     return error;
4535
4536   count = cpcs->ChainPosClassRuleCount = GET_UShort();
4537
4538   FORGET_Frame();
4539
4540   cpcs->ChainPosClassRule = NULL;
4541
4542   if ( ALLOC_ARRAY( cpcs->ChainPosClassRule, count,
4543                     HB_ChainPosClassRule ) )
4544     return error;
4545
4546   cpcr = cpcs->ChainPosClassRule;
4547
4548   for ( n = 0; n < count; n++ )
4549   {
4550     if ( ACCESS_Frame( 2L ) )
4551       goto Fail;
4552
4553     new_offset = GET_UShort() + base_offset;
4554
4555     FORGET_Frame();
4556
4557     cur_offset = FILE_Pos();
4558     if ( FILE_Seek( new_offset ) ||
4559          ( error = Load_ChainPosClassRule( ccpf2, &cpcr[n],
4560                                            stream ) ) != HB_Err_Ok )
4561       goto Fail;
4562     (void)FILE_Seek( cur_offset );
4563   }
4564
4565   return HB_Err_Ok;
4566
4567 Fail:
4568   for ( m = 0; m < n; m++ )
4569     Free_ChainPosClassRule( &cpcr[m] );
4570
4571   FREE( cpcr );
4572   return error;
4573 }
4574
4575
4576 static void  Free_ChainPosClassSet( HB_ChainPosClassSet*  cpcs )
4577 {
4578   HB_UShort               n, count;
4579
4580   HB_ChainPosClassRule*  cpcr;
4581
4582
4583   if ( cpcs->ChainPosClassRule )
4584   {
4585     count = cpcs->ChainPosClassRuleCount;
4586     cpcr  = cpcs->ChainPosClassRule;
4587
4588     for ( n = 0; n < count; n++ )
4589       Free_ChainPosClassRule( &cpcr[n] );
4590
4591     FREE( cpcr );
4592   }
4593 }
4594
4595
4596 /* ChainContextPosFormat2 */
4597
4598 static HB_Error  Load_ChainContextPos2( HB_ChainContextPosFormat2*  ccpf2,
4599                                         HB_Stream                    stream )
4600 {
4601   HB_Error  error;
4602
4603   HB_UShort              n, m, count;
4604   HB_UInt               cur_offset, new_offset, base_offset;
4605   HB_UInt               backtrack_offset, input_offset, lookahead_offset;
4606
4607   HB_ChainPosClassSet*  cpcs;
4608
4609
4610   base_offset = FILE_Pos() - 2;
4611
4612   if ( ACCESS_Frame( 2L ) )
4613     return error;
4614
4615   new_offset = GET_UShort() + base_offset;
4616
4617   FORGET_Frame();
4618
4619   cur_offset = FILE_Pos();
4620   if ( FILE_Seek( new_offset ) ||
4621        ( error = _HB_OPEN_Load_Coverage( &ccpf2->Coverage, stream ) ) != HB_Err_Ok )
4622     return error;
4623   (void)FILE_Seek( cur_offset );
4624
4625   if ( ACCESS_Frame( 8L ) )
4626     goto Fail5;
4627
4628   backtrack_offset = GET_UShort();
4629   input_offset     = GET_UShort();
4630   lookahead_offset = GET_UShort();
4631
4632   /* `ChainPosClassSetCount' is the upper limit for input class values,
4633      thus we read it now to make an additional safety check. No limit
4634      is known or needed for the other two class definitions          */
4635
4636   count = ccpf2->ChainPosClassSetCount = GET_UShort();
4637
4638   FORGET_Frame();
4639
4640   if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccpf2->BacktrackClassDef, 65535,
4641                                                        backtrack_offset, base_offset,
4642                                                        stream ) ) != HB_Err_Ok )
4643     goto Fail5;
4644   if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccpf2->InputClassDef, count,
4645                                                        input_offset, base_offset,
4646                                                        stream ) ) != HB_Err_Ok )
4647     goto Fail4;
4648   if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccpf2->LookaheadClassDef, 65535,
4649                                                        lookahead_offset, base_offset,
4650                                                        stream ) ) != HB_Err_Ok )
4651     goto Fail3;
4652
4653   ccpf2->ChainPosClassSet   = NULL;
4654   ccpf2->MaxBacktrackLength = 0;
4655   ccpf2->MaxInputLength     = 0;
4656   ccpf2->MaxLookaheadLength = 0;
4657
4658   if ( ALLOC_ARRAY( ccpf2->ChainPosClassSet, count, HB_ChainPosClassSet ) )
4659     goto Fail2;
4660
4661   cpcs = ccpf2->ChainPosClassSet;
4662
4663   for ( n = 0; n < count; n++ )
4664   {
4665     if ( ACCESS_Frame( 2L ) )
4666       goto Fail1;
4667
4668     new_offset = GET_UShort() + base_offset;
4669
4670     FORGET_Frame();
4671
4672     if ( new_offset != base_offset )      /* not a NULL offset */
4673     {
4674       cur_offset = FILE_Pos();
4675       if ( FILE_Seek( new_offset ) ||
4676            ( error = Load_ChainPosClassSet( ccpf2, &cpcs[n],
4677                                             stream ) ) != HB_Err_Ok )
4678         goto Fail1;
4679       (void)FILE_Seek( cur_offset );
4680     }
4681     else
4682     {
4683       /* we create a ChainPosClassSet table with no entries */
4684
4685       ccpf2->ChainPosClassSet[n].ChainPosClassRuleCount = 0;
4686       ccpf2->ChainPosClassSet[n].ChainPosClassRule      = NULL;
4687     }
4688   }
4689
4690   return HB_Err_Ok;
4691
4692 Fail1:
4693   for ( m = 0; m < n; m++ )
4694     Free_ChainPosClassSet( &cpcs[m] );
4695
4696   FREE( cpcs );
4697
4698 Fail2:
4699   _HB_OPEN_Free_ClassDefinition( &ccpf2->LookaheadClassDef );
4700
4701 Fail3:
4702   _HB_OPEN_Free_ClassDefinition( &ccpf2->InputClassDef );
4703
4704 Fail4:
4705   _HB_OPEN_Free_ClassDefinition( &ccpf2->BacktrackClassDef );
4706
4707 Fail5:
4708   _HB_OPEN_Free_Coverage( &ccpf2->Coverage );
4709   return error;
4710 }
4711
4712
4713 static void  Free_ChainContextPos2( HB_ChainContextPosFormat2*  ccpf2 )
4714 {
4715   HB_UShort              n, count;
4716
4717   HB_ChainPosClassSet*  cpcs;
4718
4719
4720   if ( ccpf2->ChainPosClassSet )
4721   {
4722     count = ccpf2->ChainPosClassSetCount;
4723     cpcs  = ccpf2->ChainPosClassSet;
4724
4725     for ( n = 0; n < count; n++ )
4726       Free_ChainPosClassSet( &cpcs[n] );
4727
4728     FREE( cpcs );
4729   }
4730
4731   _HB_OPEN_Free_ClassDefinition( &ccpf2->LookaheadClassDef );
4732   _HB_OPEN_Free_ClassDefinition( &ccpf2->InputClassDef );
4733   _HB_OPEN_Free_ClassDefinition( &ccpf2->BacktrackClassDef );
4734
4735   _HB_OPEN_Free_Coverage( &ccpf2->Coverage );
4736 }
4737
4738
4739 /* ChainContextPosFormat3 */
4740
4741 static HB_Error  Load_ChainContextPos3( HB_ChainContextPosFormat3*  ccpf3,
4742                                         HB_Stream                    stream )
4743 {
4744   HB_Error  error;
4745
4746   HB_UShort             n, nb, ni, nl, m, count;
4747   HB_UShort             backtrack_count, input_count, lookahead_count;
4748   HB_UInt              cur_offset, new_offset, base_offset;
4749
4750   HB_Coverage*         b;
4751   HB_Coverage*         i;
4752   HB_Coverage*         l;
4753   HB_PosLookupRecord*  plr;
4754
4755
4756   base_offset = FILE_Pos() - 2L;
4757
4758   if ( ACCESS_Frame( 2L ) )
4759     return error;
4760
4761   ccpf3->BacktrackGlyphCount = GET_UShort();
4762
4763   FORGET_Frame();
4764
4765   ccpf3->BacktrackCoverage = NULL;
4766
4767   backtrack_count = ccpf3->BacktrackGlyphCount;
4768
4769   if ( ALLOC_ARRAY( ccpf3->BacktrackCoverage, backtrack_count,
4770                     HB_Coverage ) )
4771     return error;
4772
4773   b = ccpf3->BacktrackCoverage;
4774
4775   for ( nb = 0; nb < backtrack_count; nb++ )
4776   {
4777     if ( ACCESS_Frame( 2L ) )
4778       goto Fail4;
4779
4780     new_offset = GET_UShort() + base_offset;
4781
4782     FORGET_Frame();
4783
4784     cur_offset = FILE_Pos();
4785     if ( FILE_Seek( new_offset ) ||
4786          ( error = _HB_OPEN_Load_Coverage( &b[nb], stream ) ) != HB_Err_Ok )
4787       goto Fail4;
4788     (void)FILE_Seek( cur_offset );
4789   }
4790
4791   if ( ACCESS_Frame( 2L ) )
4792     goto Fail4;
4793
4794   ccpf3->InputGlyphCount = GET_UShort();
4795
4796   FORGET_Frame();
4797
4798   ccpf3->InputCoverage = NULL;
4799
4800   input_count = ccpf3->InputGlyphCount;
4801
4802   if ( ALLOC_ARRAY( ccpf3->InputCoverage, input_count, HB_Coverage ) )
4803     goto Fail4;
4804
4805   i = ccpf3->InputCoverage;
4806
4807   for ( ni = 0; ni < input_count; ni++ )
4808   {
4809     if ( ACCESS_Frame( 2L ) )
4810       goto Fail3;
4811
4812     new_offset = GET_UShort() + base_offset;
4813
4814     FORGET_Frame();
4815
4816     cur_offset = FILE_Pos();
4817     if ( FILE_Seek( new_offset ) ||
4818          ( error = _HB_OPEN_Load_Coverage( &i[ni], stream ) ) != HB_Err_Ok )
4819       goto Fail3;
4820     (void)FILE_Seek( cur_offset );
4821   }
4822
4823   if ( ACCESS_Frame( 2L ) )
4824     goto Fail3;
4825
4826   ccpf3->LookaheadGlyphCount = GET_UShort();
4827
4828   FORGET_Frame();
4829
4830   ccpf3->LookaheadCoverage = NULL;
4831
4832   lookahead_count = ccpf3->LookaheadGlyphCount;
4833
4834   if ( ALLOC_ARRAY( ccpf3->LookaheadCoverage, lookahead_count,
4835                     HB_Coverage ) )
4836     goto Fail3;
4837
4838   l = ccpf3->LookaheadCoverage;
4839
4840   for ( nl = 0; nl < lookahead_count; nl++ )
4841   {
4842     if ( ACCESS_Frame( 2L ) )
4843       goto Fail2;
4844
4845     new_offset = GET_UShort() + base_offset;
4846
4847     FORGET_Frame();
4848
4849     cur_offset = FILE_Pos();
4850     if ( FILE_Seek( new_offset ) ||
4851          ( error = _HB_OPEN_Load_Coverage( &l[nl], stream ) ) != HB_Err_Ok )
4852       goto Fail2;
4853     (void)FILE_Seek( cur_offset );
4854   }
4855
4856   if ( ACCESS_Frame( 2L ) )
4857     goto Fail2;
4858
4859   ccpf3->PosCount = GET_UShort();
4860
4861   FORGET_Frame();
4862
4863   ccpf3->PosLookupRecord = NULL;
4864
4865   count = ccpf3->PosCount;
4866
4867   if ( ALLOC_ARRAY( ccpf3->PosLookupRecord, count, HB_PosLookupRecord ) )
4868     goto Fail2;
4869
4870   plr = ccpf3->PosLookupRecord;
4871
4872   if ( ACCESS_Frame( count * 4L ) )
4873     goto Fail1;
4874
4875   for ( n = 0; n < count; n++ )
4876   {
4877     plr[n].SequenceIndex   = GET_UShort();
4878     plr[n].LookupListIndex = GET_UShort();
4879   }
4880
4881   FORGET_Frame();
4882
4883   return HB_Err_Ok;
4884
4885 Fail1:
4886   FREE( plr );
4887
4888 Fail2:
4889   for ( m = 0; m < nl; m++ )
4890     _HB_OPEN_Free_Coverage( &l[m] );
4891
4892   FREE( l );
4893
4894 Fail3:
4895   for ( m = 0; m < ni; m++ )
4896     _HB_OPEN_Free_Coverage( &i[m] );
4897
4898   FREE( i );
4899
4900 Fail4:
4901   for ( m = 0; m < nb; m++ )
4902     _HB_OPEN_Free_Coverage( &b[m] );
4903
4904   FREE( b );
4905   return error;
4906 }
4907
4908
4909 static void  Free_ChainContextPos3( HB_ChainContextPosFormat3*  ccpf3 )
4910 {
4911   HB_UShort      n, count;
4912
4913   HB_Coverage*  c;
4914
4915
4916   FREE( ccpf3->PosLookupRecord );
4917
4918   if ( ccpf3->LookaheadCoverage )
4919   {
4920     count = ccpf3->LookaheadGlyphCount;
4921     c     = ccpf3->LookaheadCoverage;
4922
4923     for ( n = 0; n < count; n++ )
4924       _HB_OPEN_Free_Coverage( &c[n] );
4925
4926     FREE( c );
4927   }
4928
4929   if ( ccpf3->InputCoverage )
4930   {
4931     count = ccpf3->InputGlyphCount;
4932     c     = ccpf3->InputCoverage;
4933
4934     for ( n = 0; n < count; n++ )
4935       _HB_OPEN_Free_Coverage( &c[n] );
4936
4937     FREE( c );
4938   }
4939
4940   if ( ccpf3->BacktrackCoverage )
4941   {
4942     count = ccpf3->BacktrackGlyphCount;
4943     c     = ccpf3->BacktrackCoverage;
4944
4945     for ( n = 0; n < count; n++ )
4946       _HB_OPEN_Free_Coverage( &c[n] );
4947
4948     FREE( c );
4949   }
4950 }
4951
4952
4953 /* ChainContextPos */
4954
4955 static HB_Error  Load_ChainContextPos( HB_GPOS_SubTable* st,
4956                                        HB_Stream             stream )
4957 {
4958   HB_Error  error;
4959   HB_ChainContextPos*  ccp = &st->chain;
4960
4961
4962   if ( ACCESS_Frame( 2L ) )
4963     return error;
4964
4965   ccp->PosFormat = GET_UShort();
4966
4967   FORGET_Frame();
4968
4969   switch ( ccp->PosFormat )
4970   {
4971   case 1:
4972     return Load_ChainContextPos1( &ccp->ccpf.ccpf1, stream );
4973
4974   case 2:
4975     return Load_ChainContextPos2( &ccp->ccpf.ccpf2, stream );
4976
4977   case 3:
4978     return Load_ChainContextPos3( &ccp->ccpf.ccpf3, stream );
4979
4980   default:
4981     return ERR(HB_Err_Invalid_SubTable_Format);
4982   }
4983
4984   return HB_Err_Ok;               /* never reached */
4985 }
4986
4987
4988 static void  Free_ChainContextPos( HB_GPOS_SubTable* st )
4989 {
4990   HB_ChainContextPos*  ccp = &st->chain;
4991
4992   switch ( ccp->PosFormat )
4993   {
4994   case 1:  Free_ChainContextPos1( &ccp->ccpf.ccpf1 ); break;
4995   case 2:  Free_ChainContextPos2( &ccp->ccpf.ccpf2 ); break;
4996   case 3:  Free_ChainContextPos3( &ccp->ccpf.ccpf3 ); break;
4997   default:                                                    break;
4998   }
4999 }
5000
5001
5002 static HB_Error  Lookup_ChainContextPos1(
5003                    GPOS_Instance*               gpi,
5004                    HB_ChainContextPosFormat1*  ccpf1,
5005                    HB_Buffer                   buffer,
5006                    HB_UShort                    flags,
5007                    HB_UShort                    context_length,
5008                    int                          nesting_level )
5009 {
5010   HB_UShort          index, property;
5011   HB_UShort          i, j, k, num_cpr;
5012   HB_UShort          bgc, igc, lgc;
5013   HB_Error           error;
5014   HB_GPOSHeader*    gpos = gpi->gpos;
5015
5016   HB_ChainPosRule*  cpr;
5017   HB_ChainPosRule   curr_cpr;
5018   HB_GDEFHeader*    gdef;
5019
5020
5021   gdef = gpos->gdef;
5022
5023   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
5024     return error;
5025
5026   error = _HB_OPEN_Coverage_Index( &ccpf1->Coverage, IN_CURGLYPH(), &index );
5027   if ( error )
5028     return error;
5029
5030   cpr     = ccpf1->ChainPosRuleSet[index].ChainPosRule;
5031   num_cpr = ccpf1->ChainPosRuleSet[index].ChainPosRuleCount;
5032
5033   for ( k = 0; k < num_cpr; k++ )
5034   {
5035     curr_cpr = cpr[k];
5036     bgc      = curr_cpr.BacktrackGlyphCount;
5037     igc      = curr_cpr.InputGlyphCount;
5038     lgc      = curr_cpr.LookaheadGlyphCount;
5039
5040     if ( context_length != 0xFFFF && context_length < igc )
5041       goto next_chainposrule;
5042
5043     /* check whether context is too long; it is a first guess only */
5044
5045     if ( bgc > buffer->in_pos || buffer->in_pos + igc + lgc > buffer->in_length )
5046       goto next_chainposrule;
5047
5048     if ( bgc )
5049     {
5050       /* Since we don't know in advance the number of glyphs to inspect,
5051          we search backwards for matches in the backtrack glyph array    */
5052
5053       for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- )
5054       {
5055         while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5056         {
5057           if ( error && error != HB_Err_Not_Covered )
5058             return error;
5059
5060           if ( j + 1 == bgc - i )
5061             goto next_chainposrule;
5062           j--;
5063         }
5064
5065         /* In OpenType 1.3, it is undefined whether the offsets of
5066            backtrack glyphs is in logical order or not.  Version 1.4
5067            will clarify this:
5068
5069              Logical order -      a  b  c  d  e  f  g  h  i  j
5070                                               i
5071              Input offsets -                  0  1
5072              Backtrack offsets -  3  2  1  0
5073              Lookahead offsets -                    0  1  2  3           */
5074
5075         if ( IN_GLYPH( j ) != curr_cpr.Backtrack[i] )
5076           goto next_chainposrule;
5077       }
5078     }
5079
5080     /* Start at 1 because [0] is implied */
5081
5082     for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ )
5083     {
5084       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5085       {
5086         if ( error && error != HB_Err_Not_Covered )
5087           return error;
5088
5089         if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
5090           goto next_chainposrule;
5091         j++;
5092       }
5093
5094       if ( IN_GLYPH( j ) != curr_cpr.Input[i - 1] )
5095         goto next_chainposrule;
5096     }
5097
5098     /* we are starting to check for lookahead glyphs right after the
5099        last context glyph                                            */
5100
5101     for ( i = 0; i < lgc; i++, j++ )
5102     {
5103       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5104       {
5105         if ( error && error != HB_Err_Not_Covered )
5106           return error;
5107
5108         if ( j + lgc - i == (HB_Int)buffer->in_length )
5109           goto next_chainposrule;
5110         j++;
5111       }
5112
5113       if ( IN_GLYPH( j ) != curr_cpr.Lookahead[i] )
5114         goto next_chainposrule;
5115     }
5116
5117     return Do_ContextPos( gpi, igc,
5118                           curr_cpr.PosCount,
5119                           curr_cpr.PosLookupRecord,
5120                           buffer,
5121                           nesting_level );
5122
5123   next_chainposrule:
5124     ;
5125   }
5126
5127   return HB_Err_Not_Covered;
5128 }
5129
5130
5131 static HB_Error  Lookup_ChainContextPos2(
5132                    GPOS_Instance*               gpi,
5133                    HB_ChainContextPosFormat2*  ccpf2,
5134                    HB_Buffer                   buffer,
5135                    HB_UShort                    flags,
5136                    HB_UShort                    context_length,
5137                    int                          nesting_level )
5138 {
5139   HB_UShort              index, property;
5140   HB_Error               error;
5141   HB_UShort              i, j, k;
5142   HB_UShort              bgc, igc, lgc;
5143   HB_UShort              known_backtrack_classes,
5144                          known_input_classes,
5145                          known_lookahead_classes;
5146
5147   HB_UShort*             backtrack_classes;
5148   HB_UShort*             input_classes;
5149   HB_UShort*             lookahead_classes;
5150
5151   HB_UShort*             bc;
5152   HB_UShort*             ic;
5153   HB_UShort*             lc;
5154   HB_GPOSHeader*        gpos = gpi->gpos;
5155
5156   HB_ChainPosClassSet*  cpcs;
5157   HB_ChainPosClassRule  cpcr;
5158   HB_GDEFHeader*        gdef;
5159
5160
5161   gdef = gpos->gdef;
5162
5163   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
5164     return error;
5165
5166   /* Note: The coverage table in format 2 doesn't give an index into
5167            anything.  It just lets us know whether or not we need to
5168            do any lookup at all.                                     */
5169
5170   error = _HB_OPEN_Coverage_Index( &ccpf2->Coverage, IN_CURGLYPH(), &index );
5171   if ( error )
5172     return error;
5173
5174   if (ccpf2->MaxInputLength < 1)
5175     return HB_Err_Not_Covered;
5176
5177   if ( ALLOC_ARRAY( backtrack_classes, ccpf2->MaxBacktrackLength, HB_UShort ) )
5178     return error;
5179   known_backtrack_classes = 0;
5180
5181   if ( ALLOC_ARRAY( input_classes, ccpf2->MaxInputLength, HB_UShort ) )
5182     goto End3;
5183   known_input_classes = 1;
5184
5185   if ( ALLOC_ARRAY( lookahead_classes, ccpf2->MaxLookaheadLength, HB_UShort ) )
5186     goto End2;
5187   known_lookahead_classes = 0;
5188
5189   error = _HB_OPEN_Get_Class( &ccpf2->InputClassDef, IN_CURGLYPH(),
5190                      &input_classes[0], NULL );
5191   if ( error && error != HB_Err_Not_Covered )
5192     goto End1;
5193
5194   cpcs = &ccpf2->ChainPosClassSet[input_classes[0]];
5195   if ( !cpcs )
5196   {
5197     error = ERR(HB_Err_Invalid_SubTable);
5198     goto End1;
5199   }
5200
5201   for ( k = 0; k < cpcs->ChainPosClassRuleCount; k++ )
5202   {
5203     cpcr = cpcs->ChainPosClassRule[k];
5204     bgc  = cpcr.BacktrackGlyphCount;
5205     igc  = cpcr.InputGlyphCount;
5206     lgc  = cpcr.LookaheadGlyphCount;
5207
5208     if ( context_length != 0xFFFF && context_length < igc )
5209       goto next_chainposclassrule;
5210
5211     /* check whether context is too long; it is a first guess only */
5212
5213     if ( bgc > buffer->in_pos || buffer->in_pos + igc + lgc > buffer->in_length )
5214       goto next_chainposclassrule;
5215
5216     if ( bgc )
5217     {
5218       /* Since we don't know in advance the number of glyphs to inspect,
5219          we search backwards for matches in the backtrack glyph array.
5220          Note that `known_backtrack_classes' starts at index 0.         */
5221
5222       bc       = cpcr.Backtrack;
5223
5224       for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- )
5225       {
5226         while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5227         {
5228           if ( error && error != HB_Err_Not_Covered )
5229             goto End1;
5230
5231           if ( j + 1 == bgc - i )
5232             goto next_chainposclassrule;
5233           j++;
5234         }
5235
5236         if ( i >= known_backtrack_classes )
5237         {
5238           /* Keeps us from having to do this for each rule */
5239
5240           error = _HB_OPEN_Get_Class( &ccpf2->BacktrackClassDef, IN_GLYPH( j ),
5241                              &backtrack_classes[i], NULL );
5242           if ( error && error != HB_Err_Not_Covered )
5243             goto End1;
5244           known_backtrack_classes = i;
5245         }
5246
5247         if ( bc[i] != backtrack_classes[i] )
5248           goto next_chainposclassrule;
5249       }
5250     }
5251
5252     ic       = cpcr.Input;
5253
5254     /* Start at 1 because [0] is implied */
5255
5256     for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ )
5257     {
5258       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5259       {
5260         if ( error && error != HB_Err_Not_Covered )
5261           goto End1;
5262
5263         if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
5264           goto next_chainposclassrule;
5265         j++;
5266       }
5267
5268       if ( i >= known_input_classes )
5269       {
5270         error = _HB_OPEN_Get_Class( &ccpf2->InputClassDef, IN_GLYPH( j ),
5271                            &input_classes[i], NULL );
5272         if ( error && error != HB_Err_Not_Covered )
5273           goto End1;
5274         known_input_classes = i;
5275       }
5276
5277       if ( ic[i - 1] != input_classes[i] )
5278         goto next_chainposclassrule;
5279     }
5280
5281     /* we are starting to check for lookahead glyphs right after the
5282        last context glyph                                            */
5283
5284     lc       = cpcr.Lookahead;
5285
5286     for ( i = 0; i < lgc; i++, j++ )
5287     {
5288       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5289       {
5290         if ( error && error != HB_Err_Not_Covered )
5291           goto End1;
5292
5293         if ( j + lgc - i == (HB_Int)buffer->in_length )
5294           goto next_chainposclassrule;
5295         j++;
5296       }
5297
5298       if ( i >= known_lookahead_classes )
5299       {
5300         error = _HB_OPEN_Get_Class( &ccpf2->LookaheadClassDef, IN_GLYPH( j ),
5301                            &lookahead_classes[i], NULL );
5302         if ( error && error != HB_Err_Not_Covered )
5303           goto End1;
5304         known_lookahead_classes = i;
5305       }
5306
5307       if ( lc[i] != lookahead_classes[i] )
5308         goto next_chainposclassrule;
5309     }
5310
5311     error = Do_ContextPos( gpi, igc,
5312                            cpcr.PosCount,
5313                            cpcr.PosLookupRecord,
5314                            buffer,
5315                            nesting_level );
5316     goto End1;
5317
5318   next_chainposclassrule:
5319     ;
5320   }
5321
5322   error = HB_Err_Not_Covered;
5323
5324 End1:
5325   FREE( lookahead_classes );
5326
5327 End2:
5328   FREE( input_classes );
5329
5330 End3:
5331   FREE( backtrack_classes );
5332   return error;
5333 }
5334
5335
5336 static HB_Error  Lookup_ChainContextPos3(
5337                    GPOS_Instance*               gpi,
5338                    HB_ChainContextPosFormat3*  ccpf3,
5339                    HB_Buffer                   buffer,
5340                    HB_UShort                    flags,
5341                    HB_UShort                    context_length,
5342                    int                          nesting_level )
5343 {
5344   HB_UShort        index, i, j, property;
5345   HB_UShort        bgc, igc, lgc;
5346   HB_Error         error;
5347   HB_GPOSHeader*  gpos = gpi->gpos;
5348
5349   HB_Coverage*    bc;
5350   HB_Coverage*    ic;
5351   HB_Coverage*    lc;
5352   HB_GDEFHeader*  gdef;
5353
5354
5355   gdef = gpos->gdef;
5356
5357   if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) )
5358     return error;
5359
5360   bgc = ccpf3->BacktrackGlyphCount;
5361   igc = ccpf3->InputGlyphCount;
5362   lgc = ccpf3->LookaheadGlyphCount;
5363
5364   if ( context_length != 0xFFFF && context_length < igc )
5365     return HB_Err_Not_Covered;
5366
5367   /* check whether context is too long; it is a first guess only */
5368
5369   if ( bgc > buffer->in_pos || buffer->in_pos + igc + lgc > buffer->in_length )
5370     return HB_Err_Not_Covered;
5371
5372   if ( bgc )
5373   {
5374     /* Since we don't know in advance the number of glyphs to inspect,
5375        we search backwards for matches in the backtrack glyph array    */
5376
5377     bc       = ccpf3->BacktrackCoverage;
5378
5379     for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- )
5380     {
5381       while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5382       {
5383         if ( error && error != HB_Err_Not_Covered )
5384           return error;
5385
5386         if ( j + 1 == bgc - i )
5387           return HB_Err_Not_Covered;
5388         j--;
5389       }
5390
5391       error = _HB_OPEN_Coverage_Index( &bc[i], IN_GLYPH( j ), &index );
5392       if ( error )
5393         return error;
5394     }
5395   }
5396
5397   ic       = ccpf3->InputCoverage;
5398
5399   for ( i = 0, j = buffer->in_pos; i < igc; i++, j++ )
5400   {
5401     /* We already called CHECK_Property for IN_GLYPH ( buffer->in_pos ) */
5402     while ( j > buffer->in_pos && CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5403     {
5404       if ( error && error != HB_Err_Not_Covered )
5405         return error;
5406
5407       if ( j + igc - i + lgc == (HB_Int)buffer->in_length )
5408         return HB_Err_Not_Covered;
5409       j++;
5410     }
5411
5412     error = _HB_OPEN_Coverage_Index( &ic[i], IN_GLYPH( j ), &index );
5413     if ( error )
5414       return error;
5415   }
5416
5417   /* we are starting to check for lookahead glyphs right after the
5418      last context glyph                                            */
5419
5420   lc       = ccpf3->LookaheadCoverage;
5421
5422   for ( i = 0; i < lgc; i++, j++ )
5423   {
5424     while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) )
5425     {
5426       if ( error && error != HB_Err_Not_Covered )
5427         return error;
5428
5429       if ( j + lgc - i == (HB_Int)buffer->in_length )
5430         return HB_Err_Not_Covered;
5431       j++;
5432     }
5433
5434     error = _HB_OPEN_Coverage_Index( &lc[i], IN_GLYPH( j ), &index );
5435     if ( error )
5436       return error;
5437   }
5438
5439   return Do_ContextPos( gpi, igc,
5440                         ccpf3->PosCount,
5441                         ccpf3->PosLookupRecord,
5442                         buffer,
5443                         nesting_level );
5444 }
5445
5446
5447 static HB_Error  Lookup_ChainContextPos(
5448                    GPOS_Instance*        gpi,
5449                    HB_GPOS_SubTable* st,
5450                    HB_Buffer            buffer,
5451                    HB_UShort             flags,
5452                    HB_UShort             context_length,
5453                    int                   nesting_level )
5454 {
5455   HB_ChainContextPos*  ccp = &st->chain;
5456
5457   switch ( ccp->PosFormat )
5458   {
5459   case 1:
5460     return Lookup_ChainContextPos1( gpi, &ccp->ccpf.ccpf1, buffer,
5461                                     flags, context_length,
5462                                     nesting_level );
5463
5464   case 2:
5465     return Lookup_ChainContextPos2( gpi, &ccp->ccpf.ccpf2, buffer,
5466                                     flags, context_length,
5467                                     nesting_level );
5468
5469   case 3:
5470     return Lookup_ChainContextPos3( gpi, &ccp->ccpf.ccpf3, buffer,
5471                                     flags, context_length,
5472                                     nesting_level );
5473
5474   default:
5475     return ERR(HB_Err_Invalid_SubTable_Format);
5476   }
5477
5478   return HB_Err_Ok;               /* never reached */
5479 }
5480
5481
5482
5483 /***********
5484  * GPOS API
5485  ***********/
5486
5487
5488
5489 HB_Error  HB_GPOS_Select_Script( HB_GPOSHeader*  gpos,
5490                                  HB_UInt         script_tag,
5491                                  HB_UShort*       script_index )
5492 {
5493   HB_UShort          n;
5494
5495   HB_ScriptList*    sl;
5496   HB_ScriptRecord*  sr;
5497
5498
5499   if ( !gpos || !script_index )
5500     return ERR(HB_Err_Invalid_Argument);
5501
5502   sl = &gpos->ScriptList;
5503   sr = sl->ScriptRecord;
5504
5505   for ( n = 0; n < sl->ScriptCount; n++ )
5506     if ( script_tag == sr[n].ScriptTag )
5507     {
5508       *script_index = n;
5509
5510       return HB_Err_Ok;
5511     }
5512
5513   return HB_Err_Not_Covered;
5514 }
5515
5516
5517
5518 HB_Error  HB_GPOS_Select_Language( HB_GPOSHeader*  gpos,
5519                                    HB_UInt         language_tag,
5520                                    HB_UShort        script_index,
5521                                    HB_UShort*       language_index,
5522                                    HB_UShort*       req_feature_index )
5523 {
5524   HB_UShort           n;
5525
5526   HB_ScriptList*     sl;
5527   HB_ScriptRecord*   sr;
5528   HB_ScriptTable*         s;
5529   HB_LangSysRecord*  lsr;
5530
5531
5532   if ( !gpos || !language_index || !req_feature_index )
5533     return ERR(HB_Err_Invalid_Argument);
5534
5535   sl = &gpos->ScriptList;
5536   sr = sl->ScriptRecord;
5537
5538   if ( script_index >= sl->ScriptCount )
5539     return ERR(HB_Err_Invalid_Argument);
5540
5541   s   = &sr[script_index].Script;
5542   lsr = s->LangSysRecord;
5543
5544   for ( n = 0; n < s->LangSysCount; n++ )
5545     if ( language_tag == lsr[n].LangSysTag )
5546     {
5547       *language_index = n;
5548       *req_feature_index = lsr[n].LangSys.ReqFeatureIndex;
5549
5550       return HB_Err_Ok;
5551     }
5552
5553   return HB_Err_Not_Covered;
5554 }
5555
5556
5557 /* selecting 0xFFFF for language_index asks for the values of the
5558    default language (DefaultLangSys)                              */
5559
5560
5561 HB_Error  HB_GPOS_Select_Feature( HB_GPOSHeader*  gpos,
5562                                   HB_UInt         feature_tag,
5563                                   HB_UShort        script_index,
5564                                   HB_UShort        language_index,
5565                                   HB_UShort*       feature_index )
5566 {
5567   HB_UShort           n;
5568
5569   HB_ScriptList*     sl;
5570   HB_ScriptRecord*   sr;
5571   HB_ScriptTable*         s;
5572   HB_LangSysRecord*  lsr;
5573   HB_LangSys*        ls;
5574   HB_UShort*          fi;
5575
5576   HB_FeatureList*    fl;
5577   HB_FeatureRecord*  fr;
5578
5579
5580   if ( !gpos || !feature_index )
5581     return ERR(HB_Err_Invalid_Argument);
5582
5583   sl = &gpos->ScriptList;
5584   sr = sl->ScriptRecord;
5585
5586   fl = &gpos->FeatureList;
5587   fr = fl->FeatureRecord;
5588
5589   if ( script_index >= sl->ScriptCount )
5590     return ERR(HB_Err_Invalid_Argument);
5591
5592   s   = &sr[script_index].Script;
5593   lsr = s->LangSysRecord;
5594
5595   if ( language_index == 0xFFFF )
5596     ls = &s->DefaultLangSys;
5597   else
5598   {
5599     if ( language_index >= s->LangSysCount )
5600       return ERR(HB_Err_Invalid_Argument);
5601
5602     ls = &lsr[language_index].LangSys;
5603   }
5604
5605   fi = ls->FeatureIndex;
5606
5607   for ( n = 0; n < ls->FeatureCount; n++ )
5608   {
5609     if ( fi[n] >= fl->FeatureCount )
5610       return ERR(HB_Err_Invalid_SubTable_Format);
5611
5612     if ( feature_tag == fr[fi[n]].FeatureTag )
5613     {
5614       *feature_index = fi[n];
5615
5616       return HB_Err_Ok;
5617     }
5618   }
5619
5620   return HB_Err_Not_Covered;
5621 }
5622
5623
5624 /* The next three functions return a null-terminated list */
5625
5626
5627 HB_Error  HB_GPOS_Query_Scripts( HB_GPOSHeader*  gpos,
5628                                  HB_UInt**       script_tag_list )
5629 {
5630   HB_Error           error;
5631   HB_UShort          n;
5632   HB_UInt*          stl;
5633
5634   HB_ScriptList*    sl;
5635   HB_ScriptRecord*  sr;
5636
5637
5638   if ( !gpos || !script_tag_list )
5639     return ERR(HB_Err_Invalid_Argument);
5640
5641   sl = &gpos->ScriptList;
5642   sr = sl->ScriptRecord;
5643
5644   if ( ALLOC_ARRAY( stl, sl->ScriptCount + 1, HB_UInt ) )
5645     return error;
5646
5647   for ( n = 0; n < sl->ScriptCount; n++ )
5648     stl[n] = sr[n].ScriptTag;
5649   stl[n] = 0;
5650
5651   *script_tag_list = stl;
5652
5653   return HB_Err_Ok;
5654 }
5655
5656
5657
5658 HB_Error  HB_GPOS_Query_Languages( HB_GPOSHeader*  gpos,
5659                                    HB_UShort        script_index,
5660                                    HB_UInt**       language_tag_list )
5661 {
5662   HB_Error            error;
5663   HB_UShort           n;
5664   HB_UInt*           ltl;
5665
5666   HB_ScriptList*     sl;
5667   HB_ScriptRecord*   sr;
5668   HB_ScriptTable*    s;
5669   HB_LangSysRecord*  lsr;
5670
5671
5672   if ( !gpos || !language_tag_list )
5673     return ERR(HB_Err_Invalid_Argument);
5674
5675   sl = &gpos->ScriptList;
5676   sr = sl->ScriptRecord;
5677
5678   if ( script_index >= sl->ScriptCount )
5679     return ERR(HB_Err_Invalid_Argument);
5680
5681   s   = &sr[script_index].Script;
5682   lsr = s->LangSysRecord;
5683
5684   if ( ALLOC_ARRAY( ltl, s->LangSysCount + 1, HB_UInt ) )
5685     return error;
5686
5687   for ( n = 0; n < s->LangSysCount; n++ )
5688     ltl[n] = lsr[n].LangSysTag;
5689   ltl[n] = 0;
5690
5691   *language_tag_list = ltl;
5692
5693   return HB_Err_Ok;
5694 }
5695
5696
5697 /* selecting 0xFFFF for language_index asks for the values of the
5698    default language (DefaultLangSys)                              */
5699
5700
5701 HB_Error  HB_GPOS_Query_Features( HB_GPOSHeader*  gpos,
5702                                   HB_UShort        script_index,
5703                                   HB_UShort        language_index,
5704                                   HB_UInt**       feature_tag_list )
5705 {
5706   HB_UShort           n;
5707   HB_Error            error;
5708   HB_UInt*           ftl;
5709
5710   HB_ScriptList*     sl;
5711   HB_ScriptRecord*   sr;
5712   HB_ScriptTable*    s;
5713   HB_LangSysRecord*  lsr;
5714   HB_LangSys*        ls;
5715   HB_UShort*          fi;
5716
5717   HB_FeatureList*    fl;
5718   HB_FeatureRecord*  fr;
5719
5720
5721   if ( !gpos || !feature_tag_list )
5722     return ERR(HB_Err_Invalid_Argument);
5723
5724   sl = &gpos->ScriptList;
5725   sr = sl->ScriptRecord;
5726
5727   fl = &gpos->FeatureList;
5728   fr = fl->FeatureRecord;
5729
5730   if ( script_index >= sl->ScriptCount )
5731     return ERR(HB_Err_Invalid_Argument);
5732
5733   s   = &sr[script_index].Script;
5734   lsr = s->LangSysRecord;
5735
5736   if ( language_index == 0xFFFF )
5737     ls = &s->DefaultLangSys;
5738   else
5739   {
5740     if ( language_index >= s->LangSysCount )
5741       return ERR(HB_Err_Invalid_Argument);
5742
5743     ls = &lsr[language_index].LangSys;
5744   }
5745
5746   fi = ls->FeatureIndex;
5747
5748   if ( ALLOC_ARRAY( ftl, ls->FeatureCount + 1, HB_UInt ) )
5749     return error;
5750
5751   for ( n = 0; n < ls->FeatureCount; n++ )
5752   {
5753     if ( fi[n] >= fl->FeatureCount )
5754     {
5755       FREE( ftl );
5756       return ERR(HB_Err_Invalid_SubTable_Format);
5757     }
5758     ftl[n] = fr[fi[n]].FeatureTag;
5759   }
5760   ftl[n] = 0;
5761
5762   *feature_tag_list = ftl;
5763
5764   return HB_Err_Ok;
5765 }
5766
5767
5768 /* Do an individual subtable lookup.  Returns HB_Err_Ok if positioning
5769    has been done, or HB_Err_Not_Covered if not.                        */
5770 static HB_Error  GPOS_Do_Glyph_Lookup( GPOS_Instance*    gpi,
5771                                        HB_UShort         lookup_index,
5772                                        HB_Buffer        buffer,
5773                                        HB_UShort         context_length,
5774                                        int               nesting_level )
5775 {
5776   HB_Error             error = HB_Err_Not_Covered;
5777   HB_UShort            i, flags, lookup_count;
5778   HB_GPOSHeader*       gpos = gpi->gpos;
5779   HB_Lookup*           lo;
5780   int                  lookup_type;
5781
5782
5783   nesting_level++;
5784
5785   if ( nesting_level > HB_MAX_NESTING_LEVEL )
5786     return ERR(HB_Err_Not_Covered); /* ERR() call intended */
5787
5788   lookup_count = gpos->LookupList.LookupCount;
5789   if (lookup_index >= lookup_count)
5790     return error;
5791
5792   lo    = &gpos->LookupList.Lookup[lookup_index];
5793   flags = lo->LookupFlag;
5794   lookup_type = lo->LookupType;
5795
5796   for ( i = 0; i < lo->SubTableCount; i++ )
5797   {
5798     HB_GPOS_SubTable *st = &lo->SubTable[i].st.gpos;
5799
5800     switch (lookup_type) {
5801       case HB_GPOS_LOOKUP_SINGLE:
5802         error = Lookup_SinglePos        ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5803       case HB_GPOS_LOOKUP_PAIR:
5804         error = Lookup_PairPos          ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5805       case HB_GPOS_LOOKUP_CURSIVE:
5806         error = Lookup_CursivePos       ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5807       case HB_GPOS_LOOKUP_MARKBASE:
5808         error = Lookup_MarkBasePos      ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5809       case HB_GPOS_LOOKUP_MARKLIG:
5810         error = Lookup_MarkLigPos       ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5811       case HB_GPOS_LOOKUP_MARKMARK:
5812         error = Lookup_MarkMarkPos      ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5813       case HB_GPOS_LOOKUP_CONTEXT:
5814         error = Lookup_ContextPos       ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5815       case HB_GPOS_LOOKUP_CHAIN:
5816         error = Lookup_ChainContextPos  ( gpi, st, buffer, flags, context_length, nesting_level ); break;
5817     /*case HB_GPOS_LOOKUP_EXTENSION:
5818         error = Lookup_ExtensionPos     ( gpi, st, buffer, flags, context_length, nesting_level ); break;*/
5819       default:
5820         error = HB_Err_Not_Covered;
5821     }
5822
5823     /* Check whether we have a successful positioning or an error other
5824        than HB_Err_Not_Covered                                         */
5825     if ( error != HB_Err_Not_Covered )
5826       return error;
5827   }
5828
5829   return HB_Err_Not_Covered;
5830 }
5831
5832
5833 HB_INTERNAL HB_Error
5834 _HB_GPOS_Load_SubTable( HB_GPOS_SubTable* st,
5835                         HB_Stream         stream,
5836                         HB_UShort         lookup_type )
5837 {
5838   switch ( lookup_type ) {
5839     case HB_GPOS_LOOKUP_SINGLE:         return Load_SinglePos           ( st, stream );
5840     case HB_GPOS_LOOKUP_PAIR:           return Load_PairPos             ( st, stream );
5841     case HB_GPOS_LOOKUP_CURSIVE:        return Load_CursivePos          ( st, stream );
5842     case HB_GPOS_LOOKUP_MARKBASE:       return Load_MarkBasePos         ( st, stream );
5843     case HB_GPOS_LOOKUP_MARKLIG:        return Load_MarkLigPos          ( st, stream );
5844     case HB_GPOS_LOOKUP_MARKMARK:       return Load_MarkMarkPos         ( st, stream );
5845     case HB_GPOS_LOOKUP_CONTEXT:        return Load_ContextPos          ( st, stream );
5846     case HB_GPOS_LOOKUP_CHAIN:          return Load_ChainContextPos     ( st, stream );
5847   /*case HB_GPOS_LOOKUP_EXTENSION:      return Load_ExtensionPos        ( st, stream );*/
5848     default:                            return ERR(HB_Err_Invalid_SubTable_Format);
5849   }
5850 }
5851
5852
5853 HB_INTERNAL void
5854 _HB_GPOS_Free_SubTable( HB_GPOS_SubTable* st,
5855                         HB_UShort         lookup_type )
5856 {
5857   switch ( lookup_type ) {
5858     case HB_GPOS_LOOKUP_SINGLE:         Free_SinglePos          ( st ); return;
5859     case HB_GPOS_LOOKUP_PAIR:           Free_PairPos            ( st ); return;
5860     case HB_GPOS_LOOKUP_CURSIVE:        Free_CursivePos         ( st ); return;
5861     case HB_GPOS_LOOKUP_MARKBASE:       Free_MarkBasePos        ( st ); return;
5862     case HB_GPOS_LOOKUP_MARKLIG:        Free_MarkLigPos         ( st ); return;
5863     case HB_GPOS_LOOKUP_MARKMARK:       Free_MarkMarkPos        ( st ); return;
5864     case HB_GPOS_LOOKUP_CONTEXT:        Free_ContextPos         ( st ); return;
5865     case HB_GPOS_LOOKUP_CHAIN:          Free_ChainContextPos    ( st ); return;
5866   /*case HB_GPOS_LOOKUP_EXTENSION:      Free_ExtensionPos       ( st ); return;*/
5867     default:                                                                    return;
5868   }
5869 }
5870
5871
5872 /* apply one lookup to the input string object */
5873
5874 static HB_Error  GPOS_Do_String_Lookup( GPOS_Instance*    gpi,
5875                                    HB_UShort         lookup_index,
5876                                    HB_Buffer        buffer )
5877 {
5878   HB_Error         error, retError = HB_Err_Not_Covered;
5879   HB_GPOSHeader*  gpos = gpi->gpos;
5880
5881   HB_UInt*  properties = gpos->LookupList.Properties;
5882
5883   const int       nesting_level = 0;
5884   /* 0xFFFF indicates that we don't have a context length yet */
5885   const HB_UShort context_length = 0xFFFF;
5886
5887
5888   gpi->last  = 0xFFFF;     /* no last valid glyph for cursive pos. */
5889
5890   buffer->in_pos = 0;
5891   while ( buffer->in_pos < buffer->in_length )
5892   {
5893     if ( ~IN_PROPERTIES( buffer->in_pos ) & properties[lookup_index] )
5894     {
5895       /* Note that the connection between mark and base glyphs hold
5896          exactly one (string) lookup.  For example, it would be possible
5897          that in the first lookup, mark glyph X is attached to base
5898          glyph A, and in the next lookup it is attached to base glyph B.
5899          It is up to the font designer to provide meaningful lookups and
5900          lookup order.                                                   */
5901
5902       error = GPOS_Do_Glyph_Lookup( gpi, lookup_index, buffer, context_length, nesting_level );
5903       if ( error && error != HB_Err_Not_Covered )
5904         return error;
5905     }
5906     else
5907     {
5908       /* Contrary to properties defined in GDEF, user-defined properties
5909          will always stop a possible cursive positioning.                */
5910       gpi->last = 0xFFFF;
5911
5912       error = HB_Err_Not_Covered;
5913     }
5914
5915     if ( error == HB_Err_Not_Covered )
5916       (buffer->in_pos)++;
5917     else
5918       retError = error;
5919   }
5920
5921   return retError;
5922 }
5923
5924
5925 static HB_Error  Position_CursiveChain ( HB_Buffer     buffer )
5926 {
5927   HB_UInt   i, j;
5928   HB_Position positions = buffer->positions;
5929
5930   /* First handle all left-to-right connections */
5931   for (j = 0; j < buffer->in_length; j++)
5932   {
5933     if (positions[j].cursive_chain > 0)
5934       positions[j].y_pos += positions[j - positions[j].cursive_chain].y_pos;
5935   }
5936
5937   /* Then handle all right-to-left connections */
5938   for (i = buffer->in_length; i > 0; i--)
5939   {
5940     j = i - 1;
5941
5942     if (positions[j].cursive_chain < 0)
5943       positions[j].y_pos += positions[j - positions[j].cursive_chain].y_pos;
5944   }
5945
5946   return HB_Err_Ok;
5947 }
5948
5949
5950 HB_Error  HB_GPOS_Add_Feature( HB_GPOSHeader*  gpos,
5951                                HB_UShort        feature_index,
5952                                HB_UInt          property )
5953 {
5954   HB_UShort    i;
5955
5956   HB_Feature  feature;
5957   HB_UInt*     properties;
5958   HB_UShort*   index;
5959   HB_UShort    lookup_count;
5960
5961   /* Each feature can only be added once */
5962
5963   if ( !gpos ||
5964        feature_index >= gpos->FeatureList.FeatureCount ||
5965        gpos->FeatureList.ApplyCount == gpos->FeatureList.FeatureCount )
5966     return ERR(HB_Err_Invalid_Argument);
5967
5968   gpos->FeatureList.ApplyOrder[gpos->FeatureList.ApplyCount++] = feature_index;
5969
5970   properties = gpos->LookupList.Properties;
5971
5972   feature = gpos->FeatureList.FeatureRecord[feature_index].Feature;
5973   index   = feature.LookupListIndex;
5974   lookup_count = gpos->LookupList.LookupCount;
5975
5976   for ( i = 0; i < feature.LookupListCount; i++ )
5977   {
5978     HB_UShort lookup_index = index[i];
5979     if (lookup_index < lookup_count)
5980       properties[lookup_index] |= property;
5981   }
5982
5983   return HB_Err_Ok;
5984 }
5985
5986
5987
5988 HB_Error  HB_GPOS_Clear_Features( HB_GPOSHeader*  gpos )
5989 {
5990   HB_UShort i;
5991
5992   HB_UInt*  properties;
5993
5994
5995   if ( !gpos )
5996     return ERR(HB_Err_Invalid_Argument);
5997
5998   gpos->FeatureList.ApplyCount = 0;
5999
6000   properties = gpos->LookupList.Properties;
6001
6002   for ( i = 0; i < gpos->LookupList.LookupCount; i++ )
6003     properties[i] = 0;
6004
6005   return HB_Err_Ok;
6006 }
6007
6008 #ifdef HB_SUPPORT_MULTIPLE_MASTER
6009 HB_Error  HB_GPOS_Register_MM_Function( HB_GPOSHeader*  gpos,
6010                                         HB_MMFunction   mmfunc,
6011                                         void*            data )
6012 {
6013   if ( !gpos )
6014     return ERR(HB_Err_Invalid_Argument);
6015
6016   gpos->mmfunc = mmfunc;
6017   gpos->data   = data;
6018
6019   return HB_Err_Ok;
6020 }
6021 #endif
6022
6023 /* If `dvi' is TRUE, glyph contour points for anchor points and device
6024    tables are ignored -- you will get device independent values.         */
6025
6026
6027 HB_Error  HB_GPOS_Apply_String( HB_Font            font,
6028                                 HB_GPOSHeader*    gpos,
6029                                 HB_UShort          load_flags,
6030                                 HB_Buffer         buffer,
6031                                 HB_Bool            dvi,
6032                                 HB_Bool            r2l )
6033 {
6034   HB_Error       error, retError = HB_Err_Not_Covered;
6035   GPOS_Instance  gpi;
6036   int            i, j, lookup_count, num_features;
6037
6038   if ( !font || !gpos || !buffer )
6039     return ERR(HB_Err_Invalid_Argument);
6040
6041   if ( buffer->in_length == 0 )
6042     return HB_Err_Not_Covered;
6043
6044   gpi.font       = font;
6045   gpi.gpos       = gpos;
6046   gpi.load_flags = load_flags;
6047   gpi.r2l        = r2l;
6048   gpi.dvi        = dvi;
6049
6050   lookup_count = gpos->LookupList.LookupCount;
6051   num_features = gpos->FeatureList.ApplyCount;
6052
6053   if ( num_features )
6054     {
6055       error = _hb_buffer_clear_positions( buffer );
6056       if ( error )
6057         return error;
6058     }
6059
6060   for ( i = 0; i < num_features; i++ )
6061   {
6062     HB_UShort  feature_index = gpos->FeatureList.ApplyOrder[i];
6063     HB_Feature feature = gpos->FeatureList.FeatureRecord[feature_index].Feature;
6064
6065     for ( j = 0; j < feature.LookupListCount; j++ )
6066     {
6067       HB_UShort lookup_index = feature.LookupListIndex[j];
6068
6069       /* Skip nonexistant lookups */
6070       if (lookup_index >= lookup_count)
6071        continue;
6072
6073       error = GPOS_Do_String_Lookup( &gpi, lookup_index, buffer );
6074       if ( error )
6075       {
6076         if ( error != HB_Err_Not_Covered )
6077           return error;
6078       }
6079       else
6080         retError = error;
6081     }
6082   }
6083
6084   if ( num_features )
6085     {
6086   error = Position_CursiveChain ( buffer );
6087   if ( error )
6088     return error;
6089     }
6090
6091   return retError;
6092 }
6093
6094 /* END */