FT_Stream_OpenMemory( stream, base, size );    stream->close = close;    *astream = stream;  Exit:    return error;  }  /* Create a new FT_Face given a buffer and a driver name. */  static FT_Error  open_face_from_buffer( FT_Library  library,                         FT_Byte*    base,                         FT_ULong    size,                         FT_Long     face_index,                         char*       driver_name,                         FT_Face*    aface )  {    FT_Open_Args  args;    FT_Error      error;    FT_Stream     stream;    FT_Memory     memory = library->memory;    error = new_memory_stream( library,                               base,                               size,                               memory_stream_close,                               &stream );    if ( error )    {      FT_FREE( base );      return error;    }    args.flags  = FT_OPEN_STREAM;    args.stream = stream;    if ( driver_name )    {      args.flags  = args.flags | FT_OPEN_DRIVER;      args.driver = FT_Get_Module( library, driver_name );    }    /* At this point, face_index has served its purpose;      */    /* whoever calls this function has already used it to     */    /* locate the correct font data.  We should not propagate */    /* this index to FT_Open_Face() (unless it is negative).  */    if ( face_index > 0 )      face_index = 0;    error = FT_Open_Face( library, &args, face_index, aface );    if ( error == FT_Err_Ok )      (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;    return error;  }  /* Create a new FT_Face from a file spec to an LWFN file. */  static FT_Error  FT_New_Face_From_LWFN( FT_Library    library,                         const UInt8*  pathname,                         FT_Long       face_index,                         FT_Face*      aface )  {    FT_Byte*  pfb_data;    FT_ULong  pfb_size;    FT_Error  error;    short     res;    if ( noErr != FT_FSPathMakeRes( pathname, &res ) )      return FT_Err_Cannot_Open_Resource;    pfb_data = NULL;    pfb_size = 0;    error = read_lwfn( library->memory, res, &pfb_data, &pfb_size );    CloseResFile( res ); /* PFB is already loaded, useless anymore */    if ( error )      return error;    return open_face_from_buffer( library,                                  pfb_data,                                  pfb_size,                                  face_index,                                  "type1",                                  aface );  }  /* Create a new FT_Face from an SFNT resource, specified by res ID. */  static FT_Error  FT_New_Face_From_SFNT( FT_Library  library,                         short       sfnt_id,                         FT_Long     face_index,                         FT_Face*    aface )  {    Handle     sfnt = NULL;    FT_Byte*   sfnt_data;    size_t     sfnt_size;    FT_Error   error  = FT_Err_Ok;    FT_Memory  memory = library->memory;    int        is_cff;    sfnt = GetResource( 'sfnt', sfnt_id );    if ( ResError() )      return FT_Err_Invalid_Handle;    sfnt_size = (FT_ULong)GetHandleSize( sfnt );    if ( FT_ALLOC( sfnt_data, (FT_Long)sfnt_size ) )    {      ReleaseResource( sfnt );      return error;    }    HLock( sfnt );    ft_memcpy( sfnt_data, *sfnt, sfnt_size );    HUnlock( sfnt );    ReleaseResource( sfnt );    is_cff = sfnt_size > 4 && sfnt_data[0] == 'O' &&                              sfnt_data[1] == 'T' &&                              sfnt_data[2] == 'T' &&                              sfnt_data[3] == 'O';    return open_face_from_buffer( library,                                  sfnt_data,                                  sfnt_size,                                  face_index,                                  is_cff ? "cff" : "truetype",                                  aface );  }  /* Create a new FT_Face from a file spec to a suitcase file. */  static FT_Error  FT_New_Face_From_Suitcase( FT_Library    library,                             const UInt8*  pathname,                             FT_Long       face_index,                             FT_Face*      aface )  {    FT_Error  error = FT_Err_Cannot_Open_Resource;    short     res_ref, res_index;    Handle    fond;    short     num_faces_in_res, num_faces_in_fond;    if ( noErr != FT_FSPathMakeRes( pathname, &res_ref ) )      return FT_Err_Cannot_Open_Resource;    UseResFile( res_ref );    if ( ResError() )      return FT_Err_Cannot_Open_Resource;    num_faces_in_res = 0;    for ( res_index = 1; ; ++res_index )    {      fond = Get1IndResource( 'FOND', res_index );      if ( ResError() )        break;      num_faces_in_fond  = count_faces( fond, pathname );      num_faces_in_res  += num_faces_in_fond;      if ( 0 <= face_index && face_index < num_faces_in_fond && error )        error = FT_New_Face_From_FOND( library, fond, face_index, aface );      face_index -= num_faces_in_fond;    }    CloseResFile( res_ref );    if ( FT_Err_Ok == error && NULL != aface )      (*aface)->num_faces = num_faces_in_res;    return error;  }  /* documentation is in ftmac.h */  FT_EXPORT_DEF( FT_Error )  FT_New_Face_From_FOND( FT_Library  library,                         Handle      fond,                         FT_Long     face_index,                         FT_Face*    aface )  {    short     sfnt_id, have_sfnt, have_lwfn = 0;    short     fond_id;    OSType    fond_type;    Str255    fond_name;    Str255    lwfn_file_name;    UInt8     path_lwfn[HFS_MAXPATHLEN];    OSErr     err;    FT_Error  error;    GetResInfo( fond, &fond_id, &fond_type, fond_name );    if ( ResError() != noErr || fond_type != 'FOND' )      return FT_Err_Invalid_File_Format;    HLock( fond );    parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, face_index );    HUnlock( fond );    if ( lwfn_file_name[0] )    {      short  res;      res = HomeResFile( fond );      if ( noErr != ResError() )        goto found_no_lwfn_file;#if HAVE_FSREF      {        UInt8  path_fond[HFS_MAXPATHLEN];        FSRef  ref;        err = FSGetForkCBInfo( res, kFSInvalidVolumeRefNum,                               NULL, NULL, NULL, &ref, NULL );        if ( noErr != err )          goto found_no_lwfn_file;        err = FSRefMakePath( &ref, path_fond, sizeof ( path_fond ) );        if ( noErr != err )          goto found_no_lwfn_file;        error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,                                     path_lwfn, sizeof ( path_lwfn ) );        if ( FT_Err_Ok == error )          have_lwfn = 1;      }#elif HAVE_FSSPEC      {        UInt8     path_fond[HFS_MAXPATHLEN];        FCBPBRec  pb;        Str255    fond_file_name;        FSSpec    spec;        FT_MEM_SET( &spec, 0, sizeof ( FSSpec ) );        FT_MEM_SET( &pb,   0, sizeof ( FCBPBRec ) );        pb.ioNamePtr = fond_file_name;        pb.ioVRefNum = 0;        pb.ioRefNum  = res;        pb.ioFCBIndx = 0;        err = PBGetFCBInfoSync( &pb );        if ( noErr != err )          goto found_no_lwfn_file;        err = FSMakeFSSpec( pb.ioFCBVRefNum, pb.ioFCBParID,                            fond_file_name, &spec );        if ( noErr != err )          goto found_no_lwfn_file;        err = FT_FSpMakePath( &spec, path_fond, sizeof ( path_fond ) );        if ( noErr != err )          goto found_no_lwfn_file;        error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,                                     path_lwfn, sizeof ( path_lwfn ) );        if ( FT_Err_Ok == error )          have_lwfn = 1;      }#endif /* HAVE_FSREF, HAVE_FSSPEC */    }    if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )      return FT_New_Face_From_LWFN( library,                                    path_lwfn,                                    face_index,                                    aface );  found_no_lwfn_file:    if ( have_sfnt )      return FT_New_Face_From_SFNT( library,                                    sfnt_id,                                    face_index,                                    aface );    return FT_Err_Unknown_File_Format;  }  /* Common function to load a new FT_Face from a resource file. */  static FT_Error  FT_New_Face_From_Resource( FT_Library    library,                             const UInt8*  pathname,                             FT_Long       face_index,                             FT_Face*      aface )  {    OSType    file_type;    FT_Error  error;    /* LWFN is a (very) specific file format, check for it explicitly */    file_type = get_file_type_from_path( pathname );    if ( file_type == 'LWFN' )      return FT_New_Face_From_LWFN( library, pathname, face_index, aface );    /* Otherwise the file type doesn't matter (there are more than  */    /* `FFIL' and `tfil').  Just try opening it as a font suitcase; */    /* if it works, fine.                                           */    error = FT_New_Face_From_Suitcase( library, pathname, face_index, aface );    if ( error == 0 )      return error;    /* let it fall through to normal loader (.ttf, .otf, etc.); */    /* we signal this by returning no error and no FT_Face      */    *aface = NULL;    return 0;  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    FT_New_Face                                                        */  /*                                                                       */  /* <Description>                                                         */  /*    This is the Mac-specific implementation of FT_New_Face.  In        */  /*    addition to the standard FT_New_Face() functionality, it also      */  /*    accepts pathnames to Mac suitcase files.  For further              */  /*    documentation see the original FT_New_Face() in freetype.h.        */  /*                                                                       */  FT_EXPORT_DEF( FT_Error )  FT_New_Face( FT_Library   library,               const char*  pathname,               FT_Long      face_index,               FT_Face*     aface )  {    FT_Open_Args  args;    FT_Error      error;    /* test for valid `library' and `aface' delayed to FT_Open_Face() */    if ( !pathname )      return FT_Err_Invalid_Argument;    error  = FT_Err_Ok;    *aface = NULL;    /* try resourcefork based font: LWFN, FFIL */    error = FT_New_Face_From_Resource( library, (UInt8 *)pathname,                                       face_index, aface );    if ( error != 0 || *aface != NULL )      return error;    /* let it fall through to normal loader (.ttf, .otf, etc.) */    args.flags    = FT_OPEN_PATHNAME;    args.pathname = (char*)pathname;    return FT_Open_Face( library, &args, face_index, aface );  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    FT_New_Face_From_FSRef                                             */  /*                                                                       */  /* <Description>                                                         */  /*    FT_New_Face_From_FSRef is identical to FT_New_Face except it       */  /*    accepts an FSRef instead of a path.                                */  /*                                                                       */  FT_EXPORT_DEF( FT_Error )  FT_New_Face_From_FSRef( FT_Library    library,                          const FSRef*  ref,                          FT_Long       face_index,                          FT_Face*      aface )  {#if !HAVE_FSREF    return FT_Err_Unimplemented_Feature;#else    FT_Error      error;    FT_Open_Args  args;    OSErr   err;    UInt8   pathname[HFS_MAXPATHLEN];    if ( !ref )      return FT_Err_Invalid_Argument;    err = FSRefMakePath( ref, pathname, sizeof ( pathname ) );    if ( err )      error = FT_Err_Cannot_Open_Resource;    error = FT_New_Face_From_Resource( library, pathname, face_index, aface );    if ( error != 0 || *aface != NULL )      return error;    /* fallback to datafork font */    args.flags    = FT_OPEN_PATHNAME;    args.pathname = (char*)pathname;    return FT_Open_Face( library, &args, face_index, aface );#endif /* HAVE_FSREF */  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    FT_New_Face_From_FSSpec                                            */  /*                                                                       */  /* <Description>                                                         */  /*    FT_New_Face_From_FSSpec is identical to FT_New_Face except it      */  /*    accepts an FSSpec instead of a path.                               */  /*                                                                       */  FT_EXPORT_DEF( FT_Error )  FT_New_Face_From_FSSpec( FT_Library     library,                           const FSSpec*  spec,                           FT_Long        face_index,                           FT_Face*       aface )  {#if HAVE_FSREF    FSRef  ref;    if ( !spec || FSpMakeFSRef( spec, &ref ) != noErr )      return FT_Err_Invalid_Argument;    else      return FT_New_Face_From_FSRef( library, &ref, face_index, aface );#elif HAVE_FSSPEC    FT_Error      error;    FT_Open_Args  args;    OSErr         err;    UInt8         pathname[HFS_MAXPATHLEN];    if ( !spec )      return FT_Err_Invalid_Argument;    err = FT_FSpMakePath( spec, pathname, sizeof ( pathname ) );    if ( err )      error = FT_Err_Cannot_Open_Resource;    error = FT_New_Face_From_Resource( library, pathname, face_index, aface );    if ( error != 0 || *aface != NULL )      return error;    /* fallback to datafork font */    args.flags    = FT_OPEN_PATHNAME;    args.pathname = (char*)pathname;    return FT_Open_Face( library, &args, face_index, aface );#else    return FT_Err_Unimplemented_Feature;#endif /* HAVE_FSREF, HAVE_FSSPEC */  }/* END */