kc3-lang/freetype

diff --git a/src/base/ftmac.c b/src/base/ftmac.c
new file mode 100644
index 0000000..617c786
--- /dev/null
+++ b/src/base/ftmac.c
@@ -0,0 +1,717 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmac.c                                                                */
+/*                                                                         */
+/*    Mac FOND support. Written by just@letterror.com.                     */
+/*                                                                         */
+/*  Copyright 1996-2000 by                                                 */
+/*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*
+    Notes
+
+    Mac suitcase files can (and often do!) contain multiple fonts. To
+    support this I use the face_index argument of FT_(Open|New)_Face()
+    functions, and pretend the suitcase file is a collection.
+    Warning: although the FOND driver sets face->num_faces field to the
+    number of available fonts, but the Type 1 driver sets it to 1 anyway.
+    So this field is currently not reliable, and I don't see a clean way
+    to  resolve that. The face_index argument translates to
+      Get1IndResource( 'FOND', face_index + 1 );
+    so clients should figure out the resource index of the FOND.
+    (I'll try to provide some example code for this at some point.)
+
+
+    The Mac FOND support works roughly like this:
+
+    - Check whether the offered stream points to a Mac suitcase file.
+      This is done by checking the file type: it has to be 'FFIL' or 'tfil'.
+      The stream that gets passed to our init_face() routine is a stdio
+      stream, which isn't usable for us, since the FOND resources live
+      in the resource fork. So we just grab the stream->pathname field.
+
+    - Read the FOND resource into memory, then check whether there is
+      a TrueType font and/or (!) a Type 1 font available.
+
+    - If there is a Type 1 font available (as a separate 'LWFN' file),
+      read its data into memory, massage it slightly so it becomes
+      PFB data, wrap it into a memory stream, load the Type 1 driver
+      and delegate the rest of the work to it by calling FT_Open_Face().
+      (XXX TODO: after this has been done, the kerning data from the FOND
+      resource should be appended to the face: on the Mac there are usually
+      no AFM files available. However, this is tricky since we need to map
+      Mac char codes to ps glyph names to glyph ID's...)
+
+    - If there is a TrueType font (an 'sfnt' resource), read it into
+      memory, wrap it into a memory stream, load the TrueType driver
+      and delegate the rest of the work to it, by calling FT_Open_Face().
+  */
+
+#include <freetype/freetype.h>
+#include <freetype/internal/ftstream.h>
+#include <truetype/ttobjs.h>
+#include <type1z/z1objs.h>
+
+#include <Resources.h>
+#include <Fonts.h>
+#include <Errors.h>
+
+#include <ctype.h>  /* for isupper() and isalnum() */
+
+#include <ftmac.h>
+
+
+
+  /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
+     TrueType in case *both* are available (this is not common,
+     but it *is* possible). */
+#ifndef PREFER_LWFN
+#define PREFER_LWFN 1
+#endif
+
+
+
+  /* Quick 'n' Dirty Pascal string to C string converter.
+     Warning: this call is not thread safe! Use with caution. */
+  static
+  char * p2c_str( unsigned char *pstr )
+  {
+    static char cstr[256];
+
+
+    strncpy( cstr, (char*)pstr+1, pstr[0] );
+    cstr[pstr[0]] = '\0';
+    return cstr;
+  }
+
+
+  /* Given a pathname, fill in a file spec. */
+  static
+  int file_spec_from_path( const char* pathname, FSSpec *spec )
+  {
+    Str255    p_path;
+    FT_ULong  path_len;
+
+
+    /* convert path to a pascal string */
+    path_len = strlen( pathname );
+    if ( path_len > 255 )
+      return -1;
+    p_path[0] = (unsigned char)path_len;
+    strncpy( (char*)p_path+1, pathname, path_len );
+
+    if ( FSMakeFSSpec( 0, 0, p_path, spec ) != noErr )
+      return -1;
+    else
+      return 0;
+  }
+
+
+  /* Return the file type of the file specified by spec. */
+  static
+  OSType get_file_type( FSSpec  *spec )
+  {
+    FInfo   finfo;
+
+
+    if ( FSpGetFInfo( spec, &finfo ) != noErr )
+      return 0;  /* file might not exist */
+    return finfo.fdType;
+  }
+
+
+  /* Given a PostScript font name, create the Macintosh LWFN file name. */
+  static
+  void create_lwfn_name( char* ps_name, Str255 lwfn_file_name )
+  {
+    int       max = 5, count = 0;
+    FT_Byte*  p = lwfn_file_name;
+    FT_Byte*  q = (FT_Byte*)ps_name;
+
+
+    lwfn_file_name[0] = 0;
+
+    while ( *q )
+    {
+      if ( isupper(*q) )
+      {
+        if ( count )
+          max = 3;
+        count = 0;
+      }
+      if ( count < max && (isalnum(*q) || *q == '_' ) )
+      {
+        *++p = *q;
+        lwfn_file_name[0]++;
+        count++;
+      }
+      q++;
+    }
+  }
+
+
+  /* Given a file reference, answer its location as a vRefNum
+     and a dirID. */
+  static
+  FT_Error get_file_location( short          ref_num,
+                              short*         v_ref_num,
+                              long*          dir_id,
+                              unsigned char* file_name )
+  {
+    FCBPBRec  pb;
+    OSErr     error;
+
+
+    pb.ioNamePtr = file_name;
+    pb.ioVRefNum = 0;
+    pb.ioRefNum  = ref_num;
+    pb.ioFCBIndx = 0;
+
+    error = PBGetFCBInfoSync( &pb );
+    if ( error == noErr )
+    {
+      *v_ref_num = pb.ioFCBVRefNum;
+      *dir_id = pb.ioFCBParID;
+    }
+    return error;
+  }
+
+
+  /* Make a file spec for an LWFN file from a FOND resource and
+     a file name. */
+  static
+  FT_Error make_lwfn_spec( Handle          fond,
+                           unsigned char*  file_name,
+                           FSSpec*         spec )
+  {
+    FT_Error  error;
+    short     ref_num, v_ref_num;
+    long      dir_id;
+    Str255    fond_file_name;
+
+
+    ref_num = HomeResFile( fond );
+    error = ResError();
+    if ( !error )
+      error = get_file_location( ref_num, &v_ref_num, &dir_id, fond_file_name );
+    if ( !error )
+      error = FSMakeFSSpec( v_ref_num, dir_id, file_name, spec );
+
+    return error;
+  }
+
+
+  /* Look inside the FOND data, answer whether there should be an SFNT
+     resource, and answer the name of a possible LWFN Type 1 file. */
+  static
+  void parse_fond(  char*   fond_data,
+                    short   *have_sfnt,
+                    short   *sfnt_id,
+                    Str255  lwfn_file_name )
+  {
+    AsscEntry*  assoc;
+    FamRec*     fond;
+
+
+    *sfnt_id          = 0;
+    *have_sfnt        = 0;
+    lwfn_file_name[0] = 0;
+
+    fond = (FamRec*)fond_data;
+    assoc = (AsscEntry*)(fond_data + sizeof(FamRec) + 2);
+
+    if ( assoc->fontSize == 0 )
+    {
+      *have_sfnt = 1;
+      *sfnt_id = assoc->fontID;
+    }
+
+    if ( fond->ffStylOff )
+    {
+      unsigned char*  p = (unsigned char*)fond_data;
+      StyleTable*     style;
+      unsigned short  string_count;
+      unsigned char*  name_table = 0;
+      char            ps_name[256];
+      unsigned char*  names[64];
+      int             i;
+
+      p += fond->ffStylOff;
+      style = (StyleTable*)p;
+      p += sizeof(StyleTable);
+      string_count = *(unsigned short*)(p);
+      p += sizeof(short);
+
+      for ( i = 0 ; i < string_count && i < 64; i++ )
+      {
+        names[i] = p;
+        p += names[i][0];
+        p++;
+      }
+      strcpy(ps_name, p2c_str(names[0]));  /* Family name */
+
+      if ( style->indexes[0] > 1 )
+      {
+        unsigned char* suffixes = names[style->indexes[0]-1];
+        for ( i=1; i<=suffixes[0]; i++ )
+          strcat( ps_name, p2c_str(names[suffixes[i]-1]) );
+      }
+      create_lwfn_name( ps_name, lwfn_file_name );
+    }
+  }
+
+
+  /* Read Type 1 data from the POST resources inside the LWFN file,
+     return a PFB buffer. This is somewhat convoluted because the FT2
+     PFB parser wants the ASCII header as one chunk, and the LWFN
+     chunks are often not organized that way, so we'll glue chunks
+     of the same type together. */
+  static
+  FT_Error read_lwfn( FT_Memory  memory,
+                      FSSpec*    lwfn_spec,
+                      FT_Byte**  pfb_data,
+                      FT_ULong*  size )
+  {
+    FT_Error       error = FT_Err_Ok;
+    short          res_ref, res_id;
+    unsigned char  *buffer, *p, *size_p;
+    FT_ULong       total_size = 0;
+    FT_ULong       post_size, pfb_chunk_size;
+    Handle         post_data;
+    char           code, last_code;
+
+
+    res_ref = FSpOpenResFile( lwfn_spec, fsRdPerm );
+    if ( ResError() )
+      return FT_Err_Out_Of_Memory;
+    UseResFile( res_ref );
+
+    /* First pass: load all POST resources, and determine the size of
+       the output buffer. */
+    res_id = 501;
+    last_code = -1;
+    for (;;)
+    {
+      post_data = Get1Resource( 'POST', res_id++ );
+      if ( post_data == NULL )
+        break;  /* we're done */
+
+      code = (*post_data)[0];
+
+      if ( code != last_code )
+      {
+        if ( code == 5 )
+          total_size += 2; /* just the end code */
+        else
+          total_size += 6; /* code + 4 bytes chunk length */
+      }
+
+      total_size += GetHandleSize( post_data ) - 2;
+      last_code = code;
+    }
+
+    if ( ALLOC( buffer, (FT_Long)total_size ) )
+      goto Error;
+
+    /* Second pass: append all POST data to the buffer, add PFB fields.
+       Glue all consequtive chunks of the same type together. */
+    p = buffer;
+    res_id = 501;
+    last_code = -1;
+    pfb_chunk_size = 0;
+
+    for (;;)
+    {
+      post_data = Get1Resource( 'POST', res_id++ );
+      if ( post_data == NULL )
+        break;  /* we're done */
+
+      post_size = (FT_ULong)GetHandleSize( post_data ) - 2;
+      code = (*post_data)[0];
+
+      if ( code != last_code )
+      {
+
+        if ( last_code != -1 )
+        {
+          /* we're done adding a chunk, fill in the size field */
+          *size_p++ = (FT_Byte)(pfb_chunk_size & 0xFF);
+          *size_p++ = (FT_Byte)((pfb_chunk_size >> 8) & 0xFF);
+          *size_p++ = (FT_Byte)((pfb_chunk_size >> 16) & 0xFF);
+          *size_p++ = (FT_Byte)((pfb_chunk_size >> 24) & 0xFF);
+          pfb_chunk_size = 0;
+        }
+
+        *p++ = 0x80;
+        if ( code == 5 )
+          *p++ = 0x03;  /* the end */
+        else if ( code == 2 )
+          *p++ = 0x02;  /* binary segment */
+        else
+          *p++ = 0x01;  /* ASCII segment */
+
+        if ( code != 5 )
+        {
+          size_p = p;   /* save for later */
+          p += 4;       /* make space for size field */
+        }
+      }
+
+      memcpy( p, *post_data + 2, post_size );
+      pfb_chunk_size += post_size;
+      p += post_size;
+      last_code = code;
+    }
+
+    *pfb_data = buffer;
+    *size = total_size;
+
+Error:
+    CloseResFile( res_ref );
+    return error;
+  }
+
+
+  /* Finalizer for a memory stream; gets called by FT_Done_Face().
+     It frees the memory it uses. */
+  static
+  void memory_stream_close( FT_Stream  stream )
+  {
+    FT_Memory  memory = stream->memory;
+
+
+    FREE( stream->base );
+    stream->size               = 0;
+    stream->base               = 0;
+    stream->close              = 0;
+  }
+
+
+  /* Create a new memory stream from a buffer and a size. */
+  static
+  FT_Error new_memory_stream( FT_Library       library,
+                              FT_Byte*         base,
+                              FT_ULong         size,
+                              FT_Stream_Close  close,
+                              FT_Stream*       astream )
+  {
+      FT_Error   error;
+      FT_Memory  memory;
+      FT_Stream  stream;
+
+
+      if ( !library )
+        return FT_Err_Invalid_Library_Handle;
+
+      if ( !base )
+        return FT_Err_Invalid_Argument;
+
+      *astream = 0;
+      memory = library->memory;
+      if ( ALLOC( stream, sizeof(*stream) ) )
+        goto Exit;
+
+      FT_New_Memory_Stream( library,
+                            base,
+                            size,
+                            stream );
+
+      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 )
+    {
+      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 );
+    }
+    error = FT_Open_Face( library, &args, face_index, aface );
+    if ( !error )
+      (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
+    FREE( stream );  /* FT_Open_Face() made a copy */
+    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,
+                                  FSSpec*     spec,
+                                  FT_Long     face_index,
+                                  FT_Face*    aface )
+  {
+    FT_Byte*      pfb_data;
+    FT_ULong      pfb_size;
+    FT_Error      error;
+    FT_Memory     memory = library->memory;
+
+
+    error = read_lwfn( library->memory, spec, &pfb_data, &pfb_size );
+    if ( error )
+      return error;
+
+#if 0
+    {
+      FILE* f;
+      char * path;
+
+      path = p2c_str( spec->name );
+      strcat( path, ".PFB" );
+      f = fopen(path, "wb");
+      if ( f )
+      {
+        fwrite( pfb_data, 1, pfb_size, f );
+        fclose( f );
+      }
+    }
+#endif
+
+    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_Stream     stream = NULL;
+    FT_Error      error = 0;
+    FT_Memory     memory = library->memory;
+
+
+    sfnt = GetResource( 'sfnt', sfnt_id );
+    if ( ResError() )
+      return FT_Err_Invalid_Handle;
+
+    sfnt_size = (FT_ULong)GetHandleSize( sfnt );
+    if ( ALLOC( sfnt_data, (FT_Long)sfnt_size ) )
+    {
+      ReleaseResource( sfnt );
+      return error;
+    }
+
+    HLock( sfnt );
+    memcpy( sfnt_data, *sfnt, sfnt_size);
+    HUnlock( sfnt );
+    ReleaseResource( sfnt );
+
+    return open_face_from_buffer( library,
+                                  sfnt_data,
+                                  sfnt_size,
+                                  face_index,
+                                  "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,
+                                      FSSpec*     spec,
+                                      FT_Long     face_index,
+                                      FT_Face*    aface )
+  {
+    FT_Error  error = FT_Err_Ok;
+    short     res_ref, res_index;
+    Handle    fond;
+
+
+    res_ref = FSpOpenResFile( spec, fsRdPerm );
+    if ( ResError() )
+      return FT_Err_Cannot_Open_Resource;
+    UseResFile( res_ref );
+
+    /* face_index may be -1, in which case we
+       just need to do a sanity check */
+    if ( face_index < 0)
+      res_index = 1;
+    else
+    {
+      res_index = (short)(face_index + 1);
+      face_index = 0;
+    }
+    fond = Get1IndResource( 'FOND', res_index );
+    if ( ResError() )
+    {
+      error = FT_Err_Cannot_Open_Resource;
+      goto Error;
+    }
+
+    error = FT_New_Face_From_FOND( library, fond, face_index, aface );
+
+Error:
+    CloseResFile( res_ref );
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face_From_FOND                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new face object from an FOND resource.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fond       :: An FOND resource.                                    */
+  /*                                                                       */
+  /*    face_index :: only supported for the -1 `sanity check'             */
+  /*                  special case.                                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Notes>                                                               */
+  /*    This function can be used to create FT_Face abjects from fonts     */
+  /*    that are installed in the system like so:                          */
+  /*      fond = GetResource( 'FOND', fontName );                          */
+  /*      error = FT_New_Face_From_FOND( library, fond, 0, &face );        */
+  /*                                                                       */
+  FT_EXPORT_FUNC( 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;
+    Str255    lwfn_file_name;
+    short     fond_id;
+    OSType    fond_type;
+    Str255    fond_name;
+    FSSpec    lwfn_spec;
+    FT_Error  error = FT_Err_Unknown_File_Format;
+
+
+    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 );
+    HUnlock( fond );
+
+    if ( lwfn_file_name[0] )
+    {
+      if ( make_lwfn_spec( fond, lwfn_file_name, &lwfn_spec ) == FT_Err_Ok )
+        have_lwfn = 1;  /* yeah, we got one! */
+      else
+        have_lwfn = 0;  /* no LWFN file found */
+    }
+
+    if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
+      return FT_New_Face_From_LWFN( library,
+                                    &lwfn_spec,
+                                    face_index,
+                                    aface );
+    else if ( have_sfnt )
+      return FT_New_Face_From_SFNT( library,
+                                    sfnt_id,
+                                    face_index,
+                                    aface );
+
+    return FT_Err_Unknown_File_Format;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <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 ftobjs.c.            */
+  /*                                                                       */
+  FT_EXPORT_FUNC( FT_Error )  FT_New_Face( FT_Library   library,
+                                           const char*  pathname,
+                                           FT_Long      face_index,
+                                           FT_Face*     aface )
+  {
+    FT_Open_Args  args;
+    FSSpec        spec;
+    OSType        file_type;
+
+
+    /* test for valid `library' and `aface' delayed to FT_Open_Face() */
+    if ( !pathname )
+      return FT_Err_Invalid_Argument;
+
+    if ( file_spec_from_path( pathname, &spec ) )
+      return FT_Err_Invalid_Argument;
+
+    file_type = get_file_type( &spec );
+    if ( file_type == 'FFIL' || file_type == 'tfil' )
+      return FT_New_Face_From_Suitcase( library, &spec, face_index, aface );
+    else if ( file_type == 'LWFN' )
+      return FT_New_Face_From_LWFN( library, &spec, face_index, aface );
+    else
+    {
+      args.flags    = ft_open_pathname;
+      args.pathname = (char*)pathname;
+
+      return FT_Open_Face( library, &args, face_index, aface );
+    }
+  }
+