Home | History | Annotate | Download | only in mac
      1 /***************************************************************************/
      2 /*                                                                         */
      3 /*  ftmac.c                                                                */
      4 /*                                                                         */
      5 /*    Mac FOND support.  Written by just (at) letterror.com.                    */
      6 /*  Heavily Fixed by mpsuzuki, George Williams and Sean McBride            */
      7 /*                                                                         */
      8 /*  Copyright 1996-2015 by                                                 */
      9 /*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
     10 /*                                                                         */
     11 /*  This file is part of the FreeType project, and may only be used,       */
     12 /*  modified, and distributed under the terms of the FreeType project      */
     13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
     14 /*  this file you indicate that you have read the license and              */
     15 /*  understand and accept it fully.                                        */
     16 /*                                                                         */
     17 /***************************************************************************/
     18 
     19 
     20   /*
     21     Notes
     22 
     23     Mac suitcase files can (and often do!) contain multiple fonts.  To
     24     support this I use the face_index argument of FT_(Open|New)_Face()
     25     functions, and pretend the suitcase file is a collection.
     26 
     27     Warning: fbit and NFNT bitmap resources are not supported yet.  In old
     28     sfnt fonts, bitmap glyph data for each size is stored in each `NFNT'
     29     resources instead of the `bdat' table in the sfnt resource.  Therefore,
     30     face->num_fixed_sizes is set to 0, because bitmap data in `NFNT'
     31     resource is unavailable at present.
     32 
     33     The Mac FOND support works roughly like this:
     34 
     35     - Check whether the offered stream points to a Mac suitcase file.  This
     36       is done by checking the file type: it has to be 'FFIL' or 'tfil'.  The
     37       stream that gets passed to our init_face() routine is a stdio stream,
     38       which isn't usable for us, since the FOND resources live in the
     39       resource fork.  So we just grab the stream->pathname field.
     40 
     41     - Read the FOND resource into memory, then check whether there is a
     42       TrueType font and/or(!) a Type 1 font available.
     43 
     44     - If there is a Type 1 font available (as a separate `LWFN' file), read
     45       its data into memory, massage it slightly so it becomes PFB data, wrap
     46       it into a memory stream, load the Type 1 driver and delegate the rest
     47       of the work to it by calling FT_Open_Face().  (XXX TODO: after this
     48       has been done, the kerning data from the FOND resource should be
     49       appended to the face: On the Mac there are usually no AFM files
     50       available.  However, this is tricky since we need to map Mac char
     51       codes to ps glyph names to glyph ID's...)
     52 
     53     - If there is a TrueType font (an `sfnt' resource), read it into memory,
     54       wrap it into a memory stream, load the TrueType driver and delegate
     55       the rest of the work to it, by calling FT_Open_Face().
     56 
     57     - Some suitcase fonts (notably Onyx) might point the `LWFN' file to
     58       itself, even though it doesn't contains `POST' resources.  To handle
     59       this special case without opening the file an extra time, we just
     60       ignore errors from the `LWFN' and fallback to the `sfnt' if both are
     61       available.
     62   */
     63 
     64 
     65 #include <ft2build.h>
     66 #include FT_FREETYPE_H
     67 #include FT_TRUETYPE_TAGS_H
     68 #include FT_INTERNAL_STREAM_H
     69 #include "ftbase.h"
     70 
     71 #if defined( __GNUC__ ) || defined( __IBMC__ )
     72   /* This is for Mac OS X.  Without redefinition, OS_INLINE */
     73   /* expands to `static inline' which doesn't survive the   */
     74   /* -ansi compilation flag of GCC.                         */
     75 #if !HAVE_ANSI_OS_INLINE
     76 #undef  OS_INLINE
     77 #define OS_INLINE   static __inline__
     78 #endif
     79 #include <CoreServices/CoreServices.h>
     80 #include <ApplicationServices/ApplicationServices.h>
     81 #include <sys/syslimits.h> /* PATH_MAX */
     82 #else
     83 #include <Resources.h>
     84 #include <Fonts.h>
     85 #include <Endian.h>
     86 #include <Errors.h>
     87 #include <Files.h>
     88 #include <TextUtils.h>
     89 #endif
     90 
     91 #ifndef PATH_MAX
     92 #define PATH_MAX 1024 /* same with Mac OS X's syslimits.h */
     93 #endif
     94 
     95 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
     96 #include <FSp_fopen.h>
     97 #endif
     98 
     99 #define FT_DEPRECATED_ATTRIBUTE
    100 
    101 #include FT_MAC_H
    102 
    103   /* undefine blocking-macros in ftmac.h */
    104 #undef FT_GetFile_From_Mac_Name
    105 #undef FT_GetFile_From_Mac_ATS_Name
    106 #undef FT_New_Face_From_FOND
    107 #undef FT_New_Face_From_FSSpec
    108 #undef FT_New_Face_From_FSRef
    109 
    110 
    111   /* FSSpec functions are deprecated since Mac OS X 10.4 */
    112 #ifndef HAVE_FSSPEC
    113 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
    114 #define HAVE_FSSPEC  1
    115 #else
    116 #define HAVE_FSSPEC  0
    117 #endif
    118 #endif
    119 
    120   /* most FSRef functions were introduced since Mac OS 9 */
    121 #ifndef HAVE_FSREF
    122 #if TARGET_API_MAC_OSX
    123 #define HAVE_FSREF  1
    124 #else
    125 #define HAVE_FSREF  0
    126 #endif
    127 #endif
    128 
    129   /* QuickDraw is deprecated since Mac OS X 10.4 */
    130 #ifndef HAVE_QUICKDRAW_CARBON
    131 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
    132 #define HAVE_QUICKDRAW_CARBON  1
    133 #else
    134 #define HAVE_QUICKDRAW_CARBON  0
    135 #endif
    136 #endif
    137 
    138   /* AppleTypeService is available since Mac OS X */
    139 #ifndef HAVE_ATS
    140 #if TARGET_API_MAC_OSX
    141 #define HAVE_ATS  1
    142 #ifndef kATSOptionFlagsUnRestrictedScope /* since Mac OS X 10.1 */
    143 #define kATSOptionFlagsUnRestrictedScope kATSOptionFlagsDefault
    144 #endif
    145 #else
    146 #define HAVE_ATS  0
    147 #endif
    148 #endif
    149 
    150   /* `configure' checks the availability of `ResourceIndex' strictly */
    151   /* and sets HAVE_TYPE_RESOURCE_INDEX to 1 or 0 always.  If it is   */
    152   /* not set (e.g., a build without `configure'), the availability   */
    153   /* is guessed from the SDK version.                                */
    154 #ifndef HAVE_TYPE_RESOURCE_INDEX
    155 #if !defined( MAC_OS_X_VERSION_10_5 ) || \
    156     ( MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5 )
    157 #define HAVE_TYPE_RESOURCE_INDEX 0
    158 #else
    159 #define HAVE_TYPE_RESOURCE_INDEX 1
    160 #endif
    161 #endif /* !HAVE_TYPE_RESOURCE_INDEX */
    162 
    163 #if ( HAVE_TYPE_RESOURCE_INDEX == 0 )
    164 typedef short ResourceIndex;
    165 #endif
    166 
    167   /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
    168      TrueType in case *both* are available (this is not common,
    169      but it *is* possible). */
    170 #ifndef PREFER_LWFN
    171 #define PREFER_LWFN  1
    172 #endif
    173 
    174 #ifdef FT_MACINTOSH
    175 
    176 #if !HAVE_QUICKDRAW_CARBON  /* QuickDraw is deprecated since Mac OS X 10.4 */
    177 
    178   FT_EXPORT_DEF( FT_Error )
    179   FT_GetFile_From_Mac_Name( const char*  fontName,
    180                             FSSpec*      pathSpec,
    181                             FT_Long*     face_index )
    182   {
    183     FT_UNUSED( fontName );
    184     FT_UNUSED( pathSpec );
    185     FT_UNUSED( face_index );
    186 
    187     return FT_THROW( Unimplemented_Feature );
    188   }
    189 
    190 #else
    191 
    192   FT_EXPORT_DEF( FT_Error )
    193   FT_GetFile_From_Mac_Name( const char*  fontName,
    194                             FSSpec*      pathSpec,
    195                             FT_Long*     face_index )
    196   {
    197     OptionBits            options = kFMUseGlobalScopeOption;
    198 
    199     FMFontFamilyIterator  famIter;
    200     OSStatus              status = FMCreateFontFamilyIterator( NULL, NULL,
    201                                                                options,
    202                                                                &famIter );
    203     FMFont                the_font = 0;
    204     FMFontFamily          family   = 0;
    205 
    206 
    207     if ( !fontName || !face_index )
    208       return FT_THROW( Invalid_Argument );
    209 
    210     *face_index = 0;
    211     while ( status == 0 && !the_font )
    212     {
    213       status = FMGetNextFontFamily( &famIter, &family );
    214       if ( status == 0 )
    215       {
    216         int                           stat2;
    217         FMFontFamilyInstanceIterator  instIter;
    218         Str255                        famNameStr;
    219         char                          famName[256];
    220 
    221 
    222         /* get the family name */
    223         FMGetFontFamilyName( family, famNameStr );
    224         CopyPascalStringToC( famNameStr, famName );
    225 
    226         /* iterate through the styles */
    227         FMCreateFontFamilyInstanceIterator( family, &instIter );
    228 
    229         *face_index = 0;
    230         stat2       = 0;
    231 
    232         while ( stat2 == 0 && !the_font )
    233         {
    234           FMFontStyle  style;
    235           FMFontSize   size;
    236           FMFont       font;
    237 
    238 
    239           stat2 = FMGetNextFontFamilyInstance( &instIter, &font,
    240                                                &style, &size );
    241           if ( stat2 == 0 && size == 0 )
    242           {
    243             char  fullName[256];
    244 
    245 
    246             /* build up a complete face name */
    247             ft_strcpy( fullName, famName );
    248             if ( style & bold )
    249               ft_strcat( fullName, " Bold" );
    250             if ( style & italic )
    251               ft_strcat( fullName, " Italic" );
    252 
    253             /* compare with the name we are looking for */
    254             if ( ft_strcmp( fullName, fontName ) == 0 )
    255             {
    256               /* found it! */
    257               the_font = font;
    258             }
    259             else
    260               ++(*face_index);
    261           }
    262         }
    263 
    264         FMDisposeFontFamilyInstanceIterator( &instIter );
    265       }
    266     }
    267 
    268     FMDisposeFontFamilyIterator( &famIter );
    269 
    270     if ( the_font )
    271     {
    272       FMGetFontContainer( the_font, pathSpec );
    273       return FT_Err_Ok;
    274     }
    275     else
    276       return FT_THROW( Unknown_File_Format );
    277   }
    278 
    279 #endif /* HAVE_QUICKDRAW_CARBON */
    280 
    281 
    282 #if HAVE_ATS
    283 
    284   /* Private function.                                         */
    285   /* The FSSpec type has been discouraged for a long time,     */
    286   /* unfortunately an FSRef replacement API for                */
    287   /* ATSFontGetFileSpecification() is only available in        */
    288   /* Mac OS X 10.5 and later.                                  */
    289   static OSStatus
    290   FT_ATSFontGetFileReference( ATSFontRef  ats_font_id,
    291                               FSRef*      ats_font_ref )
    292   {
    293     OSStatus  err;
    294 
    295 #if !defined( MAC_OS_X_VERSION_10_5 ) || \
    296     MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
    297     FSSpec    spec;
    298 
    299 
    300     err = ATSFontGetFileSpecification( ats_font_id, &spec );
    301     if ( noErr == err )
    302       err = FSpMakeFSRef( &spec, ats_font_ref );
    303 #else
    304     err = ATSFontGetFileReference( ats_font_id, ats_font_ref );
    305 #endif
    306 
    307     return err;
    308   }
    309 
    310 
    311   static FT_Error
    312   FT_GetFileRef_From_Mac_ATS_Name( const char*  fontName,
    313                                    FSRef*       ats_font_ref,
    314                                    FT_Long*     face_index )
    315   {
    316     CFStringRef  cf_fontName;
    317     ATSFontRef   ats_font_id;
    318 
    319 
    320     *face_index = 0;
    321 
    322     cf_fontName = CFStringCreateWithCString( NULL, fontName,
    323                                              kCFStringEncodingMacRoman );
    324     ats_font_id = ATSFontFindFromName( cf_fontName,
    325                                        kATSOptionFlagsUnRestrictedScope );
    326     CFRelease( cf_fontName );
    327 
    328     if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
    329       return FT_THROW( Unknown_File_Format );
    330 
    331     if ( noErr != FT_ATSFontGetFileReference( ats_font_id, ats_font_ref ) )
    332       return FT_THROW( Unknown_File_Format );
    333 
    334     /* face_index calculation by searching preceding fontIDs */
    335     /* with same FSRef                                       */
    336     {
    337       ATSFontRef  id2 = ats_font_id - 1;
    338       FSRef       ref2;
    339 
    340 
    341       while ( id2 > 0 )
    342       {
    343         if ( noErr != FT_ATSFontGetFileReference( id2, &ref2 ) )
    344           break;
    345         if ( noErr != FSCompareFSRefs( ats_font_ref, &ref2 ) )
    346           break;
    347 
    348         id2--;
    349       }
    350       *face_index = ats_font_id - ( id2 + 1 );
    351     }
    352 
    353     return FT_Err_Ok;
    354   }
    355 
    356 #endif
    357 
    358 #if !HAVE_ATS
    359 
    360   FT_EXPORT_DEF( FT_Error )
    361   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,
    362                                     UInt8*       path,
    363                                     UInt32       maxPathSize,
    364                                     FT_Long*     face_index )
    365   {
    366     FT_UNUSED( fontName );
    367     FT_UNUSED( path );
    368     FT_UNUSED( maxPathSize );
    369     FT_UNUSED( face_index );
    370 
    371     return FT_THROW( Unimplemented_Feature );
    372   }
    373 
    374 #else
    375 
    376   FT_EXPORT_DEF( FT_Error )
    377   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,
    378                                     UInt8*       path,
    379                                     UInt32       maxPathSize,
    380                                     FT_Long*     face_index )
    381   {
    382     FSRef     ref;
    383     FT_Error  err;
    384 
    385 
    386     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );
    387     if ( err )
    388       return err;
    389 
    390     if ( noErr != FSRefMakePath( &ref, path, maxPathSize ) )
    391       return FT_THROW( Unknown_File_Format );
    392 
    393     return FT_Err_Ok;
    394   }
    395 
    396 #endif /* HAVE_ATS */
    397 
    398 
    399 #if !HAVE_FSSPEC || !HAVE_ATS
    400 
    401   FT_EXPORT_DEF( FT_Error )
    402   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
    403                                 FSSpec*      pathSpec,
    404                                 FT_Long*     face_index )
    405   {
    406     FT_UNUSED( fontName );
    407     FT_UNUSED( pathSpec );
    408     FT_UNUSED( face_index );
    409 
    410     return FT_THROW( Unimplemented_Feature );
    411   }
    412 
    413 #else
    414 
    415   /* This function is deprecated because FSSpec is deprecated in Mac OS X. */
    416   FT_EXPORT_DEF( FT_Error )
    417   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
    418                                 FSSpec*      pathSpec,
    419                                 FT_Long*     face_index )
    420   {
    421     FSRef     ref;
    422     FT_Error  err;
    423 
    424 
    425     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );
    426     if ( err )
    427       return err;
    428 
    429     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL,
    430                                     pathSpec, NULL ) )
    431       return FT_THROW( Unknown_File_Format );
    432 
    433     return FT_Err_Ok;
    434   }
    435 
    436 #endif
    437 
    438 
    439 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
    440 
    441 #define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )
    442 
    443 
    444   FT_CALLBACK_DEF( void )
    445   ft_FSp_stream_close( FT_Stream  stream )
    446   {
    447     ft_fclose( STREAM_FILE( stream ) );
    448 
    449     stream->descriptor.pointer = NULL;
    450     stream->size               = 0;
    451     stream->base               = 0;
    452   }
    453 
    454 
    455   FT_CALLBACK_DEF( unsigned long )
    456   ft_FSp_stream_io( FT_Stream       stream,
    457                     unsigned long   offset,
    458                     unsigned char*  buffer,
    459                     unsigned long   count )
    460   {
    461     FT_FILE*  file;
    462 
    463 
    464     file = STREAM_FILE( stream );
    465 
    466     ft_fseek( file, offset, SEEK_SET );
    467 
    468     return (unsigned long)ft_fread( buffer, 1, count, file );
    469   }
    470 
    471 #endif  /* __MWERKS__ && !TARGET_RT_MAC_MACHO */
    472 
    473 
    474 #if HAVE_FSSPEC && !HAVE_FSREF
    475 
    476   /* isDirectory is a dummy to synchronize API with FSPathMakeRef() */
    477   static OSErr
    478   FT_FSPathMakeSpec( const UInt8*  pathname,
    479                      FSSpec*       spec_p,
    480                      Boolean       isDirectory )
    481   {
    482     const char  *p, *q;
    483     short       vRefNum;
    484     long        dirID;
    485     Str255      nodeName;
    486     OSErr       err;
    487     FT_UNUSED( isDirectory );
    488 
    489 
    490     p = q = (const char *)pathname;
    491     dirID   = 0;
    492     vRefNum = 0;
    493 
    494     while ( 1 )
    495     {
    496       int  len = ft_strlen( p );
    497 
    498 
    499       if ( len > 255 )
    500         len = 255;
    501 
    502       q = p + len;
    503 
    504       if ( q == p )
    505         return 0;
    506 
    507       if ( 255 < ft_strlen( (char *)pathname ) )
    508       {
    509         while ( p < q && *q != ':' )
    510           q--;
    511       }
    512 
    513       if ( p < q )
    514         *(char *)nodeName = q - p;
    515       else if ( ft_strlen( p ) < 256 )
    516         *(char *)nodeName = ft_strlen( p );
    517       else
    518         return errFSNameTooLong;
    519 
    520       ft_strncpy( (char *)nodeName + 1, (char *)p, *(char *)nodeName );
    521       err = FSMakeFSSpec( vRefNum, dirID, nodeName, spec_p );
    522       if ( err || '\0' == *q )
    523         return err;
    524 
    525       vRefNum = spec_p->vRefNum;
    526       dirID   = spec_p->parID;
    527 
    528       p = q;
    529     }
    530   }
    531 
    532 
    533   static OSErr
    534   FT_FSpMakePath( const FSSpec*  spec_p,
    535                   UInt8*         path,
    536                   UInt32         maxPathSize )
    537   {
    538     OSErr   err;
    539     FSSpec  spec = *spec_p;
    540     short   vRefNum;
    541     long    dirID;
    542     Str255  parDir_name;
    543 
    544 
    545     FT_MEM_SET( path, 0, maxPathSize );
    546     while ( 1 )
    547     {
    548       int             child_namelen = ft_strlen( (char *)path );
    549       unsigned char   node_namelen  = spec.name[0];
    550       unsigned char*  node_name     = spec.name + 1;
    551 
    552 
    553       if ( node_namelen + child_namelen > maxPathSize )
    554         return errFSNameTooLong;
    555 
    556       FT_MEM_MOVE( path + node_namelen + 1, path, child_namelen );
    557       FT_MEM_COPY( path, node_name, node_namelen );
    558       if ( child_namelen > 0 )
    559         path[node_namelen] = ':';
    560 
    561       vRefNum        = spec.vRefNum;
    562       dirID          = spec.parID;
    563       parDir_name[0] = '\0';
    564       err = FSMakeFSSpec( vRefNum, dirID, parDir_name, &spec );
    565       if ( noErr != err || dirID == spec.parID )
    566         break;
    567     }
    568     return noErr;
    569   }
    570 
    571 #endif /* HAVE_FSSPEC && !HAVE_FSREF */
    572 
    573 
    574   static OSErr
    575   FT_FSPathMakeRes( const UInt8*    pathname,
    576                     ResFileRefNum*  res )
    577   {
    578 
    579 #if HAVE_FSREF
    580 
    581     OSErr  err;
    582     FSRef  ref;
    583 
    584 
    585     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )
    586       return FT_THROW( Cannot_Open_Resource );
    587 
    588     /* at present, no support for dfont format */
    589     err = FSOpenResourceFile( &ref, 0, NULL, fsRdPerm, res );
    590     if ( noErr == err )
    591       return err;
    592 
    593     /* fallback to original resource-fork font */
    594     *res = FSOpenResFile( &ref, fsRdPerm );
    595     err  = ResError();
    596 
    597 #else
    598 
    599     OSErr   err;
    600     FSSpec  spec;
    601 
    602 
    603     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
    604       return FT_THROW( Cannot_Open_Resource );
    605 
    606     /* at present, no support for dfont format without FSRef */
    607     /* (see above), try original resource-fork font          */
    608     *res = FSpOpenResFile( &spec, fsRdPerm );
    609     err  = ResError();
    610 
    611 #endif /* HAVE_FSREF */
    612 
    613     return err;
    614   }
    615 
    616 
    617   /* Return the file type for given pathname */
    618   static OSType
    619   get_file_type_from_path( const UInt8*  pathname )
    620   {
    621 
    622 #if HAVE_FSREF
    623 
    624     FSRef          ref;
    625     FSCatalogInfo  info;
    626 
    627 
    628     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )
    629       return ( OSType ) 0;
    630 
    631     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoFinderInfo, &info,
    632                                     NULL, NULL, NULL ) )
    633       return ( OSType ) 0;
    634 
    635     return ((FInfo *)(info.finderInfo))->fdType;
    636 
    637 #else
    638 
    639     FSSpec  spec;
    640     FInfo   finfo;
    641 
    642 
    643     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
    644       return ( OSType ) 0;
    645 
    646     if ( noErr != FSpGetFInfo( &spec, &finfo ) )
    647       return ( OSType ) 0;
    648 
    649     return finfo.fdType;
    650 
    651 #endif /* HAVE_FSREF */
    652 
    653   }
    654 
    655 
    656   /* Given a PostScript font name, create the Macintosh LWFN file name. */
    657   static void
    658   create_lwfn_name( char*   ps_name,
    659                     Str255  lwfn_file_name )
    660   {
    661     int       max = 5, count = 0;
    662     FT_Byte*  p = lwfn_file_name;
    663     FT_Byte*  q = (FT_Byte*)ps_name;
    664 
    665 
    666     lwfn_file_name[0] = 0;
    667 
    668     while ( *q )
    669     {
    670       if ( ft_isupper( *q ) )
    671       {
    672         if ( count )
    673           max = 3;
    674         count = 0;
    675       }
    676       if ( count < max && ( ft_isalnum( *q ) || *q == '_' ) )
    677       {
    678         *++p = *q;
    679         lwfn_file_name[0]++;
    680         count++;
    681       }
    682       q++;
    683     }
    684   }
    685 
    686 
    687   static short
    688   count_faces_sfnt( char*  fond_data )
    689   {
    690     /* The count is 1 greater than the value in the FOND.  */
    691     /* Isn't that cute? :-)                                */
    692 
    693     return EndianS16_BtoN( *( (short*)( fond_data +
    694                                         sizeof ( FamRec ) ) ) ) + 1;
    695   }
    696 
    697 
    698   static short
    699   count_faces_scalable( char*  fond_data )
    700   {
    701     AsscEntry*  assoc;
    702     short       i, face, face_all;
    703 
    704 
    705     face_all = EndianS16_BtoN( *( (short *)( fond_data +
    706                                              sizeof ( FamRec ) ) ) ) + 1;
    707     assoc    = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
    708     face     = 0;
    709 
    710     for ( i = 0; i < face_all; i++ )
    711     {
    712       if ( 0 == EndianS16_BtoN( assoc[i].fontSize ) )
    713         face++;
    714     }
    715     return face;
    716   }
    717 
    718 
    719   /* Look inside the FOND data, answer whether there should be an SFNT
    720      resource, and answer the name of a possible LWFN Type 1 file.
    721 
    722      Thanks to Paul Miller (paulm (at) profoundeffects.com) for the fix
    723      to load a face OTHER than the first one in the FOND!
    724   */
    725 
    726   static void
    727   parse_fond( char*   fond_data,
    728               short*  have_sfnt,
    729               ResID*  sfnt_id,
    730               Str255  lwfn_file_name,
    731               short   face_index )
    732   {
    733     AsscEntry*  assoc;
    734     AsscEntry*  base_assoc;
    735     FamRec*     fond;
    736 
    737 
    738     *sfnt_id          = 0;
    739     *have_sfnt        = 0;
    740     lwfn_file_name[0] = 0;
    741 
    742     fond       = (FamRec*)fond_data;
    743     assoc      = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
    744     base_assoc = assoc;
    745 
    746     /* the maximum faces in a FOND is 48, size of StyleTable.indexes[] */
    747     if ( 47 < face_index )
    748       return;
    749 
    750     /* Let's do a little range checking before we get too excited here */
    751     if ( face_index < count_faces_sfnt( fond_data ) )
    752     {
    753       assoc += face_index;        /* add on the face_index! */
    754 
    755       /* if the face at this index is not scalable,
    756          fall back to the first one (old behavior) */
    757       if ( EndianS16_BtoN( assoc->fontSize ) == 0 )
    758       {
    759         *have_sfnt = 1;
    760         *sfnt_id   = EndianS16_BtoN( assoc->fontID );
    761       }
    762       else if ( base_assoc->fontSize == 0 )
    763       {
    764         *have_sfnt = 1;
    765         *sfnt_id   = EndianS16_BtoN( base_assoc->fontID );
    766       }
    767     }
    768 
    769     if ( EndianS32_BtoN( fond->ffStylOff ) )
    770     {
    771       unsigned char*  p = (unsigned char*)fond_data;
    772       StyleTable*     style;
    773       unsigned short  string_count;
    774       char            ps_name[256];
    775       unsigned char*  names[64];
    776       int             i;
    777 
    778 
    779       p += EndianS32_BtoN( fond->ffStylOff );
    780       style = (StyleTable*)p;
    781       p += sizeof ( StyleTable );
    782       string_count = EndianS16_BtoN( *(short*)(p) );
    783       p += sizeof ( short );
    784 
    785       for ( i = 0; i < string_count && i < 64; i++ )
    786       {
    787         names[i] = p;
    788         p       += names[i][0];
    789         p++;
    790       }
    791 
    792       {
    793         size_t  ps_name_len = (size_t)names[0][0];
    794 
    795 
    796         if ( ps_name_len != 0 )
    797         {
    798           ft_memcpy(ps_name, names[0] + 1, ps_name_len);
    799           ps_name[ps_name_len] = 0;
    800         }
    801         if ( style->indexes[face_index] > 1 &&
    802              style->indexes[face_index] <= FT_MIN( string_count, 64 ) )
    803         {
    804           unsigned char*  suffixes = names[style->indexes[face_index] - 1];
    805 
    806 
    807           for ( i = 1; i <= suffixes[0]; i++ )
    808           {
    809             unsigned char*  s;
    810             size_t          j = suffixes[i] - 1;
    811 
    812 
    813             if ( j < string_count && ( s = names[j] ) != NULL )
    814             {
    815               size_t  s_len = (size_t)s[0];
    816 
    817 
    818               if ( s_len != 0 && ps_name_len + s_len < sizeof ( ps_name ) )
    819               {
    820                 ft_memcpy( ps_name + ps_name_len, s + 1, s_len );
    821                 ps_name_len += s_len;
    822                 ps_name[ps_name_len] = 0;
    823               }
    824             }
    825           }
    826         }
    827       }
    828 
    829       create_lwfn_name( ps_name, lwfn_file_name );
    830     }
    831   }
    832 
    833 
    834   static  FT_Error
    835   lookup_lwfn_by_fond( const UInt8*      path_fond,
    836                        ConstStr255Param  base_lwfn,
    837                        UInt8*            path_lwfn,
    838                        int               path_size )
    839   {
    840 
    841 #if HAVE_FSREF
    842 
    843     FSRef  ref, par_ref;
    844     int    dirname_len;
    845 
    846 
    847     /* Pathname for FSRef can be in various formats: HFS, HFS+, and POSIX. */
    848     /* We should not extract parent directory by string manipulation.      */
    849 
    850     if ( noErr != FSPathMakeRef( path_fond, &ref, FALSE ) )
    851       return FT_THROW( Invalid_Argument );
    852 
    853     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,
    854                                     NULL, NULL, NULL, &par_ref ) )
    855       return FT_THROW( Invalid_Argument );
    856 
    857     if ( noErr != FSRefMakePath( &par_ref, path_lwfn, path_size ) )
    858       return FT_THROW( Invalid_Argument );
    859 
    860     if ( ft_strlen( (char *)path_lwfn ) + 1 + base_lwfn[0] > path_size )
    861       return FT_THROW( Invalid_Argument );
    862 
    863     /* now we have absolute dirname in path_lwfn */
    864     if ( path_lwfn[0] == '/' )
    865       ft_strcat( (char *)path_lwfn, "/" );
    866     else
    867       ft_strcat( (char *)path_lwfn, ":" );
    868 
    869     dirname_len = ft_strlen( (char *)path_lwfn );
    870     ft_strcat( (char *)path_lwfn, (char *)base_lwfn + 1 );
    871     path_lwfn[dirname_len + base_lwfn[0]] = '\0';
    872 
    873     if ( noErr != FSPathMakeRef( path_lwfn, &ref, FALSE ) )
    874       return FT_THROW( Cannot_Open_Resource );
    875 
    876     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,
    877                                     NULL, NULL, NULL, NULL ) )
    878       return FT_THROW( Cannot_Open_Resource );
    879 
    880     return FT_Err_Ok;
    881 
    882 #else
    883 
    884     int     i;
    885     FSSpec  spec;
    886 
    887 
    888     /* pathname for FSSpec is always HFS format */
    889     if ( ft_strlen( (char *)path_fond ) > path_size )
    890       return FT_THROW( Invalid_Argument );
    891 
    892     ft_strcpy( (char *)path_lwfn, (char *)path_fond );
    893 
    894     i = ft_strlen( (char *)path_lwfn ) - 1;
    895     while ( i > 0 && ':' != path_lwfn[i] )
    896       i--;
    897 
    898     if ( i + 1 + base_lwfn[0] > path_size )
    899       return FT_THROW( Invalid_Argument );
    900 
    901     if ( ':' == path_lwfn[i] )
    902     {
    903       ft_strcpy( (char *)path_lwfn + i + 1, (char *)base_lwfn + 1 );
    904       path_lwfn[i + 1 + base_lwfn[0]] = '\0';
    905     }
    906     else
    907     {
    908       ft_strcpy( (char *)path_lwfn, (char *)base_lwfn + 1 );
    909       path_lwfn[base_lwfn[0]] = '\0';
    910     }
    911 
    912     if ( noErr != FT_FSPathMakeSpec( path_lwfn, &spec, FALSE ) )
    913       return FT_THROW( Cannot_Open_Resource );
    914 
    915     return FT_Err_Ok;
    916 
    917 #endif /* HAVE_FSREF */
    918 
    919   }
    920 
    921 
    922   static short
    923   count_faces( Handle        fond,
    924                const UInt8*  pathname )
    925   {
    926     ResID     sfnt_id;
    927     short     have_sfnt, have_lwfn;
    928     Str255    lwfn_file_name;
    929     UInt8     buff[PATH_MAX];
    930     FT_Error  err;
    931     short     num_faces;
    932 
    933 
    934     have_sfnt = have_lwfn = 0;
    935 
    936     HLock( fond );
    937     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, 0 );
    938 
    939     if ( lwfn_file_name[0] )
    940     {
    941       err = lookup_lwfn_by_fond( pathname, lwfn_file_name,
    942                                  buff, sizeof ( buff )  );
    943       if ( FT_Err_Ok == err )
    944         have_lwfn = 1;
    945     }
    946 
    947     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
    948       num_faces = 1;
    949     else
    950       num_faces = count_faces_scalable( *fond );
    951 
    952     HUnlock( fond );
    953     return num_faces;
    954   }
    955 
    956 
    957   /* Read Type 1 data from the POST resources inside the LWFN file,
    958      return a PFB buffer.  This is somewhat convoluted because the FT2
    959      PFB parser wants the ASCII header as one chunk, and the LWFN
    960      chunks are often not organized that way, so we glue chunks
    961      of the same type together. */
    962   static FT_Error
    963   read_lwfn( FT_Memory      memory,
    964              ResFileRefNum  res,
    965              FT_Byte**      pfb_data,
    966              FT_ULong*      size )
    967   {
    968     FT_Error       error = FT_Err_Ok;
    969     ResID          res_id;
    970     unsigned char  *buffer, *p, *size_p = NULL;
    971     FT_ULong       total_size = 0;
    972     FT_ULong       old_total_size = 0;
    973     FT_ULong       post_size, pfb_chunk_size;
    974     Handle         post_data;
    975     char           code, last_code;
    976 
    977 
    978     UseResFile( res );
    979 
    980     /* First pass: load all POST resources, and determine the size of */
    981     /* the output buffer.                                             */
    982     res_id    = 501;
    983     last_code = -1;
    984 
    985     for (;;)
    986     {
    987       post_data = Get1Resource( TTAG_POST, res_id++ );
    988       if ( post_data == NULL )
    989         break;  /* we are done */
    990 
    991       code = (*post_data)[0];
    992 
    993       if ( code != last_code )
    994       {
    995         if ( code == 5 )
    996           total_size += 2; /* just the end code */
    997         else
    998           total_size += 6; /* code + 4 bytes chunk length */
    999       }
   1000 
   1001       total_size += GetHandleSize( post_data ) - 2;
   1002       last_code = code;
   1003 
   1004       /* detect integer overflows */
   1005       if ( total_size < old_total_size )
   1006       {
   1007         error = FT_ERR( Array_Too_Large );
   1008         goto Error;
   1009       }
   1010 
   1011       old_total_size = total_size;
   1012     }
   1013 
   1014     if ( FT_ALLOC( buffer, (FT_Long)total_size ) )
   1015       goto Error;
   1016 
   1017     /* Second pass: append all POST data to the buffer, add PFB fields. */
   1018     /* Glue all consecutive chunks of the same type together.           */
   1019     p              = buffer;
   1020     res_id         = 501;
   1021     last_code      = -1;
   1022     pfb_chunk_size = 0;
   1023 
   1024     for (;;)
   1025     {
   1026       post_data = Get1Resource( TTAG_POST, res_id++ );
   1027       if ( post_data == NULL )
   1028         break;  /* we are done */
   1029 
   1030       post_size = (FT_ULong)GetHandleSize( post_data ) - 2;
   1031       code = (*post_data)[0];
   1032 
   1033       if ( code != last_code )
   1034       {
   1035         if ( last_code != -1 )
   1036         {
   1037           /* we are done adding a chunk, fill in the size field */
   1038           if ( size_p != NULL )
   1039           {
   1040             *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );
   1041             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );
   1042             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
   1043             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
   1044           }
   1045           pfb_chunk_size = 0;
   1046         }
   1047 
   1048         *p++ = 0x80;
   1049         if ( code == 5 )
   1050           *p++ = 0x03;  /* the end */
   1051         else if ( code == 2 )
   1052           *p++ = 0x02;  /* binary segment */
   1053         else
   1054           *p++ = 0x01;  /* ASCII segment */
   1055 
   1056         if ( code != 5 )
   1057         {
   1058           size_p = p;   /* save for later */
   1059           p += 4;       /* make space for size field */
   1060         }
   1061       }
   1062 
   1063       ft_memcpy( p, *post_data + 2, post_size );
   1064       pfb_chunk_size += post_size;
   1065       p += post_size;
   1066       last_code = code;
   1067     }
   1068 
   1069     *pfb_data = buffer;
   1070     *size = total_size;
   1071 
   1072   Error:
   1073     CloseResFile( res );
   1074     return error;
   1075   }
   1076 
   1077 
   1078   /* Create a new FT_Face from a file spec to an LWFN file. */
   1079   static FT_Error
   1080   FT_New_Face_From_LWFN( FT_Library    library,
   1081                          const UInt8*  pathname,
   1082                          FT_Long       face_index,
   1083                          FT_Face*      aface )
   1084   {
   1085     FT_Byte*       pfb_data;
   1086     FT_ULong       pfb_size;
   1087     FT_Error       error;
   1088     ResFileRefNum  res;
   1089 
   1090 
   1091     if ( noErr != FT_FSPathMakeRes( pathname, &res ) )
   1092       return FT_THROW( Cannot_Open_Resource );
   1093 
   1094     pfb_data = NULL;
   1095     pfb_size = 0;
   1096     error = read_lwfn( library->memory, res, &pfb_data, &pfb_size );
   1097     CloseResFile( res ); /* PFB is already loaded, useless anymore */
   1098     if ( error )
   1099       return error;
   1100 
   1101     return open_face_from_buffer( library,
   1102                                   pfb_data,
   1103                                   pfb_size,
   1104                                   face_index,
   1105                                   "type1",
   1106                                   aface );
   1107   }
   1108 
   1109 
   1110   /* Create a new FT_Face from an SFNT resource, specified by res ID. */
   1111   static FT_Error
   1112   FT_New_Face_From_SFNT( FT_Library  library,
   1113                          ResID       sfnt_id,
   1114                          FT_Long     face_index,
   1115                          FT_Face*    aface )
   1116   {
   1117     Handle     sfnt = NULL;
   1118     FT_Byte*   sfnt_data;
   1119     size_t     sfnt_size;
   1120     FT_Error   error  = FT_Err_Ok;
   1121     FT_Memory  memory = library->memory;
   1122     int        is_cff, is_sfnt_ps;
   1123 
   1124 
   1125     sfnt = GetResource( TTAG_sfnt, sfnt_id );
   1126     if ( sfnt == NULL )
   1127       return FT_THROW( Invalid_Handle );
   1128 
   1129     sfnt_size = (FT_ULong)GetHandleSize( sfnt );
   1130     if ( FT_ALLOC( sfnt_data, (FT_Long)sfnt_size ) )
   1131     {
   1132       ReleaseResource( sfnt );
   1133       return error;
   1134     }
   1135 
   1136     HLock( sfnt );
   1137     ft_memcpy( sfnt_data, *sfnt, sfnt_size );
   1138     HUnlock( sfnt );
   1139     ReleaseResource( sfnt );
   1140 
   1141     is_cff     = sfnt_size > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 );
   1142     is_sfnt_ps = sfnt_size > 4 && !ft_memcmp( sfnt_data, "typ1", 4 );
   1143 
   1144     if ( is_sfnt_ps )
   1145     {
   1146       FT_Stream  stream;
   1147 
   1148 
   1149       if ( FT_NEW( stream ) )
   1150         goto Try_OpenType;
   1151 
   1152       FT_Stream_OpenMemory( stream, sfnt_data, sfnt_size );
   1153       if ( !open_face_PS_from_sfnt_stream( library,
   1154                                            stream,
   1155                                            face_index,
   1156                                            0, NULL,
   1157                                            aface ) )
   1158       {
   1159         FT_Stream_Close( stream );
   1160         FT_FREE( stream );
   1161         FT_FREE( sfnt_data );
   1162         goto Exit;
   1163       }
   1164 
   1165       FT_FREE( stream );
   1166     }
   1167   Try_OpenType:
   1168     error = open_face_from_buffer( library,
   1169                                    sfnt_data,
   1170                                    sfnt_size,
   1171                                    face_index,
   1172                                    is_cff ? "cff" : "truetype",
   1173                                    aface );
   1174   Exit:
   1175     return error;
   1176   }
   1177 
   1178 
   1179   /* Create a new FT_Face from a file spec to a suitcase file. */
   1180   static FT_Error
   1181   FT_New_Face_From_Suitcase( FT_Library    library,
   1182                              const UInt8*  pathname,
   1183                              FT_Long       face_index,
   1184                              FT_Face*      aface )
   1185   {
   1186     FT_Error       error = FT_ERR( Cannot_Open_Resource );
   1187     ResFileRefNum  res_ref;
   1188     ResourceIndex  res_index;
   1189     Handle         fond;
   1190     short          num_faces_in_res;
   1191 
   1192 
   1193     if ( noErr != FT_FSPathMakeRes( pathname, &res_ref ) )
   1194       return FT_THROW( Cannot_Open_Resource );
   1195 
   1196     UseResFile( res_ref );
   1197     if ( ResError() )
   1198       return FT_THROW( Cannot_Open_Resource );
   1199 
   1200     num_faces_in_res = 0;
   1201     for ( res_index = 1; ; ++res_index )
   1202     {
   1203       short  num_faces_in_fond;
   1204 
   1205 
   1206       fond = Get1IndResource( TTAG_FOND, res_index );
   1207       if ( ResError() )
   1208         break;
   1209 
   1210       num_faces_in_fond  = count_faces( fond, pathname );
   1211       num_faces_in_res  += num_faces_in_fond;
   1212 
   1213       if ( 0 <= face_index && face_index < num_faces_in_fond && error )
   1214         error = FT_New_Face_From_FOND( library, fond, face_index, aface );
   1215 
   1216       face_index -= num_faces_in_fond;
   1217     }
   1218 
   1219     CloseResFile( res_ref );
   1220     if ( FT_Err_Ok == error && NULL != aface )
   1221       (*aface)->num_faces = num_faces_in_res;
   1222     return error;
   1223   }
   1224 
   1225 
   1226   /* documentation is in ftmac.h */
   1227 
   1228   FT_EXPORT_DEF( FT_Error )
   1229   FT_New_Face_From_FOND( FT_Library  library,
   1230                          Handle      fond,
   1231                          FT_Long     face_index,
   1232                          FT_Face*    aface )
   1233   {
   1234     short     have_sfnt, have_lwfn = 0;
   1235     ResID     sfnt_id, fond_id;
   1236     OSType    fond_type;
   1237     Str255    fond_name;
   1238     Str255    lwfn_file_name;
   1239     UInt8     path_lwfn[PATH_MAX];
   1240     OSErr     err;
   1241     FT_Error  error = FT_Err_Ok;
   1242 
   1243 
   1244     /* test for valid `aface' and `library' delayed to */
   1245     /* `FT_New_Face_From_XXX'                          */
   1246 
   1247     GetResInfo( fond, &fond_id, &fond_type, fond_name );
   1248     if ( ResError() != noErr || fond_type != TTAG_FOND )
   1249       return FT_THROW( Invalid_File_Format );
   1250 
   1251     HLock( fond );
   1252     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, face_index );
   1253     HUnlock( fond );
   1254 
   1255     if ( lwfn_file_name[0] )
   1256     {
   1257       ResFileRefNum  res;
   1258 
   1259 
   1260       res = HomeResFile( fond );
   1261       if ( noErr != ResError() )
   1262         goto found_no_lwfn_file;
   1263 
   1264 #if HAVE_FSREF
   1265 
   1266       {
   1267         UInt8  path_fond[PATH_MAX];
   1268         FSRef  ref;
   1269 
   1270 
   1271         err = FSGetForkCBInfo( res, kFSInvalidVolumeRefNum,
   1272                                NULL, NULL, NULL, &ref, NULL );
   1273         if ( noErr != err )
   1274           goto found_no_lwfn_file;
   1275 
   1276         err = FSRefMakePath( &ref, path_fond, sizeof ( path_fond ) );
   1277         if ( noErr != err )
   1278           goto found_no_lwfn_file;
   1279 
   1280         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
   1281                                      path_lwfn, sizeof ( path_lwfn ) );
   1282         if ( FT_Err_Ok == error )
   1283           have_lwfn = 1;
   1284       }
   1285 
   1286 #elif HAVE_FSSPEC
   1287 
   1288       {
   1289         UInt8     path_fond[PATH_MAX];
   1290         FCBPBRec  pb;
   1291         Str255    fond_file_name;
   1292         FSSpec    spec;
   1293 
   1294 
   1295         FT_MEM_SET( &spec, 0, sizeof ( FSSpec ) );
   1296         FT_MEM_SET( &pb,   0, sizeof ( FCBPBRec ) );
   1297 
   1298         pb.ioNamePtr = fond_file_name;
   1299         pb.ioVRefNum = 0;
   1300         pb.ioRefNum  = res;
   1301         pb.ioFCBIndx = 0;
   1302 
   1303         err = PBGetFCBInfoSync( &pb );
   1304         if ( noErr != err )
   1305           goto found_no_lwfn_file;
   1306 
   1307         err = FSMakeFSSpec( pb.ioFCBVRefNum, pb.ioFCBParID,
   1308                             fond_file_name, &spec );
   1309         if ( noErr != err )
   1310           goto found_no_lwfn_file;
   1311 
   1312         err = FT_FSpMakePath( &spec, path_fond, sizeof ( path_fond ) );
   1313         if ( noErr != err )
   1314           goto found_no_lwfn_file;
   1315 
   1316         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
   1317                                      path_lwfn, sizeof ( path_lwfn ) );
   1318         if ( FT_Err_Ok == error )
   1319           have_lwfn = 1;
   1320       }
   1321 
   1322 #endif /* HAVE_FSREF, HAVE_FSSPEC */
   1323 
   1324     }
   1325 
   1326     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
   1327       error = FT_New_Face_From_LWFN( library,
   1328                                      path_lwfn,
   1329                                      face_index,
   1330                                      aface );
   1331     else
   1332       error = FT_ERR( Unknown_File_Format );
   1333 
   1334   found_no_lwfn_file:
   1335     if ( have_sfnt && FT_Err_Ok != error )
   1336       error = FT_New_Face_From_SFNT( library,
   1337                                      sfnt_id,
   1338                                      face_index,
   1339                                      aface );
   1340 
   1341     return error;
   1342   }
   1343 
   1344 
   1345   /* Common function to load a new FT_Face from a resource file. */
   1346   static FT_Error
   1347   FT_New_Face_From_Resource( FT_Library    library,
   1348                              const UInt8*  pathname,
   1349                              FT_Long       face_index,
   1350                              FT_Face*      aface )
   1351   {
   1352     OSType    file_type;
   1353     FT_Error  error;
   1354 
   1355 
   1356     /* LWFN is a (very) specific file format, check for it explicitly */
   1357     file_type = get_file_type_from_path( pathname );
   1358     if ( file_type == TTAG_LWFN )
   1359       return FT_New_Face_From_LWFN( library, pathname, face_index, aface );
   1360 
   1361     /* Otherwise the file type doesn't matter (there are more than  */
   1362     /* `FFIL' and `tfil').  Just try opening it as a font suitcase; */
   1363     /* if it works, fine.                                           */
   1364 
   1365     error = FT_New_Face_From_Suitcase( library, pathname, face_index, aface );
   1366     if ( error == 0 )
   1367       return error;
   1368 
   1369     /* let it fall through to normal loader (.ttf, .otf, etc.); */
   1370     /* we signal this by returning no error and no FT_Face      */
   1371     *aface = NULL;
   1372     return 0;
   1373   }
   1374 
   1375 
   1376   /*************************************************************************/
   1377   /*                                                                       */
   1378   /* <Function>                                                            */
   1379   /*    FT_New_Face                                                        */
   1380   /*                                                                       */
   1381   /* <Description>                                                         */
   1382   /*    This is the Mac-specific implementation of FT_New_Face.  In        */
   1383   /*    addition to the standard FT_New_Face() functionality, it also      */
   1384   /*    accepts pathnames to Mac suitcase files.  For further              */
   1385   /*    documentation see the original FT_New_Face() in freetype.h.        */
   1386   /*                                                                       */
   1387   FT_EXPORT_DEF( FT_Error )
   1388   FT_New_Face( FT_Library   library,
   1389                const char*  pathname,
   1390                FT_Long      face_index,
   1391                FT_Face*     aface )
   1392   {
   1393     FT_Open_Args  args;
   1394     FT_Error      error;
   1395 
   1396 
   1397     /* test for valid `library' and `aface' delayed to FT_Open_Face() */
   1398     if ( !pathname )
   1399       return FT_THROW( Invalid_Argument );
   1400 
   1401     *aface = NULL;
   1402 
   1403     /* try resourcefork based font: LWFN, FFIL */
   1404     error = FT_New_Face_From_Resource( library, (UInt8 *)pathname,
   1405                                        face_index, aface );
   1406     if ( error != 0 || *aface != NULL )
   1407       return error;
   1408 
   1409     /* let it fall through to normal loader (.ttf, .otf, etc.) */
   1410     args.flags    = FT_OPEN_PATHNAME;
   1411     args.pathname = (char*)pathname;
   1412     return FT_Open_Face( library, &args, face_index, aface );
   1413   }
   1414 
   1415 
   1416   /*************************************************************************/
   1417   /*                                                                       */
   1418   /* <Function>                                                            */
   1419   /*    FT_New_Face_From_FSRef                                             */
   1420   /*                                                                       */
   1421   /* <Description>                                                         */
   1422   /*    FT_New_Face_From_FSRef is identical to FT_New_Face except it       */
   1423   /*    accepts an FSRef instead of a path.                                */
   1424   /*                                                                       */
   1425   /* This function is deprecated because Carbon data types (FSRef)         */
   1426   /* are not cross-platform, and thus not suitable for the freetype API.   */
   1427   FT_EXPORT_DEF( FT_Error )
   1428   FT_New_Face_From_FSRef( FT_Library    library,
   1429                           const FSRef*  ref,
   1430                           FT_Long       face_index,
   1431                           FT_Face*      aface )
   1432   {
   1433 
   1434 #if !HAVE_FSREF
   1435 
   1436     FT_UNUSED( library );
   1437     FT_UNUSED( ref );
   1438     FT_UNUSED( face_index );
   1439     FT_UNUSED( aface );
   1440 
   1441     return FT_THROW( Unimplemented_Feature );
   1442 
   1443 #else
   1444 
   1445     FT_Error      error;
   1446     FT_Open_Args  args;
   1447     OSErr   err;
   1448     UInt8   pathname[PATH_MAX];
   1449 
   1450 
   1451     /* test for valid `library' and `aface' delayed to `FT_Open_Face' */
   1452 
   1453     if ( !ref )
   1454       return FT_THROW( Invalid_Argument );
   1455 
   1456     err = FSRefMakePath( ref, pathname, sizeof ( pathname ) );
   1457     if ( err )
   1458       error = FT_ERR( Cannot_Open_Resource );
   1459 
   1460     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
   1461     if ( error != 0 || *aface != NULL )
   1462       return error;
   1463 
   1464     /* fallback to datafork font */
   1465     args.flags    = FT_OPEN_PATHNAME;
   1466     args.pathname = (char*)pathname;
   1467     return FT_Open_Face( library, &args, face_index, aface );
   1468 
   1469 #endif /* HAVE_FSREF */
   1470 
   1471   }
   1472 
   1473 
   1474   /*************************************************************************/
   1475   /*                                                                       */
   1476   /* <Function>                                                            */
   1477   /*    FT_New_Face_From_FSSpec                                            */
   1478   /*                                                                       */
   1479   /* <Description>                                                         */
   1480   /*    FT_New_Face_From_FSSpec is identical to FT_New_Face except it      */
   1481   /*    accepts an FSSpec instead of a path.                               */
   1482   /*                                                                       */
   1483   /* This function is deprecated because Carbon data types (FSSpec)        */
   1484   /* are not cross-platform, and thus not suitable for the freetype API.   */
   1485   FT_EXPORT_DEF( FT_Error )
   1486   FT_New_Face_From_FSSpec( FT_Library     library,
   1487                            const FSSpec*  spec,
   1488                            FT_Long        face_index,
   1489                            FT_Face*       aface )
   1490   {
   1491 
   1492 #if HAVE_FSREF
   1493 
   1494     FSRef  ref;
   1495 
   1496 
   1497     if ( !spec || FSpMakeFSRef( spec, &ref ) != noErr )
   1498       return FT_THROW( Invalid_Argument );
   1499     else
   1500       return FT_New_Face_From_FSRef( library, &ref, face_index, aface );
   1501 
   1502 #elif HAVE_FSSPEC
   1503 
   1504     FT_Error      error;
   1505     FT_Open_Args  args;
   1506     OSErr         err;
   1507     UInt8         pathname[PATH_MAX];
   1508 
   1509 
   1510     if ( !spec )
   1511       return FT_THROW( Invalid_Argument );
   1512 
   1513     err = FT_FSpMakePath( spec, pathname, sizeof ( pathname ) );
   1514     if ( err )
   1515       error = FT_ERR( Cannot_Open_Resource );
   1516 
   1517     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
   1518     if ( error != 0 || *aface != NULL )
   1519       return error;
   1520 
   1521     /* fallback to datafork font */
   1522     args.flags    = FT_OPEN_PATHNAME;
   1523     args.pathname = (char*)pathname;
   1524     return FT_Open_Face( library, &args, face_index, aface );
   1525 
   1526 #else
   1527 
   1528     FT_UNUSED( library );
   1529     FT_UNUSED( spec );
   1530     FT_UNUSED( face_index );
   1531     FT_UNUSED( aface );
   1532 
   1533     return FT_THROW( Unimplemented_Feature );
   1534 
   1535 #endif /* HAVE_FSREF, HAVE_FSSPEC */
   1536 
   1537   }
   1538 
   1539 #endif /* FT_MACINTOSH */
   1540 
   1541 
   1542 /* END */
   1543