freetype1/lib/extend/ftxgdef.c

   1 /*******************************************************************
   2  *
   3  *  ftxgdef.c
   4  *
   5  *    TrueType Open GDEF table support.
   6  *
   7  *  Copyright 1996-1999 by
   8  *  David Turner, Robert Wilhelm, and Werner Lemberg.
   9  *
  10  *  This file is part of the FreeType project, and may only be used
  11  *  modified and distributed under the terms of the FreeType project
  12  *  license, LICENSE.TXT.  By continuing to use, modify, or distribute
  13  *  this file you indicate that you have read the license and
  14  *  understand and accept it fully.
  15  *
  16  ******************************************************************/
  17
  18 #include "tttypes.h"
  19 #include "tttags.h"
  20 #include "ttload.h"
  21 #include "ttextend.h"
  22 #include "ttmemory.h"
  23 #include "ttfile.h"
  24
  25 #include "ftxopen.h"
  26 #include "ftxopenf.h"
  27
  28
  29 #define GDEF_ID  Build_Extension_ID( 'G', 'D', 'E', 'F' )
  30
  31
  32   static TT_Error  Load_AttachList( TTO_AttachList*  al,
  33                                     PFace            input );
  34   static TT_Error  Load_LigCaretList( TTO_LigCaretList*  lcl,
  35                                       PFace              input );
  36
  37   static void  Free_AttachList( TTO_AttachList*  al );
  38   static void  Free_LigCaretList( TTO_LigCaretList*  lcl );
  39
  40   static void  Free_NewGlyphClasses( TTO_GDEFHeader*  gdef );
  41
  42
  43
  44   /**********************
  45    * Extension Functions
  46    **********************/
  47
  48
  49   static TT_Error  GDEF_Create( void*  ext,
  50                                 PFace  face )
  51   {
  52     DEFINE_LOAD_LOCALS( face->stream );
  53
  54     TTO_GDEFHeader*  gdef = (TTO_GDEFHeader*)ext;
  55     Long             table;
  56
  57
  58     /* by convention */
  59
  60     if ( !gdef )
  61       return TT_Err_Ok;
  62
  63     /* a null offset indicates that there is no GDEF table */
  64
  65     gdef->offset = 0;
  66
  67     /* we store the start offset and the size of the subtable */
  68
  69     table = TT_LookUp_Table( face, TTAG_GDEF );
  70     if ( table < 0 )
  71       return TT_Err_Ok;             /* The table is optional */
  72
  73     if ( FILE_Seek( face->dirTables[table].Offset ) ||
  74          ACCESS_Frame( 4L ) )
  75       return error;
  76
  77     gdef->offset  = FILE_Pos() - 4L;    /* undo ACCESS_Frame() */
  78     gdef->Version = GET_ULong();
  79
  80     FORGET_Frame();
  81
  82     gdef->loaded = FALSE;
  83
  84     return TT_Err_Ok;
  85   }
  86
  87
  88   static TT_Error  GDEF_Destroy( void*  ext,
  89                                  PFace  face )
  90   {
  91     TTO_GDEFHeader*  gdef = (TTO_GDEFHeader*)ext;
  92
  93
  94     /* by convention */
  95
  96     if ( !gdef )
  97       return TT_Err_Ok;
  98
  99     if ( gdef->loaded )
 100     {
 101       Free_LigCaretList( &gdef->LigCaretList );
 102       Free_AttachList( &gdef->AttachList );
 103       Free_ClassDefinition( &gdef->GlyphClassDef );
 104       Free_ClassDefinition( &gdef->MarkAttachClassDef );
 105
 106       Free_NewGlyphClasses( gdef );
 107     }
 108
 109     return TT_Err_Ok;
 110   }
 111
 112
 113   EXPORT_FUNC
 114   TT_Error  TT_Init_GDEF_Extension( TT_Engine  engine )
 115   {
 116     PEngine_Instance  _engine = HANDLE_Engine( engine );
 117
 118
 119     if ( !_engine )
 120       return TT_Err_Invalid_Engine;
 121
 122     return  TT_Register_Extension( _engine,
 123                                    GDEF_ID,
 124                                    sizeof ( TTO_GDEFHeader ),
 125                                    GDEF_Create,
 126                                    GDEF_Destroy );
 127   }
 128
 129
 130   EXPORT_FUNC
 131   TT_Error  TT_Load_GDEF_Table( TT_Face          face,
 132                                 TTO_GDEFHeader*  retptr )
 133   {
 134     ULong            cur_offset, new_offset, base_offset;
 135
 136     TT_Error         error;
 137     TT_Stream        stream;
 138     TTO_GDEFHeader*  gdef;
 139
 140     PFace  faze = HANDLE_Face( face );
 141
 142
 143     if ( !retptr )
 144       return TT_Err_Invalid_Argument;
 145
 146     if ( !faze )
 147       return TT_Err_Invalid_Face_Handle;
 148
 149     error = TT_Extension_Get( faze, GDEF_ID, (void**)&gdef );
 150     if ( error )
 151       return error;
 152
 153     if ( gdef->offset == 0 )
 154       return TT_Err_Table_Missing;      /* no GDEF table; nothing to do */
 155
 156     /* now access stream */
 157
 158     if ( USE_Stream( faze->stream, stream ) )
 159       return error;
 160
 161     base_offset = gdef->offset;
 162
 163     /* skip version */
 164
 165     if ( FILE_Seek( base_offset + 4L ) ||
 166          ACCESS_Frame( 2L ) )
 167       return error;
 168
 169     new_offset = GET_UShort();
 170
 171     FORGET_Frame();
 172
 173     /* all GDEF subtables are optional */
 174
 175     if ( new_offset )
 176     {
 177       new_offset += base_offset;
 178
 179       /* only classes 1-4 are allowed here */
 180
 181       cur_offset = FILE_Pos();
 182       if ( FILE_Seek( new_offset ) ||
 183            ( error = Load_ClassDefinition( &gdef->GlyphClassDef, 5,
 184                                            faze ) ) != TT_Err_Ok )
 185         return error;
 186       (void)FILE_Seek( cur_offset );
 187     }
 188     else
 189       gdef->GlyphClassDef.loaded = FALSE;
 190
 191     if ( ACCESS_Frame( 2L ) )
 192       return error;
 193
 194     new_offset = GET_UShort();
 195
 196     FORGET_Frame();
 197
 198     if ( new_offset )
 199     {
 200       new_offset += base_offset;
 201
 202       cur_offset = FILE_Pos();
 203       if ( FILE_Seek( new_offset ) ||
 204            ( error = Load_AttachList( &gdef->AttachList,
 205                                       faze ) ) != TT_Err_Ok )
 206         goto Fail1;
 207       (void)FILE_Seek( cur_offset );
 208     }
 209     else
 210       gdef->AttachList.loaded = FALSE;
 211
 212     if ( ACCESS_Frame( 2L ) )
 213       return error;
 214
 215     new_offset = GET_UShort();
 216
 217     FORGET_Frame();
 218
 219     if ( new_offset )
 220     {
 221       new_offset += base_offset;
 222
 223       cur_offset = FILE_Pos();
 224       if ( FILE_Seek( new_offset ) ||
 225            ( error = Load_LigCaretList( &gdef->LigCaretList,
 226                                         faze ) ) != TT_Err_Ok )
 227         goto Fail2;
 228       (void)FILE_Seek( cur_offset );
 229     }
 230     else
 231       gdef->LigCaretList.loaded = FALSE;
 232
 233     /* OpenType 1.2 has introduced the `MarkAttachClassDef' field.  We
 234        first have to scan the LookupFlag values to find out whether we
 235        must load it or not.  Here we only store the current file offset. */
 236
 237     gdef->MarkAttachClassDef_offset = FILE_Pos();
 238     gdef->MarkAttachClassDef.loaded = FALSE;
 239
 240     gdef->LastGlyph       = 0;
 241     gdef->NewGlyphClasses = NULL;
 242     gdef->loaded          = TRUE;
 243
 244     *retptr = *gdef;
 245     DONE_Stream( stream );
 246
 247     return TT_Err_Ok;
 248
 249   Fail2:
 250     Free_AttachList( &gdef->AttachList );
 251
 252   Fail1:
 253     Free_ClassDefinition( &gdef->GlyphClassDef );
 254
 255     /* release stream */
 256
 257     DONE_Stream( stream );
 258
 259     return error;
 260   }
 261
 262
 263
 264   /*******************************
 265    * AttachList related functions
 266    *******************************/
 267
 268
 269   /* AttachPoint */
 270
 271   static TT_Error  Load_AttachPoint( TTO_AttachPoint*  ap,
 272                                      PFace             input )
 273   {
 274     DEFINE_LOAD_LOCALS( input->stream );
 275
 276     UShort   n, count;
 277     UShort*  pi;
 278
 279
 280     if ( ACCESS_Frame( 2L ) )
 281       return error;
 282
 283     count = ap->PointCount = GET_UShort();
 284
 285     FORGET_Frame();
 286
 287     ap->PointIndex = NULL;
 288
 289     if ( count )
 290     {
 291       if ( ALLOC_ARRAY( ap->PointIndex, count, UShort ) )
 292         return error;
 293
 294       pi = ap->PointIndex;
 295
 296       if ( ACCESS_Frame( count * 2L ) )
 297       {
 298         FREE( pi );
 299         return error;
 300       }
 301
 302       for ( n = 0; n < count; n++ )
 303         pi[n] = GET_UShort();
 304
 305       FORGET_Frame();
 306     }
 307
 308     return TT_Err_Ok;
 309   }
 310
 311
 312   static void  Free_AttachPoint( TTO_AttachPoint*  ap )
 313   {
 314     FREE( ap->PointIndex );
 315   }
 316
 317
 318   /* AttachList */
 319
 320   static TT_Error  Load_AttachList( TTO_AttachList*  al,
 321                                     PFace            input )
 322   {
 323     DEFINE_LOAD_LOCALS( input->stream );
 324
 325     UShort            n, count;
 326     ULong             cur_offset, new_offset, base_offset;
 327
 328     TTO_AttachPoint*  ap;
 329
 330
 331     base_offset = FILE_Pos();
 332
 333     if ( ACCESS_Frame( 2L ) )
 334       return error;
 335
 336     new_offset = GET_UShort() + base_offset;
 337
 338     FORGET_Frame();
 339
 340     cur_offset = FILE_Pos();
 341     if ( FILE_Seek( new_offset ) ||
 342          ( error = Load_Coverage( &al->Coverage, input ) ) != TT_Err_Ok )
 343       return error;
 344     (void)FILE_Seek( cur_offset );
 345
 346     if ( ACCESS_Frame( 2L ) )
 347       goto Fail2;
 348
 349     count = al->GlyphCount = GET_UShort();
 350
 351     FORGET_Frame();
 352
 353     al->AttachPoint = NULL;
 354
 355     if ( ALLOC_ARRAY( al->AttachPoint, count, TTO_AttachPoint ) )
 356       goto Fail2;
 357
 358     ap = al->AttachPoint;
 359
 360     for ( n = 0; n < count; n++ )
 361     {
 362       if ( ACCESS_Frame( 2L ) )
 363         goto Fail1;
 364
 365       new_offset = GET_UShort() + base_offset;
 366
 367       FORGET_Frame();
 368
 369       cur_offset = FILE_Pos();
 370       if ( FILE_Seek( new_offset ) ||
 371            ( error = Load_AttachPoint( &ap[n], input ) ) != TT_Err_Ok )
 372         goto Fail1;
 373       (void)FILE_Seek( cur_offset );
 374     }
 375
 376     al->loaded = TRUE;
 377
 378     return TT_Err_Ok;
 379
 380   Fail1:
 381     for ( n = 0; n < count; n++ )
 382       Free_AttachPoint( &ap[n] );
 383
 384     FREE( ap );
 385
 386   Fail2:
 387     Free_Coverage( &al->Coverage );
 388     return error;
 389   }
 390
 391
 392   static void  Free_AttachList( TTO_AttachList*  al )
 393   {
 394     UShort            n, count;
 395
 396     TTO_AttachPoint*  ap;
 397
 398
 399     if ( !al->loaded )
 400       return;
 401
 402     if ( al->AttachPoint )
 403     {
 404       count = al->GlyphCount;
 405       ap    = al->AttachPoint;
 406
 407       for ( n = 0; n < count; n++ )
 408         Free_AttachPoint( &ap[n] );
 409
 410       FREE( ap );
 411     }
 412
 413     Free_Coverage( &al->Coverage );
 414   }
 415
 416
 417
 418   /*********************************
 419    * LigCaretList related functions
 420    *********************************/
 421
 422
 423   /* CaretValueFormat1 */
 424   /* CaretValueFormat2 */
 425   /* CaretValueFormat3 */
 426   /* CaretValueFormat4 */
 427
 428   static TT_Error  Load_CaretValue( TTO_CaretValue*  cv,
 429                                     PFace            input )
 430   {
 431     DEFINE_LOAD_LOCALS( input->stream );
 432
 433     ULong    cur_offset, new_offset, base_offset;
 434
 435
 436     base_offset = FILE_Pos();
 437
 438     if ( ACCESS_Frame( 2L ) )
 439       return error;
 440
 441     cv->CaretValueFormat = GET_UShort();
 442
 443     FORGET_Frame();
 444
 445     switch ( cv->CaretValueFormat )
 446     {
 447     case 1:
 448       if ( ACCESS_Frame( 2L ) )
 449         return error;
 450
 451       cv->cvf.cvf1.Coordinate = GET_Short();
 452
 453       FORGET_Frame();
 454
 455       break;
 456
 457     case 2:
 458       if ( ACCESS_Frame( 2L ) )
 459         return error;
 460
 461       cv->cvf.cvf2.CaretValuePoint = GET_UShort();
 462
 463       FORGET_Frame();
 464
 465       break;
 466
 467     case 3:
 468       if ( ACCESS_Frame( 4L ) )
 469         return error;
 470
 471       cv->cvf.cvf3.Coordinate = GET_Short();
 472
 473       new_offset = GET_UShort() + base_offset;
 474
 475       FORGET_Frame();
 476
 477       cur_offset = FILE_Pos();
 478       if ( FILE_Seek( new_offset ) ||
 479            ( error = Load_Device( &cv->cvf.cvf3.Device,
 480                                   input ) ) != TT_Err_Ok )
 481         return error;
 482       (void)FILE_Seek( cur_offset );
 483
 484       break;
 485
 486     case 4:
 487       if ( ACCESS_Frame( 2L ) )
 488         return error;
 489
 490       cv->cvf.cvf4.IdCaretValue = GET_UShort();
 491
 492       FORGET_Frame();
 493       break;
 494
 495     default:
 496       return TTO_Err_Invalid_GDEF_SubTable_Format;
 497     }
 498
 499     return TT_Err_Ok;
 500   }
 501
 502
 503   static void  Free_CaretValue( TTO_CaretValue*  cv )
 504   {
 505     if ( cv->CaretValueFormat == 3 )
 506       Free_Device( &cv->cvf.cvf3.Device );
 507   }
 508
 509
 510   /* LigGlyph */
 511
 512   static TT_Error  Load_LigGlyph( TTO_LigGlyph*  lg,
 513                                   PFace          input )
 514   {
 515     DEFINE_LOAD_LOCALS( input->stream );
 516
 517     UShort           n, count;
 518     ULong            cur_offset, new_offset, base_offset;
 519
 520     TTO_CaretValue*  cv;
 521
 522
 523     base_offset = FILE_Pos();
 524
 525     if ( ACCESS_Frame( 2L ) )
 526       return error;
 527
 528     count = lg->CaretCount = GET_UShort();
 529
 530     FORGET_Frame();
 531
 532     lg->CaretValue = NULL;
 533
 534     if ( ALLOC_ARRAY( lg->CaretValue, count, TTO_CaretValue ) )
 535       return error;
 536
 537     cv = lg->CaretValue;
 538
 539     for ( n = 0; n < count; n++ )
 540     {
 541       if ( ACCESS_Frame( 2L ) )
 542         goto Fail;
 543
 544       new_offset = GET_UShort() + base_offset;
 545
 546       FORGET_Frame();
 547
 548       cur_offset = FILE_Pos();
 549       if ( FILE_Seek( new_offset ) ||
 550            ( error = Load_CaretValue( &cv[n], input ) ) != TT_Err_Ok )
 551         goto Fail;
 552       (void)FILE_Seek( cur_offset );
 553     }
 554
 555     return TT_Err_Ok;
 556
 557   Fail:
 558     for ( n = 0; n < count; n++ )
 559       Free_CaretValue( &cv[n] );
 560
 561     FREE( cv );
 562     return error;
 563   }
 564
 565
 566   static void  Free_LigGlyph( TTO_LigGlyph*  lg )
 567   {
 568     UShort           n, count;
 569
 570     TTO_CaretValue*  cv;
 571
 572
 573     if ( lg->CaretValue )
 574     {
 575       count = lg->CaretCount;
 576       cv    = lg->CaretValue;
 577
 578       for ( n = 0; n < count; n++ )
 579         Free_CaretValue( &cv[n] );
 580
 581       FREE( cv );
 582     }
 583   }
 584
 585
 586   /* LigCaretList */
 587
 588   static TT_Error  Load_LigCaretList( TTO_LigCaretList*  lcl,
 589                                       PFace              input )
 590   {
 591     DEFINE_LOAD_LOCALS( input->stream );
 592
 593     UShort         n, count;
 594     ULong          cur_offset, new_offset, base_offset;
 595
 596     TTO_LigGlyph*  lg;
 597
 598
 599     base_offset = FILE_Pos();
 600
 601     if ( ACCESS_Frame( 2L ) )
 602       return error;
 603
 604     new_offset = GET_UShort() + base_offset;
 605
 606     FORGET_Frame();
 607
 608     cur_offset = FILE_Pos();
 609     if ( FILE_Seek( new_offset ) ||
 610          ( error = Load_Coverage( &lcl->Coverage, input ) ) != TT_Err_Ok )
 611       return error;
 612     (void)FILE_Seek( cur_offset );
 613
 614     if ( ACCESS_Frame( 2L ) )
 615       goto Fail2;
 616
 617     count = lcl->LigGlyphCount = GET_UShort();
 618
 619     FORGET_Frame();
 620
 621     lcl->LigGlyph = NULL;
 622
 623     if ( ALLOC_ARRAY( lcl->LigGlyph, count, TTO_LigGlyph ) )
 624       goto Fail2;
 625
 626     lg = lcl->LigGlyph;
 627
 628     for ( n = 0; n < count; n++ )
 629     {
 630       if ( ACCESS_Frame( 2L ) )
 631         goto Fail1;
 632
 633       new_offset = GET_UShort() + base_offset;
 634
 635       FORGET_Frame();
 636
 637       cur_offset = FILE_Pos();
 638       if ( FILE_Seek( new_offset ) ||
 639            ( error = Load_LigGlyph( &lg[n], input ) ) != TT_Err_Ok )
 640         goto Fail1;
 641       (void)FILE_Seek( cur_offset );
 642     }
 643
 644     lcl->loaded = TRUE;
 645
 646     return TT_Err_Ok;
 647
 648   Fail1:
 649     for ( n = 0; n < count; n++ )
 650       Free_LigGlyph( &lg[n] );
 651
 652     FREE( lg );
 653
 654   Fail2:
 655     Free_Coverage( &lcl->Coverage );
 656     return error;
 657   }
 658
 659
 660   static void  Free_LigCaretList( TTO_LigCaretList*  lcl )
 661   {
 662     UShort         n, count;
 663
 664     TTO_LigGlyph*  lg;
 665
 666
 667     if ( !lcl->loaded )
 668       return;
 669
 670     if ( lcl->LigGlyph )
 671     {
 672       count = lcl->LigGlyphCount;
 673       lg    = lcl->LigGlyph;
 674
 675       for ( n = 0; n < count; n++ )
 676         Free_LigGlyph( &lg[n] );
 677
 678       FREE( lg );
 679     }
 680
 681     Free_Coverage( &lcl->Coverage );
 682   }
 683
 684
 685
 686   /***********
 687    * GDEF API
 688    ***********/
 689
 690
 691   static UShort  Get_New_Class( TTO_GDEFHeader*  gdef,
 692                                 UShort           glyphID,
 693                                 UShort           index )
 694   {
 695     UShort                 glyph_index, array_index;
 696     UShort                 byte, bits;
 697
 698     TTO_ClassRangeRecord*  gcrr;
 699     UShort**               ngc;
 700
 701
 702     if ( glyphID >= gdef->LastGlyph )
 703       return 0;
 704
 705     gcrr = gdef->GlyphClassDef.cd.cd2.ClassRangeRecord;
 706     ngc  = gdef->NewGlyphClasses;
 707
 708     if ( glyphID < gcrr[index].Start )
 709     {
 710       array_index = 0;
 711       if ( index == 0 )
 712         glyph_index = glyphID;
 713       else
 714         glyph_index = glyphID - gcrr[index - 1].End - 1;
 715     }
 716     else
 717     {
 718       array_index = index + 1;
 719       glyph_index = glyphID - gcrr[index].End - 1;
 720     }
 721
 722     byte = ngc[array_index][glyph_index / 4 + 1];
 723     bits = byte >> ( 16 - ( glyph_index % 4 + 1 ) * 4 );
 724
 725     return bits & 0x000F;
 726   }
 727
 728
 729   EXPORT_FUNC
 730   TT_Error  TT_GDEF_Get_Glyph_Property( TTO_GDEFHeader*  gdef,
 731                                         TT_UShort        glyphID,
 732                                         TT_UShort*       property )
 733   {
 734     UShort    class, index;
 735
 736     TT_Error  error;
 737
 738
 739     if ( !gdef || !property )
 740       return TT_Err_Invalid_Argument;
 741
 742     /* first, we check for mark attach classes */
 743
 744     if ( gdef->MarkAttachClassDef.loaded )
 745     {
 746       error = Get_Class( &gdef->MarkAttachClassDef, glyphID, &class, &index );
 747       if ( error && error != TTO_Err_Not_Covered )
 748         return error;
 749       if ( !error )
 750       {
 751         *property = class << 8;
 752         return TT_Err_Ok;
 753       }
 754     }
 755
 756     error = Get_Class( &gdef->GlyphClassDef, glyphID, &class, &index );
 757     if ( error && error != TTO_Err_Not_Covered )
 758       return error;
 759
 760     /* if we have a constructed class table, check whether additional
 761        values have been assigned                                      */
 762
 763     if ( error == TTO_Err_Not_Covered && gdef->NewGlyphClasses )
 764       class = Get_New_Class( gdef, glyphID, index );
 765
 766     switch ( class )
 767     {
 768     case UNCLASSIFIED_GLYPH:
 769       *property = 0;
 770       break;
 771
 772     case SIMPLE_GLYPH:
 773       *property = TTO_BASE_GLYPH;
 774       break;
 775
 776     case LIGATURE_GLYPH:
 777       *property = TTO_LIGATURE;
 778       break;
 779
 780     case MARK_GLYPH:
 781       *property = TTO_MARK;
 782       break;
 783
 784     case COMPONENT_GLYPH:
 785       *property = TTO_COMPONENT;
 786       break;
 787     }
 788
 789     return TT_Err_Ok;
 790   }
 791
 792
 793   static TT_Error  Make_ClassRange( TTO_ClassDefinition*  cd,
 794                                     UShort                start,
 795                                     UShort                end,
 796                                     UShort                class )
 797   {
 798     TT_Error               error;
 799     UShort                 index;
 800
 801     TTO_ClassDefFormat2*   cdf2;
 802     TTO_ClassRangeRecord*  crr;
 803
 804
 805     cdf2 = &cd->cd.cd2;
 806
 807     cdf2->ClassRangeCount++;
 808
 809     if ( REALLOC_ARRAY( cdf2->ClassRangeRecord, cdf2->ClassRangeCount,
 810                         TTO_ClassRangeRecord ) )
 811       return error;
 812
 813     crr   = cdf2->ClassRangeRecord;
 814     index = cdf2->ClassRangeCount - 1;
 815
 816     crr[index].Start = start;
 817     crr[index].End   = end;
 818     crr[index].Class = class;
 819
 820     cd->Defined[class] = TRUE;
 821
 822     return TT_Err_Ok;
 823   }
 824
 825
 826   EXPORT_FUNC
 827   TT_Error  TT_GDEF_Build_ClassDefinition( TTO_GDEFHeader*  gdef,
 828                                            TT_UShort        num_glyphs,
 829                                            TT_UShort        glyph_count,
 830                                            TT_UShort*       glyph_array,
 831                                            TT_UShort*       class_array )
 832   {
 833     UShort                 start, curr_glyph, curr_class;
 834     UShort                 n, count;
 835     TT_Error               error;
 836
 837     TTO_ClassDefinition*   gcd;
 838     TTO_ClassRangeRecord*  gcrr;
 839     UShort**               ngc;
 840
 841
 842     if ( !gdef || !glyph_array || !class_array )
 843       return TT_Err_Invalid_Argument;
 844
 845     gcd = &gdef->GlyphClassDef;
 846
 847     /* We build a format 2 table */
 848
 849     gcd->ClassFormat = 2;
 850
 851     /* A GlyphClassDef table contains at most 5 different class values */
 852
 853     if ( ALLOC_ARRAY( gcd->Defined, 5, Bool ) )
 854       return error;
 855
 856     gcd->cd.cd2.ClassRangeCount  = 0;
 857     gcd->cd.cd2.ClassRangeRecord = NULL;
 858
 859     start      = glyph_array[0];
 860     curr_class = class_array[0];
 861     curr_glyph = start;
 862
 863     if ( curr_class >= 5 )
 864     {
 865       error = TT_Err_Invalid_Argument;
 866       goto Fail4;
 867     }
 868
 869     glyph_count--;
 870
 871     for ( n = 0; n <= glyph_count; n++ )
 872     {
 873       if ( curr_glyph == glyph_array[n] && curr_class == class_array[n] )
 874       {
 875         if ( n == glyph_count )
 876         {
 877           if ( ( error = Make_ClassRange( gcd, start,
 878                                           curr_glyph,
 879                                           curr_class ) ) != TT_Err_Ok )
 880             goto Fail3;
 881         }
 882         else
 883         {
 884           if ( curr_glyph == 0xFFFF )
 885           {
 886             error = TT_Err_Invalid_Argument;
 887             goto Fail3;
 888           }
 889           else
 890             curr_glyph++;
 891         }
 892       }
 893       else
 894       {
 895         if ( ( error = Make_ClassRange( gcd, start,
 896                                         curr_glyph - 1,
 897                                         curr_class ) ) != TT_Err_Ok )
 898           goto Fail3;
 899
 900         if ( curr_glyph > glyph_array[n] )
 901         {
 902           error = TT_Err_Invalid_Argument;
 903           goto Fail3;
 904         }
 905
 906         start      = glyph_array[n];
 907         curr_class = class_array[n];
 908         curr_glyph = start;
 909
 910         if ( curr_class >= 5 )
 911         {
 912           error = TT_Err_Invalid_Argument;
 913           goto Fail3;
 914         }
 915
 916         if ( n == glyph_count )
 917         {
 918           if ( ( error = Make_ClassRange( gcd, start,
 919                                           curr_glyph,
 920                                           curr_class ) ) != TT_Err_Ok )
 921             goto Fail3;
 922         }
 923         else
 924         {
 925           if ( curr_glyph == 0xFFFF )
 926           {
 927             error = TT_Err_Invalid_Argument;
 928             goto Fail3;
 929           }
 930           else
 931             curr_glyph++;
 932         }
 933       }
 934     }
 935
 936     /* now prepare the arrays for class values assigned during the lookup
 937        process                                                            */
 938
 939     if ( ALLOC_ARRAY( gdef->NewGlyphClasses,
 940                       gcd->cd.cd2.ClassRangeCount + 1, UShort* ) )
 941       goto Fail2;
 942
 943     count = gcd->cd.cd2.ClassRangeCount;
 944     gcrr  = gcd->cd.cd2.ClassRangeRecord;
 945     ngc   = gdef->NewGlyphClasses;
 946
 947     /* We allocate arrays for all glyphs not covered by the class range
 948        records.  Each element holds four class values.                  */
 949
 950     if ( gcrr[0].Start )
 951     {
 952       if ( ALLOC_ARRAY( ngc[0], gcrr[0].Start / 4 + 1, UShort ) )
 953         goto Fail1;
 954     }
 955
 956     for ( n = 1; n < count; n++ )
 957     {
 958       if ( gcrr[n].Start - gcrr[n - 1].End > 1 )
 959         if ( ALLOC_ARRAY( ngc[n],
 960                           ( gcrr[n].Start - gcrr[n - 1].End - 1 ) / 4 + 1,
 961                           UShort ) )
 962           goto Fail1;
 963     }
 964
 965     if ( gcrr[count - 1].End != num_glyphs - 1 )
 966     {
 967       if ( ALLOC_ARRAY( ngc[count],
 968                         ( num_glyphs - gcrr[count - 1].End - 1 ) / 4 + 1,
 969                         UShort ) )
 970         goto Fail1;
 971     }
 972
 973     gdef->LastGlyph = num_glyphs - 1;
 974
 975     gdef->MarkAttachClassDef_offset = 0L;
 976     gdef->MarkAttachClassDef.loaded = FALSE;
 977
 978     return TT_Err_Ok;
 979
 980   Fail1:
 981     for ( n = 0; n < count; n++ )
 982       FREE( ngc[n] );
 983
 984   Fail2:
 985     FREE( gdef->NewGlyphClasses );
 986
 987   Fail3:
 988     FREE( gcd->cd.cd2.ClassRangeRecord );
 989
 990   Fail4:
 991     FREE( gcd->Defined );
 992     return error;
 993   }
 994
 995
 996   static void  Free_NewGlyphClasses( TTO_GDEFHeader*  gdef )
 997   {
 998     UShort**  ngc;
 999     UShort    n, count;
1000
1001
1002     if ( gdef->NewGlyphClasses )
1003     {
1004       count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount + 1;
1005       ngc   = gdef->NewGlyphClasses;
1006
1007       for ( n = 0; n < count; n++ )
1008         FREE( ngc[n] );
1009
1010       FREE( ngc );
1011     }
1012   }
1013
1014
1015   TT_Error  Add_Glyph_Property( TTO_GDEFHeader*  gdef,
1016                                 UShort           glyphID,
1017                                 UShort           property )
1018   {
1019     TT_Error               error;
1020     UShort                 class, new_class, index;
1021     UShort                 byte, bits, mask;
1022     UShort                 array_index, glyph_index;
1023
1024     TTO_ClassRangeRecord*  gcrr;
1025     UShort**               ngc;
1026
1027
1028     error = Get_Class( &gdef->GlyphClassDef, glyphID, &class, &index );
1029     if ( error && error != TTO_Err_Not_Covered )
1030       return error;
1031
1032     /* we don't accept glyphs covered in `GlyphClassDef' */
1033
1034     if ( !error )
1035       return TTO_Err_Not_Covered;
1036
1037     switch ( property )
1038     {
1039     case 0:
1040       new_class = UNCLASSIFIED_GLYPH;
1041       break;
1042
1043     case TTO_BASE_GLYPH:
1044       new_class = SIMPLE_GLYPH;
1045       break;
1046
1047     case TTO_LIGATURE:
1048       new_class = LIGATURE_GLYPH;
1049       break;
1050
1051     case TTO_MARK:
1052       new_class = MARK_GLYPH;
1053       break;
1054
1055     case TTO_COMPONENT:
1056       new_class = COMPONENT_GLYPH;
1057       break;
1058
1059     default:
1060       return TT_Err_Invalid_Argument;
1061     }
1062
1063     gcrr = gdef->GlyphClassDef.cd.cd2.ClassRangeRecord;
1064     ngc  = gdef->NewGlyphClasses;
1065
1066     if ( glyphID < gcrr[index].Start )
1067     {
1068       array_index = 0;
1069       if ( index == 0 )
1070         glyph_index = glyphID;
1071       else
1072         glyph_index = glyphID - gcrr[index - 1].End - 1;
1073     }
1074     else
1075     {
1076       array_index = index + 1;
1077       glyph_index = glyphID - gcrr[index].End - 1;
1078     }
1079
1080     byte  = ngc[array_index][glyph_index / 4 + 1];
1081     bits  = byte >> ( 16 - ( glyph_index % 4 + 1 ) * 4 );
1082     class = bits & 0x000F;
1083
1084     /* we don't overwrite existing entries */
1085
1086     if ( !class )
1087     {
1088       bits = new_class << ( 16 - ( glyph_index % 4 + 1 ) * 4 );
1089       mask = ~( 0x000F << ( 16 - ( glyph_index % 4 + 1 ) * 4 ) );
1090
1091       ngc[array_index][glyph_index / 4 + 1] &= mask;
1092       ngc[array_index][glyph_index / 4 + 1] |= bits;
1093     }
1094
1095     return TT_Err_Ok;
1096   }
1097
1098
1099 /* END */