src/base/ftmac.c

   1 /****************************************************************************
   2  *
   3  * ftmac.c
   4  *
   5  *   Mac FOND support.  Written by just@letterror.com.
   6  * Heavily modified by mpsuzuki, George Williams, and Sean McBride.
   7  *
   8  * This file is for Mac OS X only; see builds/mac/ftoldmac.c for
   9  * classic platforms built by MPW.
  10  *
  11  * Copyright (C) 1996-2023 by
  12  * Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.
  13  *
  14  * This file is part of the FreeType project, and may only be used,
  15  * modified, and distributed under the terms of the FreeType project
  16  * license, LICENSE.TXT.  By continuing to use, modify, or distribute
  17  * this file you indicate that you have read the license and
  18  * understand and accept it fully.
  19  *
  20  */
  21
  22
  23   /*
  24     Notes
  25
  26     Mac suitcase files can (and often do!) contain multiple fonts.  To
  27     support this I use the face_index argument of FT_(Open|New)_Face()
  28     functions, and pretend the suitcase file is a collection.
  29
  30     Warning: fbit and NFNT bitmap resources are not supported yet.  In old
  31     sfnt fonts, bitmap glyph data for each size is stored in each `NFNT'
  32     resources instead of the `bdat' table in the sfnt resource.  Therefore,
  33     face->num_fixed_sizes is set to 0, because bitmap data in `NFNT'
  34     resource is unavailable at present.
  35
  36     The Mac FOND support works roughly like this:
  37
  38     - Check whether the offered stream points to a Mac suitcase file.  This
  39       is done by checking the file type: it has to be 'FFIL' or 'tfil'.  The
  40       stream that gets passed to our init_face() routine is a stdio stream,
  41       which isn't usable for us, since the FOND resources live in the
  42       resource fork.  So we just grab the stream->pathname field.
  43
  44     - Read the FOND resource into memory, then check whether there is a
  45       TrueType font and/or(!) a Type 1 font available.
  46
  47     - If there is a Type 1 font available (as a separate `LWFN' file), read
  48       its data into memory, massage it slightly so it becomes PFB data, wrap
  49       it into a memory stream, load the Type 1 driver and delegate the rest
  50       of the work to it by calling FT_Open_Face().  (XXX TODO: after this
  51       has been done, the kerning data from the FOND resource should be
  52       appended to the face: On the Mac there are usually no AFM files
  53       available.  However, this is tricky since we need to map Mac char
  54       codes to ps glyph names to glyph ID's...)
  55
  56     - If there is a TrueType font (an `sfnt' resource), read it into memory,
  57       wrap it into a memory stream, load the TrueType driver and delegate
  58       the rest of the work to it, by calling FT_Open_Face().
  59
  60     - Some suitcase fonts (notably Onyx) might point the `LWFN' file to
  61       itself, even though it doesn't contains `POST' resources.  To handle
  62       this special case without opening the file an extra time, we just
  63       ignore errors from the `LWFN' and fallback to the `sfnt' if both are
  64       available.
  65   */
  66
  67
  68 #include <freetype/freetype.h>
  69 #include <freetype/tttags.h>
  70 #include <freetype/internal/ftdebug.h>
  71 #include <freetype/internal/ftstream.h>
  72 #include "ftbase.h"
  73
  74
  75 #ifdef FT_MACINTOSH
  76
  77   /* This is for Mac OS X.  Without redefinition, OS_INLINE */
  78   /* expands to `static inline' which doesn't survive the   */
  79   /* -ansi compilation flag of GCC.                         */
  80 #if !HAVE_ANSI_OS_INLINE
  81 #undef  OS_INLINE
  82 #define OS_INLINE  static __inline__
  83 #endif
  84
  85   /* `configure' checks the availability of `ResourceIndex' strictly */
  86   /* and sets HAVE_TYPE_RESOURCE_INDEX 1 or 0 always.  If it is      */
  87   /* not set (e.g., a build without `configure'), the availability   */
  88   /* is guessed from the SDK version.                                */
  89 #ifndef HAVE_TYPE_RESOURCE_INDEX
  90 #if !defined( MAC_OS_X_VERSION_10_5 ) || \
  91     ( MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5 )
  92 #define HAVE_TYPE_RESOURCE_INDEX 0
  93 #else
  94 #define HAVE_TYPE_RESOURCE_INDEX 1
  95 #endif
  96 #endif /* !HAVE_TYPE_RESOURCE_INDEX */
  97
  98 #if ( HAVE_TYPE_RESOURCE_INDEX == 0 )
  99   typedef short  ResourceIndex;
 100 #endif
 101
 102 #include <CoreServices/CoreServices.h>
 103 #include <ApplicationServices/ApplicationServices.h>
 104 #include <sys/syslimits.h> /* PATH_MAX */
 105
 106   /* Don't want warnings about our own use of deprecated functions. */
 107 #define FT_DEPRECATED_ATTRIBUTE
 108
 109 #include <freetype/ftmac.h>
 110
 111 #ifndef kATSOptionFlagsUnRestrictedScope /* since Mac OS X 10.1 */
 112 #define kATSOptionFlagsUnRestrictedScope kATSOptionFlagsDefault
 113 #endif
 114
 115
 116   /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
 117      TrueType in case *both* are available (this is not common,
 118      but it *is* possible). */
 119 #ifndef PREFER_LWFN
 120 #define PREFER_LWFN  1
 121 #endif
 122
 123
 124   /* This function is deprecated because FSSpec is deprecated in Mac OS X  */
 125   FT_EXPORT_DEF( FT_Error )
 126   FT_GetFile_From_Mac_Name( const char*  fontName,
 127                             FSSpec*      pathSpec,
 128                             FT_Long*     face_index )
 129   {
 130     FT_UNUSED( fontName );
 131     FT_UNUSED( pathSpec );
 132     FT_UNUSED( face_index );
 133
 134     return FT_THROW( Unimplemented_Feature );
 135   }
 136
 137
 138   /* Private function.                                         */
 139   /* The FSSpec type has been discouraged for a long time,     */
 140   /* unfortunately an FSRef replacement API for                */
 141   /* ATSFontGetFileSpecification() is only available in        */
 142   /* Mac OS X 10.5 and later.                                  */
 143   static OSStatus
 144   FT_ATSFontGetFileReference( ATSFontRef  ats_font_id,
 145                               FSRef*      ats_font_ref )
 146   {
 147 #if defined( MAC_OS_X_VERSION_10_5 ) && \
 148     ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
 149
 150     OSStatus  err;
 151
 152     err = ATSFontGetFileReference( ats_font_id, ats_font_ref );
 153
 154     return err;
 155 #elif __LP64__ /* No 64bit Carbon API on legacy platforms */
 156     FT_UNUSED( ats_font_id );
 157     FT_UNUSED( ats_font_ref );
 158
 159
 160     return fnfErr;
 161 #else /* 32bit Carbon API on legacy platforms */
 162     OSStatus  err;
 163     FSSpec    spec;
 164
 165
 166     err = ATSFontGetFileSpecification( ats_font_id, &spec );
 167     if ( noErr == err )
 168       err = FSpMakeFSRef( &spec, ats_font_ref );
 169
 170     return err;
 171 #endif
 172   }
 173
 174
 175   static FT_Error
 176   FT_GetFileRef_From_Mac_ATS_Name( const char*  fontName,
 177                                    FSRef*       ats_font_ref,
 178                                    FT_Long*     face_index )
 179   {
 180     CFStringRef  cf_fontName;
 181     ATSFontRef   ats_font_id;
 182
 183
 184     *face_index = 0;
 185
 186     cf_fontName = CFStringCreateWithCString( NULL, fontName,
 187                                              kCFStringEncodingMacRoman );
 188     ats_font_id = ATSFontFindFromName( cf_fontName,
 189                                        kATSOptionFlagsUnRestrictedScope );
 190     CFRelease( cf_fontName );
 191
 192     if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
 193       return FT_THROW( Unknown_File_Format );
 194
 195     if ( noErr != FT_ATSFontGetFileReference( ats_font_id, ats_font_ref ) )
 196       return FT_THROW( Unknown_File_Format );
 197
 198     /* face_index calculation by searching preceding fontIDs */
 199     /* with same FSRef                                       */
 200     {
 201       ATSFontRef  id2 = ats_font_id - 1;
 202       FSRef       ref2;
 203
 204
 205       while ( id2 > 0 )
 206       {
 207         if ( noErr != FT_ATSFontGetFileReference( id2, &ref2 ) )
 208           break;
 209         if ( noErr != FSCompareFSRefs( ats_font_ref, &ref2 ) )
 210           break;
 211
 212         id2 --;
 213       }
 214       *face_index = ats_font_id - ( id2 + 1 );
 215     }
 216
 217     return FT_Err_Ok;
 218   }
 219
 220
 221   FT_EXPORT_DEF( FT_Error )
 222   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,
 223                                     UInt8*       path,
 224                                     UInt32       maxPathSize,
 225                                     FT_Long*     face_index )
 226   {
 227     FSRef     ref;
 228     FT_Error  err;
 229
 230
 231     if ( !fontName || !face_index )
 232       return FT_THROW( Invalid_Argument);
 233
 234     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );
 235     if ( err )
 236       return err;
 237
 238     if ( noErr != FSRefMakePath( &ref, path, maxPathSize ) )
 239       return FT_THROW( Unknown_File_Format );
 240
 241     return FT_Err_Ok;
 242   }
 243
 244
 245   /* This function is deprecated because FSSpec is deprecated in Mac OS X  */
 246   FT_EXPORT_DEF( FT_Error )
 247   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
 248                                 FSSpec*      pathSpec,
 249                                 FT_Long*     face_index )
 250   {
 251 #if ( __LP64__ ) || ( defined( MAC_OS_X_VERSION_10_5 ) && \
 252       ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 ) )
 253     FT_UNUSED( fontName );
 254     FT_UNUSED( pathSpec );
 255     FT_UNUSED( face_index );
 256
 257     return FT_THROW( Unimplemented_Feature );
 258 #else
 259     FSRef     ref;
 260     FT_Error  err;
 261
 262
 263     if ( !fontName || !face_index )
 264       return FT_THROW( Invalid_Argument );
 265
 266     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );
 267     if ( err )
 268       return err;
 269
 270     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL,
 271                                     pathSpec, NULL ) )
 272       return FT_THROW( Unknown_File_Format );
 273
 274     return FT_Err_Ok;
 275 #endif
 276   }
 277
 278
 279   static OSErr
 280   FT_FSPathMakeRes( const UInt8*    pathname,
 281                     ResFileRefNum*  res )
 282   {
 283     OSErr  err;
 284     FSRef  ref;
 285
 286
 287     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )
 288       return FT_THROW( Cannot_Open_Resource );
 289
 290     /* at present, no support for dfont format */
 291     err = FSOpenResourceFile( &ref, 0, NULL, fsRdPerm, res );
 292     if ( noErr == err )
 293       return err;
 294
 295     /* fallback to original resource-fork font */
 296     *res = FSOpenResFile( &ref, fsRdPerm );
 297     err  = ResError();
 298
 299     return err;
 300   }
 301
 302
 303   /* Return the file type for given pathname */
 304   static OSType
 305   get_file_type_from_path( const UInt8*  pathname )
 306   {
 307     FSRef          ref;
 308     FSCatalogInfo  info;
 309
 310
 311     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )
 312       return ( OSType ) 0;
 313
 314     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoFinderInfo, &info,
 315                                     NULL, NULL, NULL ) )
 316       return ( OSType ) 0;
 317
 318     return ( (FInfo *)( info.finderInfo ) )->fdType;
 319   }
 320
 321
 322   /* Given a PostScript font name, create the Macintosh LWFN file name. */
 323   static void
 324   create_lwfn_name( char*   ps_name,
 325                     Str255  lwfn_file_name )
 326   {
 327     int       max = 5, count = 0;
 328     FT_Byte*  p = lwfn_file_name;
 329     FT_Byte*  q = (FT_Byte*)ps_name;
 330
 331
 332     lwfn_file_name[0] = 0;
 333
 334     while ( *q )
 335     {
 336       if ( ft_isupper( *q ) )
 337       {
 338         if ( count )
 339           max = 3;
 340         count = 0;
 341       }
 342       if ( count < max && ( ft_isalnum( *q ) || *q == '_' ) )
 343       {
 344         *++p = *q;
 345         lwfn_file_name[0]++;
 346         count++;
 347       }
 348       q++;
 349     }
 350   }
 351
 352
 353   static short
 354   count_faces_sfnt( char*  fond_data )
 355   {
 356     /* The count is 1 greater than the value in the FOND.  */
 357     /* Isn't that cute? :-)                                */
 358
 359     return EndianS16_BtoN( *( (short*)( fond_data +
 360                                         sizeof ( FamRec ) ) ) ) + 1;
 361   }
 362
 363
 364   static short
 365   count_faces_scalable( char*  fond_data )
 366   {
 367     AsscEntry*  assoc;
 368     short       i, face, face_all;
 369
 370
 371     face_all = EndianS16_BtoN( *( (short *)( fond_data +
 372                                              sizeof ( FamRec ) ) ) ) + 1;
 373     assoc    = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
 374     face     = 0;
 375
 376     for ( i = 0; i < face_all; i++ )
 377     {
 378       if ( 0 == EndianS16_BtoN( assoc[i].fontSize ) )
 379         face++;
 380     }
 381     return face;
 382   }
 383
 384
 385   /* Look inside the FOND data, answer whether there should be an SFNT
 386      resource, and answer the name of a possible LWFN Type 1 file.
 387
 388      Thanks to Paul Miller (paulm@profoundeffects.com) for the fix
 389      to load a face OTHER than the first one in the FOND!
 390   */
 391
 392
 393   static void
 394   parse_fond( char*   fond_data,
 395               short*  have_sfnt,
 396               ResID*  sfnt_id,
 397               Str255  lwfn_file_name,
 398               short   face_index )
 399   {
 400     AsscEntry*  assoc;
 401     AsscEntry*  base_assoc;
 402     FamRec*     fond;
 403
 404
 405     *sfnt_id          = 0;
 406     *have_sfnt        = 0;
 407     lwfn_file_name[0] = 0;
 408
 409     fond       = (FamRec*)fond_data;
 410     assoc      = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
 411     base_assoc = assoc;
 412
 413     /* the maximum faces in a FOND is 48, size of StyleTable.indexes[] */
 414     if ( 47 < face_index )
 415       return;
 416
 417     /* Let's do a little range checking before we get too excited here */
 418     if ( face_index < count_faces_sfnt( fond_data ) )
 419     {
 420       assoc += face_index;        /* add on the face_index! */
 421
 422       /* if the face at this index is not scalable,
 423          fall back to the first one (old behavior) */
 424       if ( EndianS16_BtoN( assoc->fontSize ) == 0 )
 425       {
 426         *have_sfnt = 1;
 427         *sfnt_id   = EndianS16_BtoN( assoc->fontID );
 428       }
 429       else if ( base_assoc->fontSize == 0 )
 430       {
 431         *have_sfnt = 1;
 432         *sfnt_id   = EndianS16_BtoN( base_assoc->fontID );
 433       }
 434     }
 435
 436     if ( EndianS32_BtoN( fond->ffStylOff ) )
 437     {
 438       unsigned char*  p = (unsigned char*)fond_data;
 439       StyleTable*     style;
 440       unsigned short  string_count;
 441       char            ps_name[256];
 442       unsigned char*  names[64];
 443       int             i;
 444
 445
 446       p += EndianS32_BtoN( fond->ffStylOff );
 447       style = (StyleTable*)p;
 448       p += sizeof ( StyleTable );
 449       string_count = EndianS16_BtoN( *(short*)(p) );
 450       string_count = FT_MIN( 64, string_count );
 451       p += sizeof ( short );
 452
 453       for ( i = 0; i < string_count; i++ )
 454       {
 455         names[i] = p;
 456         p       += names[i][0];
 457         p++;
 458       }
 459
 460       {
 461         size_t  ps_name_len = (size_t)names[0][0];
 462
 463
 464         if ( ps_name_len != 0 )
 465         {
 466           ft_memcpy( ps_name, names[0] + 1, ps_name_len );
 467           ps_name[ps_name_len] = 0;
 468         }
 469         if ( style->indexes[face_index] > 1 &&
 470              style->indexes[face_index] <= string_count )
 471         {
 472           unsigned char*  suffixes = names[style->indexes[face_index] - 1];
 473
 474
 475           for ( i = 1; i <= suffixes[0]; i++ )
 476           {
 477             unsigned char*  s;
 478             size_t          j = suffixes[i] - 1;
 479
 480
 481             if ( j < string_count && ( s = names[j] ) != NULL )
 482             {
 483               size_t  s_len = (size_t)s[0];
 484
 485
 486               if ( s_len != 0 && ps_name_len + s_len < sizeof ( ps_name ) )
 487               {
 488                 ft_memcpy( ps_name + ps_name_len, s + 1, s_len );
 489                 ps_name_len += s_len;
 490                 ps_name[ps_name_len] = 0;
 491               }
 492             }
 493           }
 494         }
 495       }
 496
 497       create_lwfn_name( ps_name, lwfn_file_name );
 498     }
 499   }
 500
 501
 502   static  FT_Error
 503   lookup_lwfn_by_fond( const UInt8*      path_fond,
 504                        ConstStr255Param  base_lwfn,
 505                        UInt8*            path_lwfn,
 506                        size_t            path_size )
 507   {
 508     FSRef   ref, par_ref;
 509     size_t  dirname_len;
 510
 511
 512     /* Pathname for FSRef can be in various formats: HFS, HFS+, and POSIX. */
 513     /* We should not extract parent directory by string manipulation.      */
 514
 515     if ( noErr != FSPathMakeRef( path_fond, &ref, FALSE ) )
 516       return FT_THROW( Invalid_Argument );
 517
 518     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,
 519                                     NULL, NULL, NULL, &par_ref ) )
 520       return FT_THROW( Invalid_Argument );
 521
 522     if ( noErr != FSRefMakePath( &par_ref, path_lwfn, path_size ) )
 523       return FT_THROW( Invalid_Argument );
 524
 525     if ( ft_strlen( (char *)path_lwfn ) + 1 + base_lwfn[0] > path_size )
 526       return FT_THROW( Invalid_Argument );
 527
 528     /* now we have absolute dirname in path_lwfn */
 529     ft_strcat( (char *)path_lwfn, "/" );
 530     dirname_len = ft_strlen( (char *)path_lwfn );
 531     ft_strcat( (char *)path_lwfn, (char *)base_lwfn + 1 );
 532     path_lwfn[dirname_len + base_lwfn[0]] = '\0';
 533
 534     if ( noErr != FSPathMakeRef( path_lwfn, &ref, FALSE ) )
 535       return FT_THROW( Cannot_Open_Resource );
 536
 537     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,
 538                                     NULL, NULL, NULL, NULL ) )
 539       return FT_THROW( Cannot_Open_Resource );
 540
 541     return FT_Err_Ok;
 542   }
 543
 544
 545   static short
 546   count_faces( Handle        fond,
 547                const UInt8*  pathname )
 548   {
 549     ResID     sfnt_id;
 550     short     have_sfnt, have_lwfn;
 551     Str255    lwfn_file_name;
 552     UInt8     buff[PATH_MAX];
 553     FT_Error  err;
 554     short     num_faces;
 555
 556
 557     have_sfnt = have_lwfn = 0;
 558
 559     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, 0 );
 560
 561     if ( lwfn_file_name[0] )
 562     {
 563       err = lookup_lwfn_by_fond( pathname, lwfn_file_name,
 564                                  buff, sizeof ( buff ) );
 565       if ( !err )
 566         have_lwfn = 1;
 567     }
 568
 569     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
 570       num_faces = 1;
 571     else
 572       num_faces = count_faces_scalable( *fond );
 573
 574     return num_faces;
 575   }
 576
 577
 578   /* Read Type 1 data from the POST resources inside the LWFN file,
 579      return a PFB buffer.  This is somewhat convoluted because the FT2
 580      PFB parser wants the ASCII header as one chunk, and the LWFN
 581      chunks are often not organized that way, so we glue chunks
 582      of the same type together. */
 583   static FT_Error
 584   read_lwfn( FT_Memory      memory,
 585              ResFileRefNum  res,
 586              FT_Byte**      pfb_data,
 587              FT_ULong*      size )
 588   {
 589     FT_Error       error = FT_Err_Ok;
 590     ResID          res_id;
 591     unsigned char  *buffer, *p, *size_p = NULL;
 592     FT_ULong       total_size = 0;
 593     FT_ULong       old_total_size = 0;
 594     FT_ULong       post_size, pfb_chunk_size;
 595     Handle         post_data;
 596     char           code, last_code;
 597
 598
 599     UseResFile( res );
 600
 601     /* First pass: load all POST resources, and determine the size of */
 602     /* the output buffer.                                             */
 603     res_id    = 501;
 604     last_code = -1;
 605
 606     for (;;)
 607     {
 608       post_data = Get1Resource( TTAG_POST, res_id++ );
 609       if ( !post_data )
 610         break;  /* we are done */
 611
 612       code = (*post_data)[0];
 613
 614       if ( code != last_code )
 615       {
 616         if ( code == 5 )
 617           total_size += 2; /* just the end code */
 618         else
 619           total_size += 6; /* code + 4 bytes chunk length */
 620       }
 621
 622       total_size += (FT_ULong)GetHandleSize( post_data ) - 2;
 623       last_code = code;
 624
 625       /* detect resource fork overflow */
 626       if ( FT_MAC_RFORK_MAX_LEN < total_size )
 627       {
 628         error = FT_THROW( Array_Too_Large );
 629         goto Error;
 630       }
 631
 632       old_total_size = total_size;
 633     }
 634
 635     if ( FT_QALLOC( buffer, (FT_Long)total_size ) )
 636       goto Error;
 637
 638     /* Second pass: append all POST data to the buffer, add PFB fields. */
 639     /* Glue all consecutive chunks of the same type together.           */
 640     p              = buffer;
 641     res_id         = 501;
 642     last_code      = -1;
 643     pfb_chunk_size = 0;
 644
 645     for (;;)
 646     {
 647       post_data = Get1Resource( TTAG_POST, res_id++ );
 648       if ( !post_data )
 649         break;  /* we are done */
 650
 651       post_size = (FT_ULong)GetHandleSize( post_data ) - 2;
 652       code = (*post_data)[0];
 653
 654       if ( code != last_code )
 655       {
 656         if ( last_code != -1 )
 657         {
 658           /* we are done adding a chunk, fill in the size field */
 659           if ( size_p )
 660           {
 661             *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );
 662             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );
 663             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
 664             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
 665           }
 666           pfb_chunk_size = 0;
 667         }
 668
 669         *p++ = 0x80;
 670         if ( code == 5 )
 671           *p++ = 0x03;  /* the end */
 672         else if ( code == 2 )
 673           *p++ = 0x02;  /* binary segment */
 674         else
 675           *p++ = 0x01;  /* ASCII segment */
 676
 677         if ( code != 5 )
 678         {
 679           size_p = p;   /* save for later */
 680           p += 4;       /* make space for size field */
 681         }
 682       }
 683
 684       ft_memcpy( p, *post_data + 2, post_size );
 685       pfb_chunk_size += post_size;
 686       p += post_size;
 687       last_code = code;
 688     }
 689
 690     *pfb_data = buffer;
 691     *size = total_size;
 692
 693   Error:
 694     CloseResFile( res );
 695     return error;
 696   }
 697
 698
 699   /* Create a new FT_Face from a file path to an LWFN file. */
 700   static FT_Error
 701   FT_New_Face_From_LWFN( FT_Library    library,
 702                          const UInt8*  pathname,
 703                          FT_Long       face_index,
 704                          FT_Face*      aface )
 705   {
 706     FT_Byte*       pfb_data;
 707     FT_ULong       pfb_size;
 708     FT_Error       error;
 709     ResFileRefNum  res;
 710
 711
 712     if ( noErr != FT_FSPathMakeRes( pathname, &res ) )
 713       return FT_THROW( Cannot_Open_Resource );
 714
 715     pfb_data = NULL;
 716     pfb_size = 0;
 717     error = read_lwfn( library->memory, res, &pfb_data, &pfb_size );
 718     CloseResFile( res ); /* PFB is already loaded, useless anymore */
 719     if ( error )
 720       return error;
 721
 722     return open_face_from_buffer( library,
 723                                   pfb_data,
 724                                   pfb_size,
 725                                   face_index,
 726                                   "type1",
 727                                   aface );
 728   }
 729
 730
 731   /* Create a new FT_Face from an SFNT resource, specified by res ID. */
 732   static FT_Error
 733   FT_New_Face_From_SFNT( FT_Library  library,
 734                          ResID       sfnt_id,
 735                          FT_Long     face_index,
 736                          FT_Face*    aface )
 737   {
 738     Handle     sfnt = NULL;
 739     FT_Byte*   sfnt_data;
 740     size_t     sfnt_size;
 741     FT_Error   error  = FT_Err_Ok;
 742     FT_Memory  memory = library->memory;
 743     int        is_cff, is_sfnt_ps;
 744
 745
 746     sfnt = GetResource( TTAG_sfnt, sfnt_id );
 747     if ( !sfnt )
 748       return FT_THROW( Invalid_Handle );
 749
 750     sfnt_size = (FT_ULong)GetHandleSize( sfnt );
 751
 752     /* detect resource fork overflow */
 753     if ( FT_MAC_RFORK_MAX_LEN < sfnt_size )
 754       return FT_THROW( Array_Too_Large );
 755
 756     if ( FT_QALLOC( sfnt_data, (FT_Long)sfnt_size ) )
 757     {
 758       ReleaseResource( sfnt );
 759       return error;
 760     }
 761
 762     ft_memcpy( sfnt_data, *sfnt, sfnt_size );
 763     ReleaseResource( sfnt );
 764
 765     is_cff     = sfnt_size > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 );
 766     is_sfnt_ps = sfnt_size > 4 && !ft_memcmp( sfnt_data, "typ1", 4 );
 767
 768     if ( is_sfnt_ps )
 769     {
 770       FT_Stream  stream;
 771
 772
 773       if ( FT_NEW( stream ) )
 774         goto Try_OpenType;
 775
 776       FT_Stream_OpenMemory( stream, sfnt_data, sfnt_size );
 777       if ( !open_face_PS_from_sfnt_stream( library,
 778                                            stream,
 779                                            face_index,
 780                                            0, NULL,
 781                                            aface ) )
 782       {
 783         FT_Stream_Close( stream );
 784         FT_FREE( stream );
 785         FT_FREE( sfnt_data );
 786         goto Exit;
 787       }
 788
 789       FT_FREE( stream );
 790     }
 791   Try_OpenType:
 792     error = open_face_from_buffer( library,
 793                                    sfnt_data,
 794                                    sfnt_size,
 795                                    face_index,
 796                                    is_cff ? "cff" : "truetype",
 797                                    aface );
 798   Exit:
 799     return error;
 800   }
 801
 802
 803   /* Create a new FT_Face from a file path to a suitcase file. */
 804   static FT_Error
 805   FT_New_Face_From_Suitcase( FT_Library    library,
 806                              const UInt8*  pathname,
 807                              FT_Long       face_index,
 808                              FT_Face*      aface )
 809   {
 810     FT_Error       error = FT_ERR( Cannot_Open_Resource );
 811     ResFileRefNum  res_ref;
 812     ResourceIndex  res_index;
 813     Handle         fond;
 814     short          num_faces_in_res;
 815
 816
 817     if ( noErr != FT_FSPathMakeRes( pathname, &res_ref ) )
 818       return FT_THROW( Cannot_Open_Resource );
 819
 820     UseResFile( res_ref );
 821     if ( ResError() )
 822       return FT_THROW( Cannot_Open_Resource );
 823
 824     num_faces_in_res = 0;
 825     for ( res_index = 1; ; res_index++ )
 826     {
 827       short  num_faces_in_fond;
 828
 829
 830       fond = Get1IndResource( TTAG_FOND, res_index );
 831       if ( ResError() )
 832         break;
 833
 834       num_faces_in_fond  = count_faces( fond, pathname );
 835       num_faces_in_res  += num_faces_in_fond;
 836
 837       if ( 0 <= face_index && face_index < num_faces_in_fond && error )
 838         error = FT_New_Face_From_FOND( library, fond, face_index, aface );
 839
 840       face_index -= num_faces_in_fond;
 841     }
 842
 843     CloseResFile( res_ref );
 844     if ( !error && aface && *aface )
 845       (*aface)->num_faces = num_faces_in_res;
 846     return error;
 847   }
 848
 849
 850   /* documentation is in ftmac.h */
 851
 852   FT_EXPORT_DEF( FT_Error )
 853   FT_New_Face_From_FOND( FT_Library  library,
 854                          Handle      fond,
 855                          FT_Long     face_index,
 856                          FT_Face*    aface )
 857   {
 858     short     have_sfnt, have_lwfn = 0;
 859     ResID     sfnt_id, fond_id;
 860     OSType    fond_type;
 861     Str255    fond_name;
 862     Str255    lwfn_file_name;
 863     UInt8     path_lwfn[PATH_MAX];
 864     OSErr     err;
 865     FT_Error  error = FT_Err_Ok;
 866
 867
 868     /* check of `library' and `aface' delayed to `FT_New_Face_From_XXX' */
 869
 870     GetResInfo( fond, &fond_id, &fond_type, fond_name );
 871     if ( ResError() != noErr || fond_type != TTAG_FOND )
 872       return FT_THROW( Invalid_File_Format );
 873
 874     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, face_index );
 875
 876     if ( lwfn_file_name[0] )
 877     {
 878       ResFileRefNum  res;
 879
 880
 881       res = HomeResFile( fond );
 882       if ( noErr != ResError() )
 883         goto found_no_lwfn_file;
 884
 885       {
 886         UInt8  path_fond[PATH_MAX];
 887         FSRef  ref;
 888
 889
 890         err = FSGetForkCBInfo( res, kFSInvalidVolumeRefNum,
 891                                NULL, NULL, NULL, &ref, NULL );
 892         if ( noErr != err )
 893           goto found_no_lwfn_file;
 894
 895         err = FSRefMakePath( &ref, path_fond, sizeof ( path_fond ) );
 896         if ( noErr != err )
 897           goto found_no_lwfn_file;
 898
 899         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
 900                                      path_lwfn, sizeof ( path_lwfn ) );
 901         if ( !error )
 902           have_lwfn = 1;
 903       }
 904     }
 905
 906     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
 907       error = FT_New_Face_From_LWFN( library,
 908                                      path_lwfn,
 909                                      face_index,
 910                                      aface );
 911     else
 912       error = FT_THROW( Unknown_File_Format );
 913
 914   found_no_lwfn_file:
 915     if ( have_sfnt && error )
 916       error = FT_New_Face_From_SFNT( library,
 917                                      sfnt_id,
 918                                      face_index,
 919                                      aface );
 920
 921     return error;
 922   }
 923
 924
 925   /* Common function to load a new FT_Face from a resource file. */
 926   static FT_Error
 927   FT_New_Face_From_Resource( FT_Library    library,
 928                              const UInt8*  pathname,
 929                              FT_Long       face_index,
 930                              FT_Face*      aface )
 931   {
 932     OSType    file_type;
 933     FT_Error  error;
 934
 935
 936     /* LWFN is a (very) specific file format, check for it explicitly */
 937     file_type = get_file_type_from_path( pathname );
 938     if ( file_type == TTAG_LWFN )
 939       return FT_New_Face_From_LWFN( library, pathname, face_index, aface );
 940
 941     /* Otherwise the file type doesn't matter (there are more than  */
 942     /* `FFIL' and `tfil').  Just try opening it as a font suitcase; */
 943     /* if it works, fine.                                           */
 944
 945     error = FT_New_Face_From_Suitcase( library, pathname, face_index, aface );
 946     if ( error )
 947     {
 948       /* let it fall through to normal loader (.ttf, .otf, etc.); */
 949       /* we signal this by returning no error and no FT_Face      */
 950       *aface = NULL;
 951     }
 952
 953     return FT_Err_Ok;
 954   }
 955
 956
 957   /**************************************************************************
 958    *
 959    * @Function:
 960    *   FT_New_Face
 961    *
 962    * @Description:
 963    *   This is the Mac-specific implementation of FT_New_Face.  In
 964    *   addition to the standard FT_New_Face() functionality, it also
 965    *   accepts pathnames to Mac suitcase files.  For further
 966    *   documentation see the original FT_New_Face() in freetype.h.
 967    */
 968   FT_EXPORT_DEF( FT_Error )
 969   FT_New_Face( FT_Library   library,
 970                const char*  pathname,
 971                FT_Long      face_index,
 972                FT_Face*     aface )
 973   {
 974     FT_Open_Args  args;
 975     FT_Error      error;
 976
 977
 978     /* test for valid `library' and `aface' delayed to FT_Open_Face() */
 979     if ( !pathname )
 980       return FT_THROW( Invalid_Argument );
 981
 982     *aface = NULL;
 983
 984     /* try resourcefork based font: LWFN, FFIL */
 985     error = FT_New_Face_From_Resource( library, (UInt8 *)pathname,
 986                                        face_index, aface );
 987     if ( error || *aface )
 988       return error;
 989
 990     /* let it fall through to normal loader (.ttf, .otf, etc.) */
 991     args.flags    = FT_OPEN_PATHNAME;
 992     args.pathname = (char*)pathname;
 993
 994     return FT_Open_Face( library, &args, face_index, aface );
 995   }
 996
 997
 998   /**************************************************************************
 999    *
1000    * @Function:
1001    *   FT_New_Face_From_FSRef
1002    *
1003    * @Description:
1004    *   FT_New_Face_From_FSRef is identical to FT_New_Face except it
1005    *   accepts an FSRef instead of a path.
1006    *
1007    * This function is deprecated because Carbon data types (FSRef)
1008    * are not cross-platform, and thus not suitable for the FreeType API.
1009    */
1010   FT_EXPORT_DEF( FT_Error )
1011   FT_New_Face_From_FSRef( FT_Library    library,
1012                           const FSRef*  ref,
1013                           FT_Long       face_index,
1014                           FT_Face*      aface )
1015   {
1016     FT_Error      error;
1017     FT_Open_Args  args;
1018
1019     OSErr  err;
1020     UInt8  pathname[PATH_MAX];
1021
1022
1023     /* check of `library' and `aface' delayed to */
1024     /* `FT_New_Face_From_Resource'               */
1025
1026     if ( !ref )
1027       return FT_THROW( Invalid_Argument );
1028
1029     err = FSRefMakePath( ref, pathname, sizeof ( pathname ) );
1030     if ( err )
1031       error = FT_THROW( Cannot_Open_Resource );
1032
1033     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
1034     if ( error || *aface )
1035       return error;
1036
1037     /* fallback to datafork font */
1038     args.flags    = FT_OPEN_PATHNAME;
1039     args.pathname = (char*)pathname;
1040     return FT_Open_Face( library, &args, face_index, aface );
1041   }
1042
1043
1044   /**************************************************************************
1045    *
1046    * @Function:
1047    *   FT_New_Face_From_FSSpec
1048    *
1049    * @Description:
1050    *   FT_New_Face_From_FSSpec is identical to FT_New_Face except it
1051    *   accepts an FSSpec instead of a path.
1052    *
1053    * This function is deprecated because FSSpec is deprecated in Mac OS X
1054    */
1055   FT_EXPORT_DEF( FT_Error )
1056   FT_New_Face_From_FSSpec( FT_Library     library,
1057                            const FSSpec*  spec,
1058                            FT_Long        face_index,
1059                            FT_Face*       aface )
1060   {
1061 #if ( __LP64__ ) || ( defined( MAC_OS_X_VERSION_10_5 ) && \
1062       ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 ) )
1063     FT_UNUSED( library );
1064     FT_UNUSED( spec );
1065     FT_UNUSED( face_index );
1066     FT_UNUSED( aface );
1067
1068     return FT_THROW( Unimplemented_Feature );
1069 #else
1070     FSRef  ref;
1071
1072
1073     /* check of `library' and `aface' delayed to `FT_New_Face_From_FSRef' */
1074
1075     if ( !spec || FSpMakeFSRef( spec, &ref ) != noErr )
1076       return FT_THROW( Invalid_Argument );
1077     else
1078       return FT_New_Face_From_FSRef( library, &ref, face_index, aface );
1079 #endif
1080   }
1081
1082 #else /* !FT_MACINTOSH */
1083
1084   /* ANSI C doesn't like empty source files */
1085   typedef int  ft_mac_dummy_;
1086
1087 #endif /* !FT_MACINTOSH */
1088
1089
1090 /* END */