1 /***************************************************************************/

     2 /*                                                                         */

     3 /*  ftmac.c                                                                */

     4 /*                                                                         */

     5 /*    Mac FOND support.  Written by just@letterror.com.                    */

     6 /*  Heavily Fixed by mpsuzuki, George Williams and Sean McBride            */

     7 /*                                                                         */

     8 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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 

   175 #if !HAVE_QUICKDRAW_CARBON  /* QuickDraw is deprecated since Mac OS X 10.4 */

   176 

   177   FT_EXPORT_DEF( FT_Error )

   178   FT_GetFile_From_Mac_Name( const char*  fontName,

   179                             FSSpec*      pathSpec,

   180                             FT_Long*     face_index )

   181   {

   182     FT_UNUSED( fontName );

   183     FT_UNUSED( pathSpec );

   184     FT_UNUSED( face_index );

   185 

   186     return FT_Err_Unimplemented_Feature;

   187   }

   188 

   189 #else

   190 

   191   FT_EXPORT_DEF( FT_Error )

   192   FT_GetFile_From_Mac_Name( const char*  fontName,

   193                             FSSpec*      pathSpec,

   194                             FT_Long*     face_index )

   195   {

   196     OptionBits            options = kFMUseGlobalScopeOption;

   197 

   198     FMFontFamilyIterator  famIter;

   199     OSStatus              status = FMCreateFontFamilyIterator( NULL, NULL,

   200                                                                options,

   201                                                                &famIter );

   202     FMFont                the_font = 0;

   203     FMFontFamily          family   = 0;

   204 

   205 

   206     *face_index = 0;

   207     while ( status == 0 && !the_font )

   208     {

   209       status = FMGetNextFontFamily( &famIter, &family );

   210       if ( status == 0 )

   211       {

   212         int                           stat2;

   213         FMFontFamilyInstanceIterator  instIter;

   214         Str255                        famNameStr;

   215         char                          famName[256];

   216 

   217 

   218         /* get the family name */

   219         FMGetFontFamilyName( family, famNameStr );

   220         CopyPascalStringToC( famNameStr, famName );

   221 

   222         /* iterate through the styles */

   223         FMCreateFontFamilyInstanceIterator( family, &instIter );

   224 

   225         *face_index = 0;

   226         stat2       = 0;

   227 

   228         while ( stat2 == 0 && !the_font )

   229         {

   230           FMFontStyle  style;

   231           FMFontSize   size;

   232           FMFont       font;

   233 

   234 

   235           stat2 = FMGetNextFontFamilyInstance( &instIter, &font,

   236                                                &style, &size );

   237           if ( stat2 == 0 && size == 0 )

   238           {

   239             char  fullName[256];

   240 

   241 

   242             /* build up a complete face name */

   243             ft_strcpy( fullName, famName );

   244             if ( style & bold )

   245               ft_strcat( fullName, " Bold" );

   246             if ( style & italic )

   247               ft_strcat( fullName, " Italic" );

   248 

   249             /* compare with the name we are looking for */

   250             if ( ft_strcmp( fullName, fontName ) == 0 )

   251             {

   252               /* found it! */

   253               the_font = font;

   254             }

   255             else

   256               ++(*face_index);

   257           }

   258         }

   259 

   260         FMDisposeFontFamilyInstanceIterator( &instIter );

   261       }

   262     }

   263 

   264     FMDisposeFontFamilyIterator( &famIter );

   265 

   266     if ( the_font )

   267     {

   268       FMGetFontContainer( the_font, pathSpec );

   269       return FT_Err_Ok;

   270     }

   271     else

   272       return FT_Err_Unknown_File_Format;

   273   }

   274 

   275 #endif /* HAVE_QUICKDRAW_CARBON */

   276 

   277 

   278 #if HAVE_ATS

   279 

   280   /* Private function.                                         */

   281   /* The FSSpec type has been discouraged for a long time,     */

   282   /* unfortunately an FSRef replacement API for                */

   283   /* ATSFontGetFileSpecification() is only available in        */

   284   /* Mac OS X 10.5 and later.                                  */

   285   static OSStatus

   286   FT_ATSFontGetFileReference( ATSFontRef  ats_font_id,

   287                               FSRef*      ats_font_ref )

   288   {

   289     OSStatus  err;

   290 

   291 #if !defined( MAC_OS_X_VERSION_10_5 ) || \

   292     MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5

   293     FSSpec    spec;

   294 

   295 

   296     err = ATSFontGetFileSpecification( ats_font_id, &spec );

   297     if ( noErr == err )

   298       err = FSpMakeFSRef( &spec, ats_font_ref );

   299 #else

   300     err = ATSFontGetFileReference( ats_font_id, ats_font_ref );

   301 #endif

   302 

   303     return err;

   304   }

   305 

   306 

   307   static FT_Error

   308   FT_GetFileRef_From_Mac_ATS_Name( const char*  fontName,

   309                                    FSRef*       ats_font_ref,

   310                                    FT_Long*     face_index )

   311   {

   312     CFStringRef  cf_fontName;

   313     ATSFontRef   ats_font_id;

   314 

   315 

   316     *face_index = 0;

   317 

   318     cf_fontName = CFStringCreateWithCString( NULL, fontName,

   319                                              kCFStringEncodingMacRoman );

   320     ats_font_id = ATSFontFindFromName( cf_fontName,

   321                                        kATSOptionFlagsUnRestrictedScope );

   322     CFRelease( cf_fontName );

   323 

   324     if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )

   325       return FT_Err_Unknown_File_Format;

   326 

   327     if ( noErr != FT_ATSFontGetFileReference( ats_font_id, ats_font_ref ) )

   328       return FT_Err_Unknown_File_Format;

   329 

   330     /* face_index calculation by searching preceding fontIDs */

   331     /* with same FSRef                                       */

   332     {

   333       ATSFontRef  id2 = ats_font_id - 1;

   334       FSRef       ref2;

   335 

   336 

   337       while ( id2 > 0 )

   338       {

   339         if ( noErr != FT_ATSFontGetFileReference( id2, &ref2 ) )

   340           break;

   341         if ( noErr != FSCompareFSRefs( ats_font_ref, &ref2 ) )

   342           break;

   343 

   344         id2--;

   345       }

   346       *face_index = ats_font_id - ( id2 + 1 );

   347     }

   348 

   349     return FT_Err_Ok;

   350   }

   351 

   352 #endif

   353 

   354 #if !HAVE_ATS

   355 

   356   FT_EXPORT_DEF( FT_Error )

   357   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,

   358                                     UInt8*       path,

   359                                     UInt32       maxPathSize,

   360                                     FT_Long*     face_index )

   361   {

   362     FT_UNUSED( fontName );

   363     FT_UNUSED( path );

   364     FT_UNUSED( maxPathSize );

   365     FT_UNUSED( face_index );

   366 

   367     return FT_Err_Unimplemented_Feature;

   368   }

   369 

   370 #else

   371 

   372   FT_EXPORT_DEF( FT_Error )

   373   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,

   374                                     UInt8*       path,

   375                                     UInt32       maxPathSize,

   376                                     FT_Long*     face_index )

   377   {

   378     FSRef     ref;

   379     FT_Error  err;

   380 

   381 

   382     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );

   383     if ( FT_Err_Ok != err )

   384       return err;

   385 

   386     if ( noErr != FSRefMakePath( &ref, path, maxPathSize ) )

   387       return FT_Err_Unknown_File_Format;

   388 

   389     return FT_Err_Ok;

   390   }

   391 

   392 #endif /* HAVE_ATS */

   393 

   394 

   395 #if !HAVE_FSSPEC || !HAVE_ATS

   396 

   397   FT_EXPORT_DEF( FT_Error )

   398   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,

   399                                 FSSpec*      pathSpec,

   400                                 FT_Long*     face_index )

   401   {

   402     FT_UNUSED( fontName );

   403     FT_UNUSED( pathSpec );

   404     FT_UNUSED( face_index );

   405 

   406     return FT_Err_Unimplemented_Feature;

   407   }

   408 

   409 #else

   410 

   411   /* This function is deprecated because FSSpec is deprecated in Mac OS X. */

   412   FT_EXPORT_DEF( FT_Error )

   413   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,

   414                                 FSSpec*      pathSpec,

   415                                 FT_Long*     face_index )

   416   {

   417     FSRef     ref;

   418     FT_Error  err;

   419 

   420 

   421     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );

   422     if ( FT_Err_Ok != err )

   423       return err;

   424 

   425     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL,

   426                                     pathSpec, NULL ) )

   427       return FT_Err_Unknown_File_Format;

   428 

   429     return FT_Err_Ok;

   430   }

   431 

   432 #endif

   433 

   434 

   435 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO

   436 

   437 #define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )

   438 

   439 

   440   FT_CALLBACK_DEF( void )

   441   ft_FSp_stream_close( FT_Stream  stream )

   442   {

   443     ft_fclose( STREAM_FILE( stream ) );

   444 

   445     stream->descriptor.pointer = NULL;

   446     stream->size               = 0;

   447     stream->base               = 0;

   448   }

   449 

   450 

   451   FT_CALLBACK_DEF( unsigned long )

   452   ft_FSp_stream_io( FT_Stream       stream,

   453                     unsigned long   offset,

   454                     unsigned char*  buffer,

   455                     unsigned long   count )

   456   {

   457     FT_FILE*  file;

   458 

   459 

   460     file = STREAM_FILE( stream );

   461 

   462     ft_fseek( file, offset, SEEK_SET );

   463 

   464     return (unsigned long)ft_fread( buffer, 1, count, file );

   465   }

   466 

   467 #endif  /* __MWERKS__ && !TARGET_RT_MAC_MACHO */

   468 

   469 

   470 #if HAVE_FSSPEC && !HAVE_FSREF

   471 

   472   /* isDirectory is a dummy to synchronize API with FSPathMakeRef() */

   473   static OSErr

   474   FT_FSPathMakeSpec( const UInt8*  pathname,

   475                      FSSpec*       spec_p,

   476                      Boolean       isDirectory )

   477   {

   478     const char  *p, *q;

   479     short       vRefNum;

   480     long        dirID;

   481     Str255      nodeName;

   482     OSErr       err;

   483     FT_UNUSED( isDirectory );

   484 

   485 

   486     p = q = (const char *)pathname;

   487     dirID   = 0;

   488     vRefNum = 0;

   489 

   490     while ( 1 )

   491     {

   492       int  len = ft_strlen( p );

   493 

   494 

   495       if ( len > 255 )

   496         len = 255;

   497 

   498       q = p + len;

   499 

   500       if ( q == p )

   501         return 0;

   502 

   503       if ( 255 < ft_strlen( (char *)pathname ) )

   504       {

   505         while ( p < q && *q != ':' )

   506           q--;

   507       }

   508 

   509       if ( p < q )

   510         *(char *)nodeName = q - p;

   511       else if ( ft_strlen( p ) < 256 )

   512         *(char *)nodeName = ft_strlen( p );

   513       else

   514         return errFSNameTooLong;

   515 

   516       ft_strncpy( (char *)nodeName + 1, (char *)p, *(char *)nodeName );

   517       err = FSMakeFSSpec( vRefNum, dirID, nodeName, spec_p );

   518       if ( err || '\0' == *q )

   519         return err;

   520 

   521       vRefNum = spec_p->vRefNum;

   522       dirID   = spec_p->parID;

   523 

   524       p = q;

   525     }

   526   }

   527 

   528 

   529   static OSErr

   530   FT_FSpMakePath( const FSSpec*  spec_p,

   531                   UInt8*         path,

   532                   UInt32         maxPathSize )

   533   {

   534     OSErr   err;

   535     FSSpec  spec = *spec_p;

   536     short   vRefNum;

   537     long    dirID;

   538     Str255  parDir_name;

   539 

   540 

   541     FT_MEM_SET( path, 0, maxPathSize );

   542     while ( 1 )

   543     {

   544       int             child_namelen = ft_strlen( (char *)path );

   545       unsigned char   node_namelen  = spec.name[0];

   546       unsigned char*  node_name     = spec.name + 1;

   547 

   548 

   549       if ( node_namelen + child_namelen > maxPathSize )

   550         return errFSNameTooLong;

   551 

   552       FT_MEM_MOVE( path + node_namelen + 1, path, child_namelen );

   553       FT_MEM_COPY( path, node_name, node_namelen );

   554       if ( child_namelen > 0 )

   555         path[node_namelen] = ':';

   556 

   557       vRefNum        = spec.vRefNum;

   558       dirID          = spec.parID;

   559       parDir_name[0] = '\0';

   560       err = FSMakeFSSpec( vRefNum, dirID, parDir_name, &spec );

   561       if ( noErr != err || dirID == spec.parID )

   562         break;

   563     }

   564     return noErr;

   565   }

   566 

   567 #endif /* HAVE_FSSPEC && !HAVE_FSREF */

   568 

   569 

   570   static OSErr

   571   FT_FSPathMakeRes( const UInt8*    pathname,

   572                     ResFileRefNum*  res )

   573   {

   574 

   575 #if HAVE_FSREF

   576 

   577     OSErr  err;

   578     FSRef  ref;

   579 

   580 

   581     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )

   582       return FT_Err_Cannot_Open_Resource;

   583 

   584     /* at present, no support for dfont format */

   585     err = FSOpenResourceFile( &ref, 0, NULL, fsRdPerm, res );

   586     if ( noErr == err )

   587       return err;

   588 

   589     /* fallback to original resource-fork font */

   590     *res = FSOpenResFile( &ref, fsRdPerm );

   591     err  = ResError();

   592 

   593 #else

   594 

   595     OSErr   err;

   596     FSSpec  spec;

   597 

   598 

   599     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )

   600       return FT_Err_Cannot_Open_Resource;

   601 

   602     /* at present, no support for dfont format without FSRef */

   603     /* (see above), try original resource-fork font          */

   604     *res = FSpOpenResFile( &spec, fsRdPerm );

   605     err  = ResError();

   606 

   607 #endif /* HAVE_FSREF */

   608 

   609     return err;

   610   }

   611 

   612 

   613   /* Return the file type for given pathname */

   614   static OSType

   615   get_file_type_from_path( const UInt8*  pathname )

   616   {

   617 

   618 #if HAVE_FSREF

   619 

   620     FSRef          ref;

   621     FSCatalogInfo  info;

   622 

   623 

   624     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )

   625       return ( OSType ) 0;

   626 

   627     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoFinderInfo, &info,

   628                                     NULL, NULL, NULL ) )

   629       return ( OSType ) 0;

   630 

   631     return ((FInfo *)(info.finderInfo))->fdType;

   632 

   633 #else

   634 

   635     FSSpec  spec;

   636     FInfo   finfo;

   637 

   638 

   639     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )

   640       return ( OSType ) 0;

   641 

   642     if ( noErr != FSpGetFInfo( &spec, &finfo ) )

   643       return ( OSType ) 0;

   644 

   645     return finfo.fdType;

   646 

   647 #endif /* HAVE_FSREF */

   648 

   649   }

   650 

   651 

   652   /* Given a PostScript font name, create the Macintosh LWFN file name. */

   653   static void

   654   create_lwfn_name( char*   ps_name,

   655                     Str255  lwfn_file_name )

   656   {

   657     int       max = 5, count = 0;

   658     FT_Byte*  p = lwfn_file_name;

   659     FT_Byte*  q = (FT_Byte*)ps_name;

   660 

   661 

   662     lwfn_file_name[0] = 0;

   663 

   664     while ( *q )

   665     {

   666       if ( ft_isupper( *q ) )

   667       {

   668         if ( count )

   669           max = 3;

   670         count = 0;

   671       }

   672       if ( count < max && ( ft_isalnum( *q ) || *q == '_' ) )

   673       {

   674         *++p = *q;

   675         lwfn_file_name[0]++;

   676         count++;

   677       }

   678       q++;

   679     }

   680   }

   681 

   682 

   683   static short

   684   count_faces_sfnt( char*  fond_data )

   685   {

   686     /* The count is 1 greater than the value in the FOND.  */

   687     /* Isn't that cute? :-)                                */

   688 

   689     return EndianS16_BtoN( *( (short*)( fond_data +

   690                                         sizeof ( FamRec ) ) ) ) + 1;

   691   }

   692 

   693 

   694   static short

   695   count_faces_scalable( char*  fond_data )

   696   {

   697     AsscEntry*  assoc;

   698     FamRec*     fond;

   699     short       i, face, face_all;

   700 

   701 

   702     fond     = (FamRec*)fond_data;

   703     face_all = EndianS16_BtoN( *( (short *)( fond_data +

   704                                              sizeof ( FamRec ) ) ) ) + 1;

   705     assoc    = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );

   706     face     = 0;

   707 

   708     for ( i = 0; i < face_all; i++ )

   709     {

   710       if ( 0 == EndianS16_BtoN( assoc[i].fontSize ) )

   711         face++;

   712     }

   713     return face;

   714   }

   715 

   716 

   717   /* Look inside the FOND data, answer whether there should be an SFNT

   718      resource, and answer the name of a possible LWFN Type 1 file.

   719 

   720      Thanks to Paul Miller (paulm@profoundeffects.com) for the fix

   721      to load a face OTHER than the first one in the FOND!

   722   */

   723 

   724   static void

   725   parse_fond( char*   fond_data,

   726               short*  have_sfnt,

   727               ResID*  sfnt_id,

   728               Str255  lwfn_file_name,

   729               short   face_index )

   730   {

   731     AsscEntry*  assoc;

   732     AsscEntry*  base_assoc;

   733     FamRec*     fond;

   734 

   735 

   736     *sfnt_id          = 0;

   737     *have_sfnt        = 0;

   738     lwfn_file_name[0] = 0;

   739 

   740     fond       = (FamRec*)fond_data;

   741     assoc      = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );

   742     base_assoc = assoc;

   743 

   744     /* the maximum faces in a FOND is 48, size of StyleTable.indexes[] */

   745     if ( 47 < face_index )

   746       return;

   747 

   748     /* Let's do a little range checking before we get too excited here */

   749     if ( face_index < count_faces_sfnt( fond_data ) )

   750     {

   751       assoc += face_index;        /* add on the face_index! */

   752 

   753       /* if the face at this index is not scalable,

   754          fall back to the first one (old behavior) */

   755       if ( EndianS16_BtoN( assoc->fontSize ) == 0 )

   756       {

   757         *have_sfnt = 1;

   758         *sfnt_id   = EndianS16_BtoN( assoc->fontID );

   759       }

   760       else if ( base_assoc->fontSize == 0 )

   761       {

   762         *have_sfnt = 1;

   763         *sfnt_id   = EndianS16_BtoN( base_assoc->fontID );

   764       }

   765     }

   766 

   767     if ( EndianS32_BtoN( fond->ffStylOff ) )

   768     {

   769       unsigned char*  p = (unsigned char*)fond_data;

   770       StyleTable*     style;

   771       unsigned short  string_count;

   772       char            ps_name[256];

   773       unsigned char*  names[64];

   774       int             i;

   775 

   776 

   777       p += EndianS32_BtoN( fond->ffStylOff );

   778       style = (StyleTable*)p;

   779       p += sizeof ( StyleTable );

   780       string_count = EndianS16_BtoN( *(short*)(p) );

   781       p += sizeof ( short );

   782 

   783       for ( i = 0; i < string_count && i < 64; i++ )

   784       {

   785         names[i] = p;

   786         p       += names[i][0];

   787         p++;

   788       }

   789 

   790       {

   791         size_t  ps_name_len = (size_t)names[0][0];

   792 

   793 

   794         if ( ps_name_len != 0 )

   795         {

   796           ft_memcpy(ps_name, names[0] + 1, ps_name_len);

   797           ps_name[ps_name_len] = 0;

   798         }

   799         if ( style->indexes[face_index] > 1 &&

   800              style->indexes[face_index] <= FT_MIN( string_count, 64 ) )

   801         {

   802           unsigned char*  suffixes = names[style->indexes[face_index] - 1];

   803 

   804 

   805           for ( i = 1; i <= suffixes[0]; i++ )

   806           {

   807             unsigned char*  s;

   808             size_t          j = suffixes[i] - 1;

   809 

   810 

   811             if ( j < string_count && ( s = names[j] ) != NULL )

   812             {

   813               size_t  s_len = (size_t)s[0];

   814 

   815 

   816               if ( s_len != 0 && ps_name_len + s_len < sizeof ( ps_name ) )

   817               {

   818                 ft_memcpy( ps_name + ps_name_len, s + 1, s_len );

   819                 ps_name_len += s_len;

   820                 ps_name[ps_name_len] = 0;

   821               }

   822             }

   823           }

   824         }

   825       }

   826 

   827       create_lwfn_name( ps_name, lwfn_file_name );

   828     }

   829   }

   830 

   831 

   832   static  FT_Error

   833   lookup_lwfn_by_fond( const UInt8*      path_fond,

   834                        ConstStr255Param  base_lwfn,

   835                        UInt8*            path_lwfn,

   836                        int               path_size )

   837   {

   838 

   839 #if HAVE_FSREF

   840 

   841     FSRef  ref, par_ref;

   842     int    dirname_len;

   843 

   844 

   845     /* Pathname for FSRef can be in various formats: HFS, HFS+, and POSIX. */

   846     /* We should not extract parent directory by string manipulation.      */

   847 

   848     if ( noErr != FSPathMakeRef( path_fond, &ref, FALSE ) )

   849       return FT_Err_Invalid_Argument;

   850 

   851     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,

   852                                     NULL, NULL, NULL, &par_ref ) )

   853       return FT_Err_Invalid_Argument;

   854 

   855     if ( noErr != FSRefMakePath( &par_ref, path_lwfn, path_size ) )

   856       return FT_Err_Invalid_Argument;

   857 

   858     if ( ft_strlen( (char *)path_lwfn ) + 1 + base_lwfn[0] > path_size )

   859       return FT_Err_Invalid_Argument;

   860 

   861     /* now we have absolute dirname in path_lwfn */

   862     if ( path_lwfn[0] == '/' )

   863       ft_strcat( (char *)path_lwfn, "/" );

   864     else

   865       ft_strcat( (char *)path_lwfn, ":" );

   866 

   867     dirname_len = ft_strlen( (char *)path_lwfn );

   868     ft_strcat( (char *)path_lwfn, (char *)base_lwfn + 1 );

   869     path_lwfn[dirname_len + base_lwfn[0]] = '\0';

   870 

   871     if ( noErr != FSPathMakeRef( path_lwfn, &ref, FALSE ) )

   872       return FT_Err_Cannot_Open_Resource;

   873 

   874     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,

   875                                     NULL, NULL, NULL, NULL ) )

   876       return FT_Err_Cannot_Open_Resource;

   877 

   878     return FT_Err_Ok;

   879 

   880 #else

   881 

   882     int     i;

   883     FSSpec  spec;

   884 

   885 

   886     /* pathname for FSSpec is always HFS format */

   887     if ( ft_strlen( (char *)path_fond ) > path_size )

   888       return FT_Err_Invalid_Argument;

   889 

   890     ft_strcpy( (char *)path_lwfn, (char *)path_fond );

   891 

   892     i = ft_strlen( (char *)path_lwfn ) - 1;

   893     while ( i > 0 && ':' != path_lwfn[i] )

   894       i--;

   895 

   896     if ( i + 1 + base_lwfn[0] > path_size )

   897       return FT_Err_Invalid_Argument;

   898 

   899     if ( ':' == path_lwfn[i] )

   900     {

   901       ft_strcpy( (char *)path_lwfn + i + 1, (char *)base_lwfn + 1 );

   902       path_lwfn[i + 1 + base_lwfn[0]] = '\0';

   903     }

   904     else

   905     {

   906       ft_strcpy( (char *)path_lwfn, (char *)base_lwfn + 1 );

   907       path_lwfn[base_lwfn[0]] = '\0';

   908     }

   909 

   910     if ( noErr != FT_FSPathMakeSpec( path_lwfn, &spec, FALSE ) )

   911       return FT_Err_Cannot_Open_Resource;

   912 

   913     return FT_Err_Ok;

   914 

   915 #endif /* HAVE_FSREF */

   916 

   917   }

   918 

   919 

   920   static short

   921   count_faces( Handle        fond,

   922                const UInt8*  pathname )

   923   {

   924     ResID     sfnt_id;

   925     short     have_sfnt, have_lwfn;

   926     Str255    lwfn_file_name;

   927     UInt8     buff[PATH_MAX];

   928     FT_Error  err;

   929     short     num_faces;

   930 

   931 

   932     have_sfnt = have_lwfn = 0;

   933 

   934     HLock( fond );

   935     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, 0 );

   936 

   937     if ( lwfn_file_name[0] )

   938     {

   939       err = lookup_lwfn_by_fond( pathname, lwfn_file_name,

   940                                  buff, sizeof ( buff )  );

   941       if ( FT_Err_Ok == err )

   942         have_lwfn = 1;

   943     }

   944 

   945     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )

   946       num_faces = 1;

   947     else

   948       num_faces = count_faces_scalable( *fond );

   949 

   950     HUnlock( fond );

   951     return num_faces;

   952   }

   953 

   954 

   955   /* Read Type 1 data from the POST resources inside the LWFN file,

   956      return a PFB buffer.  This is somewhat convoluted because the FT2

   957      PFB parser wants the ASCII header as one chunk, and the LWFN

   958      chunks are often not organized that way, so we glue chunks

   959      of the same type together. */

   960   static FT_Error

   961   read_lwfn( FT_Memory      memory,

   962              ResFileRefNum  res,

   963              FT_Byte**      pfb_data,

   964              FT_ULong*      size )

   965   {

   966     FT_Error       error = FT_Err_Ok;

   967     ResID          res_id;

   968     unsigned char  *buffer, *p, *size_p = NULL;

   969     FT_ULong       total_size = 0;

   970     FT_ULong       old_total_size = 0;

   971     FT_ULong       post_size, pfb_chunk_size;

   972     Handle         post_data;

   973     char           code, last_code;

   974 

   975 

   976     UseResFile( res );

   977 

   978     /* First pass: load all POST resources, and determine the size of */

   979     /* the output buffer.                                             */

   980     res_id    = 501;

   981     last_code = -1;

   982 

   983     for (;;)

   984     {

   985       post_data = Get1Resource( TTAG_POST, res_id++ );

   986       if ( post_data == NULL )

   987         break;  /* we are done */

   988 

   989       code = (*post_data)[0];

   990 

   991       if ( code != last_code )

   992       {

   993         if ( code == 5 )

   994           total_size += 2; /* just the end code */

   995         else

   996           total_size += 6; /* code + 4 bytes chunk length */

   997       }

   998 

   999       total_size += GetHandleSize( post_data ) - 2;

  1000       last_code = code;

  1001 

  1002       /* detect integer overflows */

  1003       if ( total_size < old_total_size )

  1004       {

  1005         error = FT_Err_Array_Too_Large;

  1006         goto Error;

  1007       }

  1008 

  1009       old_total_size = total_size;

  1010     }

  1011 

  1012     if ( FT_ALLOC( buffer, (FT_Long)total_size ) )

  1013       goto Error;

  1014 

  1015     /* Second pass: append all POST data to the buffer, add PFB fields. */

  1016     /* Glue all consecutive chunks of the same type together.           */

  1017     p              = buffer;

  1018     res_id         = 501;

  1019     last_code      = -1;

  1020     pfb_chunk_size = 0;

  1021 

  1022     for (;;)

  1023     {

  1024       post_data = Get1Resource( TTAG_POST, res_id++ );

  1025       if ( post_data == NULL )

  1026         break;  /* we are done */

  1027 

  1028       post_size = (FT_ULong)GetHandleSize( post_data ) - 2;

  1029       code = (*post_data)[0];

  1030 

  1031       if ( code != last_code )

  1032       {

  1033         if ( last_code != -1 )

  1034         {

  1035           /* we are done adding a chunk, fill in the size field */

  1036           if ( size_p != NULL )

  1037           {

  1038             *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );

  1039             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );

  1040             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );

  1041             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );

  1042           }

  1043           pfb_chunk_size = 0;

  1044         }

  1045 

  1046         *p++ = 0x80;

  1047         if ( code == 5 )

  1048           *p++ = 0x03;  /* the end */

  1049         else if ( code == 2 )

  1050           *p++ = 0x02;  /* binary segment */

  1051         else

  1052           *p++ = 0x01;  /* ASCII segment */

  1053 

  1054         if ( code != 5 )

  1055         {

  1056           size_p = p;   /* save for later */

  1057           p += 4;       /* make space for size field */

  1058         }

  1059       }

  1060 

  1061       ft_memcpy( p, *post_data + 2, post_size );

  1062       pfb_chunk_size += post_size;

  1063       p += post_size;

  1064       last_code = code;

  1065     }

  1066 

  1067     *pfb_data = buffer;

  1068     *size = total_size;

  1069 

  1070   Error:

  1071     CloseResFile( res );

  1072     return error;

  1073   }

  1074 

  1075 

  1076   /* Create a new FT_Face from a file spec to an LWFN file. */

  1077   static FT_Error

  1078   FT_New_Face_From_LWFN( FT_Library    library,

  1079                          const UInt8*  pathname,

  1080                          FT_Long       face_index,

  1081                          FT_Face*      aface )

  1082   {

  1083     FT_Byte*       pfb_data;

  1084     FT_ULong       pfb_size;

  1085     FT_Error       error;

  1086     ResFileRefNum  res;

  1087 

  1088 

  1089     if ( noErr != FT_FSPathMakeRes( pathname, &res ) )

  1090       return FT_Err_Cannot_Open_Resource;

  1091 

  1092     pfb_data = NULL;

  1093     pfb_size = 0;

  1094     error = read_lwfn( library->memory, res, &pfb_data, &pfb_size );

  1095     CloseResFile( res ); /* PFB is already loaded, useless anymore */

  1096     if ( error )

  1097       return error;

  1098 

  1099     return open_face_from_buffer( library,

  1100                                   pfb_data,

  1101                                   pfb_size,

  1102                                   face_index,

  1103                                   "type1",

  1104                                   aface );

  1105   }

  1106 

  1107 

  1108   /* Create a new FT_Face from an SFNT resource, specified by res ID. */

  1109   static FT_Error

  1110   FT_New_Face_From_SFNT( FT_Library  library,

  1111                          ResID       sfnt_id,

  1112                          FT_Long     face_index,

  1113                          FT_Face*    aface )

  1114   {

  1115     Handle     sfnt = NULL;

  1116     FT_Byte*   sfnt_data;

  1117     size_t     sfnt_size;

  1118     FT_Error   error  = FT_Err_Ok;

  1119     FT_Memory  memory = library->memory;

  1120     int        is_cff, is_sfnt_ps;

  1121 

  1122 

  1123     sfnt = GetResource( TTAG_sfnt, sfnt_id );

  1124     if ( sfnt == NULL )

  1125       return FT_Err_Invalid_Handle;

  1126 

  1127     sfnt_size = (FT_ULong)GetHandleSize( sfnt );

  1128     if ( FT_ALLOC( sfnt_data, (FT_Long)sfnt_size ) )

  1129     {

  1130       ReleaseResource( sfnt );

  1131       return error;

  1132     }

  1133 

  1134     HLock( sfnt );

  1135     ft_memcpy( sfnt_data, *sfnt, sfnt_size );

  1136     HUnlock( sfnt );