src/hb-old/harfbuzz-gdef.c

   1 /*
   2  * Copyright (C) 1998-2004  David Turner and Werner Lemberg
   3  * Copyright (C) 2006  Behdad Esfahbod
   4  *
   5  * This is part of HarfBuzz, an OpenType Layout engine library.
   6  *
   7  * Permission is hereby granted, without written agreement and without
   8  * license or royalty fees, to use, copy, modify, and distribute this
   9  * software and its documentation for any purpose, provided that the
  10  * above copyright notice and the following two paragraphs appear in
  11  * all copies of this software.
  12  *
  13  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  14  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  15  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  16  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  17  * DAMAGE.
  18  *
  19  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  20  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  21  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  22  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  23  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  24  */
  25
  26 #include "harfbuzz-impl.h"
  27 #include "harfbuzz-gdef-private.h"
  28 #include "harfbuzz-open-private.h"
  29
  30 static HB_Error  Load_AttachList( HB_AttachList*  al,
  31                                   HB_Stream        stream );
  32 static HB_Error  Load_LigCaretList( HB_LigCaretList*  lcl,
  33                                     HB_Stream          stream );
  34
  35 static void  Free_AttachList( HB_AttachList*  al);
  36 static void  Free_LigCaretList( HB_LigCaretList*  lcl);
  37
  38 static void  Free_NewGlyphClasses( HB_GDEFHeader*  gdef);
  39
  40
  41
  42 /* GDEF glyph classes */
  43
  44 #define UNCLASSIFIED_GLYPH  0
  45 #define SIMPLE_GLYPH        1
  46 #define LIGATURE_GLYPH      2
  47 #define MARK_GLYPH          3
  48 #define COMPONENT_GLYPH     4
  49
  50
  51
  52
  53
  54
  55 HB_Error  HB_New_GDEF_Table( HB_GDEFHeader** retptr )
  56 {
  57   HB_Error         error;
  58
  59   HB_GDEFHeader*  gdef;
  60
  61   if ( !retptr )
  62     return ERR(HB_Err_Invalid_Argument);
  63
  64   if ( ALLOC( gdef, sizeof( *gdef ) ) )
  65     return error;
  66
  67   gdef->GlyphClassDef.loaded = FALSE;
  68   gdef->AttachList.loaded = FALSE;
  69   gdef->LigCaretList.loaded = FALSE;
  70   gdef->MarkAttachClassDef_offset = 0;
  71   gdef->MarkAttachClassDef.loaded = FALSE;
  72
  73   gdef->LastGlyph = 0;
  74   gdef->NewGlyphClasses = NULL;
  75
  76   *retptr = gdef;
  77
  78   return HB_Err_Ok;
  79 }
  80
  81
  82 HB_Error  HB_Load_GDEF_Table( HB_Stream stream,
  83                               HB_GDEFHeader** retptr )
  84 {
  85   HB_Error         error;
  86   HB_UInt         cur_offset, new_offset, base_offset;
  87
  88   HB_GDEFHeader*  gdef;
  89
  90
  91   if ( !retptr )
  92     return ERR(HB_Err_Invalid_Argument);
  93
  94   if ( GOTO_Table( TTAG_GDEF ) )
  95     return error;
  96
  97   if (( error = HB_New_GDEF_Table ( &gdef ) ))
  98     return error;
  99
 100   base_offset = FILE_Pos();
 101
 102   /* skip version */
 103
 104   if ( FILE_Seek( base_offset + 4L ) ||
 105        ACCESS_Frame( 2L ) )
 106     goto Fail0;
 107
 108   new_offset = GET_UShort();
 109
 110   FORGET_Frame();
 111
 112   /* all GDEF subtables are optional */
 113
 114   if ( new_offset )
 115   {
 116     new_offset += base_offset;
 117
 118     /* only classes 1-4 are allowed here */
 119
 120     cur_offset = FILE_Pos();
 121     if ( FILE_Seek( new_offset ) ||
 122          ( error = _HB_OPEN_Load_ClassDefinition( &gdef->GlyphClassDef, 5,
 123                                          stream ) ) != HB_Err_Ok )
 124       goto Fail0;
 125     (void)FILE_Seek( cur_offset );
 126   }
 127
 128   if ( ACCESS_Frame( 2L ) )
 129     goto Fail1;
 130
 131   new_offset = GET_UShort();
 132
 133   FORGET_Frame();
 134
 135   if ( new_offset )
 136   {
 137     new_offset += base_offset;
 138
 139     cur_offset = FILE_Pos();
 140     if ( FILE_Seek( new_offset ) ||
 141          ( error = Load_AttachList( &gdef->AttachList,
 142                                     stream ) ) != HB_Err_Ok )
 143       goto Fail1;
 144     (void)FILE_Seek( cur_offset );
 145   }
 146
 147   if ( ACCESS_Frame( 2L ) )
 148     goto Fail2;
 149
 150   new_offset = GET_UShort();
 151
 152   FORGET_Frame();
 153
 154   if ( new_offset )
 155   {
 156     new_offset += base_offset;
 157
 158     cur_offset = FILE_Pos();
 159     if ( FILE_Seek( new_offset ) ||
 160          ( error = Load_LigCaretList( &gdef->LigCaretList,
 161                                       stream ) ) != HB_Err_Ok )
 162       goto Fail2;
 163     (void)FILE_Seek( cur_offset );
 164   }
 165
 166   /* OpenType 1.2 has introduced the `MarkAttachClassDef' field.  We
 167      first have to scan the LookupFlag values to find out whether we
 168      must load it or not.  Here we only store the offset of the table. */
 169
 170   if ( ACCESS_Frame( 2L ) )
 171     goto Fail3;
 172
 173   new_offset = GET_UShort();
 174
 175   FORGET_Frame();
 176
 177   if ( new_offset )
 178     gdef->MarkAttachClassDef_offset = new_offset + base_offset;
 179   else
 180     gdef->MarkAttachClassDef_offset = 0;
 181
 182   *retptr = gdef;
 183
 184   return HB_Err_Ok;
 185
 186 Fail3:
 187   Free_LigCaretList( &gdef->LigCaretList );
 188
 189 Fail2:
 190   Free_AttachList( &gdef->AttachList );
 191
 192 Fail1:
 193   _HB_OPEN_Free_ClassDefinition( &gdef->GlyphClassDef );
 194
 195 Fail0:
 196   FREE( gdef );
 197
 198   return error;
 199 }
 200
 201
 202 HB_Error  HB_Done_GDEF_Table ( HB_GDEFHeader* gdef )
 203 {
 204   Free_LigCaretList( &gdef->LigCaretList );
 205   Free_AttachList( &gdef->AttachList );
 206   _HB_OPEN_Free_ClassDefinition( &gdef->GlyphClassDef );
 207   _HB_OPEN_Free_ClassDefinition( &gdef->MarkAttachClassDef );
 208
 209   Free_NewGlyphClasses( gdef );
 210
 211   FREE( gdef );
 212
 213   return HB_Err_Ok;
 214 }
 215
 216
 217
 218
 219 /*******************************
 220  * AttachList related functions
 221  *******************************/
 222
 223
 224 /* AttachPoint */
 225
 226 static HB_Error  Load_AttachPoint( HB_AttachPoint*  ap,
 227                                    HB_Stream         stream )
 228 {
 229   HB_Error  error;
 230
 231   HB_UShort   n, count;
 232   HB_UShort*  pi;
 233
 234
 235   if ( ACCESS_Frame( 2L ) )
 236     return error;
 237
 238   count = ap->PointCount = GET_UShort();
 239
 240   FORGET_Frame();
 241
 242   ap->PointIndex = NULL;
 243
 244   if ( count )
 245   {
 246     if ( ALLOC_ARRAY( ap->PointIndex, count, HB_UShort ) )
 247       return error;
 248
 249     pi = ap->PointIndex;
 250
 251     if ( ACCESS_Frame( count * 2L ) )
 252     {
 253       FREE( pi );
 254       return error;
 255     }
 256
 257     for ( n = 0; n < count; n++ )
 258       pi[n] = GET_UShort();
 259
 260     FORGET_Frame();
 261   }
 262
 263   return HB_Err_Ok;
 264 }
 265
 266
 267 static void  Free_AttachPoint( HB_AttachPoint*  ap )
 268 {
 269   FREE( ap->PointIndex );
 270 }
 271
 272
 273 /* AttachList */
 274
 275 static HB_Error  Load_AttachList( HB_AttachList*  al,
 276                                   HB_Stream        stream )
 277 {
 278   HB_Error  error;
 279
 280   HB_UShort         n, m, count;
 281   HB_UInt          cur_offset, new_offset, base_offset;
 282
 283   HB_AttachPoint*  ap;
 284
 285
 286   base_offset = FILE_Pos();
 287
 288   if ( ACCESS_Frame( 2L ) )
 289     return error;
 290
 291   new_offset = GET_UShort() + base_offset;
 292
 293   FORGET_Frame();
 294
 295   cur_offset = FILE_Pos();
 296   if ( FILE_Seek( new_offset ) ||
 297        ( error = _HB_OPEN_Load_Coverage( &al->Coverage, stream ) ) != HB_Err_Ok )
 298     return error;
 299   (void)FILE_Seek( cur_offset );
 300
 301   if ( ACCESS_Frame( 2L ) )
 302     goto Fail2;
 303
 304   count = al->GlyphCount = GET_UShort();
 305
 306   FORGET_Frame();
 307
 308   al->AttachPoint = NULL;
 309
 310   if ( ALLOC_ARRAY( al->AttachPoint, count, HB_AttachPoint ) )
 311     goto Fail2;
 312
 313   ap = al->AttachPoint;
 314
 315   for ( n = 0; n < count; n++ )
 316   {
 317     if ( ACCESS_Frame( 2L ) )
 318       goto Fail1;
 319
 320     new_offset = GET_UShort() + base_offset;
 321
 322     FORGET_Frame();
 323
 324     cur_offset = FILE_Pos();
 325     if ( FILE_Seek( new_offset ) ||
 326          ( error = Load_AttachPoint( &ap[n], stream ) ) != HB_Err_Ok )
 327       goto Fail1;
 328     (void)FILE_Seek( cur_offset );
 329   }
 330
 331   al->loaded = TRUE;
 332
 333   return HB_Err_Ok;
 334
 335 Fail1:
 336   for ( m = 0; m < n; m++ )
 337     Free_AttachPoint( &ap[m] );
 338
 339   FREE( ap );
 340
 341 Fail2:
 342   _HB_OPEN_Free_Coverage( &al->Coverage );
 343   return error;
 344 }
 345
 346
 347 static void  Free_AttachList( HB_AttachList*  al)
 348 {
 349   HB_UShort         n, count;
 350
 351   HB_AttachPoint*  ap;
 352
 353
 354   if ( !al->loaded )
 355     return;
 356
 357   if ( al->AttachPoint )
 358   {
 359     count = al->GlyphCount;
 360     ap    = al->AttachPoint;
 361
 362     for ( n = 0; n < count; n++ )
 363       Free_AttachPoint( &ap[n] );
 364
 365     FREE( ap );
 366   }
 367
 368   _HB_OPEN_Free_Coverage( &al->Coverage );
 369 }
 370
 371
 372
 373 /*********************************
 374  * LigCaretList related functions
 375  *********************************/
 376
 377
 378 /* CaretValueFormat1 */
 379 /* CaretValueFormat2 */
 380 /* CaretValueFormat3 */
 381 /* CaretValueFormat4 */
 382
 383 static HB_Error  Load_CaretValue( HB_CaretValue*  cv,
 384                                   HB_Stream        stream )
 385 {
 386   HB_Error  error;
 387
 388   HB_UInt cur_offset, new_offset, base_offset;
 389
 390
 391   base_offset = FILE_Pos();
 392
 393   if ( ACCESS_Frame( 2L ) )
 394     return error;
 395
 396   cv->CaretValueFormat = GET_UShort();
 397
 398   FORGET_Frame();
 399
 400   switch ( cv->CaretValueFormat )
 401   {
 402   case 1:
 403     if ( ACCESS_Frame( 2L ) )
 404       return error;
 405
 406     cv->cvf.cvf1.Coordinate = GET_Short();
 407
 408     FORGET_Frame();
 409
 410     break;
 411
 412   case 2:
 413     if ( ACCESS_Frame( 2L ) )
 414       return error;
 415
 416     cv->cvf.cvf2.CaretValuePoint = GET_UShort();
 417
 418     FORGET_Frame();
 419
 420     break;
 421
 422   case 3:
 423     if ( ACCESS_Frame( 4L ) )
 424       return error;
 425
 426     cv->cvf.cvf3.Coordinate = GET_Short();
 427
 428     new_offset = GET_UShort() + base_offset;
 429
 430     FORGET_Frame();
 431
 432     cur_offset = FILE_Pos();
 433     if ( FILE_Seek( new_offset ) ||
 434          ( error = _HB_OPEN_Load_Device( &cv->cvf.cvf3.Device,
 435                                 stream ) ) != HB_Err_Ok )
 436       return error;
 437     (void)FILE_Seek( cur_offset );
 438
 439     break;
 440
 441   case 4:
 442     if ( ACCESS_Frame( 2L ) )
 443       return error;
 444
 445 #ifdef HB_SUPPORT_MULTIPLE_MASTER
 446     cv->cvf.cvf4.IdCaretValue = GET_UShort();
 447 #else
 448     (void) GET_UShort();
 449 #endif
 450
 451     FORGET_Frame();
 452     break;
 453
 454   default:
 455     return ERR(HB_Err_Invalid_SubTable_Format);
 456   }
 457
 458   return HB_Err_Ok;
 459 }
 460
 461
 462 static void  Free_CaretValue( HB_CaretValue*  cv)
 463 {
 464   if ( cv->CaretValueFormat == 3 )
 465     _HB_OPEN_Free_Device( cv->cvf.cvf3.Device );
 466 }
 467
 468
 469 /* LigGlyph */
 470
 471 static HB_Error  Load_LigGlyph( HB_LigGlyph*  lg,
 472                                 HB_Stream      stream )
 473 {
 474   HB_Error  error;
 475
 476   HB_UShort        n, m, count;
 477   HB_UInt         cur_offset, new_offset, base_offset;
 478
 479   HB_CaretValue*  cv;
 480
 481
 482   base_offset = FILE_Pos();
 483
 484   if ( ACCESS_Frame( 2L ) )
 485     return error;
 486
 487   count = lg->CaretCount = GET_UShort();
 488
 489   FORGET_Frame();
 490
 491   lg->CaretValue = NULL;
 492
 493   if ( ALLOC_ARRAY( lg->CaretValue, count, HB_CaretValue ) )
 494     return error;
 495
 496   cv = lg->CaretValue;
 497
 498   for ( n = 0; n < count; n++ )
 499   {
 500     if ( ACCESS_Frame( 2L ) )
 501       goto Fail;
 502
 503     new_offset = GET_UShort() + base_offset;
 504
 505     FORGET_Frame();
 506
 507     cur_offset = FILE_Pos();
 508     if ( FILE_Seek( new_offset ) ||
 509          ( error = Load_CaretValue( &cv[n], stream ) ) != HB_Err_Ok )
 510       goto Fail;
 511     (void)FILE_Seek( cur_offset );
 512   }
 513
 514   return HB_Err_Ok;
 515
 516 Fail:
 517   for ( m = 0; m < n; m++ )
 518     Free_CaretValue( &cv[m] );
 519
 520   FREE( cv );
 521   return error;
 522 }
 523
 524
 525 static void  Free_LigGlyph( HB_LigGlyph*  lg)
 526 {
 527   HB_UShort        n, count;
 528
 529   HB_CaretValue*  cv;
 530
 531
 532   if ( lg->CaretValue )
 533   {
 534     count = lg->CaretCount;
 535     cv    = lg->CaretValue;
 536
 537     for ( n = 0; n < count; n++ )
 538       Free_CaretValue( &cv[n] );
 539
 540     FREE( cv );
 541   }
 542 }
 543
 544
 545 /* LigCaretList */
 546
 547 static HB_Error  Load_LigCaretList( HB_LigCaretList*  lcl,
 548                                     HB_Stream          stream )
 549 {
 550   HB_Error  error;
 551
 552   HB_UShort      m, n, count;
 553   HB_UInt       cur_offset, new_offset, base_offset;
 554
 555   HB_LigGlyph*  lg;
 556
 557
 558   base_offset = FILE_Pos();
 559
 560   if ( ACCESS_Frame( 2L ) )
 561     return error;
 562
 563   new_offset = GET_UShort() + base_offset;
 564
 565   FORGET_Frame();
 566
 567   cur_offset = FILE_Pos();
 568   if ( FILE_Seek( new_offset ) ||
 569        ( error = _HB_OPEN_Load_Coverage( &lcl->Coverage, stream ) ) != HB_Err_Ok )
 570     return error;
 571   (void)FILE_Seek( cur_offset );
 572
 573   if ( ACCESS_Frame( 2L ) )
 574     goto Fail2;
 575
 576   count = lcl->LigGlyphCount = GET_UShort();
 577
 578   FORGET_Frame();
 579
 580   lcl->LigGlyph = NULL;
 581
 582   if ( ALLOC_ARRAY( lcl->LigGlyph, count, HB_LigGlyph ) )
 583     goto Fail2;
 584
 585   lg = lcl->LigGlyph;
 586
 587   for ( n = 0; n < count; n++ )
 588   {
 589     if ( ACCESS_Frame( 2L ) )
 590       goto Fail1;
 591
 592     new_offset = GET_UShort() + base_offset;
 593
 594     FORGET_Frame();
 595
 596     cur_offset = FILE_Pos();
 597     if ( FILE_Seek( new_offset ) ||
 598          ( error = Load_LigGlyph( &lg[n], stream ) ) != HB_Err_Ok )
 599       goto Fail1;
 600     (void)FILE_Seek( cur_offset );
 601   }
 602
 603   lcl->loaded = TRUE;
 604
 605   return HB_Err_Ok;
 606
 607 Fail1:
 608   for ( m = 0; m < n; m++ )
 609     Free_LigGlyph( &lg[m] );
 610
 611   FREE( lg );
 612
 613 Fail2:
 614   _HB_OPEN_Free_Coverage( &lcl->Coverage );
 615   return error;
 616 }
 617
 618
 619 static void  Free_LigCaretList( HB_LigCaretList*  lcl )
 620 {
 621   HB_UShort      n, count;
 622
 623   HB_LigGlyph*  lg;
 624
 625
 626   if ( !lcl->loaded )
 627     return;
 628
 629   if ( lcl->LigGlyph )
 630   {
 631     count = lcl->LigGlyphCount;
 632     lg    = lcl->LigGlyph;
 633
 634     for ( n = 0; n < count; n++ )
 635       Free_LigGlyph( &lg[n] );
 636
 637     FREE( lg );
 638   }
 639
 640   _HB_OPEN_Free_Coverage( &lcl->Coverage );
 641 }
 642
 643
 644
 645 /***********
 646  * GDEF API
 647  ***********/
 648
 649
 650 static HB_UShort  Get_New_Class( HB_GDEFHeader*  gdef,
 651                                  HB_UShort        glyphID,
 652                                  HB_UShort        index )
 653 {
 654   HB_UShort              glyph_index, array_index, count;
 655   HB_UShort              byte, bits;
 656
 657   HB_ClassRangeRecord*  gcrr;
 658   HB_UShort**            ngc;
 659
 660
 661   if ( glyphID >= gdef->LastGlyph )
 662     return 0;
 663
 664   count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount;
 665   gcrr = gdef->GlyphClassDef.cd.cd2.ClassRangeRecord;
 666   ngc  = gdef->NewGlyphClasses;
 667
 668   if ( index < count && glyphID < gcrr[index].Start )
 669   {
 670     array_index = index;
 671     if ( index == 0 )
 672       glyph_index = glyphID;
 673     else
 674       glyph_index = glyphID - gcrr[index - 1].End - 1;
 675   }
 676   else
 677   {
 678     array_index = index + 1;
 679     glyph_index = glyphID - gcrr[index].End - 1;
 680   }
 681
 682   byte = ngc[array_index][glyph_index / 4];
 683   bits = byte >> ( 16 - ( glyph_index % 4 + 1 ) * 4 );
 684
 685   return bits & 0x000F;
 686 }
 687
 688
 689
 690 HB_Error  HB_GDEF_Get_Glyph_Property( HB_GDEFHeader*  gdef,
 691                                       HB_UShort        glyphID,
 692                                       HB_UShort*       property )
 693 {
 694   HB_UShort class = 0, index = 0; /* shut compiler up */
 695
 696   HB_Error  error;
 697
 698
 699   if ( !gdef || !property )
 700     return ERR(HB_Err_Invalid_Argument);
 701
 702   /* first, we check for mark attach classes */
 703
 704   if ( gdef->MarkAttachClassDef.loaded )
 705   {
 706     error = _HB_OPEN_Get_Class( &gdef->MarkAttachClassDef, glyphID, &class, &index );
 707     if ( error && error != HB_Err_Not_Covered )
 708       return error;
 709     if ( !error )
 710     {
 711       *property = class << 8;
 712       return HB_Err_Ok;
 713     }
 714   }
 715
 716   error = _HB_OPEN_Get_Class( &gdef->GlyphClassDef, glyphID, &class, &index );
 717   if ( error && error != HB_Err_Not_Covered )
 718     return error;
 719
 720   /* if we have a constructed class table, check whether additional
 721      values have been assigned                                      */
 722
 723   if ( error == HB_Err_Not_Covered && gdef->NewGlyphClasses )
 724     class = Get_New_Class( gdef, glyphID, index );
 725
 726   switch ( class )
 727   {
 728   default:
 729   case UNCLASSIFIED_GLYPH:
 730     *property = 0;
 731     break;
 732
 733   case SIMPLE_GLYPH:
 734     *property = HB_GDEF_BASE_GLYPH;
 735     break;
 736
 737   case LIGATURE_GLYPH:
 738     *property = HB_GDEF_LIGATURE;
 739     break;
 740
 741   case MARK_GLYPH:
 742     *property = HB_GDEF_MARK;
 743     break;
 744
 745   case COMPONENT_GLYPH:
 746     *property = HB_GDEF_COMPONENT;
 747     break;
 748   }
 749
 750   return HB_Err_Ok;
 751 }
 752
 753
 754 static HB_Error  Make_ClassRange( HB_ClassDefinition*  cd,
 755                                   HB_UShort             start,
 756                                   HB_UShort             end,
 757                                   HB_UShort             class )
 758 {
 759   HB_Error               error;
 760   HB_UShort              index;
 761
 762   HB_ClassDefFormat2*   cdf2;
 763   HB_ClassRangeRecord*  crr;
 764
 765
 766   cdf2 = &cd->cd.cd2;
 767
 768   if ( REALLOC_ARRAY( cdf2->ClassRangeRecord,
 769                       cdf2->ClassRangeCount + 1 ,
 770                       HB_ClassRangeRecord ) )
 771     return error;
 772
 773   cdf2->ClassRangeCount++;
 774
 775   crr   = cdf2->ClassRangeRecord;
 776   index = cdf2->ClassRangeCount - 1;
 777
 778   crr[index].Start = start;
 779   crr[index].End   = end;
 780   crr[index].Class = class;
 781
 782   return HB_Err_Ok;
 783 }
 784
 785
 786
 787 HB_Error  HB_GDEF_Build_ClassDefinition( HB_GDEFHeader*  gdef,
 788                                          HB_UShort        num_glyphs,
 789                                          HB_UShort        glyph_count,
 790                                          HB_UShort*       glyph_array,
 791                                          HB_UShort*       class_array )
 792 {
 793   HB_UShort              start, curr_glyph, curr_class;
 794   HB_UShort              n, m, count;
 795   HB_Error               error;
 796
 797   HB_ClassDefinition*   gcd;
 798   HB_ClassRangeRecord*  gcrr;
 799   HB_UShort**            ngc;
 800
 801
 802   if ( !gdef || !glyph_array || !class_array )
 803     return ERR(HB_Err_Invalid_Argument);
 804
 805   gcd = &gdef->GlyphClassDef;
 806
 807   /* We build a format 2 table */
 808
 809   gcd->ClassFormat = 2;
 810
 811   gcd->cd.cd2.ClassRangeCount  = 0;
 812   gcd->cd.cd2.ClassRangeRecord = NULL;
 813
 814   start      = glyph_array[0];
 815   curr_class = class_array[0];
 816   curr_glyph = start;
 817
 818   if ( curr_class >= 5 )
 819   {
 820     error = ERR(HB_Err_Invalid_Argument);
 821     goto Fail4;
 822   }
 823
 824   glyph_count--;
 825
 826   for ( n = 0; n < glyph_count + 1; n++ )
 827   {
 828     if ( curr_glyph == glyph_array[n] && curr_class == class_array[n] )
 829     {
 830       if ( n == glyph_count )
 831       {
 832         if ( ( error = Make_ClassRange( gcd, start,
 833                                         curr_glyph,
 834                                         curr_class) ) != HB_Err_Ok )
 835           goto Fail3;
 836       }
 837       else
 838       {
 839         if ( curr_glyph == 0xFFFF )
 840         {
 841           error = ERR(HB_Err_Invalid_Argument);
 842           goto Fail3;
 843         }
 844         else
 845           curr_glyph++;
 846       }
 847     }
 848     else
 849     {
 850       if ( ( error = Make_ClassRange( gcd, start,
 851                                       curr_glyph - 1,
 852                                       curr_class) ) != HB_Err_Ok )
 853         goto Fail3;
 854
 855       if ( curr_glyph > glyph_array[n] )
 856       {
 857         error = ERR(HB_Err_Invalid_Argument);
 858         goto Fail3;
 859       }
 860
 861       start      = glyph_array[n];
 862       curr_class = class_array[n];
 863       curr_glyph = start;
 864
 865       if ( curr_class >= 5 )
 866       {
 867         error = ERR(HB_Err_Invalid_Argument);
 868         goto Fail3;
 869       }
 870
 871       if ( n == glyph_count )
 872       {
 873         if ( ( error = Make_ClassRange( gcd, start,
 874                                         curr_glyph,
 875                                         curr_class) ) != HB_Err_Ok )
 876           goto Fail3;
 877       }
 878       else
 879       {
 880         if ( curr_glyph == 0xFFFF )
 881         {
 882           error = ERR(HB_Err_Invalid_Argument);
 883           goto Fail3;
 884         }
 885         else
 886           curr_glyph++;
 887       }
 888     }
 889   }
 890
 891   /* now prepare the arrays for class values assigned during the lookup
 892      process                                                            */
 893
 894   if ( ALLOC_ARRAY( gdef->NewGlyphClasses,
 895                     gcd->cd.cd2.ClassRangeCount + 1, HB_UShort* ) )
 896     goto Fail3;
 897
 898   count = gcd->cd.cd2.ClassRangeCount;
 899   gcrr  = gcd->cd.cd2.ClassRangeRecord;
 900   ngc   = gdef->NewGlyphClasses;
 901
 902   /* We allocate arrays for all glyphs not covered by the class range
 903      records.  Each element holds four class values.                  */
 904
 905   if ( count > 0 )
 906   {
 907       if ( gcrr[0].Start )
 908       {
 909         if ( ALLOC_ARRAY( ngc[0], ( gcrr[0].Start + 3 ) / 4, HB_UShort ) )
 910           goto Fail2;
 911       }
 912
 913       for ( n = 1; n < count; n++ )
 914       {
 915         if ( gcrr[n].Start - gcrr[n - 1].End > 1 )
 916           if ( ALLOC_ARRAY( ngc[n],
 917                             ( gcrr[n].Start - gcrr[n - 1].End + 2 ) / 4,
 918                             HB_UShort ) )
 919             goto Fail1;
 920       }
 921
 922       if ( gcrr[count - 1].End != num_glyphs - 1 )
 923       {
 924         if ( ALLOC_ARRAY( ngc[count],
 925                           ( num_glyphs - gcrr[count - 1].End + 2 ) / 4,
 926                           HB_UShort ) )
 927             goto Fail1;
 928       }
 929   }
 930   else if ( num_glyphs > 0 )
 931   {
 932       if ( ALLOC_ARRAY( ngc[count],
 933                         ( num_glyphs + 3 ) / 4,
 934                         HB_UShort ) )
 935           goto Fail2;
 936   }
 937
 938   gdef->LastGlyph = num_glyphs - 1;
 939
 940   gdef->MarkAttachClassDef_offset = 0L;
 941   gdef->MarkAttachClassDef.loaded = FALSE;
 942
 943   gcd->loaded = TRUE;
 944
 945   return HB_Err_Ok;
 946
 947 Fail1:
 948   for ( m = 0; m < n; m++ )
 949     FREE( ngc[m] );
 950
 951 Fail2:
 952   FREE( gdef->NewGlyphClasses );
 953
 954 Fail3:
 955   FREE( gcd->cd.cd2.ClassRangeRecord );
 956
 957 Fail4:
 958   return error;
 959 }
 960
 961
 962 static void  Free_NewGlyphClasses( HB_GDEFHeader*  gdef )
 963 {
 964   HB_UShort**  ngc;
 965   HB_UShort    n, count;
 966
 967
 968   if ( gdef->NewGlyphClasses )
 969   {
 970     count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount + 1;
 971     ngc   = gdef->NewGlyphClasses;
 972
 973     for ( n = 0; n < count; n++ )
 974       FREE( ngc[n] );
 975
 976     FREE( ngc );
 977   }
 978 }
 979
 980
 981 HB_INTERNAL HB_Error
 982 _HB_GDEF_Add_Glyph_Property( HB_GDEFHeader* gdef,
 983                               HB_UShort        glyphID,
 984                               HB_UShort        property )
 985 {
 986   HB_Error               error;
 987   HB_UShort              class, new_class, index = 0; /* shut compiler up */
 988   HB_UShort              byte, bits, mask;
 989   HB_UShort              array_index, glyph_index, count;
 990
 991   HB_ClassRangeRecord*  gcrr;
 992   HB_UShort**            ngc;
 993
 994
 995   error = _HB_OPEN_Get_Class( &gdef->GlyphClassDef, glyphID, &class, &index );
 996   if ( error && error != HB_Err_Not_Covered )
 997     return error;
 998
 999   /* we don't accept glyphs covered in `GlyphClassDef' */
1000
1001   if ( !error )
1002     return HB_Err_Not_Covered;
1003
1004   switch ( property )
1005   {
1006   case 0:
1007     new_class = UNCLASSIFIED_GLYPH;
1008     break;
1009
1010   case HB_GDEF_BASE_GLYPH:
1011     new_class = SIMPLE_GLYPH;
1012     break;
1013
1014   case HB_GDEF_LIGATURE:
1015     new_class = LIGATURE_GLYPH;
1016     break;
1017
1018   case HB_GDEF_MARK:
1019     new_class = MARK_GLYPH;
1020     break;
1021
1022   case HB_GDEF_COMPONENT:
1023     new_class = COMPONENT_GLYPH;
1024     break;
1025
1026   default:
1027     return ERR(HB_Err_Invalid_Argument);
1028   }
1029
1030   count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount;
1031   gcrr = gdef->GlyphClassDef.cd.cd2.ClassRangeRecord;
1032   ngc  = gdef->NewGlyphClasses;
1033
1034   if ( index < count && glyphID < gcrr[index].Start )
1035   {
1036     array_index = index;
1037     if ( index == 0 )
1038       glyph_index = glyphID;
1039     else
1040       glyph_index = glyphID - gcrr[index - 1].End - 1;
1041   }
1042   else
1043   {
1044     array_index = index + 1;
1045     glyph_index = glyphID - gcrr[index].End - 1;
1046   }
1047
1048   byte  = ngc[array_index][glyph_index / 4];
1049   bits  = byte >> ( 16 - ( glyph_index % 4 + 1 ) * 4 );
1050   class = bits & 0x000F;
1051
1052   /* we don't overwrite existing entries */
1053
1054   if ( !class )
1055   {
1056     bits = new_class << ( 16 - ( glyph_index % 4 + 1 ) * 4 );
1057     mask = ~( 0x000F << ( 16 - ( glyph_index % 4 + 1 ) * 4 ) );
1058
1059     ngc[array_index][glyph_index / 4] &= mask;
1060     ngc[array_index][glyph_index / 4] |= bits;
1061   }
1062
1063   return HB_Err_Ok;
1064 }
1065
1066
1067 HB_INTERNAL HB_Error
1068 _HB_GDEF_Check_Property( HB_GDEFHeader* gdef,
1069                           HB_GlyphItem    gitem,
1070                           HB_UShort        flags,
1071                           HB_UShort*       property )
1072 {
1073   HB_Error  error;
1074
1075   if ( gdef )
1076   {
1077     HB_UShort basic_glyph_class;
1078     HB_UShort desired_attachment_class;
1079
1080     if ( gitem->gproperties == HB_GLYPH_PROPERTIES_UNKNOWN )
1081     {
1082       error = HB_GDEF_Get_Glyph_Property( gdef, gitem->gindex, &gitem->gproperties );
1083       if ( error )
1084         return error;
1085     }
1086
1087     *property = gitem->gproperties;
1088
1089     /* If the glyph was found in the MarkAttachmentClass table,
1090      * then that class value is the high byte of the result,
1091      * otherwise the low byte contains the basic type of the glyph
1092      * as defined by the GlyphClassDef table.
1093      */
1094     if ( *property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS  )
1095       basic_glyph_class = HB_GDEF_MARK;
1096     else
1097       basic_glyph_class = *property;
1098
1099     /* Return Not_Covered, if, for example, basic_glyph_class
1100      * is HB_GDEF_LIGATURE and LookFlags includes HB_LOOKUP_FLAG_IGNORE_LIGATURES
1101      */
1102     if ( flags & basic_glyph_class )
1103       return HB_Err_Not_Covered;
1104
1105     /* The high byte of LookupFlags has the meaning
1106      * "ignore marks of attachment type different than
1107      * the attachment type specified."
1108      */
1109     desired_attachment_class = flags & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS;
1110     if ( desired_attachment_class )
1111     {
1112       if ( basic_glyph_class == HB_GDEF_MARK &&
1113            *property != desired_attachment_class )
1114         return HB_Err_Not_Covered;
1115     }
1116   } else {
1117       *property = 0;
1118   }
1119
1120   return HB_Err_Ok;
1121 }
1122
1123 HB_INTERNAL HB_Error
1124 _HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( HB_GDEFHeader* gdef,
1125                                                   HB_Stream      stream,
1126                                                   HB_Lookup*     lo,
1127                                                   HB_UShort      num_lookups)
1128 {
1129   HB_Error   error = HB_Err_Ok;
1130   HB_UShort  i;
1131
1132   /* We now check the LookupFlags for values larger than 0xFF to find
1133      out whether we need to load the `MarkAttachClassDef' field of the
1134      GDEF table -- this hack is necessary for OpenType 1.2 tables since
1135      the version field of the GDEF table hasn't been incremented.
1136
1137      For constructed GDEF tables, we only load it if
1138      `MarkAttachClassDef_offset' is not zero (nevertheless, a build of
1139      a constructed mark attach table is not supported currently).       */
1140
1141   if ( gdef &&
1142        gdef->MarkAttachClassDef_offset && !gdef->MarkAttachClassDef.loaded )
1143   {
1144     for ( i = 0; i < num_lookups; i++ )
1145     {
1146
1147       if ( lo[i].LookupFlag & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS )
1148       {
1149         if ( FILE_Seek( gdef->MarkAttachClassDef_offset ) ||
1150              ( error = _HB_OPEN_Load_ClassDefinition( &gdef->MarkAttachClassDef,
1151                                              256, stream ) ) != HB_Err_Ok )
1152           goto Done;
1153
1154         break;
1155       }
1156     }
1157   }
1158
1159 Done:
1160   return error;
1161 }
1162
1163 /* END */