Ignore:
Timestamp:
Jan 18, 2007, 5:32:59 PM (15 years ago)
Author:
Eugene Romanenko
Message:

freetype update to version 2.3.0

Location:
trunk/poppler/freetype2/src
Files:
1 added
1 deleted
62 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/src/autofit/afhints.c

    r165 r182  
    55/*    Auto-fitter hinting routines (body).                                 */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006 by                                    */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    192192  af_glyph_hints_dump_segments( AF_GlyphHints  hints )
    193193  {
    194     FT_Int    dimension;
     194    FT_Int  dimension;
    195195
    196196
     
    213213                 seg - segments,
    214214                 (int)seg->pos,
    215                  af_dir_str( seg->dir ),
     215                 af_dir_str( (AF_Direction)seg->dir ),
    216216                 AF_INDEX_NUM( seg->link, segments ),
    217217                 AF_INDEX_NUM( seg->serif, segments ),
     
    253253                 edge - edges,
    254254                 (int)edge->fpos,
    255                  af_dir_str( edge->dir ),
     255                 af_dir_str( (AF_Direction)edge->dir ),
    256256                 AF_INDEX_NUM( edge->link, edges ),
    257257                 AF_INDEX_NUM( edge->serif, edges ),
  • trunk/poppler/freetype2/src/autofit/aflatin.c

    r165 r182  
    55/*    Auto-fitter hinting routines for latin script (body).                */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006 by                                    */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    724724            segment->min_coord = (FT_Short)min_pos;
    725725            segment->max_coord = (FT_Short)max_pos;
    726             segment->height    = segment->max_coord - segment->min_coord;
     726            segment->height    = (FT_Short)( segment->max_coord -
     727                                             segment->min_coord );
    727728
    728729            on_edge = 0;
     
    798799          p = first->prev;
    799800          if ( p->v < first_v )
    800             segment->height += ( first_v - p->v ) >> 1;
     801            segment->height = (FT_Short)( segment->height +
     802                                          ( ( first_v - p->v ) >> 1 ) );
    801803
    802804          p = last->next;
    803805          if ( p->v > last_v )
    804             segment->height += ( p->v - last_v ) >> 1;
     806            segment->height = (FT_Short)( segment->height +
     807                                          ( ( p->v - last_v ) >> 1 ) );
    805808        }
    806809        else
     
    811814          p = first->prev;
    812815          if ( p->v > first_v )
    813             segment->height += ( p->v - first_v ) >> 1;
     816            segment->height = (FT_Short)( segment->height +
     817                                          ( ( p->v - first_v ) >> 1 ) );
    814818
    815819          p = last->next;
    816820          if ( p->v < last_v )
    817             segment->height += ( last_v - p->v ) >> 1;
     821            segment->height = (FT_Short)( segment->height +
     822                                          ( ( last_v - p->v ) >> 1 ) );
    818823        }
    819824      }
  • trunk/poppler/freetype2/src/autofit/afloader.c

    r165 r182  
    207207          loader->pp2.x = FT_PIX_ROUND( pp2x_uh );
    208208
     209          if ( loader->pp1.x >= new_lsb )
     210            loader->pp1.x -= 64;
     211
     212          if ( loader->pp2.x <= pp2x_uh )
     213            loader->pp2.x += 64;
     214
    209215          slot->lsb_delta = loader->pp1.x - pp1x_uh;
    210216          slot->rsb_delta = loader->pp2.x - pp2x_uh;
  • trunk/poppler/freetype2/src/autofit/aftypes.h

    r165 r182  
    55/*    Auto-fitter types (specification only).                              */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006 by                                    */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5555
    5656#define xxAF_USE_WARPER  /* only define to use warp hinting */
    57 #define AF_DEBUG
     57#define xxAF_DEBUG
    5858
    5959#ifdef AF_DEBUG
  • trunk/poppler/freetype2/src/base/ftapi.c

    r150 r182  
    5050
    5151    FT_Stream_OpenMemory( stream, base, size );
    52   }                       
     52  }
    5353
    5454
     
    5858  {
    5959    return FT_Stream_Seek( stream, pos );
    60   }                 
     60  }
    6161
    6262
     
    6666  {
    6767    return FT_Stream_Skip( stream, distance );
    68   }                 
     68  }
    6969
    7070
     
    7575  {
    7676    return FT_Stream_Read( stream, buffer, count );
    77   }                 
     77  }
    7878
    7979
     
    8585  {
    8686    return FT_Stream_ReadAt( stream, pos, buffer, count );
    87   }                   
     87  }
    8888
    8989
     
    9494  {
    9595    return FT_Stream_ExtractFrame( stream, count, pbytes );
    96   }                   
     96  }
    9797
    9898
     
    102102  {
    103103    FT_Stream_ReleaseFrame( stream, pbytes );
    104   }                   
     104  }
    105105
    106106  FT_BASE_DEF( FT_Error )
     
    109109  {
    110110    return FT_Stream_EnterFrame( stream, count );
    111   }                   
     111  }
    112112
    113113
     
    117117    FT_Stream_ExitFrame( stream );
    118118  }
    119                    
     119
    120120
    121121/* END */
  • trunk/poppler/freetype2/src/base/ftbitmap.c

    r150 r182  
    66/*    bitmaps into 8bpp format (body).                                     */
    77/*                                                                         */
    8 /*  Copyright 2004, 2005, 2006 by                                          */
     8/*  Copyright 2004, 2005, 2006, 2007 by                                    */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    105105    int             new_pitch;
    106106    FT_UInt         ppb;
    107     FT_Int          i;
     107    FT_Int          i, width;
    108108    unsigned char*  buffer;
    109109
    110110
     111    width = bitmap->width;
    111112    pitch = bitmap->pitch;
    112113    if ( pitch < 0 )
     
    171172    if ( bitmap->pitch > 0 )
    172173    {
     174      FT_Int  len = ( width + ppb - 1 ) / ppb;
     175
     176
    173177      for ( i = 0; i < bitmap->rows; i++ )
    174178        FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),
    175                      bitmap->buffer + pitch * i, pitch );
     179                     bitmap->buffer + pitch * i, len );
    176180    }
    177181    else
    178182    {
     183      FT_Int  len = ( width + ppb - 1 ) / ppb;
     184
     185
    179186      for ( i = 0; i < bitmap->rows; i++ )
    180187        FT_MEM_COPY( buffer + new_pitch * i,
    181                      bitmap->buffer + pitch * i, pitch );
     188                     bitmap->buffer + pitch * i, len );
    182189    }
    183190
  • trunk/poppler/freetype2/src/base/ftlcdfil.c

    r165 r182  
    273273    static const FT_Byte  light_filter[5] =
    274274                            { 0, 85, 86, 85, 0 };
     275    /* the values here sum up to a value larger than 256, */
     276    /* providing a cheap gamma correction                 */
    275277    static const FT_Byte  default_filter[5] =
    276278                            { 0x10, 0x40, 0x70, 0x40, 0x10 };
     
    295297#elif defined( FT_FORCE_LIGHT_LCD_FILTER )
    296298
    297       memcpy( library->lcd_weights, default_filter, 5 );
     299      memcpy( library->lcd_weights, light_filter, 5 );
    298300      library->lcd_filter_func = _ft_lcd_filter_fir;
    299301      library->lcd_extra       = 2;
  • trunk/poppler/freetype2/src/base/ftmac.c

    r165 r182  
    44/*                                                                         */
    55/*    Mac FOND support.  Written by just@letterror.com.                    */
    6 /*  Heavily Fixed by mpsuzuki, George Williams and Sean McBride            */
     6/*  Heavily modified by mpsuzuki, George Williams, and Sean McBride.       */
     7/*                                                                         */
     8/*  This file is for Mac OS X only; see builds/mac/ftoldmac.c for          */
     9/*  classic platforms built by MPW.                                        */
    710/*                                                                         */
    811/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     
    6770#include FT_INTERNAL_STREAM_H
    6871
    69 #if defined( __GNUC__ ) || defined( __IBMC__ )
    7072  /* This is for Mac OS X.  Without redefinition, OS_INLINE */
    7173  /* expands to `static inline' which doesn't survive the   */
     
    7476#define OS_INLINE   static __inline__
    7577#include <Carbon/Carbon.h>
    76 #else
    77 #include <Resources.h>
    78 #include <Fonts.h>
    79 #include <Endian.h>
    80 #include <Errors.h>
    81 #include <Files.h>
    82 #include <TextUtils.h>
    83 #endif
    84 
    85 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
    86 #include <FSp_fopen.h>
    87 #endif
    88 
    89 #include FT_MAC_H
    90 
    91 
    92   /* FSSpec functions are deprecated since Mac OS X 10.4 */
    93 #ifndef HAVE_FSSPEC
    94 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
    95 #define HAVE_FSSPEC  1
    96 #else
    97 #define HAVE_FSSPEC  0
    98 #endif
    99 #endif
    100 
    101   /* most FSRef functions were introduced since Mac OS 9 */
    102 #ifndef HAVE_FSREF
    103 #if TARGET_API_MAC_OSX
    104 #define HAVE_FSREF  1
    105 #else
    106 #define HAVE_FSREF  0
    107 #endif
    108 #endif
    10978
    11079#ifndef HFS_MAXPATHLEN
     
    11382
    11483
    115   /* QuickDraw is deprecated since Mac OS X 10.4 */
    116 #ifndef HAVE_QUICKDRAW_CARBON
    117 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
    118 #define HAVE_QUICKDRAW_CARBON  1
    119 #else
    120 #define HAVE_QUICKDRAW_CARBON  0
    121 #endif
    122 #endif
    123 
    124   /* AppleTypeService is available since Mac OS X */
    125 #ifndef HAVE_ATS
    126 #if TARGET_API_MAC_OSX
    127 #define HAVE_ATS  1
    128 #else
    129 #define HAVE_ATS  0
    130 #endif
    131 #endif
     84#include FT_MAC_H
     85
     86  /* undefine blocking-macros in ftmac.h */
     87#undef FT_GetFile_From_Mac_Name( a, b, c )
     88#undef FT_GetFile_From_Mac_ATS_Name( a, b, c )
     89#undef FT_New_Face_From_FSSpec( a, b, c, d )
     90
    13291
    13392  /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
     
    13998
    14099
    141 #if !HAVE_QUICKDRAW_CARBON  /* QuickDraw is deprecated since Mac OS X 10.4 */
    142 
    143100  FT_EXPORT_DEF( FT_Error )
    144101  FT_GetFile_From_Mac_Name( const char*  fontName,
     
    149106  }
    150107
    151 #else
    152 
    153   FT_EXPORT_DEF( FT_Error )
    154   FT_GetFile_From_Mac_Name( const char*  fontName,
    155                             FSSpec*      pathSpec,
    156                             FT_Long*     face_index )
    157   {
    158     OptionBits            options = kFMUseGlobalScopeOption;
    159 
    160     FMFontFamilyIterator  famIter;
    161     OSStatus              status = FMCreateFontFamilyIterator( NULL, NULL,
    162                                                                options,
    163                                                                &famIter );
    164     FMFont                the_font = 0;
    165     FMFontFamily          family   = 0;
    166 
    167 
    168     *face_index = 0;
    169     while ( status == 0 && !the_font )
    170     {
    171       status = FMGetNextFontFamily( &famIter, &family );
    172       if ( status == 0 )
    173       {
    174         int                           stat2;
    175         FMFontFamilyInstanceIterator  instIter;
    176         Str255                        famNameStr;
    177         char                          famName[256];
    178 
    179 
    180         /* get the family name */
    181         FMGetFontFamilyName( family, famNameStr );
    182         CopyPascalStringToC( famNameStr, famName );
    183 
    184         /* iterate through the styles */
    185         FMCreateFontFamilyInstanceIterator( family, &instIter );
    186 
    187         *face_index = 0;
    188         stat2       = 0;
    189 
    190         while ( stat2 == 0 && !the_font )
    191         {
    192           FMFontStyle  style;
    193           FMFontSize   size;
    194           FMFont       font;
    195 
    196 
    197           stat2 = FMGetNextFontFamilyInstance( &instIter, &font,
    198                                                &style, &size );
    199           if ( stat2 == 0 && size == 0 )
    200           {
    201             char  fullName[256];
    202 
    203 
    204             /* build up a complete face name */
    205             ft_strcpy( fullName, famName );
    206             if ( style & bold )
    207               ft_strcat( fullName, " Bold" );
    208             if ( style & italic )
    209               ft_strcat( fullName, " Italic" );
    210 
    211             /* compare with the name we are looking for */
    212             if ( ft_strcmp( fullName, fontName ) == 0 )
    213             {
    214               /* found it! */
    215               the_font = font;
    216             }
    217             else
    218               ++(*face_index);
    219           }
    220         }
    221 
    222         FMDisposeFontFamilyInstanceIterator( &instIter );
    223       }
    224     }
    225 
    226     FMDisposeFontFamilyIterator( &famIter );
    227 
    228     if ( the_font )
    229     {
    230       FMGetFontContainer( the_font, pathSpec );
    231       return FT_Err_Ok;
    232     }
    233     else
    234       return FT_Err_Unknown_File_Format;
    235   }
    236 
    237 #endif /* HAVE_QUICKDRAW_CARBON */
    238 
    239 
    240 #if !HAVE_ATS
    241 
    242   FT_EXPORT_DEF( FT_Error )
    243   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
    244                                 FSSpec*      pathSpec,
    245                                 FT_Long*     face_index )
    246   {
    247     return FT_Err_Unimplemented_Feature;
    248   }
    249 
    250 #else
    251108
    252109  FT_EXPORT_DEF( FT_Error )
     
    296153  }
    297154
    298 #endif /* HAVE_ATS */
    299 
    300 
    301 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
    302 
    303 #define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )
    304 
    305 
    306   FT_CALLBACK_DEF( void )
    307   ft_FSp_stream_close( FT_Stream  stream )
    308   {
    309     ft_fclose( STREAM_FILE( stream ) );
    310 
    311     stream->descriptor.pointer = NULL;
    312     stream->size               = 0;
    313     stream->base               = 0;
    314   }
    315 
    316 
    317   FT_CALLBACK_DEF( unsigned long )
    318   ft_FSp_stream_io( FT_Stream       stream,
    319                     unsigned long   offset,
    320                     unsigned char*  buffer,
    321                     unsigned long   count )
    322   {
    323     FT_FILE*  file;
    324 
    325 
    326     file = STREAM_FILE( stream );
    327 
    328     ft_fseek( file, offset, SEEK_SET );
    329 
    330     return (unsigned long)ft_fread( buffer, 1, count, file );
    331   }
    332 
    333 #endif  /* __MWERKS__ && !TARGET_RT_MAC_MACHO */
    334 
    335 
    336 #if HAVE_FSSPEC && !HAVE_FSREF
    337 
    338   static OSErr
    339   FT_FSPathMakeSpec( const UInt8*  pathname,
    340                      FSSpec*       spec_p,
    341                      Boolean       isDirectory )
    342   {
    343     const char  *p, *q;
    344     short       vRefNum;
    345     long        dirID;
    346     Str255      nodeName;
    347     OSErr       err;
    348 
    349 
    350     p = q = (const char *)pathname;
    351     dirID   = 0;
    352     vRefNum = 0;
    353 
    354     while ( 1 )
    355     {
    356       q = p + FT_MIN( 255, ft_strlen( p ) );
    357 
    358       if ( q == p )
    359         return 0;
    360 
    361       if ( 255 < ft_strlen( (char *)pathname ) )
    362       {
    363         while ( p < q && *q != ':' )
    364           q--;
    365       }
    366 
    367       if ( p < q )
    368         *(char *)nodeName = q - p;
    369       else if ( ft_strlen( p ) < 256 )
    370         *(char *)nodeName = ft_strlen( p );
    371       else
    372         return errFSNameTooLong;
    373 
    374       ft_strncpy( (char *)nodeName + 1, (char *)p, *(char *)nodeName );
    375       err = FSMakeFSSpec( vRefNum, dirID, nodeName, spec_p );
    376       if ( err || '\0' == *q )
    377         return err;
    378 
    379       vRefNum = spec_p->vRefNum;
    380       dirID   = spec_p->parID;
    381 
    382       p = q;
    383     }
    384   }
    385 
    386 
    387   static OSErr
    388   FT_FSpMakePath( const FSSpec*  spec_p,
    389                   UInt8*         path,
    390                   UInt32         maxPathSize )
    391   {
    392     OSErr   err;
    393     FSSpec  spec = *spec_p;
    394     short   vRefNum;
    395     long    dirID;
    396     Str255  parDir_name;
    397 
    398 
    399     FT_MEM_SET( path, 0, maxPathSize );
    400     while ( 1 )
    401     {
    402       int             child_namelen = ft_strlen( (char *)path );
    403       unsigned char   node_namelen  = spec.name[0];
    404       unsigned char*  node_name     = spec.name + 1;
    405 
    406 
    407       if ( node_namelen + child_namelen > maxPathSize )
    408         return errFSNameTooLong;
    409 
    410       FT_MEM_MOVE( path + node_namelen + 1, path, child_namelen );
    411       FT_MEM_COPY( path, node_name, node_namelen );
    412       if ( child_namelen > 0 )
    413         path[node_namelen] = ':';
    414 
    415       vRefNum        = spec.vRefNum;
    416       dirID          = spec.parID;
    417       parDir_name[0] = '\0';
    418       err = FSMakeFSSpec( vRefNum, dirID, parDir_name, &spec );
    419       if ( noErr != err || dirID == spec.parID )
    420         break;
    421     }
    422     return noErr;
    423   }
    424 
    425 #endif /* HAVE_FSSPEC && !HAVE_FSREF */
    426 
    427155
    428156  static OSErr
     
    430158                    short*        res )
    431159  {
    432 
    433 #if HAVE_FSREF
    434 
    435160    OSErr  err;
    436161    FSRef  ref;
     
    449174    err  = ResError();
    450175
    451 #else
    452 
    453     OSErr   err;
    454     FSSpec  spec;
    455 
    456 
    457     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
    458       return FT_Err_Cannot_Open_Resource;
    459 
    460     /* at present, no support for dfont format without FSRef */
    461     /* (see above), try original resource-fork font          */
    462     *res = FSpOpenResFile( &spec, fsRdPerm );
    463     err  = ResError();
    464 
    465 #endif /* HAVE_FSREF */
    466 
    467176    return err;
    468177  }
     
    473182  get_file_type_from_path( const UInt8*  pathname )
    474183  {
    475 
    476 #if HAVE_FSREF
    477 
    478184    FSRef          ref;
    479185    FSCatalogInfo  info;
     
    488194
    489195    return ((FInfo *)(info.finderInfo))->fdType;
    490 
    491 #else
    492 
    493     FSSpec  spec;
    494     FInfo  finfo;
    495 
    496 
    497     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
    498       return ( OSType ) 0;
    499 
    500     if ( noErr != FSpGetFInfo( &spec, &finfo ) )
    501       return ( OSType ) 0;
    502 
    503     return finfo.fdType;
    504 
    505 #endif /* HAVE_FSREF */
    506 
    507196  }
    508197
     
    690379                       int              path_size )
    691380  {
    692 
    693 #if HAVE_FSREF
    694 
    695381    FSRef  ref, par_ref;
    696382    int    dirname_len;
     
    731417
    732418    return FT_Err_Ok;
    733 
    734 #else
    735 
    736     int     i;
    737     FSSpec  spec;
    738 
    739 
    740     /* pathname for FSSpec is always HFS format */
    741     if ( ft_strlen( (char *)path_fond ) > path_size )
    742       return FT_Err_Invalid_Argument;
    743 
    744     ft_strcpy( (char *)path_lwfn, (char *)path_fond );
    745 
    746     i = ft_strlen( (char *)path_lwfn ) - 1;
    747     while ( i > 0 && ':' != path_lwfn[i] )
    748       i--;
    749 
    750     if ( i + 1 + base_lwfn[0] > path_size )
    751       return FT_Err_Invalid_Argument;
    752 
    753     if ( ':' == path_lwfn[i] )
    754     {
    755       ft_strcpy( (char *)path_lwfn + i + 1, (char *)base_lwfn + 1 );
    756       path_lwfn[i + 1 + base_lwfn[0]] = '\0';
    757     }
    758     else
    759     {
    760       ft_strcpy( (char *)path_lwfn, (char *)base_lwfn + 1 );
    761       path_lwfn[base_lwfn[0]] = '\0';
    762     }
    763 
    764     if ( noErr != FT_FSPathMakeSpec( path_lwfn, &spec, FALSE ) )
    765       return FT_Err_Cannot_Open_Resource;
    766 
    767     return FT_Err_Ok;
    768 
    769 #endif /* HAVE_FSREF */
    770 
    771419  }
    772420
     
    1186834        goto found_no_lwfn_file;
    1187835
    1188 #if HAVE_FSREF
    1189 
    1190836      {
    1191837        UInt8  path_fond[HFS_MAXPATHLEN];
     
    1207853          have_lwfn = 1;
    1208854      }
    1209 
    1210 #elif HAVE_FSSPEC
    1211 
    1212       {
    1213         UInt8     path_fond[HFS_MAXPATHLEN];
    1214         FCBPBRec  pb;
    1215         Str255    fond_file_name;
    1216         FSSpec    spec;
    1217 
    1218 
    1219         FT_MEM_SET( &spec, 0, sizeof ( FSSpec ) );
    1220         FT_MEM_SET( &pb,   0, sizeof ( FCBPBRec ) );
    1221 
    1222         pb.ioNamePtr = fond_file_name;
    1223         pb.ioVRefNum = 0;
    1224         pb.ioRefNum  = res;
    1225         pb.ioFCBIndx = 0;
    1226 
    1227         err = PBGetFCBInfoSync( &pb );
    1228         if ( noErr != err )
    1229           goto found_no_lwfn_file;
    1230 
    1231         err = FSMakeFSSpec( pb.ioFCBVRefNum, pb.ioFCBParID,
    1232                             fond_file_name, &spec );
    1233         if ( noErr != err )
    1234           goto found_no_lwfn_file;
    1235 
    1236         err = FT_FSpMakePath( &spec, path_fond, sizeof ( path_fond ) );
    1237         if ( noErr != err )
    1238           goto found_no_lwfn_file;
    1239 
    1240         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
    1241                                      path_lwfn, sizeof ( path_lwfn ) );
    1242         if ( FT_Err_Ok == error )
    1243           have_lwfn = 1;
    1244       }
    1245 
    1246 #endif /* HAVE_FSREF, HAVE_FSSPEC */
    1247 
    1248855    }
    1249856
     
    1354961                          FT_Face*      aface )
    1355962  {
    1356 
    1357 #if !HAVE_FSREF
    1358 
    1359     return FT_Err_Unimplemented_Feature;
    1360 
    1361 #else
    1362 
    1363963    FT_Error      error;
    1364964    FT_Open_Args  args;
     
    1382982    args.pathname = (char*)pathname;
    1383983    return FT_Open_Face( library, &args, face_index, aface );
    1384 
    1385 #endif /* HAVE_FSREF */
    1386 
    1387984  }
    1388985
     
    14031000                           FT_Face*       aface )
    14041001  {
    1405 
    1406 #if HAVE_FSREF
    1407 
    14081002    FSRef  ref;
    14091003
     
    14131007    else
    14141008      return FT_New_Face_From_FSRef( library, &ref, face_index, aface );
    1415 
    1416 #elif HAVE_FSSPEC
    1417 
    1418     FT_Error      error;
    1419     FT_Open_Args  args;
    1420     OSErr         err;
    1421     UInt8         pathname[HFS_MAXPATHLEN];
    1422 
    1423 
    1424     if ( !spec )
    1425       return FT_Err_Invalid_Argument;
    1426 
    1427     err = FT_FSpMakePath( spec, pathname, sizeof ( pathname ) );
    1428     if ( err )
    1429       error = FT_Err_Cannot_Open_Resource;
    1430 
    1431     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
    1432     if ( error != 0 || *aface != NULL )
    1433       return error;
    1434 
    1435     /* fallback to datafork font */
    1436     args.flags    = FT_OPEN_PATHNAME;
    1437     args.pathname = (char*)pathname;
    1438     return FT_Open_Face( library, &args, face_index, aface );
    1439 
    1440 #else
    1441 
    1442     return FT_Err_Unimplemented_Feature;
    1443 
    1444 #endif /* HAVE_FSREF, HAVE_FSSPEC */
    1445 
    14461009  }
    14471010
  • trunk/poppler/freetype2/src/base/ftmm.c

    r150 r182  
    175175
    176176  /* documentation is in ftmm.h */
    177  
     177
    178178  /* This is exactly the same as the previous function.  It exists for */
    179179  /* orthogonality.                                                    */
  • trunk/poppler/freetype2/src/base/ftobjs.c

    r165 r182  
    55/*    The FreeType private base classes (body).                            */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    13721372    FT_Long    rlen;
    13731373    int        is_cff;
     1374    FT_Long    face_index_in_resource = 0;
    13741375
    13751376
     
    14031404                                   sfnt_data,
    14041405                                   rlen,
    1405                                    face_index,
     1406                                   face_index_in_resource,
    14061407                                   is_cff ? "cff" : "truetype",
    14071408                                   aface );
     
    14451446                                      face_index, aface );
    14461447      FT_FREE( data_offsets );
     1448      /* POST exists in an LWFN providing a single face */
     1449      if ( !error )
     1450        (*aface)->num_faces = 1;
    14471451      return error;
    14481452    }
     
    14541458    if ( !error )
    14551459    {
     1460      FT_Long  face_index_internal = face_index % count;
     1461
     1462
    14561463      error = Mac_Read_sfnt_Resource( library, stream, data_offsets, count,
    1457                                       face_index, aface );
     1464                                      face_index_internal, aface );
    14581465      FT_FREE( data_offsets );
     1466      if ( !error )
     1467        (*aface)->num_faces = count;
    14591468    }
    14601469
     
    20812090                 FT_Size_Request  req,
    20822091                 FT_Bool          ignore_width,
    2083                  FT_ULong*        index )
     2092                 FT_ULong*        size_index )
    20842093  {
    20852094    FT_Int   i;
     
    21152124      if ( w == FT_PIX_ROUND( bsize->x_ppem ) || ignore_width )
    21162125      {
    2117         if ( index )
    2118           *index = (FT_ULong)i;
     2126        if ( size_index )
     2127          *size_index = (FT_ULong)i;
    21192128
    21202129        return FT_Err_Ok;
     
    37523761      library->generic.finalizer( library );
    37533762
    3754     /* Close all modules in the library */
     3763    /* Close all faces in the library.  If we don't do
     3764     * this, we can have some subtle memory leaks.
     3765     * Example:
     3766     *
     3767     *  - the cff font driver uses the pshinter module in cff_size_done
     3768     *  - if the pshinter module is destroyed before the cff font driver,
     3769     *    opened FT_Face objects managed by the driver are not properly
     3770     *    destroyed, resulting in a memory leak
     3771     */
     3772    {
     3773      FT_UInt  n;
     3774
     3775
     3776      for ( n = 0; n < library->num_modules; n++ )
     3777      {
     3778        FT_Module  module = library->modules[n];
     3779        FT_List    faces;
     3780
     3781
     3782        if ( ( module->clazz->module_flags & FT_MODULE_FONT_DRIVER ) == 0 )
     3783          continue;
     3784
     3785        faces = &FT_DRIVER(module)->faces_list;
     3786        while ( faces->head )
     3787          FT_Done_Face( FT_FACE( faces->head->data ) );
     3788      }
     3789    }
     3790
     3791    /* Close all other modules in the library */
    37553792#if 1
    37563793    /* XXX Modules are removed in the reversed order so that  */
  • trunk/poppler/freetype2/src/base/ftoutln.c

    r165 r182  
    55/*    FreeType outline management (body).                                  */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    947947    FT_Vector*  point;
    948948
    949     int         i;
    950     FT_Pos      ray_y[3];
    951     int         result[3];
     949    int             i;
     950    FT_Pos          ray_y[3];
     951    FT_Orientation  result[3];
    952952
    953953
  • trunk/poppler/freetype2/src/bdf/README

    r150 r182  
    99
    1010BDF (Bitmap Distribution Format) is a bitmap font format defined by Adobe,
    11 which is intended to be easily understood by both humans and computers. 
     11which is intended to be easily understood by both humans and computers.
    1212This code implements a BDF driver for the FreeType library, following the
    1313Adobe Specification V 2.2.  The specification of the BDF font format is
     
    1616  http://partners.adobe.com/asn/developer/PDFS/TN/5005.BDF_Spec.pdf
    1717
    18 Many good bitmap fonts in bdf format come with XFree86 (www.XFree86.org). 
     18Many good bitmap fonts in bdf format come with XFree86 (www.XFree86.org).
    1919They do not define vertical metrics, because the X Consortium BDF
    2020specification has removed them.
     
    4141
    4242  bdfface = (BDF_Public_Face)face;
    43  
    44   if ( ( bdfface->charset_registry == "ISO10646" ) && 
     43
     44  if ( ( bdfface->charset_registry == "ISO10646" ) &&
    4545       ( bdfface->charset_encoding == "1" )        )
    4646    [..]
    4747
    4848
    49 Thus the driver always exports `ft_encoding_none' as face->charmap.encoding. 
     49Thus the driver always exports `ft_encoding_none' as face->charmap.encoding.
    5050FT_Get_Char_Index's behavior is unmodified, that is, it converts the ULong
    5151value given as argument into the corresponding glyph number.
  • trunk/poppler/freetype2/src/bdf/bdf.c

    r150 r182  
    44
    55    Copyright (C) 2001, 2002 by
    6     Francesco Zappa Nardelli 
     6    Francesco Zappa Nardelli
    77
    88Permission is hereby granted, free of charge, to any person obtaining a copy
  • trunk/poppler/freetype2/src/bdf/bdf.h

    r150 r182  
    162162    const char*  key;
    163163    void*        data;
    164  
     164
    165165  } _hashnode, *hashnode;
    166166
  • trunk/poppler/freetype2/src/cff/cffcmap.h

    r150 r182  
    4040    FT_CMapRec  cmap;
    4141    FT_UShort*  gids;   /* up to 256 elements */
    42    
     42
    4343  } CFF_CMapStdRec;
    4444
     
    4747  cff_cmap_encoding_class_rec;
    4848
    49  
     49
    5050  /*************************************************************************/
    5151  /*************************************************************************/
  • trunk/poppler/freetype2/src/cff/cffdrivr.c

    r150 r182  
    55/*    OpenType font driver implementation (body).                          */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    303303
    304304
     305  static FT_Error
     306  cff_ps_get_font_info( CFF_Face         face,
     307                        PS_FontInfoRec*  afont_info )
     308  {
     309    CFF_Font  cff   = (CFF_Font)face->extra.data;
     310    FT_Error  error = FT_Err_Ok;
     311
     312
     313    if ( cff && cff->font_info == NULL )
     314    {
     315      CFF_FontRecDict  dict = &cff->top_font.font_dict;
     316      PS_FontInfoRec  *font_info;
     317      FT_Memory        memory = face->root.memory;
     318
     319
     320      if ( FT_ALLOC( font_info, sizeof ( *font_info ) ) )
     321        goto Fail;
     322
     323      font_info->version     = cff_index_get_sid_string( &cff->string_index,
     324                                                         dict->version,
     325                                                         cff->psnames );
     326      font_info->notice      = cff_index_get_sid_string( &cff->string_index,
     327                                                         dict->notice,
     328                                                         cff->psnames );
     329      font_info->full_name   = cff_index_get_sid_string( &cff->string_index,
     330                                                         dict->full_name,
     331                                                         cff->psnames );
     332      font_info->family_name = cff_index_get_sid_string( &cff->string_index,
     333                                                         dict->family_name,
     334                                                         cff->psnames );
     335      font_info->weight      = cff_index_get_sid_string( &cff->string_index,
     336                                                         dict->weight,
     337                                                         cff->psnames );
     338      font_info->italic_angle        = dict->italic_angle;
     339      font_info->is_fixed_pitch      = dict->is_fixed_pitch;
     340      font_info->underline_position  = (FT_Short)dict->underline_position;
     341      font_info->underline_thickness = (FT_Short)dict->underline_thickness;
     342
     343      cff->font_info = font_info;
     344    }
     345
     346    *afont_info = *cff->font_info;
     347
     348  Fail:
     349    return error;
     350  }
     351
     352
    305353  static const FT_Service_PsInfoRec  cff_service_ps_info =
    306354  {
    307     (PS_GetFontInfoFunc)   NULL,        /* unsupported with CFF fonts */
     355    (PS_GetFontInfoFunc)   cff_ps_get_font_info,
    308356    (PS_HasGlyphNamesFunc) cff_ps_has_glyph_names,
    309357    (PS_GetFontPrivateFunc)NULL         /* unsupported with CFF fonts */
  • trunk/poppler/freetype2/src/cff/cffgload.c

    r165 r182  
    55/*    OpenType Glyph Loader (body).                                        */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    22762276                 FT_Int32       load_flags )
    22772277  {
    2278     FT_Error      error;
    2279     CFF_Decoder   decoder;
    2280     TT_Face       face     = (TT_Face)glyph->root.face;
    2281     FT_Bool       hinting;
    2282     CFF_Font      cff      = (CFF_Font)face->extra.data;
    2283 
    2284     FT_Matrix     font_matrix;
    2285     FT_Vector     font_offset;
     2278    FT_Error     error;
     2279    CFF_Decoder  decoder;
     2280    TT_Face      face     = (TT_Face)glyph->root.face;
     2281    FT_Bool      hinting;
     2282    CFF_Font     cff      = (CFF_Font)face->extra.data;
     2283
     2284    FT_Matrix    font_matrix;
     2285    FT_Vector    font_offset;
    22862286
    22872287
     
    22922292         cff->charset.cids )
    22932293    {
    2294       if ( glyph_index < cff->charset.max_cid )
    2295         glyph_index = cff->charset.cids[glyph_index];
    2296       else
     2294      glyph_index = cff_charset_cid_to_gindex( &cff->charset, glyph_index );
     2295      if ( glyph_index == 0 )
    22972296        return CFF_Err_Invalid_Argument;
    22982297    }
     
    24242423        /* cffload.c.                                                     */
    24252424        {
    2426           CFF_IndexRec csindex = cff->charstrings_index;
    2427 
    2428 
    2429           glyph->root.control_data =
    2430             csindex.bytes + csindex.offsets[glyph_index] - 1;
    2431           glyph->root.control_len =
    2432             charstring_len;
     2425          CFF_Index csindex = &cff->charstrings_index;
     2426
     2427
     2428          if ( csindex->offsets )
     2429          {
     2430            glyph->root.control_data = csindex->bytes +
     2431                                         csindex->offsets[glyph_index] - 1;
     2432            glyph->root.control_len  = charstring_len;
     2433          }
    24332434        }
    24342435      }
  • trunk/poppler/freetype2/src/cff/cffload.c

    r165 r182  
    55/*    OpenType and CFF data/program tables loader (body).                  */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2323#include FT_SERVICE_POSTSCRIPT_CMAPS_H
    2424#include FT_TRUETYPE_TAGS_H
     25#include FT_TYPE1_TABLES_H
    2526
    2627#include "cffload.h"
     
    3334  static const FT_UShort  cff_isoadobe_charset[229] =
    3435  {
    35     0,
    36     1,
    37     2,
    38     3,
    39     4,
    40     5,
    41     6,
    42     7,
    43     8,
    44     9,
    45     10,
    46     11,
    47     12,
    48     13,
    49     14,
    50     15,
    51     16,
    52     17,
    53     18,
    54     19,
    55     20,
    56     21,
    57     22,
    58     23,
    59     24,
    60     25,
    61     26,
    62     27,
    63     28,
    64     29,
    65     30,
    66     31,
    67     32,
    68     33,
    69     34,
    70     35,
    71     36,
    72     37,
    73     38,
    74     39,
    75     40,
    76     41,
    77     42,
    78     43,
    79     44,
    80     45,
    81     46,
    82     47,
    83     48,
    84     49,
    85     50,
    86     51,
    87     52,
    88     53,
    89     54,
    90     55,
    91     56,
    92     57,
    93     58,
    94     59,
    95     60,
    96     61,
    97     62,
    98     63,
    99     64,
    100     65,
    101     66,
    102     67,
    103     68,
    104     69,
    105     70,
    106     71,
    107     72,
    108     73,
    109     74,
    110     75,
    111     76,
    112     77,
    113     78,
    114     79,
    115     80,
    116     81,
    117     82,
    118     83,
    119     84,
    120     85,
    121     86,
    122     87,
    123     88,
    124     89,
    125     90,
    126     91,
    127     92,
    128     93,
    129     94,
    130     95,
    131     96,
    132     97,
    133     98,
    134     99,
    135     100,
    136     101,
    137     102,
    138     103,
    139     104,
    140     105,
    141     106,
    142     107,
    143     108,
    144     109,
    145     110,
    146     111,
    147     112,
    148     113,
    149     114,
    150     115,
    151     116,
    152     117,
    153     118,
    154     119,
    155     120,
    156     121,
    157     122,
    158     123,
    159     124,
    160     125,
    161     126,
    162     127,
    163     128,
    164     129,
    165     130,
    166     131,
    167     132,
    168     133,
    169     134,
    170     135,
    171     136,
    172     137,
    173     138,
    174     139,
    175     140,
    176     141,
    177     142,
    178     143,
    179     144,
    180     145,
    181     146,
    182     147,
    183     148,
    184     149,
    185     150,
    186     151,
    187     152,
    188     153,
    189     154,
    190     155,
    191     156,
    192     157,
    193     158,
    194     159,
    195     160,
    196     161,
    197     162,
    198     163,
    199     164,
    200     165,
    201     166,
    202     167,
    203     168,
    204     169,
    205     170,
    206     171,
    207     172,
    208     173,
    209     174,
    210     175,
    211     176,
    212     177,
    213     178,
    214     179,
    215     180,
    216     181,
    217     182,
    218     183,
    219     184,
    220     185,
    221     186,
    222     187,
    223     188,
    224     189,
    225     190,
    226     191,
    227     192,
    228     193,
    229     194,
    230     195,
    231     196,
    232     197,
    233     198,
    234     199,
    235     200,
    236     201,
    237     202,
    238     203,
    239     204,
    240     205,
    241     206,
    242     207,
    243     208,
    244     209,
    245     210,
    246     211,
    247     212,
    248     213,
    249     214,
    250     215,
    251     216,
    252     217,
    253     218,
    254     219,
    255     220,
    256     221,
    257     222,
    258     223,
    259     224,
    260     225,
    261     226,
    262     227,
    263     228
     36      0,   1,   2,   3,   4,   5,   6,   7,
     37      8,   9,  10,  11,  12,  13,  14,  15,
     38     16,  17,  18,  19,  20,  21,  22,  23,
     39     24,  25,  26,  27,  28,  29,  30,  31,
     40     32,  33,  34,  35,  36,  37,  38,  39,
     41     40,  41,  42,  43,  44,  45,  46,  47,
     42     48,  49,  50,  51,  52,  53,  54,  55,
     43     56,  57,  58,  59,  60,  61,  62,  63,
     44     64,  65,  66,  67,  68,  69,  70,  71,
     45     72,  73,  74,  75,  76,  77,  78,  79,
     46     80,  81,  82,  83,  84,  85,  86,  87,
     47     88,  89,  90,  91,  92,  93,  94,  95,
     48     96,  97,  98,  99, 100, 101, 102, 103,
     49    104, 105, 106, 107, 108, 109, 110, 111,
     50    112, 113, 114, 115, 116, 117, 118, 119,
     51    120, 121, 122, 123, 124, 125, 126, 127,
     52    128, 129, 130, 131, 132, 133, 134, 135,
     53    136, 137, 138, 139, 140, 141, 142, 143,
     54    144, 145, 146, 147, 148, 149, 150, 151,
     55    152, 153, 154, 155, 156, 157, 158, 159,
     56    160, 161, 162, 163, 164, 165, 166, 167,
     57    168, 169, 170, 171, 172, 173, 174, 175,
     58    176, 177, 178, 179, 180, 181, 182, 183,
     59    184, 185, 186, 187, 188, 189, 190, 191,
     60    192, 193, 194, 195, 196, 197, 198, 199,
     61    200, 201, 202, 203, 204, 205, 206, 207,
     62    208, 209, 210, 211, 212, 213, 214, 215,
     63    216, 217, 218, 219, 220, 221, 222, 223,
     64    224, 225, 226, 227, 228
    26465  };
    26566
    26667  static const FT_UShort  cff_expert_charset[166] =
    26768  {
    268     0,
    269     1,
    270     229,
    271     230,
    272     231,
    273     232,
    274     233,
    275     234,
    276     235,
    277     236,
    278     237,
    279     238,
    280     13,
    281     14,
    282     15,
    283     99,
    284     239,
    285     240,
    286     241,
    287     242,
    288     243,
    289     244,
    290     245,
    291     246,
    292     247,
    293     248,
    294     27,
    295     28,
    296     249,
    297     250,
    298     251,
    299     252,
    300     253,
    301     254,
    302     255,
    303     256,
    304     257,
    305     258,
    306     259,
    307     260,
    308     261,
    309     262,
    310     263,
    311     264,
    312     265,
    313     266,
    314     109,
    315     110,
    316     267,
    317     268,
    318     269,
    319     270,
    320     271,
    321     272,
    322     273,
    323     274,
    324     275,
    325     276,
    326     277,
    327     278,
    328     279,
    329     280,
    330     281,
    331     282,
    332     283,
    333     284,
    334     285,
    335     286,
    336     287,
    337     288,
    338     289,
    339     290,
    340     291,
    341     292,
    342     293,
    343     294,
    344     295,
    345     296,
    346     297,
    347     298,
    348     299,
    349     300,
    350     301,
    351     302,
    352     303,
    353     304,
    354     305,
    355     306,
    356     307,
    357     308,
    358     309,
    359     310,
    360     311,
    361     312,
    362     313,
    363     314,
    364     315,
    365     316,
    366     317,
    367     318,
    368     158,
    369     155,
    370     163,
    371     319,
    372     320,
    373     321,
    374     322,
    375     323,
    376     324,
    377     325,
    378     326,
    379     150,
    380     164,
    381     169,
    382     327,
    383     328,
    384     329,
    385     330,
    386     331,
    387     332,
    388     333,
    389     334,
    390     335,
    391     336,
    392     337,
    393     338,
    394     339,
    395     340,
    396     341,
    397     342,
    398     343,
    399     344,
    400     345,
    401     346,
    402     347,
    403     348,
    404     349,
    405     350,
    406     351,
    407     352,
    408     353,
    409     354,
    410     355,
    411     356,
    412     357,
    413     358,
    414     359,
    415     360,
    416     361,
    417     362,
    418     363,
    419     364,
    420     365,
    421     366,
    422     367,
    423     368,
    424     369,
    425     370,
    426     371,
    427     372,
    428     373,
    429     374,
    430     375,
    431     376,
    432     377,
    433     378
     69      0,   1, 229, 230, 231, 232, 233, 234,
     70    235, 236, 237, 238,  13,  14,  15,  99,
     71    239, 240, 241, 242, 243, 244, 245, 246,
     72    247, 248,  27,  28, 249, 250, 251, 252,
     73    253, 254, 255, 256, 257, 258, 259, 260,
     74    261, 262, 263, 264, 265, 266, 109, 110,
     75    267, 268, 269, 270, 271, 272, 273, 274,
     76    275, 276, 277, 278, 279, 280, 281, 282,
     77    283, 284, 285, 286, 287, 288, 289, 290,
     78    291, 292, 293, 294, 295, 296, 297, 298,
     79    299, 300, 301, 302, 303, 304, 305, 306,
     80    307, 308, 309, 310, 311, 312, 313, 314,
     81    315, 316, 317, 318, 158, 155, 163, 319,
     82    320, 321, 322, 323, 324, 325, 326, 150,
     83    164, 169, 327, 328, 329, 330, 331, 332,
     84    333, 334, 335, 336, 337, 338, 339, 340,
     85    341, 342, 343, 344, 345, 346, 347, 348,
     86    349, 350, 351, 352, 353, 354, 355, 356,
     87    357, 358, 359, 360, 361, 362, 363, 364,
     88    365, 366, 367, 368, 369, 370, 371, 372,
     89    373, 374, 375, 376, 377, 378
    43490  };
    43591
    43692  static const FT_UShort  cff_expertsubset_charset[87] =
    43793  {
    438     0,
    439     1,
    440     231,
    441     232,
    442     235,
    443     236,
    444     237,
    445     238,
    446     13,
    447     14,
    448     15,
    449     99,
    450     239,
    451     240,
    452     241,
    453     242,
    454     243,
    455     244,
    456     245,
    457     246,
    458     247,
    459     248,
    460     27,
    461     28,
    462     249,
    463     250,
    464     251,
    465     253,
    466     254,
    467     255,
    468     256,
    469     257,
    470     258,
    471     259,
    472     260,
    473     261,
    474     262,
    475     263,
    476     264,
    477     265,
    478     266,
    479     109,
    480     110,
    481     267,
    482     268,
    483     269,
    484     270,
    485     272,
    486     300,
    487     301,
    488     302,
    489     305,
    490     314,
    491     315,
    492     158,
    493     155,
    494     163,
    495     320,
    496     321,
    497     322,
    498     323,
    499     324,
    500     325,
    501     326,
    502     150,
    503     164,
    504     169,
    505     327,
    506     328,
    507     329,
    508     330,
    509     331,
    510     332,
    511     333,
    512     334,
    513     335,
    514     336,
    515     337,
    516     338,
    517     339,
    518     340,
    519     341,
    520     342,
    521     343,
    522     344,
    523     345,
    524     346
     94      0,   1, 231, 232, 235, 236, 237, 238,
     95     13,  14,  15,  99, 239, 240, 241, 242,
     96    243, 244, 245, 246, 247, 248,  27,  28,
     97    249, 250, 251, 253, 254, 255, 256, 257,
     98    258, 259, 260, 261, 262, 263, 264, 265,
     99    266, 109, 110, 267, 268, 269, 270, 272,
     100    300, 301, 302, 305, 314, 315, 158, 155,
     101    163, 320, 321, 322, 323, 324, 325, 326,
     102    150, 164, 169, 327, 328, 329, 330, 331,
     103    332, 333, 334, 335, 336, 337, 338, 339,
     104    340, 341, 342, 343, 344, 345, 346
    525105  };
    526106
    527107  static const FT_UShort  cff_standard_encoding[256] =
    528108  {
    529     0,
    530     0,
    531     0,
    532     0,
    533     0,
    534     0,
    535     0,
    536     0,
    537     0,
    538     0,
    539     0,
    540     0,
    541     0,
    542     0,
    543     0,
    544     0,
    545     0,
    546     0,
    547     0,
    548     0,
    549     0,
    550     0,
    551     0,
    552     0,
    553     0,
    554     0,
    555     0,
    556     0,
    557     0,
    558     0,
    559     0,
    560     0,
    561     1,
    562     2,
    563     3,
    564     4,
    565     5,
    566     6,
    567     7,
    568     8,
    569     9,
    570     10,
    571     11,
    572     12,
    573     13,
    574     14,
    575     15,
    576     16,
    577     17,
    578     18,
    579     19,
    580     20,
    581     21,
    582     22,
    583     23,
    584     24,
    585     25,
    586     26,
    587     27,
    588     28,
    589     29,
    590     30,
    591     31,
    592     32,
    593     33,
    594     34,
    595     35,
    596     36,
    597     37,
    598     38,
    599     39,
    600     40,
    601     41,
    602     42,
    603     43,
    604     44,
    605     45,
    606     46,
    607     47,
    608     48,
    609     49,
    610     50,
    611     51,
    612     52,
    613     53,
    614     54,
    615     55,
    616     56,
    617     57,
    618     58,
    619     59,
    620     60,
    621     61,
    622     62,
    623     63,
    624     64,
    625     65,
    626     66,
    627     67,
    628     68,
    629     69,
    630     70,
    631     71,
    632     72,
    633     73,
    634     74,
    635     75,
    636     76,
    637     77,
    638     78,
    639     79,
    640     80,
    641     81,
    642     82,
    643     83,
    644     84,
    645     85,
    646     86,
    647     87,
    648     88,
    649     89,
    650     90,
    651     91,
    652     92,
    653     93,
    654     94,
    655     95,
    656     0,
    657     0,
    658     0,
    659     0,
    660     0,
    661     0,
    662     0,
    663     0,
    664     0,
    665     0,
    666     0,
    667     0,
    668     0,
    669     0,
    670     0,
    671     0,
    672     0,
    673     0,
    674     0,
    675     0,
    676     0,
    677     0,
    678     0,
    679     0,
    680     0,
    681     0,
    682     0,
    683     0,
    684     0,
    685     0,
    686     0,
    687     0,
    688     0,
    689     0,
    690     96,
    691     97,
    692     98,
    693     99,
    694     100,
    695     101,
    696     102,
    697     103,
    698     104,
    699     105,
    700     106,
    701     107,
    702     108,
    703     109,
    704     110,
    705     0,
    706     111,
    707     112,
    708     113,
    709     114,
    710     0,
    711     115,
    712     116,
    713     117,
    714     118,
    715     119,
    716     120,
    717     121,
    718     122,
    719     0,
    720     123,
    721     0,
    722     124,
    723     125,
    724     126,
    725     127,
    726     128,
    727     129,
    728     130,
    729     131,
    730     0,
    731     132,
    732     133,
    733     0,
    734     134,
    735     135,
    736     136,
    737     137,
    738     0,
    739     0,
    740     0,
    741     0,
    742     0,
    743     0,
    744     0,
    745     0,
    746     0,
    747     0,
    748     0,
    749     0,
    750     0,
    751     0,
    752     0,
    753     0,
    754     138,
    755     0,
    756     139,
    757     0,
    758     0,
    759     0,
    760     0,
    761     140,
    762     141,
    763     142,
    764     143,
    765     0,
    766     0,
    767     0,
    768     0,
    769     0,
    770     144,
    771     0,
    772     0,
    773     0,
    774     145,
    775     0,
    776     0,
    777     146,
    778     147,
    779     148,
    780     149,
    781     0,
    782     0,
    783     0,
    784     0
     109      0,   0,   0,   0,   0,   0,   0,   0,
     110      0,   0,   0,   0,   0,   0,   0,   0,
     111      0,   0,   0,   0,   0,   0,   0,   0,
     112      0,   0,   0,   0,   0,   0,   0,   0,
     113      1,   2,   3,   4,   5,   6,   7,   8,
     114      9,  10,  11,  12,  13,  14,  15,  16,
     115     17,  18,  19,  20,  21,  22,  23,  24,
     116     25,  26,  27,  28,  29,  30,  31,  32,
     117     33,  34,  35,  36,  37,  38,  39,  40,
     118     41,  42,  43,  44,  45,  46,  47,  48,
     119     49,  50,  51,  52,  53,  54,  55,  56,
     120     57,  58,  59,  60,  61,  62,  63,  64,
     121     65,  66,  67,  68,  69,  70,  71,  72,
     122     73,  74,  75,  76,  77,  78,  79,  80,
     123     81,  82,  83,  84,  85,  86,  87,  88,
     124     89,  90,  91,  92,  93,  94,  95,   0,
     125      0,   0,   0,   0,   0,   0,   0,   0,
     126      0,   0,   0,   0,   0,   0,   0,   0,
     127      0,   0,   0,   0,   0,   0,   0,   0,
     128      0,   0,   0,   0,   0,   0,   0,   0,
     129      0,  96,  97,  98,  99, 100, 101, 102,
     130    103, 104, 105, 106, 107, 108, 109, 110,
     131      0, 111, 112, 113, 114,   0, 115, 116,
     132    117, 118, 119, 120, 121, 122,   0, 123,
     133      0, 124, 125, 126, 127, 128, 129, 130,
     134    131,   0, 132, 133,   0, 134, 135, 136,
     135    137,   0,   0,   0,   0,   0,   0,   0,
     136      0,   0,   0,   0,   0,   0,   0,   0,
     137      0, 138,   0, 139,   0,   0,   0,   0,
     138    140, 141, 142, 143,   0,   0,   0,   0,
     139      0, 144,   0,   0,   0, 145,   0,   0,
     140    146, 147, 148, 149,   0,   0,   0,   0
    785141  };
    786142
    787143  static const FT_UShort  cff_expert_encoding[256] =
    788144  {
    789     0,
    790     0,
    791     0,
    792     0,
    793     0,
    794     0,
    795     0,
    796     0,
    797     0,
    798     0,
    799     0,
    800     0,
    801     0,
    802     0,
    803     0,
    804     0,
    805     0,
    806     0,
    807     0,
    808     0,
    809     0,
    810     0,
    811     0,
    812     0,
    813     0,
    814     0,
    815     0,
    816     0,
    817     0,
    818     0,
    819     0,
    820     0,
    821     1,
    822     229,
    823     230,
    824     0,
    825     231,
    826     232,
    827     233,
    828     234,
    829     235,
    830     236,
    831     237,
    832     238,
    833     13,
    834     14,
    835     15,
    836     99,
    837     239,
    838     240,
    839     241,
    840     242,
    841     243,
    842     244,
    843     245,
    844     246,
    845     247,
    846     248,
    847     27,
    848     28,
    849     249,
    850     250,
    851     251,
    852     252,
    853     0,
    854     253,
    855     254,
    856     255,
    857     256,
    858     257,
    859     0,
    860     0,
    861     0,
    862     258,
    863     0,
    864     0,
    865     259,
    866     260,
    867     261,
    868     262,
    869     0,
    870     0,
    871     263,
    872     264,
    873     265,
    874     0,
    875     266,
    876     109,
    877     110,
    878     267,
    879     268,
    880     269,
    881     0,
    882     270,
    883     271,
    884     272,
    885     273,
    886     274,
    887     275,
    888     276,
    889     277,
    890     278,
    891     279,
    892     280,
    893     281,
    894     282,
    895     283,
    896     284,
    897     285,
    898     286,
    899     287,
    900     288,
    901     289,
    902     290,
    903     291,
    904     292,
    905     293,
    906     294,
    907     295,
    908     296,
    909     297,
    910     298,
    911     299,
    912     300,
    913     301,
    914     302,
    915     303,
    916     0,
    917     0,
    918     0,
    919     0,
    920     0,
    921     0,
    922     0,
    923     0,
    924     0,
    925     0,
    926     0,
    927     0,
    928     0,
    929     0,
    930     0,
    931     0,
    932     0,
    933     0,
    934     0,
    935     0,
    936     0,
    937     0,
    938     0,
    939     0,
    940     0,
    941     0,
    942     0,
    943     0,
    944     0,
    945     0,
    946     0,
    947     0,
    948     0,
    949     0,
    950     304,
    951     305,
    952     306,
    953     0,
    954     0,
    955     307,
    956     308,
    957     309,
    958     310,
    959     311,
    960     0,
    961     312,
    962     0,
    963     0,
    964     312,
    965     0,
    966     0,
    967     314,
    968     315,
    969     0,
    970     0,
    971     316,
    972     317,
    973     318,
    974     0,
    975     0,
    976     0,
    977     158,
    978     155,
    979     163,
    980     319,
    981     320,
    982     321,
    983     322,
    984     323,
    985     324,
    986     325,
    987     0,
    988     0,
    989     326,
    990     150,
    991     164,
    992     169,
    993     327,
    994     328,
    995     329,
    996     330,
    997     331,
    998     332,
    999     333,
    1000     334,
    1001     335,
    1002     336,
    1003     337,
    1004     338,
    1005     339,
    1006     340,
    1007     341,
    1008     342,
    1009     343,
    1010     344,
    1011     345,
    1012     346,
    1013     347,
    1014     348,
    1015     349,
    1016     350,
    1017     351,
    1018     352,
    1019     353,
    1020     354,
    1021     355,
    1022     356,
    1023     357,
    1024     358,
    1025     359,
    1026     360,
    1027     361,
    1028     362,
    1029     363,
    1030     364,
    1031     365,
    1032     366,
    1033     367,
    1034     368,
    1035     369,
    1036     370,
    1037     371,
    1038     372,
    1039     373,
    1040     374,
    1041     375,
    1042     376,
    1043     377,
    1044     378
     145      0,   0,   0,   0,   0,   0,   0,   0,
     146      0,   0,   0,   0,   0,   0,   0,   0,
     147      0,   0,   0,   0,   0,   0,   0,   0,
     148      0,   0,   0,   0,   0,   0,   0,   0,
     149      1, 229, 230,   0, 231, 232, 233, 234,
     150    235, 236, 237, 238,  13,  14,  15,  99,
     151    239, 240, 241, 242, 243, 244, 245, 246,
     152    247, 248,  27,  28, 249, 250, 251, 252,
     153      0, 253, 254, 255, 256, 257,   0,   0,
     154      0, 258,   0,   0, 259, 260, 261, 262,
     155      0,   0, 263, 264, 265,   0, 266, 109,
     156    110, 267, 268, 269,   0, 270, 271, 272,
     157    273, 274, 275, 276, 277, 278, 279, 280,
     158    281, 282, 283, 284, 285, 286, 287, 288,
     159    289, 290, 291, 292, 293, 294, 295, 296,
     160    297, 298, 299, 300, 301, 302, 303,   0,
     161      0,   0,   0,   0,   0,   0,   0,   0,
     162      0,   0,   0,   0,   0,   0,   0,   0,
     163      0,   0,   0,   0,   0,   0,   0,   0,
     164      0,   0,   0,   0,   0,   0,   0,   0,
     165      0, 304, 305, 306,   0,   0, 307, 308,
     166    309, 310, 311,   0, 312,   0,   0, 312,
     167      0,   0, 314, 315,   0,   0, 316, 317,
     168    318,   0,   0,   0, 158, 155, 163, 319,
     169    320, 321, 322, 323, 324, 325,   0,   0,
     170    326, 150, 164, 169, 327, 328, 329, 330,
     171    331, 332, 333, 334, 335, 336, 337, 338,
     172    339, 340, 341, 342, 343, 344, 345, 346,
     173    347, 348, 349, 350, 351, 352, 353, 354,
     174    355, 356, 357, 358, 359, 360, 361, 362,
     175    363, 364, 365, 366, 367, 368, 369, 370,
     176    371, 372, 373, 374, 375, 376, 377, 378
    1045177  };
    1046178#endif
     
    1064196
    1065197
     198  /* read an offset from the index's stream current position */
     199  static FT_ULong
     200  cff_index_read_offset( CFF_Index  idx,
     201                         FT_Error  *errorp )
     202  {
     203    FT_Error   error;
     204    FT_Stream  stream = idx->stream;
     205    FT_Byte    tmp[4];
     206    FT_ULong   result = 0;
     207
     208
     209    if ( !FT_STREAM_READ( tmp, idx->off_size ) )
     210    {
     211      FT_Int  nn;
     212
     213
     214      for ( nn = 0; nn < idx->off_size; nn++ )
     215        result = ( result << 8 ) | tmp[nn];
     216    }
     217
     218    *errorp = error;
     219    return result;
     220  }
     221
     222
    1066223  static FT_Error
    1067   cff_new_index( CFF_Index  idx,
    1068                  FT_Stream  stream,
    1069                  FT_Bool    load )
     224  cff_index_init( CFF_Index  idx,
     225                  FT_Stream  stream,
     226                  FT_Bool    load )
    1070227  {
    1071228    FT_Error   error;
     
    1077234
    1078235    idx->stream = stream;
     236    idx->start  = FT_STREAM_POS();
    1079237    if ( !FT_READ_USHORT( count ) &&
    1080238         count > 0                )
    1081239    {
    1082       FT_Byte*   p;
    1083       FT_Byte    offsize;
    1084       FT_ULong   data_size;
    1085       FT_ULong*  poff;
    1086       FT_Byte*   p_end;
     240      FT_Byte   offsize;
     241      FT_ULong  size;
    1087242
    1088243
     
    1098253      }
    1099254
    1100       idx->stream   = stream;
    1101255      idx->count    = count;
    1102256      idx->off_size = offsize;
    1103       data_size     = (FT_ULong)( count + 1 ) * offsize;
    1104 
    1105       if ( FT_NEW_ARRAY( idx->offsets, count + 1 ) ||
    1106            FT_FRAME_ENTER( data_size )             )
     257      size          = (FT_ULong)( count + 1 ) * offsize;
     258
     259      idx->data_offset = idx->start + 3 + size;
     260
     261      if ( FT_STREAM_SKIP( size - offsize ) )
     262        goto Exit;
     263
     264      size = cff_index_read_offset( idx, &error );
     265      if ( error )
     266        goto Exit;
     267
     268      if ( size == 0 )
     269      {
     270        error = CFF_Err_Invalid_Table;
     271        goto Exit;
     272      }
     273
     274      idx->data_size = --size;
     275
     276      if ( load )
     277      {
     278        /* load the data */
     279        if ( FT_FRAME_EXTRACT( size, idx->bytes ) )
     280          goto Exit;
     281      }
     282      else
     283      {
     284        /* skip the data */
     285        if ( FT_STREAM_SKIP( size ) )
     286          goto Exit;
     287      }
     288    }
     289
     290  Exit:
     291    if ( error )
     292      FT_FREE( idx->offsets );
     293
     294    return error;
     295  }
     296
     297
     298  static void
     299  cff_index_done( CFF_Index  idx )
     300  {
     301    if ( idx->stream )
     302    {
     303      FT_Stream  stream = idx->stream;
     304      FT_Memory  memory = stream->memory;
     305
     306
     307      if ( idx->bytes )
     308        FT_FRAME_RELEASE( idx->bytes );
     309
     310      FT_FREE( idx->offsets );
     311      FT_MEM_ZERO( idx, sizeof ( *idx ) );
     312    }
     313  }
     314
     315
     316  static FT_Error
     317  cff_index_load_offsets( CFF_Index  idx )
     318  {
     319    FT_Error   error  = 0;
     320    FT_Stream  stream = idx->stream;
     321    FT_Memory  memory = stream->memory;
     322
     323
     324    if ( idx->count > 0 && idx->offsets == NULL )
     325    {
     326      FT_Byte    offsize = idx->off_size;
     327      FT_ULong   data_size;
     328      FT_Byte*   p;
     329      FT_Byte*   p_end;
     330      FT_ULong*  poff;
     331
     332
     333      data_size = (FT_ULong)( idx->count + 1 ) * offsize;
     334
     335      if ( FT_NEW_ARRAY( idx->offsets, idx->count + 1 ) ||
     336           FT_STREAM_SEEK( idx->start + 3 )             ||
     337           FT_FRAME_ENTER( data_size )                  )
    1107338        goto Exit;
    1108339
     
    1134365
    1135366      FT_FRAME_EXIT();
    1136 
    1137       idx->data_offset = FT_STREAM_POS();
    1138       data_size        = poff[-1] - 1;
    1139 
    1140       if ( load )
    1141       {
    1142         /* load the data */
    1143         if ( FT_FRAME_EXTRACT( data_size, idx->bytes ) )
    1144           goto Exit;
    1145       }
    1146       else
    1147       {
    1148         /* skip the data */
    1149         if ( FT_STREAM_SKIP( data_size ) )
    1150           goto Exit;
    1151       }
    1152367    }
    1153368
     
    1157372
    1158373    return error;
    1159   }
    1160 
    1161 
    1162   static void
    1163   cff_done_index( CFF_Index  idx )
    1164   {
    1165     if ( idx->stream )
    1166     {
    1167       FT_Stream  stream = idx->stream;
    1168       FT_Memory  memory = stream->memory;
    1169 
    1170 
    1171       if ( idx->bytes )
    1172         FT_FRAME_RELEASE( idx->bytes );
    1173 
    1174       FT_FREE( idx->offsets );
    1175       FT_MEM_ZERO( idx, sizeof ( *idx ) );
    1176     }
    1177374  }
    1178375
     
    1191388    *table = 0;
    1192389
     390    if ( idx->offsets == NULL )
     391    {
     392      error = cff_index_load_offsets( idx );
     393      if ( error )
     394        goto Exit;
     395    }
     396
    1193397    if ( idx->count > 0 && !FT_NEW_ARRAY( t, idx->count + 1 ) )
    1194398    {
     
    1200404          offset = old_offset;
    1201405
     406        /* sanity check for invalid offset tables */
     407        else if ( offset < old_offset || offset - 1 >= idx->data_size )
     408          offset = old_offset;
     409
    1202410        t[n] = idx->bytes + offset - 1;
    1203411
     
    1207415    }
    1208416
     417  Exit:
    1209418    return error;
    1210419  }
     
    1223432    {
    1224433      /* compute start and end offsets */
    1225       FT_ULong  off1, off2 = 0;
    1226 
    1227 
    1228       off1 = idx->offsets[element];
    1229       if ( off1 )
    1230       {
    1231         do
     434      FT_Stream  stream = idx->stream;
     435      FT_ULong   off1, off2 = 0;
     436
     437
     438      /* load offsets from file or the offset table */
     439      if ( !idx->offsets )
     440      {
     441        FT_ULong  pos = element * idx->off_size;
     442
     443
     444        if ( FT_STREAM_SEEK( idx->start + 3 + pos ) )
     445          goto Exit;
     446
     447        off1 = cff_index_read_offset( idx, &error );
     448        if ( error )
     449          goto Exit;
     450
     451        if ( off1 != 0 )
    1232452        {
    1233           element++;
    1234           off2 = idx->offsets[element];
    1235 
    1236         } while ( off2 == 0 && element < idx->count );
    1237 
    1238         if ( !off2 )
    1239           off1 = 0;
     453          do
     454          {
     455            element++;
     456            off2 = cff_index_read_offset( idx, &error );
     457          }
     458          while ( off2 == 0 && element < idx->count );
     459        }
     460      }
     461      else   /* use offsets table */
     462      {
     463        off1 = idx->offsets[element];
     464        if ( off1 )
     465        {
     466          do
     467          {
     468            element++;
     469            off2 = idx->offsets[element];
     470
     471          } while ( off2 == 0 && element < idx->count );
     472        }
    1240473      }
    1241474
     
    1253486        {
    1254487          /* this index is still on disk/file, access it through a frame */
    1255           FT_Stream  stream = idx->stream;
    1256 
    1257 
    1258488          if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
    1259489               FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
     
    1523753      charset->cids[charset->sids[i]] = (FT_UShort)i;
    1524754
    1525     charset->max_cid = max_cid;
     755    charset->max_cid    = max_cid;
     756    charset->num_glyphs = num_glyphs;
    1526757
    1527758  Exit:
    1528759    return error;
     760  }
     761
     762
     763  FT_LOCAL_DEF( FT_UInt )
     764  cff_charset_cid_to_gindex( CFF_Charset  charset,
     765                             FT_UInt      cid )
     766  {
     767    FT_UInt  result = 0;
     768
     769
     770    if ( cid < charset->max_cid )
     771      result = charset->cids[cid];
     772
     773    return result;
    1529774  }
    1530775
     
    19591204
    19601205          if ( sid )
    1961             gid = charset->cids[sid];
     1206            gid = cff_charset_cid_to_gindex( charset, sid );
    19621207
    19631208          if ( gid != 0 )
     
    20791324        goto Exit;
    20801325
    2081       error = cff_new_index( &font->local_subrs_index, stream, 1 );
     1326      error = cff_index_init( &font->local_subrs_index, stream, 1 );
    20821327      if ( error )
    20831328        goto Exit;
     
    21011346    if ( subfont )
    21021347    {
    2103       cff_done_index( &subfont->local_subrs_index );
     1348      cff_index_done( &subfont->local_subrs_index );
    21041349      FT_FREE( subfont->local_subrs );
    21051350    }
     
    21571402
    21581403    /* read the name, top dict, string and global subrs index */
    2159     if ( FT_SET_ERROR( cff_new_index( &font->name_index,         stream, 0 )) ||
    2160          FT_SET_ERROR( cff_new_index( &font->font_dict_index,    stream, 0 )) ||
    2161          FT_SET_ERROR( cff_new_index( &font->string_index,       stream, 0 )) ||
    2162          FT_SET_ERROR( cff_new_index( &font->global_subrs_index, stream, 1 )) )
     1404    if ( FT_SET_ERROR( cff_index_init( &font->name_index,
     1405                                       stream, 0 ) )              ||
     1406         FT_SET_ERROR( cff_index_init( &font->font_dict_index,
     1407                                       stream, 0 ) )              ||
     1408         FT_SET_ERROR( cff_index_init( &font->string_index,
     1409                                       stream, 0 ) )              ||
     1410         FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
     1411                                       stream, 1 ) )              )
    21631412      goto Exit;
    21641413
     
    21881437      goto Exit;
    21891438
    2190     error = cff_new_index( &font->charstrings_index, stream, 0 );
     1439    error = cff_index_init( &font->charstrings_index, stream, 0 );
    21911440    if ( error )
    21921441      goto Exit;
     
    22051454        goto Exit;
    22061455
    2207       error = cff_new_index( &fd_index, stream, 0 );
     1456      error = cff_index_init( &fd_index, stream, 0 );
    22081457      if ( error )
    22091458        goto Exit;
     
    22411490
    22421491    Fail_CID:
    2243       cff_done_index( &fd_index );
     1492      cff_index_done( &fd_index );
    22441493
    22451494      if ( error )
     
    23111560
    23121561
    2313     cff_done_index( &font->global_subrs_index );
    2314     cff_done_index( &font->string_index );
    2315     cff_done_index( &font->font_dict_index );
    2316     cff_done_index( &font->name_index );
    2317     cff_done_index( &font->charstrings_index );
     1562    cff_index_done( &font->global_subrs_index );
     1563    cff_index_done( &font->string_index );
     1564    cff_index_done( &font->font_dict_index );
     1565    cff_index_done( &font->name_index );
     1566    cff_index_done( &font->charstrings_index );
    23181567
    23191568    /* release font dictionaries, but only if working with */
     
    23351584    CFF_Done_FD_Select( &font->fd_select, font->stream );
    23361585
     1586    if (font->font_info != NULL)
     1587    {
     1588      FT_FREE( font->font_info->version );
     1589      FT_FREE( font->font_info->notice );
     1590      FT_FREE( font->font_info->full_name );
     1591      FT_FREE( font->font_info->family_name );
     1592      FT_FREE( font->font_info->weight );
     1593      FT_FREE( font->font_info );
     1594    }
     1595
    23371596    FT_FREE( font->global_subrs );
    23381597    FT_FREE( font->font_name );
  • trunk/poppler/freetype2/src/cff/cffload.h

    r150 r182  
    55/*    OpenType & CFF data/program tables loader (specification).           */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003 by                                     */
     7/*  Copyright 1996-2001, 2002, 2003, 2007 by                               */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5353
    5454
     55  FT_LOCAL( FT_UInt )
     56  cff_charset_cid_to_gindex( CFF_Charset  charset,
     57                             FT_UInt      cid );
     58
     59
    5560  FT_LOCAL( FT_Error )
    5661  cff_font_load( FT_Stream  stream,
  • trunk/poppler/freetype2/src/cff/cffobjs.c

    r150 r182  
    55/*    OpenType objects manager (body).                                     */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    208208      CFF_Face      cffface = (CFF_Face)size->face;
    209209      SFNT_Service  sfnt    = (SFNT_Service)cffface->sfnt;
    210       FT_ULong      index;
    211 
    212 
    213       if ( sfnt->set_sbit_strike( cffface, req, &index ) )
     210      FT_ULong      strike_index;
     211
     212
     213      if ( sfnt->set_sbit_strike( cffface, req, &strike_index ) )
    214214        cffsize->strike_index = 0xFFFFFFFFUL;
    215215      else
    216         return cff_size_select( size, index );
     216        return cff_size_select( size, strike_index );
    217217    }
    218218
  • trunk/poppler/freetype2/src/cff/cffobjs.h

    r150 r182  
    55/*    OpenType objects manager (specification).                            */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    121121  FT_LOCAL( FT_Error )
    122122  cff_size_select( FT_Size   size,
    123                    FT_ULong  index );
     123                   FT_ULong  strike_index );
    124124
    125125#endif
  • trunk/poppler/freetype2/src/cff/cfftypes.h

    r150 r182  
    66/*    only).                                                               */
    77/*                                                                         */
    8 /*  Copyright 1996-2001, 2002, 2003, 2006 by                               */
     8/*  Copyright 1996-2001, 2002, 2003, 2006, 2007 by                         */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    2424#include <ft2build.h>
    2525#include FT_FREETYPE_H
     26#include FT_TYPE1_TABLES_H
    2627
    2728
     
    4041  /*    stream      :: The source input stream.                            */
    4142  /*                                                                       */
     43  /*    start       :: The position of the first index byte in the         */
     44  /*                   input stream.                                       */
     45  /*                                                                       */
    4246  /*    count       :: The number of elements in the index.                */
    4347  /*                                                                       */
     
    4751  /*                   bytes.                                              */
    4852  /*                                                                       */
    49   /*    offsets     :: A table of element offsets in the index.            */
     53  /*    data_size   :: The size of the data table in this index.           */
     54  /*                                                                       */
     55  /*    offsets     :: A table of element offsets in the index.  Must be   */
     56  /*                   loaded explicitly.                                  */
    5057  /*                                                                       */
    5158  /*    bytes       :: If the index is loaded in memory, its bytes.        */
     
    5461  {
    5562    FT_Stream  stream;
     63    FT_ULong   start;
    5664    FT_UInt    count;
    5765    FT_Byte    off_size;
    5866    FT_ULong   data_offset;
     67    FT_ULong   data_size;
    5968
    6069    FT_ULong*  offsets;
     
    8695                            /* for CID-keyed fonts                        */
    8796    FT_UInt     max_cid;
     97    FT_UInt     num_glyphs;
     98
    8899  } CFF_CharsetRec, *CFF_Charset;
    89100
     
    246257    void*            psnames;
    247258
     259    /* since version 2.3.0 */
     260    PS_FontInfoRec*  font_info;   /* font info dictionary */
     261
    248262  } CFF_FontRec, *CFF_Font;
    249263
  • trunk/poppler/freetype2/src/cid/cidparse.c

    r150 r182  
    55/*    CID-keyed Type1 parser (body).                                       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    8484
    8585  Again:
    86     /* now, read the rest of the file until we find a `StartData' */
     86    /* now, read the rest of the file until we find */
     87    /* `StartData' or `/sfnts'                      */
    8788    {
    8889      FT_Byte   buffer[256 + 10];
     
    9394      for ( offset = (FT_ULong)FT_STREAM_POS(); ; offset += 256 )
    9495      {
    95         FT_Int    stream_len;
     96        FT_Int  stream_len;
    9697
    9798
     
    117118            goto Found;
    118119          }
     120          else if ( p[1] == 's' && ft_strncmp( (char*)p, "/sfnts", 6 ) == 0 )
     121          {
     122            offset += p - buffer + 7;
     123            goto Found;
     124          }
    119125        }
    120126
     
    126132
    127133  Found:
    128     /* We have found the start of the binary data.  Now rewind and */
    129     /* extract the frame corresponding to the PostScript section.  */
     134    /* We have found the start of the binary data or the `/sfnts' token. */
     135    /* Now rewind and extract the frame corresponding to this PostScript */
     136    /* section.                                                          */
    130137
    131138    ps_len = offset - base_offset;
     
    141148    parser->num_dict       = -1;
    142149
    143     /* Finally, we check whether `StartData' was real -- it could be  */
    144     /* in a comment or string.  We also get its arguments to find out */
    145     /* whether the data is represented in binary or hex format.       */
     150    /* Finally, we check whether `StartData' or `/sfnts' was real --  */
     151    /* it could be in a comment or string.  We also get the arguments */
     152    /* of `StartData' to find out whether the data is represented in  */
     153    /* binary or hex format.                                          */
    146154
    147155    arg1 = parser->root.cursor;
     
    160168        break;
    161169
    162       if ( *cur == 'S' && ft_strncmp( (char*)cur, "StartData", 9 ) == 0 )
     170      if ( cur[0] == 'S' && ft_strncmp( (char*)cur, "StartData", 9 ) == 0 )
    163171      {
    164172        if ( ft_strncmp( (char*)arg1, "(Hex)", 5 ) == 0 )
     
    167175        limit = parser->root.limit;
    168176        cur   = parser->root.cursor;
     177        goto Exit;
     178      }
     179      else if ( cur[1] == 's' && ft_strncmp( (char*)cur, "/sfnts", 6 ) == 0 )
     180      {
     181        FT_TRACE2(( "cid_parser_new: cannot handle Type 11 fonts\n" ));
     182        error = CID_Err_Unknown_File_Format;
    169183        goto Exit;
    170184      }
  • trunk/poppler/freetype2/src/gxvalid/README

    r150 r182  
    440440      are documented  by each vendors' TrueType  font specification, but
    441441      the documentation for classic Apple dialect is not available.
    442      
     442
    443443      For example,  in the  new Apple dialect,  bit 15 is  documented as
    444444      `set to  1 if  the kerning  is vertical'.  On  the other  hand, in
     
    488488    We checked  59 fonts  bundled with MacOS  and 38 fonts  bundled with
    489489    Windows, where all font include a `kern' table.
    490    
     490
    491491      - fonts bundled with MacOS
    492492        * new Apple dialect
  • trunk/poppler/freetype2/src/gxvalid/gxvfgen.c

    r150 r182  
    466466              feat_name ? 1 : 0,
    467467              ( feat_name                                                  &&
    468                 ( ft_strncmp( feat_name, 
     468                ( ft_strncmp( feat_name,
    469469                              APPLE_RESERVED, APPLE_RESERVED_LENGTH ) == 0 )
    470470              ) ? 1 : 0,
  • trunk/poppler/freetype2/src/gxvalid/gxvkern.c

    r150 r182  
    55/*    TrueTypeGX/AAT kern table validation (body).                         */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by suzuki toshiya, Masatake YAMATO, Red Hat K.K., */
     7/*  Copyright 2004, 2005, 2006, 2007                                       */
     8/*  by suzuki toshiya, Masatake YAMATO, Red Hat K.K.,                      */
    89/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    910/*                                                                         */
     
    107108
    108109  static void
     110  gxv_kern_subtable_fmt0_pairs_validate( FT_Bytes       table,
     111                                         FT_Bytes       limit,
     112                                         FT_UShort      nPairs,
     113                                         GXV_Validator  valid )
     114  {
     115    FT_Bytes   p = table;
     116    FT_UShort  i;
     117
     118    FT_UShort  last_gid_left  = 0;
     119    FT_UShort  last_gid_right = 0;
     120
     121    FT_UNUSED( limit );
     122
     123
     124    GXV_NAME_ENTER( "kern format 0 pairs" );
     125
     126    for ( i = 0; i < nPairs; i++ )
     127    {
     128      FT_UShort  gid_left;
     129      FT_UShort  gid_right;
     130      FT_Short   kernValue;
     131
     132
     133      /* left */
     134      gid_left  = FT_NEXT_USHORT( p );
     135      gxv_glyphid_validate( gid_left, valid );
     136
     137      /* right */
     138      gid_right = FT_NEXT_USHORT( p );
     139      gxv_glyphid_validate( gid_right, valid );
     140
     141      /* Pairs of left and right GIDs must be unique and sorted. */
     142      GXV_TRACE(( "left gid = %u, right gid = %u\n", gid_left, gid_right ));
     143      if ( gid_left == last_gid_left )
     144      {
     145        if ( last_gid_right < gid_right )
     146          last_gid_right = gid_right;
     147        else
     148          FT_INVALID_DATA;
     149      }
     150      else if ( last_gid_left < gid_left )
     151      {
     152        last_gid_left  = gid_left;
     153        last_gid_right = gid_right;
     154      }
     155      else
     156        FT_INVALID_DATA;
     157
     158      /* skip the kern value */
     159      kernValue = FT_NEXT_SHORT( p );
     160    }
     161
     162    GXV_EXIT;
     163  }
     164
     165  static void
    109166  gxv_kern_subtable_fmt0_validate( FT_Bytes       table,
    110167                                   FT_Bytes       limit,
     
    115172    FT_UShort  nPairs;
    116173    FT_UShort  unitSize;
    117     FT_UShort  i;
    118 
    119 
    120     GXV_NAME_ENTER( "kern subtable format0" );
     174
     175
     176    GXV_NAME_ENTER( "kern subtable format 0" );
    121177
    122178    unitSize = 2 + 2 + 2;
     
    128184    p += 2 + 2 + 2 + 2;
    129185
    130     for ( i = 0; i < nPairs; i++ )
    131     {
    132       FT_UShort  gid_left;
    133       FT_UShort  gid_right;
    134       FT_Short   kernValue;
    135 
    136       /* TODO: should be checked pairs are unique. */
    137 
    138 
    139       /* left */
    140       gid_left  = FT_NEXT_USHORT( p );
    141       gxv_glyphid_validate( gid_left, valid );
    142 
    143       /* right */
    144       gid_right = FT_NEXT_USHORT( p );
    145       gxv_glyphid_validate( gid_right, valid );
    146 
    147       /* skip the kern value */
    148       kernValue = FT_NEXT_SHORT( p );
    149     }
     186    gxv_kern_subtable_fmt0_pairs_validate( p, limit, nPairs, valid );
    150187
    151188    GXV_EXIT;
     
    267304
    268305
    269     GXV_NAME_ENTER( "kern subtable format1" );
     306    GXV_NAME_ENTER( "kern subtable format 1" );
    270307
    271308    valid->statetable.optdata =
     
    369406
    370407
    371     GXV_NAME_ENTER( "kern subtable format2" );
     408    GXV_NAME_ENTER( "kern subtable format 2" );
    372409
    373410    GXV_ODTECT_INIT( odtect );
     
    426463
    427464
    428     GXV_NAME_ENTER( "kern subtable format3" );
     465    GXV_NAME_ENTER( "kern subtable format 3" );
    429466
    430467    GXV_LIMIT_CHECK( 2 + 1 + 1 + 1 + 1 );
  • trunk/poppler/freetype2/src/gxvalid/gxvmort2.c

    r150 r182  
    206206    setComponent = (FT_UShort)( ( flags >> 15 ) & 1 );
    207207    dontAdvance  = (FT_UShort)( ( flags >> 14 ) & 1 );
    208    
     208
    209209    offset = (FT_UShort)( flags & 0x3FFFU );
    210210
  • trunk/poppler/freetype2/src/gxvalid/gxvmorx5.c

    r150 r182  
    66/*    body for type5 (Contextual Glyph Insertion) subtable.                */
    77/*                                                                         */
    8 /*  Copyright 2005 by suzuki toshiya, Masatake YAMATO, Red Hat K.K.,      */
     8/*  Copyright 2005, 2007 by suzuki toshiya, Masatake YAMATO, Red Hat K.K., */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    110110
    111111  static void
    112   gxv_morx_subtable_type5_InsertList_validate( FT_UShort      index,
     112  gxv_morx_subtable_type5_InsertList_validate( FT_UShort      table_index,
    113113                                               FT_UShort      count,
    114114                                               FT_Bytes       table,
     
    116116                                               GXV_Validator  valid )
    117117  {
    118     FT_Bytes p = table + index * 2;
    119 
    120 
    121     while ( p < table + count * 2 + index * 2 )
     118    FT_Bytes p = table + table_index * 2;
     119
     120
     121    while ( p < table + count * 2 + table_index * 2 )
    122122    {
    123123      FT_UShort  insert_glyphID;
  • trunk/poppler/freetype2/src/otvalid/otvmod.c

    r165 r182  
    199199
    200200  static
    201   const FT_Service_OTvalidateRec  otvalid_interface = 
     201  const FT_Service_OTvalidateRec  otvalid_interface =
    202202  {
    203203    otv_validate
     
    206206
    207207  static
    208   const FT_ServiceDescRec  otvalid_services[] = 
     208  const FT_ServiceDescRec  otvalid_services[] =
    209209  {
    210210    { FT_SERVICE_ID_OPENTYPE_VALIDATE, &otvalid_interface },
  • trunk/poppler/freetype2/src/pcf/README

    r150 r182  
    1414
    1515Informations on the PCF font format can only be worked out from
    16 ``pcfread.c'', and ``pcfwrite.c'', to be found, for instance, in the XFree86
     16`pcfread.c', and `pcfwrite.c', to be found, for instance, in the XFree86
    1717(www.xfree86.org) source tree (xc/lib/font/bitmap/).
    1818
    1919Many good bitmap fonts in bdf format come with XFree86: they can be
    20 compiled into the pcf format using the ``bdftopcf'' utility.
     20compiled into the pcf format using the `bdftopcf' utility.
    2121
    2222
     
    4747
    4848  pcfface = (PCF_Public_Face)face;
    49  
    50   if ((pcfface->charset_registry == "ISO10646") && 
     49
     50  if ((pcfface->charset_registry == "ISO10646") &&
    5151        (pcfface->charset_encoding) == "1")) [..]
    5252
    53 Thus the driver always export ``ft_encoding_none'' as
     53Thus the driver always export `ft_encoding_none' as
    5454face->charmap.encoding.  FT_Get_Char_Index() behavior is unmodified, that
    5555is, it converts the ULong value given as argument into the corresponding
  • trunk/poppler/freetype2/src/pcf/pcfread.c

    r165 r182  
    33    FreeType font driver for pcf fonts
    44
    5   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006 by
     5  Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by
    66  Francesco Zappa Nardelli
    77
     
    322322
    323323  Fail:
     324    *asize = 0;
    324325    return error;
    325326  }
     
    550551
    551552    error = PCF_Err_Ok;
    552    
     553
    553554  Bail:
    554555    FT_FREE( props );
     
    11831184        root->family_name = NULL;
    11841185
    1185       /* 
     1186      /*
    11861187       * Note: We shift all glyph indices by +1 since we must
    11871188       * respect the convention that glyph 0 always corresponds
  • trunk/poppler/freetype2/src/pcf/pcfutil.c

    r165 r182  
    4848    {
    4949      unsigned int  val = *buf;
    50      
     50
    5151
    5252      val = ( ( val >> 1 ) & 0x55 ) | ( ( val << 1 ) & 0xAA );
    5353      val = ( ( val >> 2 ) & 0x33 ) | ( ( val << 2 ) & 0xCC );
    5454      val = ( ( val >> 4 ) & 0x0F ) | ( ( val << 4 ) & 0xF0 );
    55      
     55
    5656      *buf = (unsigned char)val;
    5757    }
  • trunk/poppler/freetype2/src/pfr/pfrcmap.c

    r150 r182  
    1717
    1818
    19 #include "pfrcmap.h" 
     19#include "pfrcmap.h"
    2020#include "pfrobjs.h"
    2121#include FT_INTERNAL_DEBUG_H
     
    3030    cmap->num_chars = face->phy_font.num_chars;
    3131    cmap->chars     = face->phy_font.chars;
    32    
     32
    3333    /* just for safety, check that the character entries are correctly */
    3434    /* sorted in increasing character code order                       */
    3535    {
    3636      FT_UInt  n;
    37      
     37
    3838
    3939      for ( n = 1; n < cmap->num_chars; n++ )
     
    4343      }
    4444    }
    45    
     45
    4646    return 0;
    4747  }
  • trunk/poppler/freetype2/src/pfr/pfrcmap.h

    r150 r182  
    3232    FT_UInt     num_chars;
    3333    PFR_Char    chars;
    34  
     34
    3535  } PFR_CMapRec, *PFR_CMap;
    3636
  • trunk/poppler/freetype2/src/pfr/pfrload.h

    r150 r182  
    5555    FT_UInt                  type;
    5656    PFR_ExtraItem_ParseFunc  parser;
    57  
     57
    5858  } PFR_ExtraItemRec;
    59  
     59
    6060  typedef const struct PFR_ExtraItemRec_*  PFR_ExtraItem;
    61  
     61
    6262
    6363  FT_LOCAL( FT_Error )
     
    110110
    111111  /* */
    112  
     112
    113113FT_END_HEADER
    114114
  • trunk/poppler/freetype2/src/pfr/pfrobjs.c

    r165 r182  
    55/*    FreeType PFR object methods (body).                                  */
    66/*                                                                         */
    7 /*  Copyright 2002, 2003, 2004, 2005, 2006 by                              */
     7/*  Copyright 2002, 2003, 2004, 2005, 2006, 2007 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    123123      goto Exit;
    124124
    125     /* now, set-up all root face fields */
     125    /* now set up all root face fields */
    126126    {
    127127      PFR_PhyFont  phy_font = &face->phy_font;
     
    131131      pfrface->num_glyphs = phy_font->num_chars + 1;
    132132      pfrface->face_flags = FT_FACE_FLAG_SCALABLE;
     133
     134      /* if all characters point to the same gps_offset 0, we */
     135      /* assume that the font only contains bitmaps           */
     136      {
     137        FT_UInt  nn;
     138
     139
     140        for ( nn = 0; nn < phy_font->num_chars; nn++ )
     141          if ( phy_font->chars[nn].gps_offset != 0 )
     142            break;
     143
     144        if ( nn == phy_font->num_chars )
     145          pfrface->face_flags = 0;        /* not scalable */
     146      }
    133147
    134148      if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
  • trunk/poppler/freetype2/src/psaux/psobjs.c

    r165 r182  
    589589                 "but invalid at this point\n",
    590590                 *cur ));
    591      
     591
    592592      error = PSaux_Err_Invalid_File_Format;
    593593    }
     
    12831283    FT_Error  error = PSaux_Err_Ok;
    12841284    FT_Byte*  cur;
    1285    
    1286    
     1285
     1286
    12871287    ps_parser_skip_spaces( parser );
    12881288    cur = parser->cursor;
  • trunk/poppler/freetype2/src/pshinter/pshalgo.c

    r165 r182  
    55/*    PostScript hinting algorithm (body).                                 */
    66/*                                                                         */
    7 /*  Copyright 2001, 2002, 2003, 2004, 2005, 2006 by                        */
     7/*  Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007 by                  */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    10331033        orient_prev = psh_corner_orientation( in_x, in_y, out_x, out_y );
    10341034
    1035       } while ( orient_prev != 0 );
     1035      } while ( orient_prev == 0 );
    10361036
    10371037      first = start;
     
    18671867
    18681868
    1869       if ( !FT_NEW_ARRAY( strongs, num_strongs ) )
     1869      if ( FT_NEW_ARRAY( strongs, num_strongs ) )
    18701870        return;
    18711871    }
  • trunk/poppler/freetype2/src/raster/ftraster.c

    r150 r182  
    55/*    The FreeType glyph rasterizer (body).                                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2005 by                               */
     7/*  Copyright 1996-2001, 2002, 2003, 2005, 2007 by                         */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    379379
    380380
    381 #define RAS_ARGS       TRaster_Instance*  raster,
    382 #define RAS_ARG        TRaster_Instance*  raster
    383 
    384 #define RAS_VARS       raster,
    385 #define RAS_VAR        raster
    386 
    387 #define FT_UNUSED_RASTER  FT_UNUSED( raster )
     381#define RAS_ARGS       PWorker    worker,
     382#define RAS_ARG        PWorker    worker
     383
     384#define RAS_VARS       worker,
     385#define RAS_VAR        worker
     386
     387#define FT_UNUSED_RASTER  FT_UNUSED( worker )
    388388
    389389
     
    391391
    392392
    393   typedef struct TRaster_Instance_  TRaster_Instance;
     393  typedef struct TWorker_   TWorker, *PWorker;
    394394
    395395
     
    423423  /* opcodes, and it results in a smaller executable.          */
    424424
    425   struct  TRaster_Instance_
     425  struct  TWorker_
    426426  {
    427427    Int       precision_bits;       /* precision related variables         */
     
    499499    Int       band_top;             /* band stack top                      */
    500500
    501     Int       count_table[256];     /* Look-up table used to quickly count */
    502                                     /* set bits in a gray 2x2 cell         */
    503 
    504     void*     memory;
    505 
    506501#ifdef FT_RASTER_OPTION_ANTI_ALIASING
    507502
    508     Byte      grays[5];             /* Palette of gray levels used for     */
    509                                     /* render.                             */
     503    Byte*     grays;
    510504
    511505    Byte      gray_lines[RASTER_GRAY_LINES];
     
    524518#endif /* FT_RASTER_ANTI_ALIASING */
    525519
    526 #if 0
    527     PByte       flags;              /* current flags table                 */
    528     PUShort     outs;               /* current outlines table              */
    529     FT_Vector*  coords;
    530 
    531     UShort      nPoints;            /* number of points in current glyph   */
    532     Short       nContours;          /* number of contours in current glyph */
    533 #endif
    534 
    535520  };
    536521
    537522
     523  typedef struct TRaster_
     524  {
     525    char*     buffer;
     526    long      buffer_size;
     527    void*     memory;
     528    PWorker   worker;
     529    Byte      grays[5];
     530    Short     gray_width;
     531
     532  } TRaster, *PRaster;
     533
    538534#ifdef FT_STATIC_RASTER
    539535
    540   static TRaster_Instance  cur_ras;
     536  static TWorker   cur_ras;
    541537#define ras  cur_ras
    542538
    543539#else
    544540
    545 #define ras  (*raster)
     541#define ras  (*worker)
    546542
    547543#endif /* FT_STATIC_RASTER */
     544
     545
     546static const char  count_table[256] =
     547{
     548  0 , 1 , 1 , 2 , 1 , 2 , 2 , 3 , 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4,
     549  1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
     550  1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
     551  2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
     552  1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
     553  2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
     554  2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
     555  3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
     556  1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
     557  2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
     558  2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
     559  3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
     560  2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
     561  3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
     562  3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
     563  4 , 5 , 5 , 6 , 5 , 6 , 6 , 7 , 5 , 6 , 6 , 7 , 6 , 7 , 7 , 8 };
     564
    548565
    549566
     
    24952512    Int    c1, c2;
    24962513    PByte  pix, bit, bit2;
    2497     Int*   count = ras.count_table;
     2514    char*  count = (char*)count_table;
    24982515    Byte*  grays;
    24992516
     
    31543171
    31553172  static void
    3156   ft_black_init( TRaster_Instance*  raster )
    3157   {
     3173  ft_black_init( PRaster  raster )
     3174  {
     3175    FT_UNUSED( raster );
     3176
     3177#ifdef FT_RASTER_OPTION_ANTI_ALIASING
    31583178    FT_UInt  n;
    3159     FT_ULong c;
    3160 
    3161 
    3162     /* setup count table */
    3163     for ( n = 0; n < 256; n++ )
    3164     {
    3165       c = ( n & 0x55 ) + ( ( n & 0xAA ) >> 1 );
    3166 
    3167       c = ( ( c << 6 ) & 0x3000 ) |
    3168           ( ( c << 4 ) & 0x0300 ) |
    3169           ( ( c << 2 ) & 0x0030 ) |
    3170                    (c  & 0x0003 );
    3171 
    3172       ras.count_table[n] = (UInt)c;
    3173     }
    3174 
    3175 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
     3179
    31763180
    31773181    /* set default 5-levels gray palette */
     
    31793183      raster->grays[n] = n * 255 / 4;
    31803184
    3181     ras.gray_width = RASTER_GRAY_LINES / 2;
     3185    raster->gray_width = RASTER_GRAY_LINES / 2;
    31823186
    31833187#endif
     
    31963200                FT_Raster  *araster )
    31973201  {
    3198      static TRaster_Instance  the_raster;
     3202     static TRaster  the_raster;
    31993203
    32003204
     
    32193223
    32203224  static int
    3221   ft_black_new( FT_Memory           memory,
    3222                 TRaster_Instance**  araster )
    3223   {
    3224     FT_Error           error;
    3225     TRaster_Instance*  raster;
     3225  ft_black_new( FT_Memory   memory,
     3226                PRaster    *araster )
     3227  {
     3228    FT_Error  error;
     3229    PRaster   raster;
    32263230
    32273231
     
    32403244
    32413245  static void
    3242   ft_black_done( TRaster_Instance*  raster )
     3246  ft_black_done( PRaster  raster )
    32433247  {
    32443248    FT_Memory  memory = (FT_Memory)raster->memory;
     
    32513255
    32523256  static void
    3253   ft_black_reset( TRaster_Instance*  raster,
    3254                   char*              pool_base,
    3255                   long               pool_size )
    3256   {
    3257     if ( (&ras) && pool_base && pool_size >= 4096 )
    3258     {
    3259       /* save the pool */
    3260       ras.buff     = (PLong)pool_base;
    3261       ras.sizeBuff = ras.buff + pool_size / sizeof ( Long );
     3257  ft_black_reset( PRaster   raster,
     3258                  char*     pool_base,
     3259                  long      pool_size )
     3260  {
     3261    if ( raster )
     3262    {
     3263      if ( pool_base && pool_size >= (long)sizeof(TWorker) + 2048 )
     3264      {
     3265        PWorker  worker = (PWorker)pool_base;
     3266
     3267
     3268        raster->buffer      = pool_base + ( (sizeof ( *worker ) + 7 ) & ~7 );
     3269        raster->buffer_size = ( ( pool_base + pool_size ) -
     3270                                (char*)raster->buffer ) / sizeof ( Long );
     3271        raster->worker      = worker;
     3272      }
     3273      else
     3274      {
     3275        raster->buffer      = NULL;
     3276        raster->buffer_size = 0;
     3277        raster->worker      = NULL;
     3278      }
    32623279    }
    32633280  }
     
    32653282
    32663283  static void
    3267   ft_black_set_mode( TRaster_Instance*  raster,
     3284  ft_black_set_mode( PRaster            raster,
    32683285                     unsigned long      mode,
    32693286                     const char*        palette )
     
    32743291    {
    32753292      /* set 5-levels gray palette */
    3276       ras.grays[0] = palette[0];
    3277       ras.grays[1] = palette[1];
    3278       ras.grays[2] = palette[2];
    3279       ras.grays[3] = palette[3];
    3280       ras.grays[4] = palette[4];
     3293      raster->grays[0] = palette[0];
     3294      raster->grays[1] = palette[1];
     3295      raster->grays[2] = palette[2];
     3296      raster->grays[3] = palette[3];
     3297      raster->grays[4] = palette[4];
    32813298    }
    32823299
     
    32923309
    32933310  static int
    3294   ft_black_render( TRaster_Instance*        raster,
     3311  ft_black_render( PRaster                  raster,
    32953312                   const FT_Raster_Params*  params )
    32963313  {
    32973314    const FT_Outline*  outline    = (const FT_Outline*)params->source;
    32983315    const FT_Bitmap*   target_map = params->target;
    3299 
    3300 
    3301     if ( !(&ras) || !ras.buff || !ras.sizeBuff )
     3316    PWorker            worker;
     3317
     3318
     3319    if ( !raster || !raster->buffer || !raster->buffer_size )
    33023320      return Raster_Err_Not_Ini;
    33033321
     
    33123330      return Raster_Err_Invalid;
    33133331
     3332    worker = raster->worker;
     3333
    33143334    /* this version of the raster does not support direct rendering, sorry */
    33153335    if ( params->flags & FT_RASTER_FLAG_DIRECT )
     
    33213341    ras.outline  = *outline;
    33223342    ras.target   = *target_map;
     3343
     3344    worker->buff        = (PLong) raster->buffer;
     3345    worker->sizeBuff    = worker->buff +
     3346                            raster->buffer_size / sizeof ( Long );
     3347#ifdef FT_RASTER_OPTION_ANTI_ALIASING
     3348    worker->grays       = raster->grays;
     3349    worker->gray_width  = raster->gray_width;
     3350#endif
    33233351
    33243352    return ( ( params->flags & FT_RASTER_FLAG_AA )
  • trunk/poppler/freetype2/src/sfnt/sfdriver.c

    r150 r182  
    413413    FT_UNUSED( face );
    414414    FT_UNUSED( stream );
    415    
     415
    416416    return FT_Err_Unimplemented_Feature;
    417   }                         
     417  }
    418418
    419419
     
    450450    *astrike_index = 0x7FFFFFFFUL;
    451451
    452     return tt_face_set_sbit_strike( face, &req, astrike_index );   
    453   }                               
     452    return tt_face_set_sbit_strike( face, &req, astrike_index );
     453  }
    454454
    455455
     
    460460    FT_UNUSED( face );
    461461    FT_UNUSED( stream );
    462    
     462
    463463    /*
    464      *  This function was originally implemented to load the sbit table. 
     464     *  This function was originally implemented to load the sbit table.
    465465     *  However, it has been replaced by `tt_face_load_eblc', and this stub
    466466     *  is only there for some rogue clients which would want to call it
     
    468468     */
    469469    return FT_Err_Unimplemented_Feature;
    470   }                         
     470  }
    471471
    472472
     
    477477    FT_UNUSED( face );
    478478  }
    479  
    480  
     479
     480
    481481  FT_CALLBACK_DEF( FT_Error )
    482482  tt_face_load_charmap_stub( TT_Face    face,
     
    487487    FT_UNUSED( cmap );
    488488    FT_UNUSED( input );
    489    
     489
    490490    return FT_Err_Unimplemented_Feature;
    491   }                             
     491  }
    492492
    493493
     
    498498    FT_UNUSED( face );
    499499    FT_UNUSED( cmap );
    500    
     500
    501501    return 0;
    502   }                             
    503  
     502  }
     503
    504504#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
    505505
     
    601601    0,
    602602    0,
    603 #endif   
     603#endif
    604604
    605605    tt_face_get_metrics
  • trunk/poppler/freetype2/src/sfnt/sfobjs.c

    r165 r182  
    55/*    SFNT object management (base).                                       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    226226      case TT_MS_ID_UNICODE_CS:
    227227      case TT_MS_ID_SYMBOL_CS:
     228        convert = tt_name_entry_ascii_from_utf16;
     229        break;
     230
    228231      case TT_MS_ID_UCS_4:
     232        /* Apparently, if this value is found in a name table entry, it is */
     233        /* documented as `full Unicode repertoire'.  Experience with the   */
     234        /* MsGothic font shipped with Windows Vista shows that this really */
     235        /* means UTF-16 encoded names (UCS-4 values are only used within   */
     236        /* charmaps).                                                      */
    229237        convert = tt_name_entry_ascii_from_utf16;
    230238        break;
     
    894902
    895903
    896 #if defined FT_OPTIMIZE_MEMORY && !defined FT_CONFIG_OPTION_OLD_INTERNALS
     904#if !defined FT_CONFIG_OPTION_OLD_INTERNALS
    897905        count = face->sbit_num_strikes;
    898906#else
     
    10011009
    10021010    /* freeing the horizontal metrics */
    1003 #if defined FT_OPTIMIZE_MEMORY && !defined FT_CONFIG_OPTION_OLD_INTERNALS
     1011#if !defined FT_CONFIG_OPTION_OLD_INTERNALS
    10041012    {
    10051013      FT_Stream  stream = FT_FACE_STREAM( face );
  • trunk/poppler/freetype2/src/sfnt/ttcmap.c

    r165 r182  
    55/*    TrueType character mapping table (cmap) support (body).              */
    66/*                                                                         */
    7 /*  Copyright 2002, 2003, 2004, 2005, 2006 by                              */
     7/*  Copyright 2002, 2003, 2004, 2005, 2006, 2007 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    709709  {
    710710    FT_UInt  charcode;
    711    
     711
    712712
    713713    if ( cmap->cur_charcode >= 0xFFFFUL )
     
    863863      FT_UInt  last_start = 0, last_end = 0;
    864864      FT_Int   delta;
     865      FT_Byte*  p_start   = starts;
     866      FT_Byte*  p_end     = ends;
     867      FT_Byte*  p_delta   = deltas;
     868      FT_Byte*  p_offset  = offsets;
    865869
    866870
    867871      for ( n = 0; n < num_segs; n++ )
    868872      {
    869         p = starts + n * 2;
    870         start = TT_PEEK_USHORT( p );
    871         p = ends + n * 2;
    872         end = TT_PEEK_USHORT( p );
    873         p = deltas + n * 2;
    874         delta = TT_PEEK_SHORT( p );
    875         p = offsets + n * 2;
    876         offset = TT_PEEK_USHORT( p );
     873        p      = p_offset;
     874        start  = TT_NEXT_USHORT( p_start );
     875        end    = TT_NEXT_USHORT( p_end );
     876        delta  = TT_NEXT_SHORT( p_delta );
     877        offset = TT_NEXT_USHORT( p_offset );
    877878
    878879        if ( start > end )
     
    984985    {
    985986      FT_Byte*  q;
    986      
     987
    987988
    988989      p = cmap->data + 14;               /* ends table   */
     
    10401041    FT_UInt   gindex   = 0;
    10411042    FT_Byte*  p;
    1042    
     1043
    10431044
    10441045    p = cmap->data + 6;
  • trunk/poppler/freetype2/src/sfnt/ttkern.c

    r150 r182  
    66/*    kerning data within the GPOS table at the moment.                    */
    77/*                                                                         */
    8 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     8/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    4141#define TT_KERN_INDEX( g1, g2 )  ( ( (FT_ULong)(g1) << 16 ) | (g2) )
    4242
    43 
    44 #ifdef FT_OPTIMIZE_MEMORY
    4543
    4644  FT_LOCAL_DEF( FT_Error )
     
    290288  }
    291289
    292 #else /* !OPTIMIZE_MEMORY */
    293 
    294   FT_CALLBACK_DEF( int )
    295   tt_kern_pair_compare( const void*  a,
    296                         const void*  b );
    297 
    298 
    299   FT_LOCAL_DEF( FT_Error )
    300   tt_face_load_kern( TT_Face    face,
    301                      FT_Stream  stream )
    302   {
    303     FT_Error   error;
    304     FT_Memory  memory = stream->memory;
    305 
    306     FT_UInt    n, num_tables;
    307 
    308 
    309     /* the kern table is optional; exit silently if it is missing */
    310     error = face->goto_table( face, TTAG_kern, stream, 0 );
    311     if ( error )
    312       return SFNT_Err_Ok;
    313 
    314     if ( FT_FRAME_ENTER( 4L ) )
    315       goto Exit;
    316 
    317     (void)FT_GET_USHORT();         /* version */
    318     num_tables = FT_GET_USHORT();
    319 
    320     FT_FRAME_EXIT();
    321 
    322     for ( n = 0; n < num_tables; n++ )
    323     {
    324       FT_UInt  coverage;
    325       FT_UInt  length;
    326 
    327 
    328       if ( FT_FRAME_ENTER( 6L ) )
    329         goto Exit;
    330 
    331       (void)FT_GET_USHORT();           /* version                 */
    332       length   = FT_GET_USHORT() - 6;  /* substract header length */
    333       coverage = FT_GET_USHORT();
    334 
    335       FT_FRAME_EXIT();
    336 
    337       if ( coverage == 0x0001 )
    338       {
    339         FT_UInt        num_pairs;
    340         TT_Kern0_Pair  pair;
    341         TT_Kern0_Pair  limit;
    342 
    343 
    344         /* found a horizontal format 0 kerning table! */
    345         if ( FT_FRAME_ENTER( 8L ) )
    346           goto Exit;
    347 
    348         num_pairs = FT_GET_USHORT();
    349 
    350         /* skip the rest */
    351 
    352         FT_FRAME_EXIT();
    353 
    354         /* allocate array of kerning pairs */
    355         if ( FT_QNEW_ARRAY( face->kern_pairs, num_pairs ) ||
    356              FT_FRAME_ENTER( 6L * num_pairs )             )
    357           goto Exit;
    358 
    359         pair  = face->kern_pairs;
    360         limit = pair + num_pairs;
    361         for ( ; pair < limit; pair++ )
    362         {
    363           pair->left  = FT_GET_USHORT();
    364           pair->right = FT_GET_USHORT();
    365           pair->value = FT_GET_USHORT();
    366         }
    367 
    368         FT_FRAME_EXIT();
    369 
    370         face->num_kern_pairs   = num_pairs;
    371         face->kern_table_index = n;
    372 
    373         /* ensure that the kerning pair table is sorted (yes, some */
    374         /* fonts have unsorted tables!)                            */
    375 
    376         if ( num_pairs > 0 )
    377         {
    378           TT_Kern0_Pair  pair0 = face->kern_pairs;
    379           FT_ULong       prev  = TT_KERN_INDEX( pair0->left, pair0->right );
    380 
    381 
    382           for ( pair0++; pair0 < limit; pair0++ )
    383           {
    384             FT_ULong  next = TT_KERN_INDEX( pair0->left, pair0->right );
    385 
    386 
    387             if ( next < prev )
    388               goto SortIt;
    389 
    390             prev = next;
    391           }
    392           goto Exit;
    393 
    394         SortIt:
    395           ft_qsort( (void*)face->kern_pairs, (int)num_pairs,
    396                     sizeof ( TT_Kern0_PairRec ), tt_kern_pair_compare );
    397         }
    398 
    399         goto Exit;
    400       }
    401 
    402       if ( FT_STREAM_SKIP( length ) )
    403         goto Exit;
    404     }
    405 
    406     /* no kern table found -- doesn't matter */
    407     face->kern_table_index = -1;
    408     face->num_kern_pairs   = 0;
    409     face->kern_pairs       = NULL;
    410 
    411   Exit:
    412     return error;
    413   }
    414 
    415 
    416   FT_CALLBACK_DEF( int )
    417   tt_kern_pair_compare( const void*  a,
    418                         const void*  b )
    419   {
    420     TT_Kern0_Pair  pair1 = (TT_Kern0_Pair)a;
    421     TT_Kern0_Pair  pair2 = (TT_Kern0_Pair)b;
    422 
    423     FT_ULong  index1 = TT_KERN_INDEX( pair1->left, pair1->right );
    424     FT_ULong  index2 = TT_KERN_INDEX( pair2->left, pair2->right );
    425 
    426     return index1 < index2 ? -1
    427                            : ( index1 > index2 ? 1
    428                                                : 0 );
    429   }
    430 
    431 
    432   FT_LOCAL_DEF( void )
    433   tt_face_done_kern( TT_Face  face )
    434   {
    435     FT_Memory  memory = face->root.stream->memory;
    436 
    437 
    438     FT_FREE( face->kern_pairs );
    439     face->num_kern_pairs = 0;
    440   }
    441 
    442 
    443   FT_LOCAL_DEF( FT_Int )
    444   tt_face_get_kerning( TT_Face  face,
    445                        FT_UInt  left_glyph,
    446                        FT_UInt  right_glyph )
    447   {
    448     FT_Int         result = 0;
    449     TT_Kern0_Pair  pair;
    450 
    451 
    452     if ( face && face->kern_pairs )
    453     {
    454       /* there are some kerning pairs in this font file! */
    455       FT_ULong  search_tag = TT_KERN_INDEX( left_glyph, right_glyph );
    456       FT_Long   left, right;
    457 
    458 
    459       left  = 0;
    460       right = face->num_kern_pairs - 1;
    461 
    462       while ( left <= right )
    463       {
    464         FT_Long   middle = left + ( ( right - left ) >> 1 );
    465         FT_ULong  cur_pair;
    466 
    467 
    468         pair     = face->kern_pairs + middle;
    469         cur_pair = TT_KERN_INDEX( pair->left, pair->right );
    470 
    471         if ( cur_pair == search_tag )
    472           goto Found;
    473 
    474         if ( cur_pair < search_tag )
    475           left = middle + 1;
    476         else
    477           right = middle - 1;
    478       }
    479     }
    480 
    481   Exit:
    482     return result;
    483 
    484   Found:
    485     result = pair->value;
    486     goto Exit;
    487   }
    488 
    489 #endif /* !OPTIMIZE_MEMORY */
    490 
    491 
    492290#undef TT_KERN_INDEX
    493291
  • trunk/poppler/freetype2/src/sfnt/ttkern.h

    r150 r182  
    66/*    kerning data within the GPOS table at the moment.                    */
    77/*                                                                         */
    8 /*  Copyright 1996-2001, 2002, 2005 by                                     */
     8/*  Copyright 1996-2001, 2002, 2005, 2007 by                               */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    4242                       FT_UInt     right_glyph );
    4343
    44 #ifdef FT_OPTIMIZE_MEMORY
    45 #  define TT_FACE_HAS_KERNING( face )  ( (face)->kern_avail_bits != 0 )
    46 #else
    47 #  define TT_FACE_HAS_KERNING( face )  ( (face)->kern_pairs != NULL )
    48 #endif
     44#define TT_FACE_HAS_KERNING( face )  ( (face)->kern_avail_bits != 0 )
    4945
    5046
  • trunk/poppler/freetype2/src/sfnt/ttload.c

    r150 r182  
    66/*    TTF or OTF fonts (body).                                             */
    77/*                                                                         */
    8 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     8/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    11391139    FT_FRAME_EXIT();
    11401140
     1141    /* only support versions 0 and 1 of the table */
     1142    if ( face->gasp.version >= 2 )
     1143    {
     1144      face->gasp.numRanges = 0;
     1145      error = SFNT_Err_Invalid_Table;
     1146      goto Exit;
     1147    }
     1148
    11411149    num_ranges = face->gasp.numRanges;
    11421150    FT_TRACE3(( "numRanges: %u\n", num_ranges ));
  • trunk/poppler/freetype2/src/sfnt/ttmtx.c

    r165 r182  
    55/*    Load the metrics tables common to TTF and OTF fonts (body).          */
    66/*                                                                         */
    7 /*  Copyright 2006 by                                                      */
     7/*  Copyright 2006, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6161  /*    FreeType error code.  0 means success.                             */
    6262  /*                                                                       */
    63 #if defined FT_OPTIMIZE_MEMORY && !defined FT_CONFIG_OPTION_OLD_INTERNALS
     63#if !defined FT_CONFIG_OPTION_OLD_INTERNALS
    6464
    6565  FT_LOCAL_DEF( FT_Error )
     
    6969  {
    7070    FT_Error   error;
    71     FT_ULong   table_size;
    72     FT_Byte**  ptable;
     71    FT_ULong   tag, table_size;
     72    FT_ULong*  ptable_offset;
    7373    FT_ULong*  ptable_size;
    7474
     
    7676    if ( vertical )
    7777    {
    78       error = face->goto_table( face, TTAG_vmtx, stream, &table_size );
    79       if ( error )
    80         goto Fail;
    81 
    82       ptable      = &face->vert_metrics;
    83       ptable_size = &face->vert_metrics_size;
    84     }
    85     else
    86     {
    87       error = face->goto_table( face, TTAG_hmtx, stream, &table_size );
    88       if ( error )
    89         goto Fail;
    90 
    91       ptable      = &face->horz_metrics;
    92       ptable_size = &face->horz_metrics_size;
    93     }
    94 
    95     if ( FT_FRAME_EXTRACT( table_size, *ptable ) )
     78      tag           = TTAG_vmtx;
     79      ptable_offset = &face->vert_metrics_offset;
     80      ptable_size   = &face->vert_metrics_size;
     81    }
     82    else
     83    {
     84      tag           = TTAG_hmtx;
     85      ptable_offset = &face->horz_metrics_offset;
     86      ptable_size   = &face->horz_metrics_size;
     87    }
     88
     89    error = face->goto_table( face, tag, stream, &table_size );
     90    if ( error )
    9691      goto Fail;
    9792
    98     *ptable_size = table_size;
     93    *ptable_size   = table_size;
     94    *ptable_offset = FT_STREAM_POS();
    9995
    10096  Fail:
     
    335331  /*    advance :: The advance width resp. advance height.                 */
    336332  /*                                                                       */
    337 #if defined FT_OPTIMIZE_MEMORY && !defined FT_CONFIG_OPTION_OLD_INTERNALS
     333#if !defined FT_CONFIG_OPTION_OLD_INTERNALS
    338334
    339335  FT_LOCAL_DEF( FT_Error )
     
    344340                       FT_UShort  *aadvance )
    345341  {
     342    FT_Error        error;
     343    FT_Stream       stream = face->root.stream;
    346344    TT_HoriHeader*  header;
    347     FT_Byte*        p;
    348     FT_Byte*        limit;
     345    FT_ULong        table_pos, table_size, table_end;
    349346    FT_UShort       k;
    350347
     
    352349    if ( vertical )
    353350    {
    354       header = (TT_HoriHeader*)&face->vertical;
    355       p      = face->vert_metrics;
    356       limit  = p + face->vert_metrics_size;
    357     }
    358     else
    359     {
    360       header = &face->horizontal;
    361       p      = face->horz_metrics;
    362       limit  = p + face->horz_metrics_size;
    363     }
     351      header     = (TT_HoriHeader*)&face->vertical;
     352      table_pos  = face->vert_metrics_offset;
     353      table_size = face->vert_metrics_size;
     354    }
     355    else
     356    {
     357      header     = &face->horizontal;
     358      table_pos  = face->horz_metrics_offset;
     359      table_size = face->horz_metrics_size;
     360    }
     361
     362    table_end = table_pos + table_size;
    364363
    365364    k = header->number_Of_HMetrics;
     
    369368      if ( gindex < (FT_UInt)k )
    370369      {
    371         p += 4 * gindex;
    372         if ( p + 4 > limit )
     370        table_pos += 4 * gindex;
     371        if ( table_pos + 6 > table_end )
    373372          goto NoData;
    374373
    375         *aadvance = FT_NEXT_USHORT( p );
    376         *abearing = FT_NEXT_SHORT( p );
     374        if ( FT_STREAM_SEEK( table_pos ) ||
     375             FT_READ_USHORT( *aadvance)  ||
     376             FT_READ_SHORT( *abearing )  )
     377          goto NoData;
    377378      }
    378379      else
    379380      {
    380         p += 4 * ( k - 1 );
    381         if ( p + 4 > limit )
     381        table_pos += 4 * ( k - 1 );
     382        if ( table_pos + 4 > table_end )
    382383          goto NoData;
    383384
    384         *aadvance = FT_NEXT_USHORT( p );
    385         p += 2 + 2 * ( gindex - k );
    386         if ( p + 2 > limit )
     385        if ( FT_STREAM_SEEK( table_pos ) ||
     386             FT_READ_USHORT( *aadvance ) )
     387          goto NoData;
     388
     389        table_pos += 4 + 2 * ( gindex - k );
     390        if ( table_pos + 2 > table_end )
    387391          *abearing = 0;
    388392        else
    389           *abearing = FT_PEEK_SHORT( p );
     393        {
     394          if ( !FT_STREAM_SEEK( table_pos ) )
     395            (void)FT_READ_SHORT( *abearing );
     396        }
    390397      }
    391398    }
     
    400407  }
    401408
    402 #else /* !OPTIMIZE_MEMORY || OLD_INTERNALS */
     409#else /* OLD_INTERNALS */
    403410
    404411  FT_LOCAL_DEF( FT_Error )
  • trunk/poppler/freetype2/src/sfnt/ttsbit.c

    r165 r182  
    55/*    TrueType and OpenType embedded bitmap support (body).                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2525   *  the `old internals' hack
    2626   */
    27 #if defined FT_OPTIMIZE_MEMORY && !defined FT_CONFIG_OPTION_OLD_INTERNALS
     27#if !defined FT_CONFIG_OPTION_OLD_INTERNALS
    2828
    2929#include "ttsbit0.c"
    3030
    31 #else /* !OPTIMIZE_MEMORY || OLD_INTERNALS */
     31#else /* !FT_CONFIG_OPTION_OLD_INTERNALS */
    3232
    3333#include <ft2build.h>
     
    14961496  }
    14971497
    1498 #endif /* !OPTIMIZE_MEMORY || OLD_INTERNALS */
     1498#endif /* !FT_CONFIG_OPTION_OLD_INTERNALS */
    14991499
    15001500
  • trunk/poppler/freetype2/src/sfnt/ttsbit.h

    r150 r182  
    55/*    TrueType and OpenType embedded bitmap support (specification).       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    4646                               FT_Size_Metrics*  metrics );
    4747
    48 #if !defined FT_OPTIMIZE_MEMORY || defined FT_CONFIG_OPTION_OLD_INTERNALS
     48#if defined FT_CONFIG_OPTION_OLD_INTERNALS
    4949  FT_LOCAL( FT_Error )
    5050  tt_find_sbit_image( TT_Face          face,
     
    6060                        TT_SBit_Metrics  metrics );
    6161
    62 #endif /* !FT_OPTIMIZE_MEMORY || FT_CONFIG_OPTION_OLD_INTERNALS */
     62#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
    6363
    6464  FT_LOCAL( FT_Error )
  • trunk/poppler/freetype2/src/sfnt/ttsbit0.c

    r165 r182  
    66/*    This is a heap-optimized version.                                    */
    77/*                                                                         */
    8 /*  Copyright 2005, 2006 by                                                */
     8/*  Copyright 2005, 2006, 2007 by                                          */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    1818
    1919
     20/* This file is included by ttsbit.c */
     21
     22
    2023#include <ft2build.h>
    2124#include FT_INTERNAL_DEBUG_H
     
    181184  {
    182185    FT_Byte*         strike;
    183    
     186
    184187
    185188    if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
  • trunk/poppler/freetype2/src/smooth/ftgrays.c

    r165 r182  
    55/*    A new `perfect' anti-aliasing renderer (body).                       */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2003, 2005, 2006 by                         */
     7/*  Copyright 2000-2001, 2002, 2003, 2005, 2006, 2007 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    170170
    171171
    172 #define RAS_ARG   PRaster  raster
    173 #define RAS_ARG_  PRaster  raster,
    174 
    175 #define RAS_VAR   raster
    176 #define RAS_VAR_  raster,
    177 
    178 #define ras       (*raster)
     172#define RAS_ARG   PWorker  worker
     173#define RAS_ARG_  PWorker  worker,
     174
     175#define RAS_VAR   worker
     176#define RAS_VAR_  worker,
     177
     178#define ras       (*worker)
    179179
    180180
     
    187187#define RAS_VAR_  /* empty */
    188188
    189   static TRaster  ras;
     189  static TWorker  ras;
    190190
    191191
     
    261261
    262262
    263   typedef struct  TRaster_
     263  typedef struct  TWorker_
    264264  {
    265265    TCoord  ex, ey;
     
    300300    int  cubic_level;
    301301
    302     void*       memory;
    303302    ft_jmp_buf  jump_buffer;
    304303
     
    309308    int        ycount;
    310309
     310  } TWorker, *PWorker;
     311
     312
     313  typedef struct TRaster_
     314  {
     315    void*    buffer;
     316    long     buffer_size;
     317    int      band_size;
     318    void*    memory;
     319    PWorker  worker;
     320
    311321  } TRaster, *PRaster;
     322
    312323
    313324
     
    673684      ey1       += incr;
    674685
    675       gray_set_cell( raster, ex, ey1 );
     686      gray_set_cell( &ras, ex, ey1 );
    676687
    677688      delta = (int)( first + first - ONE_PIXEL );
     
    683694        ey1       += incr;
    684695
    685         gray_set_cell( raster, ex, ey1 );
     696        gray_set_cell( &ras, ex, ey1 );
    686697      }
    687698
     
    10451056  static int
    10461057  gray_move_to( const FT_Vector*  to,
    1047                 FT_Raster         raster )
     1058                PWorker           worker )
    10481059  {
    10491060    TPos  x, y;
     
    10511062
    10521063    /* record current cell, if any */
    1053     gray_record_cell( (PRaster)raster );
     1064    gray_record_cell( worker );
    10541065
    10551066    /* start to a new position */
     
    10571068    y = UPSCALE( to->y );
    10581069
    1059     gray_start_cell( (PRaster)raster, TRUNC( x ), TRUNC( y ) );
    1060 
    1061     ((PRaster)raster)->x = x;
    1062     ((PRaster)raster)->y = y;
     1070    gray_start_cell( worker, TRUNC( x ), TRUNC( y ) );
     1071
     1072    worker->x = x;
     1073    worker->y = y;
    10631074    return 0;
    10641075  }
     
    10671078  static int
    10681079  gray_line_to( const FT_Vector*  to,
    1069                 FT_Raster         raster )
    1070   {
    1071     gray_render_line( (PRaster)raster,
    1072                       UPSCALE( to->x ), UPSCALE( to->y ) );
     1080                PWorker           worker )
     1081  {
     1082    gray_render_line( worker, UPSCALE( to->x ), UPSCALE( to->y ) );
    10731083    return 0;
    10741084  }
     
    10781088  gray_conic_to( const FT_Vector*  control,
    10791089                 const FT_Vector*  to,
    1080                  FT_Raster         raster )
    1081   {
    1082     gray_render_conic( (PRaster)raster, control, to );
     1090                 PWorker           worker )
     1091  {
     1092    gray_render_conic( worker, control, to );
    10831093    return 0;
    10841094  }
     
    10891099                 const FT_Vector*  control2,
    10901100                 const FT_Vector*  to,
    1091                  FT_Raster         raster )
    1092   {
    1093     gray_render_cubic( (PRaster)raster, control1, control2, to );
     1101                 PWorker           worker )
     1102  {
     1103    gray_render_cubic( worker, control1, control2, to );
    10941104    return 0;
    10951105  }
     
    11001110                    int             count,
    11011111                    const FT_Span*  spans,
    1102                     PRaster         raster )
     1112                    PWorker         worker )
    11031113  {
    11041114    unsigned char*  p;
    1105     FT_Bitmap*      map = &raster->target;
     1115    FT_Bitmap*      map = &worker->target;
    11061116
    11071117
     
    17671777    const FT_Outline*  outline    = (const FT_Outline*)params->source;
    17681778    const FT_Bitmap*   target_map = params->target;
     1779    PWorker            worker;
    17691780
    17701781
     
    17821793           outline->contours[outline->n_contours - 1] + 1 )
    17831794      return ErrRaster_Invalid_Outline;
     1795
     1796    worker = raster->worker;
    17841797
    17851798    /* if direct mode is not set, we must have a target bitmap */
     
    18221835    }
    18231836
     1837    gray_init_cells( worker, raster->buffer, raster->buffer_size );
     1838
    18241839    ras.outline   = *outline;
    18251840    ras.num_cells = 0;
    18261841    ras.invalid   = 1;
     1842    ras.band_size = raster->band_size;
     1843    ras.num_gray_spans = 0;
    18271844
    18281845    if ( target_map )
     
    18381855    }
    18391856
    1840     return gray_convert_glyph( (PRaster)raster );
     1857    return gray_convert_glyph( worker );
    18411858  }
    18421859
     
    19111928
    19121929
    1913     if ( raster && pool_base && pool_size >= 4096 )
    1914       gray_init_cells( rast, (char*)pool_base, pool_size );
    1915 
    1916     rast->band_size  = (int)( ( pool_size / sizeof ( TCell ) ) / 8 );
     1930    if ( raster )
     1931    {
     1932      if ( pool_base && pool_size >= (long)sizeof ( TWorker ) + 2048 )
     1933      {
     1934        PWorker  worker = (PWorker)pool_base;
     1935
     1936
     1937        rast->worker      = worker;
     1938        rast->buffer      = pool_base +
     1939                              ( ( sizeof ( TWorker ) + sizeof ( TCell ) - 1 ) &
     1940                                ~( sizeof ( TCell ) - 1 ) );
     1941        rast->buffer_size = (long)( ( pool_base + pool_size ) -
     1942                                    (char*)rast->buffer ) &
     1943                                      ~( sizeof ( TCell ) - 1 );
     1944        rast->band_size   = (int)( rast->buffer_size /
     1945                                     ( sizeof ( TCell ) * 8 ) );
     1946      }
     1947      else
     1948      {
     1949        rast->buffer      = NULL;
     1950        rast->buffer_size = 0;
     1951        rast->worker      = NULL;
     1952      }
     1953    }
    19171954  }
    19181955
  • trunk/poppler/freetype2/src/truetype/ttdriver.c

    r165 r182  
    55/*    TrueType font driver implementation (body).                          */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    188188      TT_Face       ttface = (TT_Face)size->face;
    189189      SFNT_Service  sfnt   = (SFNT_Service) ttface->sfnt;
    190       FT_ULong      index;
    191 
    192 
    193       error = sfnt->set_sbit_strike( ttface, req, &index );
     190      FT_ULong      strike_index;
     191
     192
     193      error = sfnt->set_sbit_strike( ttface, req, &strike_index );
    194194
    195195      if ( error )
    196196        ttsize->strike_index = 0xFFFFFFFFUL;
    197197      else
    198         return tt_size_select( size, index );
     198        return tt_size_select( size, strike_index );
    199199    }
    200200
  • trunk/poppler/freetype2/src/truetype/ttgload.c

    r165 r182  
    55/*    TrueType Glyph Loader (body).                                        */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    644644      loader->exec->pts          = *zone;
    645645
    646       debug = !( loader->load_flags & FT_LOAD_NO_SCALE ) &&
    647               ( (TT_Size)loader->size )->debug;
     646      debug = FT_BOOL( !( loader->load_flags & FT_LOAD_NO_SCALE ) &&
     647                       ((TT_Size)loader->size)->debug             );
    648648
    649649      error = TT_Run_Context( loader->exec, debug );
     
    17191719
    17201720    /* load execution context */
     1721    if ( IS_HINTED( load_flags ) )
    17211722    {
    17221723      TT_ExecContext  exec;
    17231724      FT_Bool         grayscale;
    17241725
     1726
     1727      if ( !size->cvt_ready )
     1728      {
     1729        FT_Error  error = tt_size_ready_bytecode( size );
     1730        if ( error )
     1731          return error;
     1732      }
    17251733
    17261734      /* query new execution context */
  • trunk/poppler/freetype2/src/truetype/ttgxvar.h

    r150 r182  
    3333  /*    GX_AVarCorrespondenceRec                                           */
    3434  /*                                                                       */
    35   /* <Description>                                                         */ 
     35  /* <Description>                                                         */
    3636  /*    A data structure representing `shortFracCorrespondence' in `avar'  */
    3737  /*    table according to the specifications from Apple.                  */
     
    9595    FT_UInt         gv_glyphcnt;
    9696    FT_ULong*       glyphoffsets;
    97    
     97
    9898  } GX_BlendRec;
    9999
  • trunk/poppler/freetype2/src/truetype/ttinterp.c

    r165 r182  
    55/*    TrueType bytecode interpreter (body).                                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    511511              FT_ULong*  size,
    512512              FT_Long    multiplier,
    513               void**     buff,
     513              void*      _pbuff,
    514514              FT_ULong   new_max )
    515515  {
    516516    FT_Error  error;
     517    void**    pbuff = (void**)_pbuff;
    517518
    518519
    519520    if ( *size < new_max )
    520521    {
    521       if ( FT_REALLOC( *buff, *size * multiplier, new_max * multiplier ) )
     522      if ( FT_REALLOC( *pbuff, *size * multiplier, new_max * multiplier ) )
    522523        return error;
    523524      *size = new_max;
     
    600601                        &tmp,
    601602                        sizeof ( FT_F26Dot6 ),
    602                         (void**)&exec->stack,
     603                        (void*)&exec->stack,
    603604                        maxp->maxStackElements + 32 );
    604605    exec->stackSize = (FT_UInt)tmp;
     
    610611                        &tmp,
    611612                        sizeof ( FT_Byte ),
    612                         (void**)&exec->glyphIns,
     613                        (void*)&exec->glyphIns,
    613614                        maxp->maxSizeOfInstructions );
    614615    exec->glyphSize = (FT_UShort)tmp;
     
    52495250      if ( CUR.pedantic_hinting )
    52505251        CUR.error = TT_Err_Invalid_Reference;
     5252      *refp = 0;
    52515253      return FAILURE;
    52525254    }
     
    54165418                                 CUR.pts.first_point );
    54175419
    5418     last_point = CUR.pts.contours[contour] - CUR.pts.first_point;
     5420    last_point = (FT_UShort)( CUR.pts.contours[contour] -
     5421                              CUR.pts.first_point );
    54195422
    54205423    /* XXX: this is probably wrong... at least it prevents memory */
  • trunk/poppler/freetype2/src/truetype/ttobjs.c

    r165 r182  
    55/*    Objects manager (body).                                              */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    293293      }
    294294
    295       ttface->internal->ignore_unpatented_hinter = !unpatented_hinting;
     295      ttface->internal->ignore_unpatented_hinter =
     296        FT_BOOL( !unpatented_hinting );
    296297    }
    297298
     
    520521
    521522
    522   /*************************************************************************/
    523   /*                                                                       */
    524   /* <Function>                                                            */
    525   /*    tt_size_init                                                       */
    526   /*                                                                       */
    527   /* <Description>                                                         */
    528   /*    Initialize a new TrueType size object.                             */
    529   /*                                                                       */
    530   /* <InOut>                                                               */
    531   /*    size :: A handle to the size object.                               */
    532   /*                                                                       */
    533   /* <Return>                                                              */
    534   /*    FreeType error code.  0 means success.                             */
    535   /*                                                                       */
    536   FT_LOCAL_DEF( FT_Error )
    537   tt_size_init( FT_Size  ttsize )           /* TT_Size */
    538   {
    539     TT_Size   size  = (TT_Size)ttsize;
    540     FT_Error  error = TT_Err_Ok;
    541 
    542523#ifdef TT_USE_BYTECODE_INTERPRETER
    543524
    544     TT_Face    face   = (TT_Face)size->root.face;
     525  static void
     526  tt_size_done_bytecode( FT_Size  ftsize )
     527  {
     528    TT_Size    size   = (TT_Size)ftsize;
     529    TT_Face    face   = (TT_Face)ftsize->face;
     530    FT_Memory  memory = face->root.memory;
     531
     532
     533    if ( size->debug )
     534    {
     535      /* the debug context must be deleted by the debugger itself */
     536      size->context = NULL;
     537      size->debug   = FALSE;
     538    }
     539
     540    FT_FREE( size->cvt );
     541    size->cvt_size = 0;
     542
     543    /* free storage area */
     544    FT_FREE( size->storage );
     545    size->storage_size = 0;
     546
     547    /* twilight zone */
     548    tt_glyphzone_done( &size->twilight );
     549
     550    FT_FREE( size->function_defs );
     551    FT_FREE( size->instruction_defs );
     552
     553    size->num_function_defs    = 0;
     554    size->max_function_defs    = 0;
     555    size->num_instruction_defs = 0;
     556    size->max_instruction_defs = 0;
     557
     558    size->max_func = 0;
     559    size->max_ins  = 0;
     560
     561    size->bytecode_ready = 0;
     562    size->cvt_ready      = 0;
     563  }
     564
     565
     566  /* Initialize bytecode-related fields in the size object.       */
     567  /* We do this only if bytecode interpretation is really needed. */
     568  static FT_Error
     569  tt_size_init_bytecode( FT_Size  ftsize )
     570  {
     571    FT_Error   error;
     572    TT_Size    size = (TT_Size)ftsize;
     573    TT_Face    face = (TT_Face)ftsize->face;
    545574    FT_Memory  memory = face->root.memory;
    546575    FT_Int     i;
     
    549578    TT_MaxProfile*  maxp = &face->max_profile;
    550579
     580
     581    size->bytecode_ready = 1;
     582    size->cvt_ready      = 0;
    551583
    552584    size->max_function_defs    = maxp->maxFunctionDefs;
     
    584616         FT_NEW_ARRAY( size->cvt,              size->cvt_size             ) ||
    585617         FT_NEW_ARRAY( size->storage,          size->storage_size         ) )
    586     {
    587       tt_size_done( ttsize );
    588 
    589       return error;
    590     }
     618      goto Exit;
    591619
    592620    /* reserve twilight zone */
     
    598626    error = tt_glyphzone_new( memory, n_twilight, 0, &size->twilight );
    599627    if ( error )
    600     {
    601       tt_size_done( ttsize );
    602 
    603       return error;
    604     }
     628      goto Exit;
    605629
    606630    size->twilight.n_points = n_twilight;
     
    622646    error = tt_size_run_fpgm( size );
    623647
     648  Exit:
    624649    if ( error )
    625       tt_size_done( ttsize );
    626 
    627 #endif /* TT_USE_BYTECODE_INTERPRETER */
     650      tt_size_done_bytecode( ftsize );
     651
     652    return error;
     653  }
     654
     655
     656  FT_LOCAL_DEF( FT_Error )
     657  tt_size_ready_bytecode( TT_Size  size )
     658  {
     659    FT_Error  error = TT_Err_Ok;
     660
     661
     662    if ( !size->bytecode_ready )
     663    {
     664      error = tt_size_init_bytecode( (FT_Size)size );
     665      if ( error )
     666        goto Exit;
     667    }
     668
     669    /* rescale CVT when needed */
     670    if ( !size->cvt_ready )
     671    {
     672      FT_UInt  i;
     673      TT_Face  face = (TT_Face) size->root.face;
     674
     675
     676      /* Scale the cvt values to the new ppem.          */
     677      /* We use by default the y ppem to scale the CVT. */
     678      for ( i = 0; i < size->cvt_size; i++ )
     679        size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
     680
     681      /* all twilight points are originally zero */
     682      for ( i = 0; i < (FT_UInt)size->twilight.n_points; i++ )
     683      {
     684        size->twilight.org[i].x = 0;
     685        size->twilight.org[i].y = 0;
     686        size->twilight.cur[i].x = 0;
     687        size->twilight.cur[i].y = 0;
     688      }
     689
     690      /* clear storage area */
     691      for ( i = 0; i < (FT_UInt)size->storage_size; i++ )
     692        size->storage[i] = 0;
     693
     694      size->GS = tt_default_graphics_state;
     695
     696      error = tt_size_run_prep( size );
     697    }
     698  Exit:
     699    return error;
     700  }
     701
     702#else /* !TT_USE_BYTECODE_INTERPRETER */
     703
     704  FT_LOCAL_DEF( FT_Error )
     705  tt_size_ready_bytecode( TT_Size  size )
     706  {
     707    FT_UNUSED( ftsize );
     708    return 0;
     709  }
     710
     711#endif /* !TT_USE_BYTECODE_INTERPRETER */
     712
     713
     714  /*************************************************************************/
     715  /*                                                                       */
     716  /* <Function>                                                            */
     717  /*    tt_size_init                                                       */
     718  /*                                                                       */
     719  /* <Description>                                                         */
     720  /*    Initialize a new TrueType size object.                             */
     721  /*                                                                       */
     722  /* <InOut>                                                               */
     723  /*    size :: A handle to the size object.                               */
     724  /*                                                                       */
     725  /* <Return>                                                              */
     726  /*    FreeType error code.  0 means success.                             */
     727  /*                                                                       */
     728  FT_LOCAL_DEF( FT_Error )
     729  tt_size_init( FT_Size  ttsize )           /* TT_Size */
     730  {
     731    TT_Size   size  = (TT_Size)ttsize;
     732    FT_Error  error = TT_Err_Ok;
     733
     734#ifdef TT_USE_BYTECODE_INTERPRETER
     735    size->bytecode_ready = 0;
     736    size->cvt_ready      = 0;
     737#endif
    628738
    629739    size->ttmetrics.valid = FALSE;
     
    648758  tt_size_done( FT_Size  ttsize )           /* TT_Size */
    649759  {
    650     TT_Size    size = (TT_Size)ttsize;
     760    TT_Size  size = (TT_Size)ttsize;
     761
    651762
    652763#ifdef TT_USE_BYTECODE_INTERPRETER
    653 
    654     FT_Memory  memory = size->root.face->memory;
    655 
    656 
    657     if ( size->debug )
    658     {
    659       /* the debug context must be deleted by the debugger itself */
    660       size->context = NULL;
    661       size->debug   = FALSE;
    662     }
    663 
    664     FT_FREE( size->cvt );
    665     size->cvt_size = 0;
    666 
    667     /* free storage area */
    668     FT_FREE( size->storage );
    669     size->storage_size = 0;
    670 
    671     /* twilight zone */
    672     tt_glyphzone_done( &size->twilight );
    673 
    674     FT_FREE( size->function_defs );
    675     FT_FREE( size->instruction_defs );
    676 
    677     size->num_function_defs    = 0;
    678     size->max_function_defs    = 0;
    679     size->num_instruction_defs = 0;
    680     size->max_instruction_defs = 0;
    681 
    682     size->max_func = 0;
    683     size->max_ins  = 0;
    684 
     764    if ( size->bytecode_ready )
     765      tt_size_done_bytecode( ttsize );
    685766#endif
    686767
     
    763844    }
    764845
    765 
    766846#ifdef TT_USE_BYTECODE_INTERPRETER
    767 
    768     {
    769       FT_UInt  i;
    770 
    771 
    772       /* Scale the cvt values to the new ppem.          */
    773       /* We use by default the y ppem to scale the CVT. */
    774       for ( i = 0; i < size->cvt_size; i++ )
    775         size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
    776 
    777       /* All twilight points are originally zero */
    778       for ( i = 0; i < (FT_UInt)size->twilight.n_points; i++ )
    779       {
    780         size->twilight.org[i].x = 0;
    781         size->twilight.org[i].y = 0;
    782         size->twilight.cur[i].x = 0;
    783         size->twilight.cur[i].y = 0;
    784       }
    785 
    786       /* clear storage area */
    787       for ( i = 0; i < (FT_UInt)size->storage_size; i++ )
    788         size->storage[i] = 0;
    789 
    790       size->GS = tt_default_graphics_state;
    791 
    792       error = tt_size_run_prep( size );
    793     }
    794 
     847    size->cvt_ready = 0;
    795848#endif /* TT_USE_BYTECODE_INTERPRETER */
    796849
  • trunk/poppler/freetype2/src/truetype/ttobjs.h

    r165 r182  
    55/*    Objects manager (specification).                                     */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    359359    TT_ExecContext     context;
    360360
     361    FT_Bool            bytecode_ready;
     362    FT_Bool            cvt_ready;
     363
    361364#endif /* TT_USE_BYTECODE_INTERPRETER */
    362365
     
    426429  tt_size_reset( TT_Size  size );
    427430
     431  FT_LOCAL( FT_Error )
     432  tt_size_ready_bytecode( TT_Size  size );
     433
    428434
    429435  /*************************************************************************/
  • trunk/poppler/freetype2/src/truetype/ttpload.c

    r165 r182  
    55/*    TrueType-specific tables loader (body).                              */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2004, 2005, 2006 by                         */
     7/*  Copyright 1996-2001, 2002, 2004, 2005, 2006, 2007 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5959  /*    FreeType error code.  0 means success.                             */
    6060  /*                                                                       */
    61 #ifdef FT_OPTIMIZE_MEMORY
    6261
    6362  FT_LOCAL_DEF( FT_Error )
     
    184183
    185184
    186 #else /* !FT_OPTIMIZE_MEMORY */
    187 
    188 
    189   FT_LOCAL_DEF( FT_Error )
    190   tt_face_load_loca( TT_Face    face,
    191                      FT_Stream  stream )
    192   {
    193     FT_Error   error;
    194     FT_Memory  memory = stream->memory;
    195     FT_Short   LongOffsets;
    196     FT_ULong   table_len;
    197 
    198 
    199     /* we need the size of the `glyf' table for malformed `loca' tables */
    200     error = face->goto_table( face, TTAG_glyf, stream, &face->glyf_len );
    201     if ( error )
    202       goto Exit;
    203 
    204     FT_TRACE2(( "Locations " ));
    205     LongOffsets = face->header.Index_To_Loc_Format;
    206 
    207     error = face->goto_table( face, TTAG_loca, stream, &table_len );
    208     if ( error )
    209     {
    210       error = TT_Err_Locations_Missing;
    211       goto Exit;
    212     }
    213 
    214     if ( LongOffsets != 0 )
    215     {
    216       face->num_locations = (FT_UShort)( table_len >> 2 );
    217 
    218       FT_TRACE2(( "(32bit offsets): %12d ", face->num_locations ));
    219 
    220       if ( FT_NEW_ARRAY( face->glyph_locations, face->num_locations ) )
    221         goto Exit;
    222 
    223       if ( FT_FRAME_ENTER( face->num_locations * 4L ) )
    224         goto Exit;
    225 
    226       {
    227         FT_Long*  loc   = face->glyph_locations;
    228         FT_Long*  limit = loc + face->num_locations;
    229 
    230 
    231         for ( ; loc < limit; loc++ )
    232           *loc = FT_GET_LONG();
    233       }
    234 
    235       FT_FRAME_EXIT();
    236     }
    237     else
    238     {
    239       face->num_locations = (FT_UShort)( table_len >> 1 );
    240 
    241       FT_TRACE2(( "(16bit offsets): %12d ", face->num_locations ));
    242 
    243       if ( FT_NEW_ARRAY( face->glyph_locations, face->num_locations ) )
    244         goto Exit;
    245 
    246       if ( FT_FRAME_ENTER( face->num_locations * 2L ) )
    247         goto Exit;
    248 
    249       {
    250         FT_Long*  loc   = face->glyph_locations;
    251         FT_Long*  limit = loc + face->num_locations;
    252 
    253 
    254         for ( ; loc < limit; loc++ )
    255           *loc = (FT_Long)( (FT_ULong)FT_GET_USHORT() * 2 );
    256       }
    257 
    258       FT_FRAME_EXIT();
    259     }
    260 
    261     FT_TRACE2(( "loaded\n" ));
    262 
    263   Exit:
    264     return error;
    265   }
    266 
    267 
    268   FT_LOCAL_DEF( FT_ULong )
    269   tt_face_get_location( TT_Face   face,
    270                         FT_UInt   gindex,
    271                         FT_UInt  *asize )
    272   {
    273     FT_ULong  offset;
    274     FT_UInt   count;
    275 
    276 
    277     offset = face->glyph_locations[gindex];
    278     count  = 0;
    279 
    280     if ( gindex < (FT_UInt)face->num_locations - 1 )
    281     {
    282       FT_ULong  offset1 = face->glyph_locations[gindex + 1];
    283 
    284 
    285       /* It isn't mentioned explicitly that the `loca' table must be  */
    286       /* ordered, but implicitly it refers to the length of an entry  */
    287       /* as the difference between the current and the next position. */
    288       /* Anyway, there do exist (malformed) fonts which don't obey    */
    289       /* this rule, so we are only able to provide an upper bound for */
    290       /* the size.                                                    */
    291       if ( offset1 >= offset )
    292         count = (FT_UInt)( offset1 - offset );
    293       else
    294         count = (FT_UInt)( face->glyf_len - offset );
    295     }
    296 
    297     *asize = count;
    298     return offset;
    299   }
    300 
    301 
    302   FT_LOCAL_DEF( void )
    303   tt_face_done_loca( TT_Face  face )
    304   {
    305     FT_Memory  memory = face->root.memory;
    306 
    307 
    308     FT_FREE( face->glyph_locations );
    309     face->num_locations = 0;
    310   }
    311 
    312 
    313 #endif /* !FT_OPTIMIZE_MEMORY */
    314 
    315185
    316186  /*************************************************************************/
     
    534404  /*    FreeType error code.  0 means success.                             */
    535405  /*                                                                       */
    536 #ifdef FT_OPTIMIZE_MEMORY
    537406
    538407  FT_LOCAL_DEF( FT_Error )
     
    622491  }
    623492
    624 #else /* !FT_OPTIMIZE_MEMORY */
    625 
    626   FT_LOCAL_DEF( FT_Error )
    627   tt_face_load_hdmx( TT_Face    face,
    628                      FT_Stream  stream )
    629   {
    630     FT_Error   error;
    631     FT_Memory  memory = stream->memory;
    632 
    633     TT_Hdmx    hdmx = &face->hdmx;
    634     FT_Short   num_records;
    635     FT_Long    num_glyphs;
    636     FT_Long    record_size;
    637 
    638 
    639     hdmx->version     = 0;
    640     hdmx->num_records = 0;
    641     hdmx->records     = 0;
    642 
    643     /* this table is optional */
    644     error = face->goto_table( face, TTAG_hdmx, stream, 0 );
    645     if ( error )
    646       return TT_Err_Ok;
    647 
    648     if ( FT_FRAME_ENTER( 8L ) )
    649       goto Exit;
    650 
    651     hdmx->version = FT_GET_USHORT();
    652     num_records   = FT_GET_SHORT();
    653     record_size   = FT_GET_LONG();
    654 
    655     FT_FRAME_EXIT();
    656 
    657     /* The maximum number of bytes in an hdmx device record is the */
    658     /* maximum number of glyphs + 2; this is 0xFFFF + 2; this is   */
    659     /* the reason why `record_size' is a long.  In practice, two   */
    660     /* bytes sufficient to hold the size value.                    */
    661     /*                                                             */
    662     /* There are at least two fonts, HANNOM-A and HANNOM-B version */
    663     /* 2.0 (2005), which get this wrong: The upper two bytes of    */
    664     /* the size value are set to 0xFF instead of 0x00.  We catch   */
    665     /* and fix this.                                               */
    666 
    667     if ( (FT_ULong)record_size >= 0xFFFF0000UL )
    668       record_size = (FT_Long)( (FT_ULong)record_size & 0xFFFFU );
    669 
    670     if ( record_size < 0 || num_records < 0 )
    671       return TT_Err_Invalid_File_Format;
    672 
    673     /* Only recognize format 0 */
    674     if ( hdmx->version != 0 )
    675       return TT_Err_Invalid_File_Format;
    676 
    677     /* we can't use FT_QNEW_ARRAY here; otherwise tt_face_free_hdmx */
    678     /* could fail during deallocation                               */
    679     if ( FT_NEW_ARRAY( hdmx->records, num_records ) )
    680       goto Exit;
    681 
    682     hdmx->num_records = num_records;
    683     num_glyphs        = face->root.num_glyphs;
    684     record_size      -= num_glyphs + 2;
    685 
    686     {
    687       TT_HdmxEntry  cur   = hdmx->records;
    688       TT_HdmxEntry  limit = cur + hdmx->num_records;
    689 
    690 
    691       for ( ; cur < limit; cur++ )
    692       {
    693         /* read record */
    694         if ( FT_READ_BYTE( cur->ppem      ) ||
    695              FT_READ_BYTE( cur->max_width ) )
    696           goto Exit;
    697 
    698         if ( FT_QALLOC( cur->widths, num_glyphs )      ||
    699              FT_STREAM_READ( cur->widths, num_glyphs ) )
    700           goto Exit;
    701 
    702         /* skip padding bytes */
    703         if ( record_size > 0 && FT_STREAM_SKIP( record_size ) )
    704           goto Exit;
    705       }
    706     }
    707 
    708   Exit:
    709     return error;
    710   }
    711 
    712 
    713   FT_LOCAL_DEF( void )
    714   tt_face_free_hdmx( TT_Face  face )
    715   {
    716     if ( face )
    717     {
    718       FT_Int     n;
    719       FT_Memory  memory = face->root.driver->root.memory;
    720 
    721 
    722       for ( n = 0; n < face->hdmx.num_records; n++ )
    723         FT_FREE( face->hdmx.records[n].widths );
    724 
    725       FT_FREE( face->hdmx.records );
    726       face->hdmx.num_records = 0;
    727     }
    728   }
    729 
    730 #endif /* !OPTIMIZE_MEMORY */
    731 
    732493
    733494  /*************************************************************************/
     
    741502                              FT_UInt  gindex )
    742503  {
    743 #ifdef FT_OPTIMIZE_MEMORY
    744 
    745504    FT_UInt   nn;
    746505    FT_Byte*  result      = NULL;
     
    759518
    760519    return result;
    761 
    762 #else
    763 
    764     FT_UShort  n;
    765 
    766 
    767     for ( n = 0; n < face->hdmx.num_records; n++ )
    768       if ( face->hdmx.records[n].ppem == ppem )
    769         return &face->hdmx.records[n].widths[gindex];
    770 
    771     return NULL;
    772 
    773 #endif
    774520  }
    775521
  • trunk/poppler/freetype2/src/type1/t1afm.c

    r165 r182  
    55/*    AFM support for Type 1 fonts (body).                                 */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    266266
    267267
     268      /* MS Windows allows versions up to 0x3FF without complaining */
    268269      if ( stream->size > 6                              &&
    269            start[0] == 0x00 && start[1] == 0x01          &&
     270           start[1] < 4                                  &&
    270271           FT_PEEK_ULONG_LE( start + 2 ) == stream->size )
    271272        error = T1_Read_PFM( t1_face, stream, fi );
  • trunk/poppler/freetype2/src/type1/t1load.c

    r165 r182  
    55/*    Type 1 font loader (body).                                           */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    356356
    357357      for ( i = 0; i < mmaster.num_axis; ++i )
    358         mmvar->axis[i].def = mm_axis_unmap( &blend->design_map[i],
    359                                             axiscoords[i] );
     358        mmvar->axis[i].def =
     359          FT_INT_TO_FIXED( mm_axis_unmap( &blend->design_map[i],
     360                                          axiscoords[i] ) );
    360361    }
    361362
     
    10111012
    10121013    loader->keywords_encountered |= T1_PRIVATE;
    1013   }
    1014 
    1015 
    1016   static int
    1017   is_space( FT_Byte  c )
    1018   {
    1019     return ( c == ' '  || c == '\t'              ||
    1020              c == '\r' || c == '\n' || c == '\f' ||
    1021              c == '\0'                           );
    10221014  }
    10231015
     
    12061198        if ( *cur == 'd' && cur + 3 < limit )
    12071199        {
    1208           if ( cur[1] == 'e'      &&
    1209                cur[2] == 'f'      &&
    1210                is_space( cur[3] ) )
     1200          if ( cur[1] == 'e'         &&
     1201               cur[2] == 'f'         &&
     1202               IS_PS_DELIM( cur[3] ) )
    12111203          {
    12121204            FT_TRACE6(( "encoding end\n" ));
     
    14881480
    14891481      /* we stop when we find a `def' or `end' keyword */
    1490       if ( cur + 3 < limit && is_space( cur[3] ) )
     1482      if ( cur + 3 < limit && IS_PS_DELIM( cur[3] ) )
    14911483      {
    14921484        if ( cur[0] == 'd' &&
  • trunk/poppler/freetype2/src/type1/t1objs.h

    r150 r182  
    153153  FT_LOCAL( FT_Error )
    154154  T1_GlyphSlot_Init( T1_GlyphSlot  slot );
    155  
     155
    156156  FT_LOCAL( void )
    157157  T1_GlyphSlot_Done( T1_GlyphSlot  slot );
  • trunk/poppler/freetype2/src/type1/t1parse.c

    r150 r182  
    106106    if ( FT_STREAM_SEEK( 0 ) )
    107107      goto Exit;
    108      
     108
    109109    error = read_pfb_tag( stream, &tag, &size );
    110110    if ( error )
    111111      goto Exit;
    112      
     112
    113113    if ( tag != 0x8001U && FT_STREAM_SEEK( 0 ) )
    114114      goto Exit;
    115      
     115
    116116    if ( !FT_FRAME_ENTER( header_length ) )
    117117    {
    118118      error = 0;
    119      
     119
    120120      if ( ft_memcmp( stream->cursor, header_string, header_length ) != 0 )
    121121        error = T1_Err_Unknown_File_Format;
  • trunk/poppler/freetype2/src/type42/t42objs.h

    r150 r182  
    55/*    Type 42 objects manager (specification).                             */
    66/*                                                                         */
    7 /*  Copyright 2002, 2003, 2006 by Roberto Alameda.                         */
     7/*  Copyright 2002, 2003, 2006, 2007 by Roberto Alameda.                   */
    88/*                                                                         */
    99/*  This file is part of the FreeType project, and may only be used,       */
     
    8787  FT_LOCAL( FT_Error )
    8888  T42_Size_Select( T42_Size  size,
    89                    FT_ULong  index );
     89                   FT_ULong  strike_index );
    9090
    9191
Note: See TracChangeset for help on using the changeset viewer.