Ignore:
Timestamp:
Jun 30, 2008, 6:26:14 PM (13 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: freetype library updated to version 2.3.5

Location:
trunk/poppler/freetype2/src
Files:
2 added
73 edited

Legend:

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

    r209 r251  
    4646  /*************************************************************************/
    4747
    48   static FT_Error
     48  FT_LOCAL_DEF( FT_Error )
    4949  af_cjk_metrics_init( AF_LatinMetrics  metrics,
    5050                       FT_Face          face )
     
    9292
    9393
    94   static void
     94  FT_LOCAL_DEF( void )
    9595  af_cjk_metrics_scale( AF_LatinMetrics  metrics,
    9696                        AF_Scaler        scaler )
     
    428428        /* insert a new edge in the list and */
    429429        /* sort according to the position    */
    430         error = af_axis_hints_new_edge( axis, seg->pos, seg->dir, memory, &edge );
     430        error = af_axis_hints_new_edge( axis, seg->pos,
     431                                        (AF_Direction)seg->dir,
     432                                        memory, &edge );
    431433        if ( error )
    432434          goto Exit;
     
    597599
    598600
    599   static FT_Error
     601  FT_LOCAL_DEF( FT_Error )
    600602  af_cjk_hints_init( AF_GlyphHints    hints,
    601603                     AF_LatinMetrics  metrics )
     
    13511353
    13521354
    1353   static FT_Error
     1355  FT_LOCAL_DEF( FT_Error )
    13541356  af_cjk_hints_apply( AF_GlyphHints    hints,
    13551357                      FT_Outline*      outline,
  • trunk/poppler/freetype2/src/autofit/afcjk.h

    r150 r251  
    55/*    Auto-fitter hinting routines for CJK script (specification).         */
    66/*                                                                         */
    7 /*  Copyright 2006 by                                                      */
     7/*  Copyright 2006, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    3232
    3333
     34  FT_LOCAL( FT_Error )
     35  af_cjk_metrics_init( AF_LatinMetrics  metrics,
     36                       FT_Face          face );
     37
     38  FT_LOCAL( void )
     39  af_cjk_metrics_scale( AF_LatinMetrics  metrics,
     40                        AF_Scaler        scaler );
     41
     42  FT_LOCAL( FT_Error )
     43  af_cjk_hints_init( AF_GlyphHints    hints,
     44                     AF_LatinMetrics  metrics );
     45
     46  FT_LOCAL( FT_Error )
     47  af_cjk_hints_apply( AF_GlyphHints    hints,
     48                      FT_Outline*      outline,
     49                      AF_LatinMetrics  metrics );
     50
    3451/* */
    3552
  • trunk/poppler/freetype2/src/autofit/afglobal.c

    r209 r251  
    55/*    Auto-fitter routines to compute global hinting values (body).        */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    8585    {
    8686     /*
    87       *  Ignore this error; we simply use Latin as the standard
    88       *  script.  XXX: Shouldn't we rather disable hinting?
     87      *  Ignore this error; we simply use the default script.
     88      *  XXX: Shouldn't we rather disable hinting?
    8989      */
    9090      error = AF_Err_Ok;
  • trunk/poppler/freetype2/src/autofit/afhints.h

    r209 r251  
    55/*    Auto-fitter hinting routines (specification).                        */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    3131  */
    3232
    33   typedef enum
     33  typedef enum  AF_Dimension_
    3434  {
    3535    AF_DIMENSION_HORZ = 0,  /* x coordinates,                    */
     
    4545  /* hint directions -- the values are computed so that two vectors are */
    4646  /* in opposite directions iff `dir1 + dir2 == 0'                      */
    47   typedef enum
     47  typedef enum  AF_Direction_
    4848  {
    4949    AF_DIR_NONE  =  4,
     
    5757
    5858  /* point hint flags */
    59   typedef enum
     59  typedef enum  AF_Flags_
    6060  {
    6161    AF_FLAG_NONE = 0,
     
    8888
    8989  /* edge hint flags */
    90   typedef enum
     90  typedef enum  AF_Edge_Flags_
    9191  {
    9292    AF_EDGE_NORMAL = 0,
  • trunk/poppler/freetype2/src/autofit/afindic.c

    r209 r251  
    4444  static void
    4545  af_indic_metrics_scale( AF_LatinMetrics  metrics,
    46                           AF_Scaler        scaler )
     46                          AF_Scaler        scaler )
    4747  {
    4848    /* use CJK routines */
     
    5353  static FT_Error
    5454  af_indic_hints_init( AF_GlyphHints    hints,
    55                        AF_LatinMetrics  metrics )
     55                       AF_LatinMetrics  metrics )
    5656  {
    5757    /* use CJK routines */
     
    6262  static FT_Error
    6363  af_indic_hints_apply( AF_GlyphHints    hints,
    64                         FT_Outline*      outline,
    65                         AF_LatinMetrics  metrics)
     64                        FT_Outline*      outline,
     65                        AF_LatinMetrics  metrics)
    6666  {
    6767    /* use CJK routines */
  • trunk/poppler/freetype2/src/autofit/aflatin.c

    r209 r251  
    198198        FT_Int      best_point, best_y, best_first, best_last;
    199199        FT_Vector*  points;
    200         FT_Bool     round;
     200        FT_Bool     round = 0;
    201201
    202202
     
    10051005      if ( !found )
    10061006      {
    1007         AF_Edge   edge;
     1007        AF_Edge  edge;
    10081008
    10091009
    10101010        /* insert a new edge in the list and */
    10111011        /* sort according to the position    */
    1012         error = af_axis_hints_new_edge( axis, seg->pos, seg->dir, memory, &edge );
     1012        error = af_axis_hints_new_edge( axis, seg->pos,
     1013                                        (AF_Direction)seg->dir,
     1014                                        memory, &edge );
    10131015        if ( error )
    10141016          goto Exit;
  • trunk/poppler/freetype2/src/autofit/afloader.c

    r209 r251  
    55/*    Auto-fitter glyph loading routines (body).                           */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    166166      /* now load the slot image into the auto-outline and run the */
    167167      /* automatic hinting process                                 */
    168       metrics->clazz->script_hints_apply( hints,
    169                                           &gloader->current.outline,
    170                                           metrics );
     168      if ( metrics->clazz->script_hints_apply )
     169        metrics->clazz->script_hints_apply( hints,
     170                                            &gloader->current.outline,
     171                                            metrics );
    171172
    172173      /* we now need to hint the metrics according to the change in */
     
    516517        load_flags &= ~FT_LOAD_RENDER;
    517518
    518         error = metrics->clazz->script_hints_init( &loader->hints, metrics );
    519         if ( error )
    520           goto Exit;
     519        if ( metrics->clazz->script_hints_init )
     520        {
     521          error = metrics->clazz->script_hints_init( &loader->hints,
     522                                                     metrics );
     523          if ( error )
     524            goto Exit;
     525        }
    521526
    522527        error = af_loader_load_g( loader, &scaler, gindex, load_flags, 0 );
  • trunk/poppler/freetype2/src/autofit/aftypes.h

    r209 r251  
    55/*    Auto-fitter types (specification only).                              */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    203203   */
    204204
    205   typedef enum
     205  typedef enum  AF_ScalerFlags_
    206206  {
    207207    AF_SCALER_FLAG_NO_HORIZONTAL = 1,  /* disable horizontal hinting */
     
    261261   */
    262262
    263   typedef enum
     263  typedef enum  AF_Script_
    264264  {
    265265    AF_SCRIPT_NONE  = 0,
  • trunk/poppler/freetype2/src/base/ftbase.c

    r209 r251  
    3333
    3434#if defined( __APPLE__ ) && !defined ( DARWIN_NO_CARBON )
    35 #include <ftmac.c>
     35#include "ftmac.c"
    3636#endif
    3737
  • trunk/poppler/freetype2/src/base/ftcalc.c

    r209 r251  
    55/*    Arithmetic computations (body).                                      */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    3434
    3535#include <ft2build.h>
     36#include FT_GLYPH_H
    3637#include FT_INTERNAL_CALC_H
    3738#include FT_INTERNAL_DEBUG_H
     
    431432      "addl  %%edx, %%eax\n"
    432433      "mov   %%eax, %0\n"
    433       : "=r"(result)
    434       : "a"(a), "d"(b)
     434      : "=a"(result), "+d"(b)
     435      : "a"(a)
    435436      : "%ecx"
    436437    );
     
    513514
    514515
    515     s  = a; a = FT_ABS(a);
    516     s ^= b; b = FT_ABS(b);
     516    s  = a; a = FT_ABS( a );
     517    s ^= b; b = FT_ABS( b );
    517518
    518519    if ( b == 0 )
     
    665666
    666667#endif /* FT_LONG64 */
     668
     669
     670  /* documentation is in ftglyph.h */
     671
     672  FT_EXPORT_DEF( void )
     673  FT_Matrix_Multiply( const FT_Matrix*  a,
     674                      FT_Matrix        *b )
     675  {
     676    FT_Fixed  xx, xy, yx, yy;
     677
     678
     679    if ( !a || !b )
     680      return;
     681
     682    xx = FT_MulFix( a->xx, b->xx ) + FT_MulFix( a->xy, b->yx );
     683    xy = FT_MulFix( a->xx, b->xy ) + FT_MulFix( a->xy, b->yy );
     684    yx = FT_MulFix( a->yx, b->xx ) + FT_MulFix( a->yy, b->yx );
     685    yy = FT_MulFix( a->yx, b->xy ) + FT_MulFix( a->yy, b->yy );
     686
     687    b->xx = xx;  b->xy = xy;
     688    b->yx = yx;  b->yy = yy;
     689  }
     690
     691
     692  /* documentation is in ftglyph.h */
     693
     694  FT_EXPORT_DEF( FT_Error )
     695  FT_Matrix_Invert( FT_Matrix*  matrix )
     696  {
     697    FT_Pos  delta, xx, yy;
     698
     699
     700    if ( !matrix )
     701      return FT_Err_Invalid_Argument;
     702
     703    /* compute discriminant */
     704    delta = FT_MulFix( matrix->xx, matrix->yy ) -
     705            FT_MulFix( matrix->xy, matrix->yx );
     706
     707    if ( !delta )
     708      return FT_Err_Invalid_Argument;  /* matrix can't be inverted */
     709
     710    matrix->xy = - FT_DivFix( matrix->xy, delta );
     711    matrix->yx = - FT_DivFix( matrix->yx, delta );
     712
     713    xx = matrix->xx;
     714    yy = matrix->yy;
     715
     716    matrix->xx = FT_DivFix( yy, delta );
     717    matrix->yy = FT_DivFix( xx, delta );
     718
     719    return FT_Err_Ok;
     720  }
     721
     722
     723  /* documentation is in ftcalc.h */
     724
     725  FT_BASE_DEF( void )
     726  FT_Matrix_Multiply_Scaled( const FT_Matrix*  a,
     727                             FT_Matrix        *b,
     728                             FT_Long           scaling )
     729  {
     730    FT_Fixed  xx, xy, yx, yy;
     731
     732    FT_Long   val = 0x10000L * scaling;
     733
     734
     735    if ( !a || !b )
     736      return;
     737
     738    xx = FT_MulDiv( a->xx, b->xx, val ) + FT_MulDiv( a->xy, b->yx, val );
     739    xy = FT_MulDiv( a->xx, b->xy, val ) + FT_MulDiv( a->xy, b->yy, val );
     740    yx = FT_MulDiv( a->yx, b->xx, val ) + FT_MulDiv( a->yy, b->yx, val );
     741    yy = FT_MulDiv( a->yx, b->xy, val ) + FT_MulDiv( a->yy, b->yy, val );
     742
     743    b->xx = xx;  b->xy = xy;
     744    b->yx = yx;  b->yy = yy;
     745  }
     746
     747
     748  /* documentation is in ftcalc.h */
     749
     750  FT_BASE_DEF( void )
     751  FT_Vector_Transform_Scaled( FT_Vector*        vector,
     752                              const FT_Matrix*  matrix,
     753                              FT_Long           scaling )
     754  {
     755    FT_Pos   xz, yz;
     756
     757    FT_Long  val = 0x10000L * scaling;
     758
     759
     760    if ( !vector || !matrix )
     761      return;
     762
     763    xz = FT_MulDiv( vector->x, matrix->xx, val ) +
     764         FT_MulDiv( vector->y, matrix->xy, val );
     765
     766    yz = FT_MulDiv( vector->x, matrix->yx, val ) +
     767         FT_MulDiv( vector->y, matrix->yy, val );
     768
     769    vector->x = xz;
     770    vector->y = yz;
     771  }
    667772
    668773
  • trunk/poppler/freetype2/src/base/ftdebug.c

    r209 r251  
    55/*    Debugging and logging component (body).                              */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2004 by                                     */
     7/*  Copyright 1996-2001, 2002, 2004, 2008 by                               */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5858
    5959    va_start( ap, fmt );
    60     vprintf( fmt, ap );
     60    vfprintf( stderr, fmt, ap );
    6161    va_end( ap );
    6262  }
     
    7272
    7373    va_start( ap, fmt );
    74     vprintf( fmt, ap );
     74    vfprintf( stderr, fmt, ap );
    7575    va_end( ap );
    7676
  • trunk/poppler/freetype2/src/base/ftglyph.c

    r209 r251  
    55/*    FreeType convenience functions to handle glyphs (body).              */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2007 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2007, 2008 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    4949  /*************************************************************************/
    5050  /****                                                                 ****/
    51   /****   Convenience functions                                         ****/
    52   /****                                                                 ****/
    53   /*************************************************************************/
    54   /*************************************************************************/
    55 
    56 
    57   /* documentation is in ftglyph.h */
    58 
    59   FT_EXPORT_DEF( void )
    60   FT_Matrix_Multiply( const FT_Matrix*  a,
    61                       FT_Matrix        *b )
    62   {
    63     FT_Fixed  xx, xy, yx, yy;
    64 
    65 
    66     if ( !a || !b )
    67       return;
    68 
    69     xx = FT_MulFix( a->xx, b->xx ) + FT_MulFix( a->xy, b->yx );
    70     xy = FT_MulFix( a->xx, b->xy ) + FT_MulFix( a->xy, b->yy );
    71     yx = FT_MulFix( a->yx, b->xx ) + FT_MulFix( a->yy, b->yx );
    72     yy = FT_MulFix( a->yx, b->xy ) + FT_MulFix( a->yy, b->yy );
    73 
    74     b->xx = xx;  b->xy = xy;
    75     b->yx = yx;  b->yy = yy;
    76   }
    77 
    78 
    79   /* documentation is in ftglyph.h */
    80 
    81   FT_EXPORT_DEF( FT_Error )
    82   FT_Matrix_Invert( FT_Matrix*  matrix )
    83   {
    84     FT_Pos  delta, xx, yy;
    85 
    86 
    87     if ( !matrix )
    88       return FT_Err_Invalid_Argument;
    89 
    90     /* compute discriminant */
    91     delta = FT_MulFix( matrix->xx, matrix->yy ) -
    92             FT_MulFix( matrix->xy, matrix->yx );
    93 
    94     if ( !delta )
    95       return FT_Err_Invalid_Argument;  /* matrix can't be inverted */
    96 
    97     matrix->xy = - FT_DivFix( matrix->xy, delta );
    98     matrix->yx = - FT_DivFix( matrix->yx, delta );
    99 
    100     xx = matrix->xx;
    101     yy = matrix->yy;
    102 
    103     matrix->xx = FT_DivFix( yy, delta );
    104     matrix->yy = FT_DivFix( xx, delta );
    105 
    106     return FT_Err_Ok;
    107   }
    108 
    109 
    110   /*************************************************************************/
    111   /*************************************************************************/
    112   /****                                                                 ****/
    11351  /****   FT_BitmapGlyph support                                        ****/
    11452  /****                                                                 ****/
     
    377315
    378316
     317    /* check arguments */
     318    if ( !target )
     319    {
     320      error = FT_Err_Invalid_Argument;
     321      goto Exit;
     322    }
     323
    379324    *target = 0;
    380325
    381     /* check arguments */
    382     if ( !target || !source || !source->clazz )
     326    if ( !source || !source->clazz )
    383327    {
    384328      error = FT_Err_Invalid_Argument;
  • trunk/poppler/freetype2/src/base/ftlcdfil.c

    r182 r251  
    55/*    FreeType API for color filtering of subpixel bitmap glyphs (body).   */
    66/*                                                                         */
    7 /*  Copyright 2006 by                                                      */
     7/*  Copyright 2006, 2008 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    162162#ifdef USE_LEGACY
    163163
    164   /* FIR filter used by the default and light filters */
     164  /* intra-pixel filter used by the legacy filter */
    165165  static void
    166166  _ft_lcd_filter_legacy( FT_Bitmap*      bitmap,
     
    182182
    183183
    184     /* horizontal in-place FIR filter */
     184    /* horizontal in-place intra-pixel filter */
    185185    if ( mode == FT_RENDER_MODE_LCD && width >= 3 )
    186186    {
  • trunk/poppler/freetype2/src/base/ftmac.c

    r209 r251  
    99/*  classic platforms built by MPW.                                        */
    1010/*                                                                         */
    11 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     11/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    1212/*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
    1313/*                                                                         */
     
    7777#define OS_INLINE  static __inline__
    7878#endif
    79 #include <Carbon/Carbon.h>
    80 
    81 #ifndef HFS_MAXPATHLEN
    82 #define HFS_MAXPATHLEN  1024
     79
     80  /* The ResourceIndex type was available SDKs on 10.5 */
     81#ifndef HAVE_TYPE_RESOURCE_INDEX
     82typedef short ResourceIndex;
    8383#endif
     84
     85#include <CoreServices/CoreServices.h>
     86#include <ApplicationServices/ApplicationServices.h>
     87#include <sys/syslimits.h> /* PATH_MAX */
    8488
    8589#define FT_DEPRECATED_ATTRIBUTE
     
    9094#undef FT_GetFile_From_Mac_Name( a, b, c )
    9195#undef FT_GetFile_From_Mac_ATS_Name( a, b, c )
     96#undef FT_New_Face_From_FOND( a, b, c, d )
    9297#undef FT_New_Face_From_FSSpec( a, b, c, d )
     98#undef FT_New_Face_From_FSRef( a, b, c, d )
     99
     100#ifndef kATSOptionFlagsUnRestrictedScope /* since Mac OS X 10.1 */
     101#define kATSOptionFlagsUnRestrictedScope kATSOptionFlagsDefault
     102#endif
    93103
    94104
     
    101111
    102112
     113  /* This function is deprecated because FSSpec is deprecated in Mac OS X  */
    103114  FT_EXPORT_DEF( FT_Error )
    104115  FT_GetFile_From_Mac_Name( const char*  fontName,
     
    116127  /* Private function.                                         */
    117128  /* The FSSpec type has been discouraged for a long time,     */
    118   /* but for some reason, there is no FSRef version of         */
    119   /* ATSFontGetFileSpecification(), so we made our own.        */
    120   /* Apple will provide one eventually.                        */
     129  /* unfortunately an FSRef replacement API for                */
     130  /* ATSFontGetFileSpecification() is only available in        */
     131  /* Mac OS X 10.5 and later.                                  */
    121132  static OSStatus
    122133  FT_ATSFontGetFileReference( ATSFontRef  ats_font_id,
    123134                              FSRef*      ats_font_ref )
    124135  {
    125 #if __LP64__
     136#if defined( MAC_OS_X_VERSION_10_5 ) && \
     137    ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
     138 
     139    OSStatus  err;
     140
     141    err = ATSFontGetFileReference( ats_font_id, ats_font_ref );
     142
     143    return err;
     144#elif __LP64__ /* No 64bit Carbon API on legacy platforms */
    126145    FT_UNUSED( ats_font_id );
    127146    FT_UNUSED( ats_font_ref );
    128147
     148
    129149    return fnfErr;
    130 #else
     150#else /* 32bit Carbon API on legacy platforms */
    131151    OSStatus  err;
    132152    FSSpec    spec;
     
    215235                                FT_Long*     face_index )
    216236  {
    217 #if __LP64__
     237#if ( __LP64__ ) || ( defined( MAC_OS_X_VERSION_10_5 ) && \
     238      ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 ) )
    218239    FT_UNUSED( fontName );
    219240    FT_UNUSED( pathSpec );
     
    240261
    241262  static OSErr
    242   FT_FSPathMakeRes( const UInt8*  pathname,
    243                     short*        res )
     263  FT_FSPathMakeRes( const UInt8*    pathname,
     264                    ResFileRefNum*  res )
    244265  {
    245266    OSErr  err;
     
    358379  parse_fond( char*   fond_data,
    359380              short*  have_sfnt,
    360               short*  sfnt_id,
     381              ResID*  sfnt_id,
    361382              Str255  lwfn_file_name,
    362383              short   face_index )
     
    374395    assoc      = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
    375396    base_assoc = assoc;
     397
     398    /* the maximum faces in a FOND is 48, size of StyleTable.indexes[] */
     399    if ( 47 < face_index )
     400      return;
    376401
    377402    /* Let's do a little range checking before we get too excited here */
     
    426451          ps_name[ps_name_len] = 0;
    427452        }
    428         if ( style->indexes[0] > 1 )
     453        if ( style->indexes[face_index] > 1 &&
     454             style->indexes[face_index] <= FT_MIN( string_count, 64 ) )
    429455        {
    430           unsigned char*  suffixes = names[style->indexes[0] - 1];
     456          unsigned char*  suffixes = names[style->indexes[face_index] - 1];
    431457
    432458
     
    464490                       size_t            path_size )
    465491  {
    466     FSRef  ref, par_ref;
    467     int    dirname_len;
     492    FSRef   ref, par_ref;
     493    size_t  dirname_len;
    468494
    469495
     
    505531               const UInt8*  pathname )
    506532  {
    507     short     sfnt_id;
     533    ResID     sfnt_id;
    508534    short     have_sfnt, have_lwfn;
    509535    Str255    lwfn_file_name;
    510     UInt8     buff[HFS_MAXPATHLEN];
     536    UInt8     buff[PATH_MAX];
    511537    FT_Error  err;
    512538    short     num_faces;
     
    540566     of the same type together. */
    541567  static FT_Error
    542   read_lwfn( FT_Memory  memory,
    543              short      res,
    544              FT_Byte**  pfb_data,
    545              FT_ULong*  size )
     568  read_lwfn( FT_Memory      memory,
     569             ResFileRefNum  res,
     570             FT_Byte**      pfb_data,
     571             FT_ULong*      size )
    546572  {
    547573    FT_Error       error = FT_Err_Ok;
    548     short          res_id;
     574    ResID          res_id;
    549575    unsigned char  *buffer, *p, *size_p = NULL;
    550576    FT_ULong       total_size = 0;
     
    564590    for (;;)
    565591    {
    566       post_data = Get1Resource( 'POST', res_id++ );
     592      post_data = Get1Resource( FT_MAKE_TAG( 'P', 'O', 'S', 'T' ),
     593                                res_id++ );
    567594      if ( post_data == NULL )
    568595        break;  /* we are done */
     
    603630    for (;;)
    604631    {
    605       post_data = Get1Resource( 'POST', res_id++ );
     632      post_data = Get1Resource( FT_MAKE_TAG( 'P', 'O', 'S', 'T' ),
     633                                res_id++ );
    606634      if ( post_data == NULL )
    607635        break;  /* we are done */
     
    708736  /* Create a new FT_Face given a buffer and a driver name. */
    709737  static FT_Error
    710   open_face_from_buffer( FT_Library  library,
    711                          FT_Byte*    base,
    712                          FT_ULong    size,
    713                          FT_Long     face_index,
    714                          char*       driver_name,
    715                          FT_Face*    aface )
     738  open_face_from_buffer( FT_Library   library,
     739                         FT_Byte*     base,
     740                         FT_ULong     size,
     741                         FT_Long      face_index,
     742                         const char*  driver_name,
     743                         FT_Face*     aface )
    716744  {
    717745    FT_Open_Args  args;
     
    765793                         FT_Face*      aface )
    766794  {
    767     FT_Byte*  pfb_data;
    768     FT_ULong  pfb_size;
    769     FT_Error  error;
    770     short     res;
     795    FT_Byte*       pfb_data;
     796    FT_ULong       pfb_size;
     797    FT_Error       error;
     798    ResFileRefNum  res;
    771799
    772800
     
    793821  static FT_Error
    794822  FT_New_Face_From_SFNT( FT_Library  library,
    795                          short       sfnt_id,
     823                         ResID       sfnt_id,
    796824                         FT_Long     face_index,
    797825                         FT_Face*    aface )
     
    805833
    806834
    807     sfnt = GetResource( 'sfnt', sfnt_id );
    808     if ( ResError() )
     835    sfnt = GetResource( FT_MAKE_TAG( 's', 'f', 'n', 't' ), sfnt_id );
     836    if ( sfnt == NULL )
    809837      return FT_Err_Invalid_Handle;
    810838
     
    840868                             FT_Face*      aface )
    841869  {
    842     FT_Error  error = FT_Err_Cannot_Open_Resource;
    843     short     res_ref, res_index;
    844     Handle    fond;
    845     short     num_faces_in_res, num_faces_in_fond;
     870    FT_Error       error = FT_Err_Cannot_Open_Resource;
     871    ResFileRefNum  res_ref;
     872    ResourceIndex  res_index;
     873    Handle         fond;
     874    short          num_faces_in_res, num_faces_in_fond;
    846875
    847876
     
    856885    for ( res_index = 1; ; ++res_index )
    857886    {
    858       fond = Get1IndResource( 'FOND', res_index );
     887      fond = Get1IndResource( FT_MAKE_TAG( 'F', 'O', 'N', 'D' ),
     888                              res_index );
    859889      if ( ResError() )
    860890        break;
     
    870900
    871901    CloseResFile( res_ref );
    872     if ( FT_Err_Ok == error && NULL != aface )
     902    if ( FT_Err_Ok == error && NULL != aface && NULL != *aface )
    873903      (*aface)->num_faces = num_faces_in_res;
    874904    return error;
     
    884914                         FT_Face*    aface )
    885915  {
    886     short     sfnt_id, have_sfnt, have_lwfn = 0;
    887     short    fond_id;
     916    short     have_sfnt, have_lwfn = 0;
     917    ResID     sfnt_id, fond_id;
    888918    OSType    fond_type;
    889919    Str255    fond_name;
    890920    Str255    lwfn_file_name;
    891     UInt8     path_lwfn[HFS_MAXPATHLEN];
     921    UInt8     path_lwfn[PATH_MAX];
    892922    OSErr     err;
    893923    FT_Error  error = FT_Err_Ok;
     
    895925
    896926    GetResInfo( fond, &fond_id, &fond_type, fond_name );
    897     if ( ResError() != noErr || fond_type != 'FOND' )
     927    if ( ResError() != noErr || fond_type != FT_MAKE_TAG( 'F', 'O', 'N', 'D' ) )
    898928      return FT_Err_Invalid_File_Format;
    899929
     
    902932    if ( lwfn_file_name[0] )
    903933    {
    904       short  res;
     934      ResFileRefNum  res;
    905935
    906936
     
    910940
    911941      {
    912         UInt8  path_fond[HFS_MAXPATHLEN];
     942        UInt8  path_fond[PATH_MAX];
    913943        FSRef  ref;
    914944
     
    962992    /* LWFN is a (very) specific file format, check for it explicitly */
    963993    file_type = get_file_type_from_path( pathname );
    964     if ( file_type == 'LWFN' )
     994    if ( file_type == FT_MAKE_TAG( 'L', 'W', 'F', 'N' ) )
    965995      return FT_New_Face_From_LWFN( library, pathname, face_index, aface );
    966996
     
    10301060  /*    accepts an FSRef instead of a path.                                */
    10311061  /*                                                                       */
     1062  /* This function is deprecated because Carbon data types (FSRef)         */
     1063  /* are not cross-platform, and thus not suitable for the freetype API.   */
    10321064  FT_EXPORT_DEF( FT_Error )
    10331065  FT_New_Face_From_FSRef( FT_Library    library,
     
    10391071    FT_Open_Args  args;
    10401072    OSErr   err;
    1041     UInt8   pathname[HFS_MAXPATHLEN];
     1073    UInt8   pathname[PATH_MAX];
    10421074
    10431075
     
    10691101  /*    accepts an FSSpec instead of a path.                               */
    10701102  /*                                                                       */
     1103  /* This function is deprecated because FSSpec is deprecated in Mac OS X  */
    10711104  FT_EXPORT_DEF( FT_Error )
    10721105  FT_New_Face_From_FSSpec( FT_Library     library,
     
    10751108                           FT_Face*       aface )
    10761109  {
    1077 #if __LP64__
     1110#if ( __LP64__ ) || ( defined( MAC_OS_X_VERSION_10_5 ) && \
     1111      ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 ) )
    10781112    FT_UNUSED( library );
    10791113    FT_UNUSED( spec );
  • trunk/poppler/freetype2/src/base/ftobjs.c

    r209 r251  
    55/*    The FreeType private base classes (body).                            */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    635635      }
    636636
    637       /* load auto-hinted outline */
    638       hinting = (FT_AutoHinter_Service)hinter->clazz->module_interface;
    639 
    640       error   = hinting->load_glyph( (FT_AutoHinter)hinter,
    641                                      slot, face->size,
    642                                      glyph_index, load_flags );
     637      {
     638        FT_Face_Internal  internal        = face->internal;
     639        FT_Int            transform_flags = internal->transform_flags;
     640
     641
     642        /* since the auto-hinter calls FT_Load_Glyph by itself, */
     643        /* make sure that glyphs aren't transformed             */
     644        internal->transform_flags = 0;
     645
     646        /* load auto-hinted outline */
     647        hinting = (FT_AutoHinter_Service)hinter->clazz->module_interface;
     648
     649        error   = hinting->load_glyph( (FT_AutoHinter)hinter,
     650                                       slot, face->size,
     651                                       glyph_index, load_flags );
     652
     653        internal->transform_flags = transform_flags;
     654      }
    643655    }
    644656    else
     
    884896  /*                                                                       */
    885897  /*    This function is called from open_face() (just below), and also    */
    886   /*    from FT_Select_Charmap( ..., FT_ENCODING_UNICODE).                 */
     898  /*    from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ).                */
    887899  /*                                                                       */
    888900  static FT_Error
     
    891903    FT_CharMap*  first;
    892904    FT_CharMap*  cur;
    893     FT_CharMap*  unicmap = NULL;  /* some UCS-2 map, if we found it */
    894905
    895906
     
    936947      if ( cur[0]->encoding == FT_ENCODING_UNICODE )
    937948      {
    938         unicmap = cur;  /* record we found a Unicode charmap */
    939 
    940         /* XXX If some new encodings to represent UCS-4 are added,  */
    941         /*     they should be added here.                           */
     949        /* XXX If some new encodings to represent UCS-4 are added, */
     950        /*     they should be added here.                          */
    942951        if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT &&
    943                cur[0]->encoding_id == TT_MS_ID_UCS_4        )          ||
     952               cur[0]->encoding_id == TT_MS_ID_UCS_4        )     ||
    944953             ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&
    945                cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32    )      )
    946 
    947         /* Hurray!  We found a UCS-4 charmap.  We can stop the scan! */
     954               cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32    ) )
    948955        {
    949956          face->charmap = cur[0];
    950           return 0;
     957          return FT_Err_Ok;
    951958        }
    952959      }
    953960    }
    954961
    955     /* We do not have any UCS-4 charmap.  Sigh.                         */
    956     /* Let's see if we have some other kind of Unicode charmap, though. */
    957     if ( unicmap != NULL )
    958     {
    959       face->charmap = unicmap[0];
    960       return 0;
    961     }
    962 
    963     /* Chou blanc! */
     962    /* We do not have any UCS-4 charmap.                */
     963    /* Do the loop again and search for UCS-2 charmaps. */
     964    cur = first + face->num_charmaps;
     965
     966    for ( ; --cur >= first; )
     967    {
     968      if ( cur[0]->encoding == FT_ENCODING_UNICODE )
     969      {
     970        face->charmap = cur[0];
     971        return FT_Err_Ok;
     972      }
     973    }
     974
    964975    return FT_Err_Invalid_CharMap_Handle;
     976  }
     977
     978
     979  /*************************************************************************/
     980  /*                                                                       */
     981  /* <Function>                                                            */
     982  /*    find_variant_selector_charmap                                      */
     983  /*                                                                       */
     984  /* <Description>                                                         */
     985  /*    This function finds the variant selector charmap, if there is one. */
     986  /*    There can only be one (platform=0, specific=5, format=14).         */
     987  /*                                                                       */
     988  static FT_CharMap
     989  find_variant_selector_charmap( FT_Face  face )
     990  {
     991    FT_CharMap*  first;
     992    FT_CharMap*  end;
     993    FT_CharMap*  cur;
     994
     995
     996    /* caller should have already checked that `face' is valid */
     997    FT_ASSERT( face );
     998
     999    first = face->charmaps;
     1000
     1001    if ( !first )
     1002      return NULL;
     1003
     1004    end = first + face->num_charmaps;  /* points after the last one */
     1005
     1006    for ( cur = first; cur < end; ++cur )
     1007    {
     1008      if ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE    &&
     1009           cur[0]->encoding_id == TT_APPLE_ID_VARIANT_SELECTOR &&
     1010           FT_Get_CMap_Format( cur[0] ) == 14                  )
     1011        return cur[0];
     1012    }
     1013
     1014    return NULL;
    9651015  }
    9661016
     
    10141064            i++ )
    10151065        if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL )
    1016           face->internal->incremental_interface = params[i].data;
     1066          face->internal->incremental_interface =
     1067            (FT_Incremental_Interface)params[i].data;
    10171068    }
    10181069#endif
    10191070
    1020     error = clazz->init_face( stream,
    1021                               face,
    1022                               (FT_Int)face_index,
    1023                               num_params,
    1024                               params );
     1071    if ( clazz->init_face )
     1072      error = clazz->init_face( stream,
     1073                                face,
     1074                                (FT_Int)face_index,
     1075                                num_params,
     1076                                params );
    10251077    if ( error )
    10261078      goto Fail;
     
    10451097    {
    10461098      destroy_charmaps( face, memory );
    1047       clazz->done_face( face );
     1099      if ( clazz->done_face )
     1100        clazz->done_face( face );
    10481101      FT_FREE( internal );
    10491102      FT_FREE( face );
     
    14891542
    14901543
     1544    if ( NULL == stream )
     1545      return FT_Err_Invalid_Stream_Operation;
     1546
    14911547    error = FT_Stream_Seek( stream, 0 );
    14921548    if ( error )
     
    16621718    FT_ListNode  node = 0;
    16631719    FT_Bool      external_stream;
     1720    FT_Module*   cur;
     1721    FT_Module*   limit;
    16641722
    16651723
     
    16761734    error = FT_Stream_New( library, args, &stream );
    16771735    if ( error )
    1678       goto Exit;
     1736      goto Fail3;
    16791737
    16801738    memory = library->memory;
     
    17131771    {
    17141772      /* check each font driver for an appropriate format */
    1715       FT_Module*  cur   = library->modules;
    1716       FT_Module*  limit = cur + library->num_modules;
     1773      cur   = library->modules;
     1774      limit = cur + library->num_modules;
    17171775
    17181776
     
    17481806    /* it may be because we have an empty data fork, so we need to check   */
    17491807    /* the resource fork.                                                  */
    1750     if ( FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format      &&
     1808    if ( FT_ERROR_BASE( error ) != FT_Err_Cannot_Open_Stream       &&
     1809         FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format      &&
    17511810         FT_ERROR_BASE( error ) != FT_Err_Invalid_Stream_Operation )
    17521811      goto Fail2;
     
    26322691    if ( !cur )
    26332692      return FT_Err_Invalid_CharMap_Handle;
     2693    if ( FT_Get_CMap_Format( charmap ) == 14 )
     2694      return FT_Err_Invalid_Argument;
    26342695
    26352696    limit = cur + face->num_charmaps;
     
    28452906    if ( agindex )
    28462907      *agindex = gindex;
     2908
     2909    return result;
     2910  }
     2911
     2912
     2913  /* documentation is in freetype.h */
     2914
     2915  FT_EXPORT_DEF( FT_UInt )
     2916  FT_Face_GetCharVariantIndex( FT_Face   face,
     2917                               FT_ULong  charcode,
     2918                               FT_ULong  variantSelector )
     2919  {
     2920    FT_UInt  result = 0;
     2921
     2922
     2923    if ( face && face->charmap &&
     2924        face->charmap->encoding == FT_ENCODING_UNICODE )
     2925    {
     2926      FT_CharMap  charmap = find_variant_selector_charmap( face );
     2927      FT_CMap     ucmap = FT_CMAP( face->charmap );
     2928
     2929
     2930      if ( charmap != NULL )
     2931      {
     2932        FT_CMap  vcmap = FT_CMAP( charmap );
     2933
     2934
     2935        result = vcmap->clazz->char_var_index( vcmap, ucmap, charcode,
     2936                                               variantSelector );
     2937      }
     2938    }
     2939
     2940    return result;
     2941  }
     2942
     2943
     2944  /* documentation is in freetype.h */
     2945
     2946  FT_EXPORT_DEF( FT_Int )
     2947  FT_Face_GetCharVariantIsDefault( FT_Face   face,
     2948                                   FT_ULong  charcode,
     2949                                   FT_ULong  variantSelector )
     2950  {
     2951    FT_Int  result = -1;
     2952
     2953
     2954    if ( face )
     2955    {
     2956      FT_CharMap  charmap = find_variant_selector_charmap( face );
     2957
     2958
     2959      if ( charmap != NULL )
     2960      {
     2961        FT_CMap  vcmap = FT_CMAP( charmap );
     2962
     2963
     2964        result = vcmap->clazz->char_var_default( vcmap, charcode,
     2965                                                 variantSelector );
     2966      }
     2967    }
     2968
     2969    return result;
     2970  }
     2971
     2972
     2973  /* documentation is in freetype.h */
     2974
     2975  FT_EXPORT_DEF( FT_UInt32* )
     2976  FT_Face_GetVariantSelectors( FT_Face  face )
     2977  {
     2978    FT_UInt32  *result = NULL;
     2979
     2980
     2981    if ( face )
     2982    {
     2983      FT_CharMap  charmap = find_variant_selector_charmap( face );
     2984
     2985
     2986      if ( charmap != NULL )
     2987      {
     2988        FT_CMap    vcmap  = FT_CMAP( charmap );
     2989        FT_Memory  memory = FT_FACE_MEMORY( face );
     2990
     2991
     2992        result = vcmap->clazz->variant_list( vcmap, memory );
     2993      }
     2994    }
     2995
     2996    return result;
     2997  }
     2998
     2999
     3000  /* documentation is in freetype.h */
     3001
     3002  FT_EXPORT_DEF( FT_UInt32* )
     3003  FT_Face_GetVariantsOfChar( FT_Face   face,
     3004                             FT_ULong  charcode )
     3005  {
     3006    FT_UInt32  *result = NULL;
     3007
     3008
     3009    if ( face )
     3010    {
     3011      FT_CharMap  charmap = find_variant_selector_charmap( face );
     3012
     3013
     3014      if ( charmap != NULL )
     3015      {
     3016        FT_CMap    vcmap  = FT_CMAP( charmap );
     3017        FT_Memory  memory = FT_FACE_MEMORY( face );
     3018
     3019
     3020        result = vcmap->clazz->charvariant_list( vcmap, memory, charcode );
     3021      }
     3022    }
     3023    return result;
     3024  }
     3025
     3026
     3027  /* documentation is in freetype.h */
     3028
     3029  FT_EXPORT_DEF( FT_UInt32* )
     3030  FT_Face_GetCharsOfVariant( FT_Face   face,
     3031                             FT_ULong  variantSelector )
     3032  {
     3033    FT_UInt32  *result = NULL;
     3034
     3035
     3036    if ( face )
     3037    {
     3038      FT_CharMap  charmap = find_variant_selector_charmap( face );
     3039
     3040
     3041      if ( charmap != NULL )
     3042      {
     3043        FT_CMap    vcmap  = FT_CMAP( charmap );
     3044        FT_Memory  memory = FT_FACE_MEMORY( face );
     3045
     3046
     3047        result = vcmap->clazz->variantchar_list( vcmap, memory,
     3048                                                 variantSelector );
     3049      }
     3050    }
    28473051
    28483052    return result;
     
    37263930    /* allocate the render pool */
    37273931    library->raster_pool_size = FT_RENDER_POOL_SIZE;
    3728     if ( FT_RENDER_POOL_SIZE > 0 )
    3729       if ( FT_ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
    3730         goto Fail;
     3932#if FT_RENDER_POOL_SIZE > 0
     3933    if ( FT_ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
     3934      goto Fail;
     3935#endif
    37313936
    37323937    /* That's ok now */
  • trunk/poppler/freetype2/src/base/ftoutln.c

    r209 r251  
    475475  {
    476476    FT_UShort   n;
    477     FT_Vector*  vec = outline->points;
     477    FT_Vector*  vec;
    478478
    479479
    480480    if ( !outline )
    481481      return;
     482
     483    vec = outline->points;
    482484
    483485    for ( n = 0; n < outline->n_points; n++ )
     
    627629
    628630
    629   /* documentation is in ftoutln.h */
     631  /* documentation is in freetype.h */
    630632
    631633  FT_EXPORT_DEF( void )
     
    633635                       const FT_Matrix*  matrix )
    634636  {
    635     FT_Pos xz, yz;
     637    FT_Pos  xz, yz;
    636638
    637639
  • trunk/poppler/freetype2/src/base/ftrfork.c

    r165 r251  
    55/*    Embedded resource forks accessor (body).                             */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005, 2006 by                                          */
     7/*  Copyright 2004, 2005, 2006, 2007 by                                    */
    88/*  Masatake YAMATO and Redhat K.K.                                        */
    99/*                                                                         */
     
    133133
    134134
     135  static int
     136  ft_raccess_sort_ref_by_id( FT_RFork_Ref*  a,
     137                             FT_RFork_Ref*  b )
     138  {
     139    if ( a->res_id < b->res_id )
     140      return -1;
     141    else if ( a->res_id > b->res_id )
     142      return 1;
     143    else
     144      return 0;
     145  }
     146
     147
    135148  FT_BASE_DEF( FT_Error )
    136149  FT_Raccess_Get_DataOffsets( FT_Library  library,
     
    142155                              FT_Long    *count )
    143156  {
    144     FT_Error   error;
    145     int        i, j, cnt, subcnt;
    146     FT_Long    tag_internal, rpos;
    147     FT_Memory  memory = library->memory;
    148     FT_Long    temp;
    149     FT_Long    *offsets_internal;
     157    FT_Error      error;
     158    int           i, j, cnt, subcnt;
     159    FT_Long       tag_internal, rpos;
     160    FT_Memory     memory = library->memory;
     161    FT_Long       temp;
     162    FT_Long       *offsets_internal;
     163    FT_RFork_Ref  *ref;
    150164
    151165
     
    180194          return error;
    181195
    182         if ( FT_NEW_ARRAY( offsets_internal, *count ) )
     196        if ( FT_NEW_ARRAY( ref, *count ) )
    183197          return error;
    184198
    185199        for ( j = 0; j < *count; ++j )
    186200        {
    187           (void)FT_STREAM_SKIP( 2 ); /* resource id */
    188           (void)FT_STREAM_SKIP( 2 ); /* rsource name */
    189 
     201          if ( FT_READ_USHORT( ref[j].res_id ) )
     202            goto Exit;
     203          if ( FT_STREAM_SKIP( 2 ) ) /* resource name */
     204            goto Exit;
    190205          if ( FT_READ_LONG( temp ) )
    191           {
    192             FT_FREE( offsets_internal );
    193             return error;
    194           }
    195 
    196           offsets_internal[j] = rdata_pos + ( temp & 0xFFFFFFL );
    197 
    198           (void)FT_STREAM_SKIP( 4 ); /* mbz */
     206            goto Exit;
     207          if ( FT_STREAM_SKIP( 4 ) ) /* mbz */
     208            goto Exit;
     209
     210          ref[j].offset = temp & 0xFFFFFFL;
    199211        }
    200212
     213        ft_qsort( ref, *count, sizeof ( FT_RFork_Ref ),
     214                  ( int(*)(const void*, const void*) )
     215                  ft_raccess_sort_ref_by_id );
     216
     217        if ( FT_NEW_ARRAY( offsets_internal, *count ) )
     218          goto Exit;
     219
     220        /* XXX: duplicated reference ID,
     221         *      gap between reference IDs are acceptable?
     222         *      further investigation on Apple implementation is needed.
     223         */
     224        for ( j = 0; j < *count; ++j )
     225          offsets_internal[j] = rdata_pos + ref[j].offset;
     226
    201227        *offsets = offsets_internal;
    202 
    203         return FT_Err_Ok;
     228        error    = FT_Err_Ok;
     229
     230      Exit:
     231        FT_FREE( ref );
     232        return error;
    204233      }
    205234    }
     
    228257  (*raccess_guess_func)( FT_Library  library,
    229258                         FT_Stream   stream,
    230                          char *      base_file_name,
     259                         char       *base_file_name,
    231260                         char      **result_file_name,
    232261                         FT_Long    *result_offset );
     
    236265  raccess_guess_apple_double( FT_Library  library,
    237266                              FT_Stream   stream,
    238                               char *      base_file_name,
     267                              char       *base_file_name,
    239268                              char      **result_file_name,
    240269                              FT_Long    *result_offset );
     
    243272  raccess_guess_apple_single( FT_Library  library,
    244273                              FT_Stream   stream,
    245                               char *      base_file_name,
     274                              char       *base_file_name,
    246275                              char      **result_file_name,
    247276                              FT_Long    *result_offset );
     
    250279  raccess_guess_darwin_ufs_export( FT_Library  library,
    251280                                   FT_Stream   stream,
    252                                    char *      base_file_name,
     281                                   char       *base_file_name,
    253282                                   char      **result_file_name,
    254283                                   FT_Long    *result_offset );
    255284
    256285  static FT_Error
     286  raccess_guess_darwin_newvfs( FT_Library  library,
     287                               FT_Stream   stream,
     288                               char       *base_file_name,
     289                               char      **result_file_name,
     290                               FT_Long    *result_offset );
     291
     292  static FT_Error
    257293  raccess_guess_darwin_hfsplus( FT_Library  library,
    258294                                FT_Stream   stream,
    259                                 char *      base_file_name,
     295                                char       *base_file_name,
    260296                                char      **result_file_name,
    261297                                FT_Long    *result_offset );
     
    264300  raccess_guess_vfat( FT_Library  library,
    265301                      FT_Stream   stream,
    266                       char *      base_file_name,
     302                      char       *base_file_name,
    267303                      char      **result_file_name,
    268304                      FT_Long    *result_offset );
     
    271307  raccess_guess_linux_cap( FT_Library  library,
    272308                           FT_Stream   stream,
    273                            char *      base_file_name,
     309                           char       *base_file_name,
    274310                           char      **result_file_name,
    275311                           FT_Long    *result_offset );
     
    278314  raccess_guess_linux_double( FT_Library  library,
    279315                              FT_Stream   stream,
    280                               char *      base_file_name,
     316                              char       *base_file_name,
    281317                              char      **result_file_name,
    282318                              FT_Long    *result_offset );
     
    285321  raccess_guess_linux_netatalk( FT_Library  library,
    286322                                FT_Stream   stream,
    287                                 char *      base_file_name,
     323                                char       *base_file_name,
    288324                                char      **result_file_name,
    289325                                FT_Long    *result_offset );
     
    299335  raccess_guess_apple_generic( FT_Library  library,
    300336                               FT_Stream   stream,
    301                                char *      base_file_name,
     337                               char       *base_file_name,
    302338                               FT_Int32    magic,
    303339                               FT_Long    *result_offset );
     
    330366      raccess_guess_apple_single,
    331367      raccess_guess_darwin_ufs_export,
     368      raccess_guess_darwin_newvfs,
    332369      raccess_guess_darwin_hfsplus,
    333370      raccess_guess_vfat,
     
    340377    {
    341378      new_names[i] = NULL;
    342       errors[i] = FT_Stream_Seek( stream, 0 );
     379      if ( NULL != stream )
     380        errors[i] = FT_Stream_Seek( stream, 0 );
     381      else
     382        errors[i] = FT_Err_Ok;
     383
    343384      if ( errors[i] )
    344385        continue ;
     
    355396  raccess_guess_apple_double( FT_Library  library,
    356397                              FT_Stream   stream,
    357                               char *      base_file_name,
     398                              char       *base_file_name,
    358399                              char      **result_file_name,
    359400                              FT_Long    *result_offset )
     
    363404
    364405    *result_file_name = NULL;
     406    if ( NULL == stream )
     407      return FT_Err_Cannot_Open_Stream;
     408
    365409    return raccess_guess_apple_generic( library, stream, base_file_name,
    366410                                        magic, result_offset );
     
    371415  raccess_guess_apple_single( FT_Library  library,
    372416                              FT_Stream   stream,
    373                               char *      base_file_name,
     417                              char       *base_file_name,
    374418                              char      **result_file_name,
    375419                              FT_Long    *result_offset )
     
    379423
    380424    *result_file_name = NULL;
     425    if ( NULL == stream )
     426      return FT_Err_Cannot_Open_Stream;
     427
    381428    return raccess_guess_apple_generic( library, stream, base_file_name,
    382429                                        magic, result_offset );
     
    387434  raccess_guess_darwin_ufs_export( FT_Library  library,
    388435                                   FT_Stream   stream,
    389                                    char *      base_file_name,
     436                                   char       *base_file_name,
    390437                                   char      **result_file_name,
    391438                                   FT_Long    *result_offset )
     
    417464  raccess_guess_darwin_hfsplus( FT_Library  library,
    418465                                FT_Stream   stream,
    419                                 char *      base_file_name,
     466                                char       *base_file_name,
    420467                                char      **result_file_name,
    421468                                FT_Long    *result_offset )
     
    434481    memory = library->memory;
    435482
    436     if ( base_file_len > FT_INT_MAX )
     483    if ( base_file_len + 6 > FT_INT_MAX )
    437484      return FT_Err_Array_Too_Large;
    438485
     
    451498
    452499  static FT_Error
     500  raccess_guess_darwin_newvfs( FT_Library  library,
     501                               FT_Stream   stream,
     502                               char       *base_file_name,
     503                               char      **result_file_name,
     504                               FT_Long    *result_offset )
     505  {
     506    /*
     507      Only meaningful on systems with Mac OS X (> 10.1).
     508     */
     509    FT_Error   error;
     510    char*      newpath;
     511    FT_Memory  memory;
     512    FT_Long    base_file_len = ft_strlen( base_file_name );
     513
     514    FT_UNUSED( stream );
     515
     516
     517    memory = library->memory;
     518
     519    if ( base_file_len + 18 > FT_INT_MAX )
     520      return FT_Err_Array_Too_Large;
     521
     522    if ( FT_ALLOC( newpath, base_file_len + 18 ) )
     523      return error;
     524
     525    FT_MEM_COPY( newpath, base_file_name, base_file_len );
     526    FT_MEM_COPY( newpath + base_file_len, "/..namedfork/rsrc", 18 );
     527
     528    *result_file_name = newpath;
     529    *result_offset    = 0;
     530
     531    return FT_Err_Ok;
     532  }
     533
     534
     535  static FT_Error
    453536  raccess_guess_vfat( FT_Library  library,
    454537                      FT_Stream   stream,
    455                       char *      base_file_name,
     538                      char       *base_file_name,
    456539                      char      **result_file_name,
    457540                      FT_Long    *result_offset )
     
    480563  raccess_guess_linux_cap( FT_Library  library,
    481564                           FT_Stream   stream,
    482                            char *      base_file_name,
     565                           char       *base_file_name,
    483566                           char      **result_file_name,
    484567                           FT_Long    *result_offset )
     
    506589  raccess_guess_linux_double( FT_Library  library,
    507590                              FT_Stream   stream,
    508                               char *      base_file_name,
     591                              char       *base_file_name,
    509592                              char      **result_file_name,
    510593                              FT_Long    *result_offset )
     
    537620  raccess_guess_linux_netatalk( FT_Library  library,
    538621                                FT_Stream   stream,
    539                                 char *      base_file_name,
     622                                char       *base_file_name,
    540623                                char      **result_file_name,
    541624                                FT_Long    *result_offset )
     
    569652  raccess_guess_apple_generic( FT_Library  library,
    570653                               FT_Stream   stream,
    571                                char *      base_file_name,
     654                               char       *base_file_name,
    572655                               FT_Int32    magic,
    573656                               FT_Long    *result_offset )
     
    630713  static FT_Error
    631714  raccess_guess_linux_double_from_file_name( FT_Library  library,
    632                                              char *      file_name,
     715                                             char       *file_name,
    633716                                             FT_Long    *result_offset )
    634717  {
     
    702785  FT_Raccess_Guess( FT_Library  library,
    703786                    FT_Stream   stream,
    704                     char*       base_name,
     787                    char       *base_name,
    705788                    char      **new_names,
    706789                    FT_Long    *offsets,
  • trunk/poppler/freetype2/src/base/ftstream.c

    r209 r251  
    55/*    I/O stream support (body).                                           */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2004, 2005, 2006 by                         */
     7/*  Copyright 2000-2001, 2002, 2004, 2005, 2006, 2008 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    9090                  FT_Long    distance )
    9191  {
     92    if ( distance < 0 )
     93      return FT_Err_Invalid_Stream_Operation;
     94
    9295    return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
    9396  }
  • trunk/poppler/freetype2/src/base/ftstroke.c

    r209 r251  
    55/*    FreeType path stroker (body).                                        */
    66/*                                                                         */
    7 /*  Copyright 2002, 2003, 2004, 2005, 2006 by                              */
     7/*  Copyright 2002, 2003, 2004, 2005, 2006, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    231231 /***************************************************************************/
    232232
    233   typedef enum
     233  typedef enum  FT_StrokeTags_
    234234  {
    235235    FT_STROKE_TAG_ON    = 1,   /* on-curve point  */
  • trunk/poppler/freetype2/src/bdf/bdfdrivr.c

    r209 r251  
    182182    bdf_cmap_done,
    183183    bdf_cmap_char_index,
    184     bdf_cmap_char_next
     184    bdf_cmap_char_next,
     185
     186    NULL, NULL, NULL, NULL, NULL
    185187  };
    186188
  • trunk/poppler/freetype2/src/cff/cffcmap.c

    r165 r251  
    55/*    CFF 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/*                                                                         */
     
    108108    (FT_CMap_DoneFunc)     cff_cmap_encoding_done,
    109109    (FT_CMap_CharIndexFunc)cff_cmap_encoding_char_index,
    110     (FT_CMap_CharNextFunc) cff_cmap_encoding_char_next
     110    (FT_CMap_CharNextFunc) cff_cmap_encoding_char_next,
     111
     112    NULL, NULL, NULL, NULL, NULL
    111113  };
    112114
     
    214216    (FT_CMap_DoneFunc)     cff_cmap_unicode_done,
    215217    (FT_CMap_CharIndexFunc)cff_cmap_unicode_char_index,
    216     (FT_CMap_CharNextFunc) cff_cmap_unicode_char_next
     218    (FT_CMap_CharNextFunc) cff_cmap_unicode_char_next,
     219
     220    NULL, NULL, NULL, NULL, NULL
    217221  };
    218222
  • trunk/poppler/freetype2/src/cff/cffdrivr.c

    r209 r251  
    2323#include FT_INTERNAL_SFNT_H
    2424#include FT_TRUETYPE_IDS_H
     25#include FT_SERVICE_CID_H
    2526#include FT_SERVICE_POSTSCRIPT_CMAPS_H
    2627#include FT_SERVICE_POSTSCRIPT_INFO_H
     28#include FT_SERVICE_POSTSCRIPT_NAME_H
    2729#include FT_SERVICE_TT_CMAP_H
    2830
     
    3638#include FT_SERVICE_XFREE86_NAME_H
    3739#include FT_SERVICE_GLYPH_DICT_H
     40
    3841
    3942  /*************************************************************************/
     
    152155              FT_Int32      load_flags )
    153156  {
    154     FT_Error  error;
     157    FT_Error       error;
    155158    CFF_GlyphSlot  slot = (CFF_GlyphSlot)cffslot;
    156159    CFF_Size       size = (CFF_Size)cffsize;
     
    164167      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
    165168
     169    /* reset the size object if necessary */
    166170    if ( load_flags & FT_LOAD_NO_SCALE )
    167171      size = NULL;
    168172
    169     /* reset the size object if necessary */
    170173    if ( size )
    171174    {
     
    185188
    186189
    187  /*
    188   *  GLYPH DICT SERVICE
    189   *
    190   */
     190  /*
     191   *  GLYPH DICT SERVICE
     192   *
     193   */
    191194
    192195  static FT_Error
     
    227230    error = CFF_Err_Ok;
    228231
    229     Exit:
    230       return error;
     232  Exit:
     233    return error;
    231234  }
    232235
     
    285288
    286289
    287  /*
    288   *  POSTSCRIPT INFO SERVICE
    289   *
    290   */
     290  /*
     291   *  POSTSCRIPT INFO SERVICE
     292   *
     293   */
    291294
    292295  static FT_Int
     
    307310    if ( cff && cff->font_info == NULL )
    308311    {
    309       CFF_FontRecDict  dict = &cff->top_font.font_dict;
    310       PS_FontInfoRec  *font_info;
    311       FT_Memory        memory = face->root.memory;
     312      CFF_FontRecDict     dict    = &cff->top_font.font_dict;
     313      PS_FontInfoRec     *font_info;
     314      FT_Memory           memory  = face->root.memory;
     315      FT_Service_PsCMaps  psnames = (FT_Service_PsCMaps)cff->psnames;
    312316
    313317
     
    317321      font_info->version     = cff_index_get_sid_string( &cff->string_index,
    318322                                                         dict->version,
    319                                                          cff->psnames );
     323                                                         psnames );
    320324      font_info->notice      = cff_index_get_sid_string( &cff->string_index,
    321325                                                         dict->notice,
    322                                                          cff->psnames );
     326                                                         psnames );
    323327      font_info->full_name   = cff_index_get_sid_string( &cff->string_index,
    324328                                                         dict->full_name,
    325                                                          cff->psnames );
     329                                                         psnames );
    326330      font_info->family_name = cff_index_get_sid_string( &cff->string_index,
    327331                                                         dict->family_name,
    328                                                          cff->psnames );
     332                                                         psnames );
    329333      font_info->weight      = cff_index_get_sid_string( &cff->string_index,
    330334                                                         dict->weight,
    331                                                          cff->psnames );
     335                                                         psnames );
    332336      font_info->italic_angle        = dict->italic_angle;
    333337      font_info->is_fixed_pitch      = dict->is_fixed_pitch;
     
    350354    (PS_HasGlyphNamesFunc) cff_ps_has_glyph_names,
    351355    (PS_GetFontPrivateFunc)NULL         /* unsupported with CFF fonts */
     356  };
     357
     358
     359  /*
     360   *  POSTSCRIPT NAME SERVICE
     361   *
     362   */
     363
     364  static const char*
     365  cff_get_ps_name( CFF_Face  face )
     366  {
     367    CFF_Font  cff = (CFF_Font)face->extra.data;
     368
     369
     370    return (const char*)cff->font_name;
     371  }
     372
     373
     374  static const FT_Service_PsFontNameRec  cff_service_ps_name =
     375  {
     376    (FT_PsName_GetFunc)cff_get_ps_name
    352377  };
    353378
     
    398423
    399424
     425  /*
     426   *  CID INFO SERVICE
     427   *
     428   */
     429  static FT_Error
     430  cff_get_ros( CFF_Face      face,
     431               const char*  *registry,
     432               const char*  *ordering,
     433               FT_Int       *supplement )
     434  {
     435    FT_Error  error = CFF_Err_Ok;
     436    CFF_Font  cff   = (CFF_Font)face->extra.data;
     437
     438
     439    if ( cff )
     440    {
     441      CFF_FontRecDict     dict    = &cff->top_font.font_dict;
     442      FT_Service_PsCMaps  psnames = (FT_Service_PsCMaps)cff->psnames;
     443
     444
     445      if ( dict->cid_registry == 0xFFFFU )
     446      {
     447        error = CFF_Err_Invalid_Argument;
     448        goto Fail;
     449      }
     450
     451      if ( registry )
     452      {
     453        if ( cff->registry == NULL )
     454          cff->registry = cff_index_get_sid_string( &cff->string_index,
     455                                                    dict->cid_registry,
     456                                                    psnames );
     457        *registry = cff->registry;
     458      }
     459     
     460      if ( ordering )
     461      {
     462        if ( cff->ordering == NULL )
     463          cff->ordering = cff_index_get_sid_string( &cff->string_index,
     464                                                    dict->cid_ordering,
     465                                                    psnames );
     466        *ordering = cff->ordering;
     467      }
     468
     469      if ( supplement )
     470        *supplement = dict->cid_supplement;
     471    }
     472     
     473  Fail:
     474    return error;
     475  }
     476
     477
     478  static const FT_Service_CIDRec  cff_service_cid_info =
     479  {
     480    (FT_CID_GetRegistryOrderingSupplementFunc)cff_get_ros
     481  };
     482
     483
    400484  /*************************************************************************/
    401485  /*************************************************************************/
     
    412496  static const FT_ServiceDescRec  cff_services[] =
    413497  {
    414     { FT_SERVICE_ID_XF86_NAME,       FT_XF86_FORMAT_CFF },
    415     { FT_SERVICE_ID_POSTSCRIPT_INFO, &cff_service_ps_info },
     498    { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF },
     499    { FT_SERVICE_ID_POSTSCRIPT_INFO,      &cff_service_ps_info },
     500    { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &cff_service_ps_name },
    416501#ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
    417     { FT_SERVICE_ID_GLYPH_DICT,      &cff_service_glyph_dict },
     502    { FT_SERVICE_ID_GLYPH_DICT,           &cff_service_glyph_dict },
    418503#endif
    419     { FT_SERVICE_ID_TT_CMAP,         &cff_service_get_cmap_info },
     504    { FT_SERVICE_ID_TT_CMAP,              &cff_service_get_cmap_info },
     505    { FT_SERVICE_ID_CID,                  &cff_service_cid_info },
    420506    { NULL, NULL }
    421507  };
  • trunk/poppler/freetype2/src/cff/cffgload.c

    r209 r251  
    55/*    OpenType Glyph Loader (body).                                        */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    111111    cff_op_return,
    112112
     113    cff_op_hsbw,        /* Type 1 opcode: invalid but seen in real life */
     114    cff_op_closepath,   /* ditto */
     115
    113116    /* do not remove */
    114117    cff_op_max
     
    188191    1, /* callsubr */
    189192    1,
     193    0,
     194
     195    2, /* hsbw */
    190196    0
    191197  };
     
    223229  /*    glyph   :: The current glyph object.                               */
    224230  /*                                                                       */
     231  /*    hinting :: Whether hinting is active.                              */
     232  /*                                                                       */
    225233  static void
    226234  cff_builder_init( CFF_Builder*   builder,
     
    252260      if ( hinting && size )
    253261      {
    254         builder->hints_globals = size->root.internal;
     262        CFF_Internal  internal = (CFF_Internal)size->root.internal;
     263
     264
     265        builder->hints_globals = (void *)internal->topfont;
    255266        builder->hints_funcs   = glyph->root.internal->glyph_hints;
    256267      }
    257     }
    258 
    259     if ( size )
    260     {
    261       builder->scale_x = size->root.metrics.x_scale;
    262       builder->scale_y = size->root.metrics.y_scale;
    263268    }
    264269
     
    340345  /*                                                                       */
    341346  /* <Input>                                                               */
    342   /*    face    :: The current face object.                                */
    343   /*                                                                       */
    344   /*    size    :: The current size object.                                */
    345   /*                                                                       */
    346   /*    slot    :: The current glyph object.                               */
     347  /*    face      :: The current face object.                              */
     348  /*                                                                       */
     349  /*    size      :: The current size object.                              */
     350  /*                                                                       */
     351  /*    slot      :: The current glyph object.                             */
     352  /*                                                                       */
     353  /*    hinting   :: Whether hinting is active.                            */
     354  /*                                                                       */
     355  /*    hint_mode :: The hinting mode.                                     */
    347356  /*                                                                       */
    348357  FT_LOCAL_DEF( void )
     
    372381
    373382
    374   /* this function is used to select the locals subrs array */
     383  /* this function is used to select the subfont */
     384  /* and the locals subrs array                  */
    375385  FT_LOCAL_DEF( FT_Error )
    376386  cff_decoder_prepare( CFF_Decoder*  decoder,
     387                       CFF_Size      size,
    377388                       FT_UInt       glyph_index )
    378389  {
    379     CFF_Font     cff   = (CFF_Font)decoder->builder.face->extra.data;
    380     CFF_SubFont  sub   = &cff->top_font;
    381     FT_Error     error = CFF_Err_Ok;
     390    CFF_Builder  *builder = &decoder->builder;
     391    CFF_Font      cff     = (CFF_Font)builder->face->extra.data;
     392    CFF_SubFont   sub     = &cff->top_font;
     393    FT_Error      error   = CFF_Err_Ok;
    382394
    383395
    384396    /* manage CID fonts */
    385     if ( cff->num_subfonts >= 1 )
     397    if ( cff->num_subfonts )
    386398    {
    387399      FT_Byte  fd_index = cff_fd_select_get( &cff->fd_select, glyph_index );
     
    394406        goto Exit;
    395407      }
    396        
     408
    397409      sub = cff->subfonts[fd_index];
     410
     411      if ( builder->hints_funcs )
     412      {
     413        CFF_Internal  internal = (CFF_Internal)size->root.internal;
     414
     415
     416        /* for CFFs without subfonts, this value has already been set */
     417        builder->hints_globals = (void *)internal->subfonts[fd_index];
     418      }
    398419    }
    399420
     
    955976          op = cff_op_rrcurveto;
    956977          break;
     978        case 9:
     979          op = cff_op_closepath;
     980          break;
    957981        case 10:
    958982          op = cff_op_callsubr;
     
    10551079            }
    10561080          }
     1081          break;
     1082        case 13:
     1083          op = cff_op_hsbw;
    10571084          break;
    10581085        case 14:
     
    11691196        }
    11701197
    1171         req_args &= 15;
     1198        req_args &= 0x000F;
    11721199        if ( num_args < req_args )
    11731200          goto Stack_Underflow;
     
    20232050          break;
    20242051
     2052        case cff_op_closepath:
     2053          /* this is an invalid Type 2 operator; however, there        */
     2054          /* exist fonts which are incorrectly converted from probably */
     2055          /* Type 1 to CFF, and some parsers seem to accept it         */
     2056
     2057          FT_TRACE4(( " closepath (invalid op)" ));
     2058
     2059          args = stack;
     2060          break;
     2061
     2062        case cff_op_hsbw:
     2063          /* this is an invalid Type 2 operator; however, there        */
     2064          /* exist fonts which are incorrectly converted from probably */
     2065          /* Type 1 to CFF, and some parsers seem to accept it         */
     2066
     2067          FT_TRACE4(( " hsbw (invalid op)" ));
     2068
     2069          decoder->glyph_width = decoder->nominal_width +
     2070                                   (args[1] >> 16);
     2071          x    = args[0];
     2072          y    = 0;
     2073          args = stack;
     2074          break;
     2075
    20252076        case cff_op_and:
    20262077          {
     
    22612312      if ( !error )
    22622313      {
    2263         error = cff_decoder_prepare( &decoder, glyph_index );
     2314        error = cff_decoder_prepare( &decoder, size, glyph_index );
    22642315        if ( !error )
    22652316          error = cff_decoder_parse_charstrings( &decoder,
     
    22922343    CFF_Decoder  decoder;
    22932344    TT_Face      face     = (TT_Face)glyph->root.face;
    2294     FT_Bool      hinting;
     2345    FT_Bool      hinting, force_scaling;
    22952346    CFF_Font     cff      = (CFF_Font)face->extra.data;
    22962347
     
    22982349    FT_Vector    font_offset;
    22992350
     2351
     2352    force_scaling = FALSE;
    23002353
    23012354    /* in a CID-keyed font, consider `glyph_index' as a CID and map */
     
    23032356    /* subsetted font, glyph_indices and CIDs are identical, though */
    23042357    if ( cff->top_font.font_dict.cid_registry != 0xFFFFU &&
    2305          cff->charset.cids )
     2358         cff->charset.cids                               )
    23062359    {
    23072360      glyph_index = cff_charset_cid_to_gindex( &cff->charset, glyph_index );
     
    23902443      return CFF_Err_Invalid_Argument;
    23912444
     2445    /* if we have a CID subfont, use its matrix (which has already */
     2446    /* been multiplied with the root matrix)                       */
     2447
     2448    /* this scaling is only relevant if the PS hinter isn't active */
     2449    if ( cff->num_subfonts )
     2450    {
     2451      FT_Byte  fd_index = cff_fd_select_get( &cff->fd_select,
     2452                                             glyph_index );
     2453
     2454      FT_Int  top_upm = cff->top_font.font_dict.units_per_em;
     2455      FT_Int  sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
     2456
     2457
     2458      font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
     2459      font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
     2460
     2461      if ( top_upm != sub_upm )
     2462      {
     2463        glyph->x_scale = FT_MulDiv( glyph->x_scale, top_upm, sub_upm );
     2464        glyph->y_scale = FT_MulDiv( glyph->y_scale, top_upm, sub_upm );
     2465
     2466        force_scaling = TRUE;
     2467      }
     2468    }
     2469    else
     2470    {
     2471      font_matrix = cff->top_font.font_dict.font_matrix;
     2472      font_offset = cff->top_font.font_dict.font_offset;
     2473    }
     2474
    23922475    glyph->root.outline.n_points   = 0;
    23932476    glyph->root.outline.n_contours = 0;
     
    24142497      if ( !error )
    24152498      {
    2416         error = cff_decoder_prepare( &decoder, glyph_index );
     2499        error = cff_decoder_prepare( &decoder, size, glyph_index );
    24172500        if ( !error )
    24182501        {
     
    24822565    if ( !error )
    24832566    {
    2484       if ( cff->num_subfonts >= 1 )
    2485       {
    2486         FT_Byte  fd_index = cff_fd_select_get( &cff->fd_select,
    2487                                                glyph_index );
    2488 
    2489 
    2490         font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
    2491         font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
    2492       }
    2493       else
    2494       {
    2495         font_matrix = cff->top_font.font_dict.font_matrix;
    2496         font_offset = cff->top_font.font_dict.font_offset;
    2497       }
    2498 
    24992567      /* Now, set the metrics -- this is rather simple, as   */
    25002568      /* the left side bearing is the xMin, and the top side */
     
    25662634        glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
    25672635
    2568         /* apply the font matrix */
    2569         if ( !( font_matrix.xx == 0x10000L &&
    2570                 font_matrix.yy == 0x10000L &&
     2636        /* apply the font matrix -- `xx' has already been normalized */
     2637        if ( !( font_matrix.yy == 0x10000L &&
    25712638                font_matrix.xy == 0        &&
    25722639                font_matrix.yx == 0        ) )
     
    25882655        metrics->vertAdvance = advance.y + font_offset.y;
    25892656
    2590         if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
     2657        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )
    25912658        {
    25922659          /* scale the outline and the metrics */
  • trunk/poppler/freetype2/src/cff/cffgload.h

    r209 r251  
    55/*    OpenType Glyph Loader (specification).                               */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5555  /*                                                                       */
    5656  /*    last          :: The last point position.                          */
    57   /*                                                                       */
    58   /*    scale_x       :: The horizontal scale (FUnits to sub-pixels).      */
    59   /*                                                                       */
    60   /*    scale_y       :: The vertical scale (FUnits to sub-pixels).        */
    6157  /*                                                                       */
    6258  /*    pos_x         :: The horizontal translation (if composite glyph).  */
     
    9591    FT_Vector       last;
    9692
    97     FT_Fixed        scale_x;
    98     FT_Fixed        scale_y;
    99 
    10093    FT_Pos          pos_x;
    10194    FT_Pos          pos_y;
     
    178171  FT_LOCAL( FT_Error )
    179172  cff_decoder_prepare( CFF_Decoder*  decoder,
     173                       CFF_Size      size,
    180174                       FT_UInt       glyph_index );
    181175
  • trunk/poppler/freetype2/src/cff/cffload.c

    r209 r251  
    3232
    3333#if 1
     34
    3435  static const FT_UShort  cff_isoadobe_charset[229] =
    3536  {
     
    176177    371, 372, 373, 374, 375, 376, 377, 378
    177178  };
    178 #endif
     179
     180#endif /* 1 */
    179181
    180182
     
    182184  cff_get_standard_encoding( FT_UInt  charcode )
    183185  {
    184     return  (FT_UShort)(charcode < 256 ? cff_standard_encoding[charcode] : 0);
     186    return (FT_UShort)( charcode < 256 ? cff_standard_encoding[charcode]
     187                                       : 0 );
    185188  }
    186189
     
    12731276    top->cid_font_name       = 0xFFFFU;
    12741277
    1275     error = cff_index_access_element( idx, font_index, &dict, &dict_len ) ||
    1276             cff_parser_run( &parser, dict, dict + dict_len );
     1278    error = cff_index_access_element( idx, font_index, &dict, &dict_len );
     1279    if ( !error )
     1280      error = cff_parser_run( &parser, dict, dict + dict_len );
    12771281
    12781282    cff_index_forget_element( idx, &dict );
     
    15911595    }
    15921596
     1597    FT_FREE( font->registry );
     1598    FT_FREE( font->ordering );
     1599
    15931600    FT_FREE( font->global_subrs );
    15941601    FT_FREE( font->font_name );
  • trunk/poppler/freetype2/src/cff/cffobjs.c

    r209 r251  
    55/*    OpenType objects manager (body).                                     */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5757  {
    5858    CFF_Face          face     = (CFF_Face)size->root.face;
    59     CFF_Font          font     = (CFF_FontRec *)face->extra.data;
     59    CFF_Font          font     = (CFF_Font)face->extra.data;
    6060    PSHinter_Service  pshinter = (PSHinter_Service)font->pshinter;
    6161    FT_Module         module;
     
    7373  cff_size_done( FT_Size  cffsize )        /* CFF_Size */
    7474  {
    75     CFF_Size  size = (CFF_Size)cffsize;
    76 
    77 
    78     if ( cffsize->internal )
     75    CFF_Size      size     = (CFF_Size)cffsize;
     76    CFF_Face      face     = (CFF_Face)size->root.face;
     77    CFF_Font      font     = (CFF_Font)face->extra.data;
     78    CFF_Internal  internal = (CFF_Internal)cffsize->internal;
     79
     80
     81    if ( internal )
    7982    {
    8083      PSH_Globals_Funcs  funcs;
     
    8386      funcs = cff_size_get_globals_funcs( size );
    8487      if ( funcs )
    85         funcs->destroy( (PSH_Globals)cffsize->internal );
    86 
    87       cffsize->internal = 0;
     88      {
     89        FT_UInt  i;
     90
     91
     92        funcs->destroy( internal->topfont );
     93
     94        for ( i = font->num_subfonts; i > 0; i-- )
     95          funcs->destroy( internal->subfonts[i - 1] );
     96      }
     97
     98      /* `internal' is freed by destroy_size (in ftobjs.c) */
    8899    }
     100  }
     101
     102
     103  /* CFF and Type 1 private dictionaries have slightly different      */
     104  /* structures; we need to synthetize a Type 1 dictionary on the fly */
     105
     106  static void
     107  cff_make_private_dict( CFF_SubFont  subfont,
     108                         PS_Private   priv )
     109  {
     110    CFF_Private  cpriv = &subfont->private_dict;
     111    FT_UInt      n, count;
     112
     113
     114    FT_MEM_ZERO( priv, sizeof ( *priv ) );
     115
     116    count = priv->num_blue_values = cpriv->num_blue_values;
     117    for ( n = 0; n < count; n++ )
     118      priv->blue_values[n] = (FT_Short)cpriv->blue_values[n];
     119
     120    count = priv->num_other_blues = cpriv->num_other_blues;
     121    for ( n = 0; n < count; n++ )
     122      priv->other_blues[n] = (FT_Short)cpriv->other_blues[n];
     123
     124    count = priv->num_family_blues = cpriv->num_family_blues;
     125    for ( n = 0; n < count; n++ )
     126      priv->family_blues[n] = (FT_Short)cpriv->family_blues[n];
     127
     128    count = priv->num_family_other_blues = cpriv->num_family_other_blues;
     129    for ( n = 0; n < count; n++ )
     130      priv->family_other_blues[n] = (FT_Short)cpriv->family_other_blues[n];
     131
     132    priv->blue_scale = cpriv->blue_scale;
     133    priv->blue_shift = (FT_Int)cpriv->blue_shift;
     134    priv->blue_fuzz  = (FT_Int)cpriv->blue_fuzz;
     135
     136    priv->standard_width[0]  = (FT_UShort)cpriv->standard_width;
     137    priv->standard_height[0] = (FT_UShort)cpriv->standard_height;
     138
     139    count = priv->num_snap_widths = cpriv->num_snap_widths;
     140    for ( n = 0; n < count; n++ )
     141      priv->snap_widths[n] = (FT_Short)cpriv->snap_widths[n];
     142
     143    count = priv->num_snap_heights = cpriv->num_snap_heights;
     144    for ( n = 0; n < count; n++ )
     145      priv->snap_heights[n] = (FT_Short)cpriv->snap_heights[n];
     146
     147    priv->force_bold     = cpriv->force_bold;
     148    priv->language_group = cpriv->language_group;
     149    priv->lenIV          = cpriv->lenIV;
    89150  }
    90151
     
    100161    if ( funcs )
    101162    {
    102       PSH_Globals    globals;
    103       CFF_Face       face    = (CFF_Face)cffsize->face;
    104       CFF_Font       font    = (CFF_FontRec *)face->extra.data;
    105       CFF_SubFont    subfont = &font->top_font;
    106 
    107       CFF_Private    cpriv   = &subfont->private_dict;
     163      CFF_Face      face     = (CFF_Face)cffsize->face;
     164      CFF_Font      font     = (CFF_Font)face->extra.data;
     165      CFF_Internal  internal;
     166
    108167      PS_PrivateRec  priv;
    109 
    110 
    111       /* IMPORTANT: The CFF and Type1 private dictionaries have    */
    112       /*            slightly different structures; we need to      */
    113       /*            synthetize a type1 dictionary on the fly here. */
    114 
    115       {
    116         FT_UInt  n, count;
    117 
    118 
    119         FT_MEM_ZERO( &priv, sizeof ( priv ) );
    120 
    121         count = priv.num_blue_values = cpriv->num_blue_values;
    122         for ( n = 0; n < count; n++ )
    123           priv.blue_values[n] = (FT_Short)cpriv->blue_values[n];
    124 
    125         count = priv.num_other_blues = cpriv->num_other_blues;
    126         for ( n = 0; n < count; n++ )
    127           priv.other_blues[n] = (FT_Short)cpriv->other_blues[n];
    128 
    129         count = priv.num_family_blues = cpriv->num_family_blues;
    130         for ( n = 0; n < count; n++ )
    131           priv.family_blues[n] = (FT_Short)cpriv->family_blues[n];
    132 
    133         count = priv.num_family_other_blues = cpriv->num_family_other_blues;
    134         for ( n = 0; n < count; n++ )
    135           priv.family_other_blues[n] = (FT_Short)cpriv->family_other_blues[n];
    136 
    137         priv.blue_scale = cpriv->blue_scale;
    138         priv.blue_shift = (FT_Int)cpriv->blue_shift;
    139         priv.blue_fuzz  = (FT_Int)cpriv->blue_fuzz;
    140 
    141         priv.standard_width[0]  = (FT_UShort)cpriv->standard_width;
    142         priv.standard_height[0] = (FT_UShort)cpriv->standard_height;
    143 
    144         count = priv.num_snap_widths = cpriv->num_snap_widths;
    145         for ( n = 0; n < count; n++ )
    146           priv.snap_widths[n] = (FT_Short)cpriv->snap_widths[n];
    147 
    148         count = priv.num_snap_heights = cpriv->num_snap_heights;
    149         for ( n = 0; n < count; n++ )
    150           priv.snap_heights[n] = (FT_Short)cpriv->snap_heights[n];
    151 
    152         priv.force_bold     = cpriv->force_bold;
    153         priv.language_group = cpriv->language_group;
    154         priv.lenIV          = cpriv->lenIV;
    155       }
    156 
    157       error = funcs->create( cffsize->face->memory, &priv, &globals );
    158       if ( !error )
    159         cffsize->internal = (FT_Size_Internal)(void*)globals;
     168      FT_Memory      memory = cffsize->face->memory;
     169
     170      FT_UInt  i;
     171
     172
     173      if ( FT_NEW( internal ) )
     174        goto Exit;
     175
     176      cff_make_private_dict( &font->top_font, &priv );
     177      error = funcs->create( cffsize->face->memory, &priv,
     178                             &internal->topfont );
     179      if ( error )
     180        goto Exit;
     181
     182      for ( i = font->num_subfonts; i > 0; i-- )
     183      {
     184        CFF_SubFont  sub = font->subfonts[i - 1];
     185
     186
     187        cff_make_private_dict( sub, &priv );
     188        error = funcs->create( cffsize->face->memory, &priv,
     189                               &internal->subfonts[i - 1] );
     190        if ( error )
     191          goto Exit;
     192      }
     193
     194      cffsize->internal = (FT_Size_Internal)(void*)internal;
    160195    }
    161196
    162197    size->strike_index = 0xFFFFFFFFUL;
    163198
     199  Exit:
    164200    return error;
    165201  }
     
    183219
    184220    if ( funcs )
    185       funcs->set_scale( (PSH_Globals)size->internal,
    186                         size->metrics.x_scale,
    187                         size->metrics.y_scale,
     221    {
     222      CFF_Face      face     = (CFF_Face)size->face;
     223      CFF_Font      font     = (CFF_Font)face->extra.data;
     224      CFF_Internal  internal = (CFF_Internal)size->internal;
     225
     226      FT_Int   top_upm  = font->top_font.font_dict.units_per_em;
     227      FT_UInt  i;
     228
     229
     230      funcs->set_scale( internal->topfont,
     231                        size->metrics.x_scale, size->metrics.y_scale,
    188232                        0, 0 );
     233
     234      for ( i = font->num_subfonts; i > 0; i-- )
     235      {
     236        CFF_SubFont  sub     = font->subfonts[i - 1];
     237        FT_Int       sub_upm = sub->font_dict.units_per_em;
     238        FT_Pos       x_scale, y_scale;
     239
     240
     241        if ( top_upm != sub_upm )
     242        {
     243          x_scale = FT_MulDiv( size->metrics.x_scale, top_upm, sub_upm );
     244          y_scale = FT_MulDiv( size->metrics.y_scale, top_upm, sub_upm );
     245        }
     246        else
     247        {
     248          x_scale = size->metrics.x_scale;
     249          y_scale = size->metrics.y_scale;
     250        }
     251
     252        funcs->set_scale( internal->subfonts[i - 1],
     253                          x_scale, y_scale, 0, 0 );
     254      }
     255    }
    189256
    190257    return CFF_Err_Ok;
     
    224291
    225292    if ( funcs )
    226       funcs->set_scale( (PSH_Globals)size->internal,
    227                         size->metrics.x_scale,
    228                         size->metrics.y_scale,
     293    {
     294      CFF_Face      cffface  = (CFF_Face)size->face;
     295      CFF_Font      font     = (CFF_Font)cffface->extra.data;
     296      CFF_Internal  internal = (CFF_Internal)size->internal;
     297
     298      FT_Int   top_upm  = font->top_font.font_dict.units_per_em;
     299      FT_UInt  i;
     300
     301
     302      funcs->set_scale( internal->topfont,
     303                        size->metrics.x_scale, size->metrics.y_scale,
    229304                        0, 0 );
     305
     306      for ( i = font->num_subfonts; i > 0; i-- )
     307      {
     308        CFF_SubFont  sub     = font->subfonts[i - 1];
     309        FT_Int       sub_upm = sub->font_dict.units_per_em;
     310        FT_Pos       x_scale, y_scale;
     311
     312
     313        if ( top_upm != sub_upm )
     314        {
     315          x_scale = FT_MulDiv( size->metrics.x_scale, top_upm, sub_upm );
     316          y_scale = FT_MulDiv( size->metrics.y_scale, top_upm, sub_upm );
     317        }
     318        else
     319        {
     320          x_scale = size->metrics.x_scale;
     321          y_scale = size->metrics.y_scale;
     322        }
     323
     324        funcs->set_scale( internal->subfonts[i - 1],
     325                          x_scale, y_scale, 0, 0 );
     326      }
     327    }
    230328
    231329    return CFF_Err_Ok;
     
    250348  {
    251349    CFF_Face          face     = (CFF_Face)slot->face;
    252     CFF_Font          font     = (CFF_FontRec *)face->extra.data;
     350    CFF_Font          font     = (CFF_Font)face->extra.data;
    253351    PSHinter_Service  pshinter = (PSHinter_Service)font->pshinter;
    254352
     
    271369    }
    272370
    273     return 0;
     371    return CFF_Err_Ok;
    274372  }
    275373
     
    289387
    290388
    291     result = ft_mem_strdup( memory, source, &error );
     389    (void)FT_STRDUP( result, source );
     390
     391    FT_UNUSED( error );
    292392
    293393    return result;
     
    435535      }
    436536
     537      if ( !dict->units_per_em )
     538        dict->units_per_em = pure_cff ? 1000 : face->root.units_per_EM;
     539
     540      /* Normalize the font matrix so that `matrix->xx' is 1; the */
     541      /* scaling is done with `units_per_em' then (at this point, */
     542      /* it already contains the scaling factor, but without      */
     543      /* normalization of the matrix).                            */
     544      /*                                                          */
     545      /* Note that the offsets must be expressed in integer font  */
     546      /* units.                                                   */
     547
     548      {
     549        FT_Matrix*  matrix = &dict->font_matrix;
     550        FT_Vector*  offset = &dict->font_offset;
     551        FT_ULong*   upm    = &dict->units_per_em;
     552        FT_Fixed    temp   = FT_ABS( matrix->yy );
     553
     554
     555        if ( temp != 0x10000L )
     556        {
     557          *upm = FT_DivFix( *upm, temp );
     558
     559          matrix->xx = FT_DivFix( matrix->xx, temp );
     560          matrix->yx = FT_DivFix( matrix->yx, temp );
     561          matrix->xy = FT_DivFix( matrix->xy, temp );
     562          matrix->yy = FT_DivFix( matrix->yy, temp );
     563          offset->x  = FT_DivFix( offset->x,  temp );
     564          offset->y  = FT_DivFix( offset->y,  temp );
     565        }
     566
     567        offset->x >>= 16;
     568        offset->y >>= 16;
     569      }
     570
     571      for ( i = cff->num_subfonts; i > 0; i-- )
     572      {
     573        CFF_FontRecDict  sub = &cff->subfonts[i - 1]->font_dict;
     574        CFF_FontRecDict  top = &cff->top_font.font_dict;
     575
     576        FT_Matrix*  matrix;
     577        FT_Vector*  offset;
     578        FT_ULong*   upm;
     579        FT_Fixed    temp;
     580
     581
     582        if ( sub->units_per_em )
     583        {
     584          FT_Int  scaling;
     585
     586
     587          if ( top->units_per_em > 1 && sub->units_per_em > 1 )
     588            scaling = FT_MIN( top->units_per_em, sub->units_per_em );
     589          else
     590            scaling = 1;
     591
     592          FT_Matrix_Multiply_Scaled( &top->font_matrix,
     593                                     &sub->font_matrix,
     594                                     scaling );
     595          FT_Vector_Transform_Scaled( &sub->font_offset,
     596                                      &top->font_matrix,
     597                                      scaling );
     598
     599          sub->units_per_em = FT_MulDiv( sub->units_per_em,
     600                                         top->units_per_em,
     601                                         scaling );
     602        }
     603        else
     604        {
     605          sub->font_matrix = top->font_matrix;
     606          sub->font_offset = top->font_offset;
     607
     608          sub->units_per_em = top->units_per_em;
     609        }
     610
     611        matrix = &sub->font_matrix;
     612        offset = &sub->font_offset;
     613        upm    = &sub->units_per_em;
     614        temp   = FT_ABS( matrix->yy );
     615
     616        if ( temp != 0x10000L )
     617        {
     618          *upm = FT_DivFix( *upm, temp );
     619
     620          /* if *upm is larger than 100*1000 we divide by 1000 --     */
     621          /* this can happen if e.g. there is no top-font FontMatrix  */
     622          /* and the subfont FontMatrix already contains the complete */
     623          /* scaling for the subfont (see section 5.11 of the PLRM)   */
     624
     625          /* 100 is a heuristic value */
     626
     627          if ( *upm > 100L * 1000L )
     628            *upm = ( *upm + 500 ) / 1000;
     629
     630          matrix->xx = FT_DivFix( matrix->xx, temp );
     631          matrix->yx = FT_DivFix( matrix->yx, temp );
     632          matrix->xy = FT_DivFix( matrix->xy, temp );
     633          matrix->yy = FT_DivFix( matrix->yy, temp );
     634          offset->x  = FT_DivFix( offset->x,  temp );
     635          offset->y  = FT_DivFix( offset->y,  temp );
     636        }
     637
     638        offset->x >>= 16;
     639        offset->y >>= 16;
     640      }
     641
    437642      if ( pure_cff )
    438643      {
     
    445650        /* compute number of glyphs */
    446651        if ( dict->cid_registry != 0xFFFFU )
    447           cffface->num_glyphs = dict->cid_count;
     652          cffface->num_glyphs = cff->charset.max_cid;
    448653        else
    449654          cffface->num_glyphs = cff->charstrings_index.count;
     
    455660        cffface->bbox.yMax = ( dict->font_bbox.yMax + 0xFFFFU ) >> 16;
    456661
    457         if ( !dict->units_per_em )
    458           dict->units_per_em = 1000;
    459662
    460663        cffface->units_per_EM = dict->units_per_em;
     
    612815        cffface->style_flags = flags;
    613816      }
    614       else
    615       {
    616         if ( !dict->units_per_em )
    617           dict->units_per_em = face->root.units_per_EM;
    618       }
    619 
    620       /* handle font matrix settings in subfonts (if any) */
    621       for ( i = cff->num_subfonts; i > 0; i-- )
    622       {
    623         CFF_FontRecDict  sub = &cff->subfonts[i - 1]->font_dict;
    624         CFF_FontRecDict  top = &cff->top_font.font_dict;
    625 
    626 
    627         if ( sub->units_per_em )
    628         {
    629           FT_Matrix  scale;
    630 
    631 
    632           scale.xx = scale.yy = (FT_Fixed)FT_DivFix( top->units_per_em,
    633                                                      sub->units_per_em );
    634           scale.xy = scale.yx = 0;
    635 
    636           FT_Matrix_Multiply( &scale, &sub->font_matrix );
    637           FT_Vector_Transform( &sub->font_offset, &scale );
    638         }
    639         else
    640         {
    641           sub->font_matrix = top->font_matrix;
    642           sub->font_offset = top->font_offset;
    643         }
    644       }
     817
    645818
    646819#ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
    647820      /* CID-keyed CFF fonts don't have glyph names -- the SFNT loader */
    648       /* has unset this flag because of the 3.0 `post' table           */
     821      /* has unset this flag because of the 3.0 `post' table.          */
    649822      if ( dict->cid_registry == 0xFFFFU )
    650823        cffface->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
    651824#endif
     825
     826      if ( dict->cid_registry != 0xFFFFU )
     827        cffface->face_flags |= FT_FACE_FLAG_CID_KEYED;
     828
    652829
    653830      /*******************************************************************/
     
    684861          goto Exit;
    685862
    686         /* we didn't find a Unicode charmap -- synthetize one */
     863        /* we didn't find a Unicode charmap -- synthesize one */
    687864        cmaprec.face        = cffface;
    688865        cmaprec.platform_id = 3;
  • trunk/poppler/freetype2/src/cff/cffobjs.h

    r209 r251  
    55/*    OpenType objects manager (specification).                            */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2626#include FT_INTERNAL_TRUETYPE_TYPES_H
    2727#include FT_SERVICE_POSTSCRIPT_CMAPS_H
     28#include FT_INTERNAL_POSTSCRIPT_HINTS_H
    2829
    2930
     
    5455  typedef struct  CFF_SizeRec_
    5556  {
    56     FT_SizeRec       root;
    57     FT_ULong         strike_index;    /* 0xFFFFFFFF to indicate invalid */
     57    FT_SizeRec  root;
     58    FT_ULong    strike_index;    /* 0xFFFFFFFF to indicate invalid */
    5859
    5960  } CFF_SizeRec, *CFF_Size;
     
    8081  } CFF_GlyphSlotRec, *CFF_GlyphSlot;
    8182
     83
     84  /*************************************************************************/
     85  /*                                                                       */
     86  /* <Type>                                                                */
     87  /*    CFF_Internal                                                       */
     88  /*                                                                       */
     89  /* <Description>                                                         */
     90  /*    The interface to the `internal' field of `FT_Size'.                */
     91  /*                                                                       */
     92  typedef struct  CFF_InternalRec_
     93  {
     94    PSH_Globals  topfont;
     95    PSH_Globals  subfonts[CFF_MAX_CID_FONTS];
     96
     97  } CFF_InternalRec, *CFF_Internal;
    8298
    8399
  • trunk/poppler/freetype2/src/cff/cffparse.c

    r209 r251  
    55/*    CFF token stream parser (body)                                       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2007 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2007, 2008 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2020#include "cffparse.h"
    2121#include FT_INTERNAL_STREAM_H
     22#include FT_INTERNAL_DEBUG_H
    2223
    2324#include "cfferrs.h"
     
    137138
    138139
     140  static const FT_Long power_tens[] =
     141  {
     142    1L,
     143    10L,
     144    100L,
     145    1000L,
     146    10000L,
     147    100000L,
     148    1000000L,
     149    10000000L,
     150    100000000L,
     151    1000000000L
     152  };
     153
     154
    139155  /* read a real */
    140156  static FT_Fixed
    141157  cff_parse_real( FT_Byte*  start,
    142158                  FT_Byte*  limit,
    143                   FT_Int    power_ten )
    144   {
    145     FT_Byte*  p    = start;
    146     FT_Long   num, divider, result, exponent;
    147     FT_Int    sign = 0, exponent_sign = 0;
     159                  FT_Int    power_ten,
     160                  FT_Int*   scaling )
     161  {
     162    FT_Byte*  p = start;
    148163    FT_UInt   nib;
    149164    FT_UInt   phase;
    150165
    151 
    152     result  = 0;
    153     num     = 0;
    154     divider = 1;
    155 
    156     /* first of all, read the integer part */
     166    FT_Long   result, number, rest, exponent;
     167    FT_Int    sign = 0, exponent_sign = 0;
     168    FT_Int    exponent_add, integer_length, fraction_length;
     169
     170
     171    if ( scaling )
     172      *scaling  = 0;
     173
     174    result = 0;
     175
     176    number   = 0;
     177    rest     = 0;
     178    exponent = 0;
     179
     180    exponent_add    = 0;
     181    integer_length  = 0;
     182    fraction_length = 0;
     183
     184    /* First of all, read the integer part. */
    157185    phase = 4;
    158186
     
    167195        /* Make sure we don't read past the end. */
    168196        if ( p >= limit )
    169           goto Bad;
     197          goto Exit;
    170198      }
    171199
     
    179207        break;
    180208      else
    181         result = result * 10 + nib;
    182     }
    183 
    184     /* read decimal part, if any */
     209      {
     210        /* Increase exponent if we can't add the digit. */
     211        if ( number >= 0xCCCCCCCL )
     212          exponent_add++;
     213        /* Skip leading zeros. */
     214        else if ( nib || number )
     215        {
     216          integer_length++;
     217          number = number * 10 + nib;
     218        }
     219      }
     220    }
     221
     222    /* Read fraction part, if any. */
    185223    if ( nib == 0xa )
    186224      for (;;)
     
    194232          /* Make sure we don't read past the end. */
    195233          if ( p >= limit )
    196             goto Bad;
     234            goto Exit;
    197235        }
    198236
     
    203241          break;
    204242
    205         if ( divider < 10000000L )
    206         {
    207           num      = num * 10 + nib;
    208           divider *= 10;
    209         }
    210       }
    211 
    212     /* read exponent, if any */
     243        /* Skip leading zeros if possible. */
     244        if ( !nib && !number )
     245          exponent_add--;
     246        /* Only add digit if we don't overflow. */
     247        else if ( number < 0xCCCCCCCL )
     248        {
     249          fraction_length++;
     250          number = number * 10 + nib;
     251        }
     252      }
     253
     254    /* Read exponent, if any. */
    213255    if ( nib == 12 )
    214256    {
     
    219261    if ( nib == 11 )
    220262    {
    221       exponent = 0;
    222 
    223263      for (;;)
    224264      {
    225         /* If we entered this iteration with phase == 4, we need */
    226         /* to read a new byte.                                   */
     265        /* If we entered this iteration with phase == 4, */
     266        /* we need to read a new byte.                   */
    227267        if ( phase )
    228268        {
     
    231271          /* Make sure we don't read past the end. */
    232272          if ( p >= limit )
    233             goto Bad;
     273            goto Exit;
    234274        }
    235275
     
    241281
    242282        exponent = exponent * 10 + nib;
     283
     284        /* Arbitrarily limit exponent. */
     285        if ( exponent > 1000 )
     286          goto Exit;
    243287      }
    244288
    245289      if ( exponent_sign )
    246290        exponent = -exponent;
    247 
    248       power_ten += (FT_Int)exponent;
    249     }
    250 
    251     /* raise to power of ten if needed */
    252     while ( power_ten > 0 )
    253     {
    254       result = result * 10;
    255       num    = num * 10;
    256 
    257       power_ten--;
    258     }
    259 
    260     while ( power_ten < 0 )
    261     {
    262       result  = result / 10;
    263       divider = divider * 10;
    264 
    265       power_ten++;
    266     }
    267 
    268     /* Move the integer part into the high 16 bits. */
    269     result <<= 16;
    270 
    271     /* Place the decimal part into the low 16 bits. */
    272     if ( num )
    273       result |= FT_DivFix( num, divider );
     291    }
     292
     293    /* We don't check `power_ten' and `exponent_add'. */
     294    exponent += power_ten + exponent_add;
     295
     296    if ( scaling )
     297    {
     298      /* Only use `fraction_length'. */
     299      fraction_length += integer_length;
     300      exponent        += integer_length;
     301
     302      if ( fraction_length <= 5 )
     303      {
     304        if ( number > 0x7FFFL )
     305        {
     306          result   = FT_DivFix( number, 10 );
     307          *scaling = exponent - fraction_length + 1;
     308        }
     309        else
     310        {
     311          if ( exponent > 0 )
     312          {
     313            FT_Int  new_fraction_length, shift;
     314
     315
     316            /* Make `scaling' as small as possible. */
     317            new_fraction_length = FT_MIN( exponent, 5 );
     318            exponent           -= new_fraction_length;
     319            shift               = new_fraction_length - fraction_length;
     320
     321            number *= power_tens[shift];
     322            if ( number > 0x7FFFL )
     323            {
     324              number   /= 10;
     325              exponent += 1;
     326            }
     327          }
     328          else
     329            exponent -= fraction_length;
     330
     331          result   = number << 16;
     332          *scaling = exponent;
     333        }
     334      }
     335      else
     336      {
     337        if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
     338        {
     339          result   = FT_DivFix( number, power_tens[fraction_length - 4] );
     340          *scaling = exponent - 4;
     341        }
     342        else
     343        {
     344          result   = FT_DivFix( number, power_tens[fraction_length - 5] );
     345          *scaling = exponent - 5;
     346        }
     347      }
     348    }
     349    else
     350    {
     351      integer_length  += exponent;
     352      fraction_length -= exponent;
     353
     354      /* Check for overflow and underflow. */
     355      if ( FT_ABS( integer_length ) > 5 )
     356        goto Exit;
     357
     358      /* Convert into 16.16 format. */
     359      if ( fraction_length > 0 )
     360      {
     361        if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
     362          goto Exit;
     363
     364        result = FT_DivFix( number, power_tens[fraction_length] );
     365      }
     366      else
     367      {
     368        number *= power_tens[-fraction_length];
     369
     370        if ( number > 0x7FFFL )
     371          goto Exit;
     372
     373        result = number << 16;
     374      }
     375    }
    274376
    275377    if ( sign )
     
    278380  Exit:
    279381    return result;
    280 
    281   Bad:
    282     result = 0;
    283     goto Exit;
    284382  }
    285383
     
    289387  cff_parse_num( FT_Byte**  d )
    290388  {
    291     return ( **d == 30 ? ( cff_parse_real   ( d[0], d[1], 0 ) >> 16 )
    292                        :   cff_parse_integer( d[0], d[1] ) );
     389    return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 )
     390                     :   cff_parse_integer( d[0], d[1] );
    293391  }
    294392
     
    298396  cff_parse_fixed( FT_Byte**  d )
    299397  {
    300     return ( **d == 30 ? cff_parse_real   ( d[0], d[1], 0 )
    301                        : cff_parse_integer( d[0], d[1] ) << 16 );
    302   }
     398    return **d == 30 ? cff_parse_real( d[0], d[1], 0, NULL )
     399                     : cff_parse_integer( d[0], d[1] ) << 16;
     400  }
     401
    303402
    304403  /* read a floating point number, either integer or real, */
    305   /* but return 1000 times the number read in.             */
     404  /* but return `10^scaling' times the number read in      */
    306405  static FT_Fixed
    307   cff_parse_fixed_thousand( FT_Byte**  d )
     406  cff_parse_fixed_scaled( FT_Byte**  d,
     407                          FT_Int     scaling )
    308408  {
    309409    return **d ==
    310       30 ? cff_parse_real     ( d[0], d[1], 3 )
    311          : (FT_Fixed)FT_MulFix( cff_parse_integer( d[0], d[1] ) << 16, 1000 );
    312   }
     410      30 ? cff_parse_real( d[0], d[1], scaling, NULL )
     411         : (FT_Fixed)FT_MulFix( cff_parse_integer( d[0], d[1] ) << 16,
     412                                                   power_tens[scaling] );
     413  }
     414
     415
     416  /* read a floating point number, either integer or real,     */
     417  /* and return it as precise as possible -- `scaling' returns */
     418  /* the scaling factor (as a power of 10)                     */
     419  static FT_Fixed
     420  cff_parse_fixed_dynamic( FT_Byte**  d,
     421                           FT_Int*    scaling )
     422  {
     423    FT_ASSERT( scaling );
     424
     425    if ( **d == 30 )
     426      return cff_parse_real( d[0], d[1], 0, scaling );
     427    else
     428    {
     429      FT_Long  number;
     430      FT_Int   integer_length;
     431
     432
     433      number = cff_parse_integer( d[0], d[1] );
     434
     435      if ( number > 0x7FFFL )
     436      {
     437        for ( integer_length = 5; integer_length < 10; integer_length++ )
     438          if ( number < power_tens[integer_length] )
     439            break;
     440
     441        if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL )
     442        {
     443          *scaling = integer_length - 4;
     444          return FT_DivFix( number, power_tens[integer_length - 4] );
     445        }
     446        else
     447        {
     448          *scaling = integer_length - 5;
     449          return FT_DivFix( number, power_tens[integer_length - 5] );
     450        }
     451      }
     452      else
     453      {
     454        *scaling = 0;
     455        return number << 16;
     456      }
     457    }
     458  }
     459
    313460
    314461  static FT_Error
     
    318465    FT_Matrix*       matrix = &dict->font_matrix;
    319466    FT_Vector*       offset = &dict->font_offset;
    320     FT_UShort*       upm    = &dict->units_per_em;
     467    FT_ULong*        upm    = &dict->units_per_em;
    321468    FT_Byte**        data   = parser->stack;
    322     FT_Error         error;
    323     FT_Fixed         temp;
    324 
    325 
    326     error = CFF_Err_Stack_Underflow;
     469    FT_Error         error  = CFF_Err_Stack_Underflow;
     470
    327471
    328472    if ( parser->top >= parser->stack + 6 )
    329473    {
    330       matrix->xx = cff_parse_fixed_thousand( data++ );
    331       matrix->yx = cff_parse_fixed_thousand( data++ );
    332       matrix->xy = cff_parse_fixed_thousand( data++ );
    333       matrix->yy = cff_parse_fixed_thousand( data++ );
    334       offset->x  = cff_parse_fixed_thousand( data++ );
    335       offset->y  = cff_parse_fixed_thousand( data   );
    336 
    337       temp = FT_ABS( matrix->yy );
    338 
    339       *upm = (FT_UShort)FT_DivFix( 0x10000L, FT_DivFix( temp, 1000 ) );
    340 
    341       if ( temp != 0x10000L )
    342       {
    343         matrix->xx = FT_DivFix( matrix->xx, temp );
    344         matrix->yx = FT_DivFix( matrix->yx, temp );
    345         matrix->xy = FT_DivFix( matrix->xy, temp );
    346         matrix->yy = FT_DivFix( matrix->yy, temp );
    347         offset->x  = FT_DivFix( offset->x,  temp );
    348         offset->y  = FT_DivFix( offset->y,  temp );
    349       }
    350 
    351       /* note that the offsets must be expressed in integer font units */
    352       offset->x >>= 16;
    353       offset->y >>= 16;
     474      FT_Int  scaling;
     475
    354476
    355477      error = CFF_Err_Ok;
    356     }
    357 
     478
     479      /* We expect a well-formed font matrix, this is, the matrix elements */
     480      /* `xx' and `yy' are of approximately the same magnitude.  To avoid  */
     481      /* loss of precision, we use the magnitude of element `xx' to scale  */
     482      /* all other elements.  The scaling factor is then contained in the  */
     483      /* `units_per_em' value.                                             */
     484
     485      matrix->xx = cff_parse_fixed_dynamic( data++, &scaling );
     486
     487      scaling = -scaling;
     488
     489      if ( scaling < 0 || scaling > 9 )
     490      {
     491        /* Return default matrix in case of unlikely values. */
     492        matrix->xx = 0x10000L;
     493        matrix->yx = 0;
     494        matrix->yx = 0;
     495        matrix->yy = 0x10000L;
     496        offset->x  = 0;
     497        offset->y  = 0;
     498        *upm       = 1;
     499
     500        goto Exit;
     501      }
     502
     503      matrix->yx = cff_parse_fixed_scaled( data++, scaling );
     504      matrix->xy = cff_parse_fixed_scaled( data++, scaling );
     505      matrix->yy = cff_parse_fixed_scaled( data++, scaling );
     506      offset->x  = cff_parse_fixed_scaled( data++, scaling );
     507      offset->y  = cff_parse_fixed_scaled( data,   scaling );
     508
     509      *upm = power_tens[scaling];
     510    }
     511
     512  Exit:
    358513    return error;
    359514  }
     
    586741
    587742            case cff_kind_fixed_thousand:
    588               val = cff_parse_fixed_thousand( parser->stack );
     743              val = cff_parse_fixed_scaled( parser->stack, 3 );
    589744
    590745            Store_Number:
  • trunk/poppler/freetype2/src/cff/cfftypes.h

    r209 r251  
    66/*    only).                                                               */
    77/*                                                                         */
    8 /*  Copyright 1996-2001, 2002, 2003, 2006, 2007 by                         */
     8/*  Copyright 1996-2001, 2002, 2003, 2006, 2007, 2008 by                   */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    115115    FT_Int     charstring_type;
    116116    FT_Matrix  font_matrix;
    117     FT_UShort  units_per_em;
     117    FT_ULong   units_per_em;  /* temporarily used as scaling value also */
    118118    FT_Vector  font_offset;
    119119    FT_ULong   unique_id;
     
    260260    PS_FontInfoRec*  font_info;   /* font info dictionary */
    261261
     262    /* since version 2.3.6 */
     263    FT_String*       registry;
     264    FT_String*       ordering;
     265     
    262266  } CFF_FontRec, *CFF_Font;
    263267
  • trunk/poppler/freetype2/src/cid/cidgload.c

    r209 r251  
    7575      {
    7676        glyph_length = glyph_data.length - cid->fd_bytes;
    77         FT_ALLOC( charstring, glyph_length );
     77        (void)FT_ALLOC( charstring, glyph_length );
    7878        if ( !error )
    7979          ft_memcpy( charstring, glyph_data.pointer + cid->fd_bytes,
  • trunk/poppler/freetype2/src/cid/cidriver.c

    r150 r251  
    55/*    CID driver interface (body).                                         */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2008 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2828#include FT_SERVICE_XFREE86_NAME_H
    2929#include FT_SERVICE_POSTSCRIPT_INFO_H
     30#include FT_SERVICE_CID_H
     31
    3032
    3133  /*************************************************************************/
     
    3941
    4042
    41  /*
    42   *  POSTSCRIPT NAME SERVICE
    43   *
    44   */
     43  /*
     44   *  POSTSCRIPT NAME SERVICE
     45   *
     46   */
    4547
    4648  static const char*
     
    6365
    6466
    65  /*
    66   *  POSTSCRIPT INFO SERVICE
    67   *
    68   */
     67  /*
     68   *  POSTSCRIPT INFO SERVICE
     69   *
     70   */
    6971
    7072  static FT_Error
     
    8587
    8688
    87  /*
    88   *  SERVICE LIST
    89   *
    90   */
     89  /*
     90   *  CID INFO SERVICE
     91   *
     92   */
     93  static FT_Error
     94  cid_get_ros( CID_Face      face,
     95               const char*  *registry,
     96               const char*  *ordering,
     97               FT_Int       *supplement )
     98  {
     99    CID_FaceInfo  cid = &face->cid;
     100
     101
     102    if ( registry )
     103      *registry = cid->registry;
     104     
     105    if ( ordering )
     106      *ordering = cid->ordering;
     107
     108    if ( supplement )
     109      *supplement = cid->supplement;
     110     
     111    return CID_Err_Ok;
     112  }
     113
     114
     115  static const FT_Service_CIDRec  cid_service_cid_info =
     116  {
     117    (FT_CID_GetRegistryOrderingSupplementFunc)cid_get_ros
     118  };
     119
     120
     121  /*
     122   *  SERVICE LIST
     123   *
     124   */
    91125
    92126  static const FT_ServiceDescRec  cid_services[] =
    93127  {
     128    { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CID },
    94129    { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &cid_service_ps_name },
    95     { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CID },
    96130    { FT_SERVICE_ID_POSTSCRIPT_INFO,      &cid_service_ps_info },
     131    { FT_SERVICE_ID_CID,                  &cid_service_cid_info },
    97132    { NULL, NULL }
    98133  };
  • trunk/poppler/freetype2/src/gxvalid/gxvfeat.c

    r150 r251  
    55/*    TrueTypeGX/AAT feat table validation (body).                         */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by suzuki toshiya, Masatake YAMATO, Red Hat K.K., */
     7/*  Copyright 2004, 2005, 2008 by                                          */
     8/*  suzuki toshiya, Masatake YAMATO, Red Hat K.K.,                         */
    89/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    910/*                                                                         */
     
    6061
    6162
    62   typedef enum
     63  typedef enum  GXV_FeatureFlagsMask_
    6364  {
    6465    GXV_FEAT_MASK_EXCLUSIVE_SETTINGS = 0x8000U,
  • trunk/poppler/freetype2/src/gxvalid/gxvmort1.c

    r209 r251  
    203203      if ( dst_gid > valid->face->num_glyphs )
    204204      {
    205         GXV_TRACE(( "substTable include toolarge gid[%d]=%d >"
     205        GXV_TRACE(( "substTable include too large gid[%d]=%d >"
    206206                    " max defined gid #%d\n",
    207207                    i, dst_gid, valid->face->num_glyphs ));
  • trunk/poppler/freetype2/src/lzw/ftzopen.h

    r209 r251  
    99/*  distributions.                                                         */
    1010/*                                                                         */
    11 /*  Copyright 2005, 2006, 2007 by David Turner.                            */
     11/*  Copyright 2005, 2006, 2007, 2008 by David Turner.                      */
    1212/*                                                                         */
    1313/*  This file is part of the FreeType project, and may only be used,       */
     
    4747
    4848
    49   typedef enum
     49  typedef enum  FT_LzwPhase_
    5050  {
    5151    FT_LZW_PHASE_START = 0,
     
    110110   */
    111111
    112   typedef struct  _FT_LzwStateRec
     112  typedef struct  FT_LzwStateRec_
    113113  {
    114114    FT_LzwPhase  phase;
  • trunk/poppler/freetype2/src/otvalid/otvalid.c

    r150 r251  
    55/*    FreeType validator for OpenType tables (body only).                  */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2626#include "otvgsub.c"
    2727#include "otvjstf.c"
     28#include "otvmath.c"
    2829#include "otvmod.c"
    2930
  • trunk/poppler/freetype2/src/otvalid/otvalid.h

    r150 r251  
    55/*    OpenType table validation (specification only).                      */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2008 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6464                     FT_Validator  valid );
    6565
     66  FT_LOCAL( void )
     67  otv_MATH_validate( FT_Bytes      table,
     68                     FT_UInt       glyph_count,
     69                     FT_Validator  ftvalid );
     70
    6671
    6772FT_END_HEADER
  • trunk/poppler/freetype2/src/otvalid/otvbase.c

    r150 r251  
    55/*    OpenType BASE table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6363
    6464    default:
    65       FT_INVALID_DATA;
     65      FT_INVALID_FORMAT;
    6666    }
    6767
     
    298298
    299299    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    300       FT_INVALID_DATA;
     300      FT_INVALID_FORMAT;
    301301
    302302    table_size = 6;
  • trunk/poppler/freetype2/src/otvalid/otvcommn.c

    r209 r251  
    55/*    OpenType common tables validation (body).                            */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005, 2006 by                                          */
     7/*  Copyright 2004, 2005, 2006, 2007 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    4040  FT_LOCAL_DEF( void )
    4141  otv_Coverage_validate( FT_Bytes       table,
    42                          OTV_Validator  valid )
     42                         OTV_Validator  valid,
     43                         FT_Int         expected_count )
    4344  {
    4445    FT_Bytes  p = table;
    4546    FT_UInt   CoverageFormat;
     47    FT_UInt   total = 0;
    4648
    4749
     
    5860      {
    5961        FT_UInt  GlyphCount;
     62        FT_UInt  i;
    6063
    6164
     
    6568
    6669        OTV_LIMIT_CHECK( GlyphCount * 2 );        /* GlyphArray */
     70
     71        for ( i = 0; i < GlyphCount; ++i )
     72        {
     73          FT_UInt  gid;
     74
     75
     76          gid = FT_NEXT_USHORT( p );
     77          if ( gid >= valid->glyph_count )
     78            FT_INVALID_GLYPH_ID;
     79        }
     80
     81        total = GlyphCount;
    6782      }
    6883      break;
     
    7186      {
    7287        FT_UInt  n, RangeCount;
    73         FT_UInt  Start, End, StartCoverageIndex, total = 0, last = 0;
     88        FT_UInt  Start, End, StartCoverageIndex, last = 0;
    7489
    7590
     
    90105            FT_INVALID_DATA;
    91106
     107          if ( End >= valid->glyph_count )
     108            FT_INVALID_GLYPH_ID;
     109
    92110          if ( n > 0 && Start <= last )
    93111            FT_INVALID_DATA;
     
    103121    }
    104122
    105     /* no need to check glyph indices used as input to coverage tables */
    106     /* since even invalid glyph indices return a meaningful result     */
     123    /* Generally, a coverage table offset has an associated count field.  */
     124    /* The number of glyphs in the table should match this field.  If     */
     125    /* there is no associated count, a value of -1 tells us not to check. */
     126    if ( expected_count != -1 && (FT_UInt)expected_count != total )
     127      FT_INVALID_DATA;
    107128
    108129    OTV_EXIT;
     
    216237    case 1:     /* ClassDefFormat1 */
    217238      {
     239        FT_UInt  StartGlyph;
    218240        FT_UInt  GlyphCount;
    219241
    220242
    221         p += 2;         /* skip StartGlyph */
    222 
    223         OTV_LIMIT_CHECK( 2 );
    224 
     243        OTV_LIMIT_CHECK( 4 );
     244
     245        StartGlyph = FT_NEXT_USHORT( p );
    225246        GlyphCount = FT_NEXT_USHORT( p );
    226247
     
    228249
    229250        OTV_LIMIT_CHECK( GlyphCount * 2 );    /* ClassValueArray */
     251
     252        if ( StartGlyph + GlyphCount - 1 >= valid->glyph_count )
     253          FT_INVALID_GLYPH_ID;
    230254      }
    231255      break;
     
    253277            FT_INVALID_DATA;
    254278
     279          if ( End >= valid->glyph_count )
     280            FT_INVALID_GLYPH_ID;
     281
    255282          last = End;
    256283        }
     
    292319    DeltaFormat = FT_NEXT_USHORT( p );
    293320
    294     if ( DeltaFormat < 1 || DeltaFormat > 3 || EndSize < StartSize )
     321    if ( DeltaFormat < 1 || DeltaFormat > 3 )
     322      FT_INVALID_FORMAT;
     323
     324    if ( EndSize < StartSize )
    295325      FT_INVALID_DATA;
    296326
     
    331361    OTV_TRACE(( " (type %d)\n", LookupType ));
    332362
    333     if ( LookupType == 0 || LookupType >= valid->type_count )
     363    if ( LookupType == 0 || LookupType > valid->type_count )
    334364      FT_INVALID_DATA;
    335365
     
    658688    OTV_TRACE(( " (Count = %d)\n", Count ));
    659689
    660     otv_Coverage_validate( table + Coverage, valid );
     690    otv_Coverage_validate( table + Coverage, valid, Count );
    661691
    662692    OTV_LIMIT_CHECK( Count * 2 );
     
    730760
    731761    OTV_LIMIT_CHECK( ( Count1 - 1 ) * 2 + Count2 * 4 );
     762    p += ( Count1 - 1 ) * 2;
    732763
    733764    for ( ; Count2 > 0; Count2-- )
     
    825856    OTV_TRACE(( " (ClassSetCount = %d)\n", ClassSetCount ));
    826857
    827     otv_Coverage_validate( table + Coverage, valid );
     858    otv_Coverage_validate( table + Coverage, valid, -1 );
    828859    otv_ClassDef_validate( table + ClassDef, valid );
    829860
     
    873904
    874905    for ( count1 = GlyphCount; count1 > 0; count1-- )
    875       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     906      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    876907
    877908    for ( ; Count > 0; Count-- )
     
    914945    OTV_TRACE(( " (ChainClassSetCount = %d)\n", ChainClassSetCount ));
    915946
    916     otv_Coverage_validate( table + Coverage, valid );
     947    otv_Coverage_validate( table + Coverage, valid, -1 );
    917948
    918949    otv_ClassDef_validate( table + BacktrackClassDef,  valid );
     
    964995
    965996    for ( ; BacktrackGlyphCount > 0; BacktrackGlyphCount-- )
    966       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     997      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    967998
    968999    InputGlyphCount = FT_NEXT_USHORT( p );
     
    9731004
    9741005    for ( count1 = InputGlyphCount; count1 > 0; count1-- )
    975       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     1006      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    9761007
    9771008    LookaheadGlyphCount = FT_NEXT_USHORT( p );
     
    9821013
    9831014    for ( ; LookaheadGlyphCount > 0; LookaheadGlyphCount-- )
    984       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     1015      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    9851016
    9861017    count2 = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvcommn.h

    r209 r251  
    55/*    OpenType common tables validation (specification).                   */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by                                                */
     7/*  Copyright 2004, 2005, 2007 by                                          */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    216216  FT_LOCAL( void )
    217217  otv_Coverage_validate( FT_Bytes       table,
    218                          OTV_Validator  valid );
     218                         OTV_Validator  valid,
     219                         FT_Int         expected_count );
    219220
    220221  /* return first covered glyph */
  • trunk/poppler/freetype2/src/otvalid/otvgdef.c

    r150 r251  
    55/*    OpenType GDEF table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by                                                */
     7/*  Copyright 2004, 2005, 2007 by                                          */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6262    OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));
    6363
    64     otv_Coverage_validate( Coverage, valid );
     64    otv_Coverage_validate( Coverage, valid, GlyphCount );
    6565    if ( GlyphCount != otv_Coverage_get_count( Coverage ) )
    6666      FT_INVALID_DATA;
     
    127127
    128128    default:
    129       FT_INVALID_DATA;
     129      FT_INVALID_FORMAT;
    130130    }
    131131
  • trunk/poppler/freetype2/src/otvalid/otvgpos.c

    r150 r251  
    55/*    OpenType GPOS table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2002, 2004, 2005, 2006 by                                    */
     7/*  Copyright 2002, 2004, 2005, 2006, 2007, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    125125    Array2     = FT_NEXT_USHORT( p );
    126126
    127     otv_Coverage_validate( table + Coverage1, valid );
    128     otv_Coverage_validate( table + Coverage2, valid );
     127    otv_Coverage_validate( table + Coverage1, valid, -1 );
     128    otv_Coverage_validate( table + Coverage2, valid, -1 );
    129129
    130130    otv_MarkArray_validate( table + Array1, valid );
     
    192192
    193193    if ( format >= 0x100 )
    194       FT_INVALID_DATA;
     194      FT_INVALID_FORMAT;
    195195
    196196    for ( count = 4; count > 0; count-- )
     
    295295
    296296    default:
    297       FT_INVALID_DATA;
     297      FT_INVALID_FORMAT;
    298298    }
    299299
     
    377377        ValueFormat = FT_NEXT_USHORT( p );
    378378
    379         otv_Coverage_validate( table + Coverage, valid );
     379        otv_Coverage_validate( table + Coverage, valid, -1 );
    380380        otv_ValueRecord_validate( p, ValueFormat, valid ); /* Value */
    381381      }
     
    396396        len_value = otv_value_length( ValueFormat );
    397397
    398         otv_Coverage_validate( table + Coverage, valid );
     398        otv_Coverage_validate( table + Coverage, valid, ValueCount );
    399399
    400400        OTV_LIMIT_CHECK( ValueCount * len_value );
     
    410410
    411411    default:
    412       FT_INVALID_DATA;
     412      FT_INVALID_FORMAT;
    413413    }
    414414
     
    499499        OTV_TRACE(( " (PairSetCount = %d)\n", PairSetCount ));
    500500
    501         otv_Coverage_validate( table + Coverage, valid );
     501        otv_Coverage_validate( table + Coverage, valid, -1 );
    502502
    503503        OTV_LIMIT_CHECK( PairSetCount * 2 );
     
    531531        len_value2 = otv_value_length( ValueFormat2 );
    532532
    533         otv_Coverage_validate( table + Coverage, valid );
     533        otv_Coverage_validate( table + Coverage, valid, -1 );
    534534        otv_ClassDef_validate( table + ClassDef1, valid );
    535535        otv_ClassDef_validate( table + ClassDef2, valid );
     
    559559
    560560    default:
    561       FT_INVALID_DATA;
     561      FT_INVALID_FORMAT;
    562562    }
    563563
     
    606606        OTV_TRACE(( " (EntryExitCount = %d)\n", EntryExitCount ));
    607607
    608         otv_Coverage_validate( table + Coverage, valid );
     608        otv_Coverage_validate( table + Coverage, valid, EntryExitCount );
    609609
    610610        OTV_LIMIT_CHECK( EntryExitCount * 4 );
     
    630630
    631631    default:
    632       FT_INVALID_DATA;
     632      FT_INVALID_FORMAT;
    633633    }
    634634
     
    645645  /*************************************************************************/
    646646
    647   /* sets valid->extra2 (0) */
     647  /* UNDOCUMENTED (in OpenType 1.5):              */
     648  /* BaseRecord tables can contain NULL pointers. */
     649
     650  /* sets valid->extra2 (1) */
    648651
    649652  static void
     
    665668    {
    666669    case 1:
    667       valid->extra2 = 0;
     670      valid->extra2 = 1;
    668671      OTV_NEST2( MarkBasePosFormat1, BaseArray );
    669672      OTV_RUN( table, valid );
     
    671674
    672675    default:
    673       FT_INVALID_DATA;
     676      FT_INVALID_FORMAT;
    674677    }
    675678
     
    712715
    713716    default:
    714       FT_INVALID_DATA;
     717      FT_INVALID_FORMAT;
    715718    }
    716719
     
    753756
    754757    default:
    755       FT_INVALID_DATA;
     758      FT_INVALID_FORMAT;
    756759    }
    757760
     
    812815
    813816    default:
    814       FT_INVALID_DATA;
     817      FT_INVALID_FORMAT;
    815818    }
    816819
     
    873876
    874877    default:
    875       FT_INVALID_DATA;
     878      FT_INVALID_FORMAT;
    876879    }
    877880
     
    926929
    927930    default:
    928       FT_INVALID_DATA;
     931      FT_INVALID_FORMAT;
    929932    }
    930933
     
    990993
    991994    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    992       FT_INVALID_DATA;
     995      FT_INVALID_FORMAT;
    993996
    994997    ScriptList  = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvgsub.c

    r150 r251  
    55/*    OpenType GSUB table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by                                                */
     7/*  Copyright 2004, 2005, 2007 by                                          */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6969        DeltaGlyphID = FT_NEXT_SHORT( p );
    7070
    71         otv_Coverage_validate( Coverage, valid );
     71        otv_Coverage_validate( Coverage, valid, -1 );
    7272
    7373        idx = otv_Coverage_get_first( Coverage ) + DeltaGlyphID;
     
    9292        OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));
    9393
    94         otv_Coverage_validate( table + Coverage, valid );
     94        otv_Coverage_validate( table + Coverage, valid, GlyphCount );
    9595
    9696        OTV_LIMIT_CHECK( GlyphCount * 2 );
     
    9999        for ( ; GlyphCount > 0; GlyphCount-- )
    100100          if ( FT_NEXT_USHORT( p ) >= valid->glyph_count )
    101             FT_INVALID_DATA;
     101            FT_INVALID_GLYPH_ID;
    102102      }
    103103      break;
    104104
    105105    default:
    106       FT_INVALID_DATA;
     106      FT_INVALID_FORMAT;
    107107    }
    108108
     
    145145
    146146    default:
    147       FT_INVALID_DATA;
     147      FT_INVALID_FORMAT;
    148148    }
    149149
     
    186186
    187187    default:
    188       FT_INVALID_DATA;
     188      FT_INVALID_FORMAT;
    189189    }
    190190
     
    260260
    261261    default:
    262       FT_INVALID_DATA;
     262      FT_INVALID_FORMAT;
    263263    }
    264264
     
    319319
    320320    default:
    321       FT_INVALID_DATA;
     321      FT_INVALID_FORMAT;
    322322    }
    323323
     
    380380
    381381    default:
    382       FT_INVALID_DATA;
     382      FT_INVALID_FORMAT;
    383383    }
    384384
     
    435435
    436436    default:
    437       FT_INVALID_DATA;
     437      FT_INVALID_FORMAT;
    438438    }
    439439
     
    477477      OTV_TRACE(( " (BacktrackGlyphCount = %d)\n", BacktrackGlyphCount ));
    478478
    479       otv_Coverage_validate( Coverage, valid );
     479      otv_Coverage_validate( Coverage, valid, -1 );
    480480
    481481      OTV_LIMIT_CHECK( BacktrackGlyphCount * 2 + 2 );
    482482
    483483      for ( ; BacktrackGlyphCount > 0; BacktrackGlyphCount-- )
    484         otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     484        otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    485485
    486486      LookaheadGlyphCount = FT_NEXT_USHORT( p );
     
    491491
    492492      for ( ; LookaheadGlyphCount > 0; LookaheadGlyphCount-- )
    493         otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     493        otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    494494
    495495      GlyphCount = FT_NEXT_USHORT( p );
     
    510510
    511511    default:
    512       FT_INVALID_DATA;
     512      FT_INVALID_FORMAT;
    513513    }
    514514
     
    561561
    562562    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    563       FT_INVALID_DATA;
     563      FT_INVALID_FORMAT;
    564564
    565565    ScriptList  = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvjstf.c

    r150 r251  
    55/*    OpenType JSTF table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    223223
    224224    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    225       FT_INVALID_DATA;
     225      FT_INVALID_FORMAT;
    226226
    227227    JstfScriptCount = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvmod.c

    r209 r251  
    55/*    FreeType's OpenType validation module implementation (body).         */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005, 2006 by                                          */
     7/*  Copyright 2004, 2005, 2006, 2007 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    8080    FT_Byte* volatile         gsub;
    8181    FT_Byte* volatile         jstf;
     82    FT_Byte* volatile         math;
    8283    FT_ULong                  len_base, len_gdef, len_gpos, len_gsub, len_jstf;
     84    FT_ULong                  len_math;
    8385    FT_ValidatorRec volatile  valid;
    8486
    8587
    86     base     = gdef     = gpos     = gsub     = jstf     = NULL;
    87     len_base = len_gdef = len_gpos = len_gsub = len_jstf = 0;
     88    base     = gdef     = gpos     = gsub     = jstf     = math     = NULL;
     89    len_base = len_gdef = len_gpos = len_gsub = len_jstf = len_math = 0;
    8890
    8991    /* load tables */
     
    124126    }
    125127
     128    if ( ot_flags & FT_VALIDATE_MATH )
     129    {
     130      error = otv_load_table( face, TTAG_MATH, &math, &len_math );
     131      if ( error )
     132        goto Exit;
     133    }
     134
    126135    /* validate tables */
    127136
     
    171180      if ( ft_setjmp( valid.jump_buffer ) == 0 )
    172181        otv_JSTF_validate( jstf, gsub, gpos, face->num_glyphs, &valid );
     182      error = valid.error;
     183      if ( error )
     184        goto Exit;
     185    }
     186
     187    if ( math )
     188    {
     189      ft_validator_init( &valid, math, math + len_math, FT_VALIDATE_DEFAULT );
     190      if ( ft_setjmp( valid.jump_buffer ) == 0 )
     191        otv_MATH_validate( math, face->num_glyphs, &valid );
    173192      error = valid.error;
    174193      if ( error )
     
    193212      FT_FREE( jstf );
    194213    }
     214    {
     215      FT_Memory  memory = FT_FACE_MEMORY( face );
     216
     217
     218      FT_FREE( math );                 /* Can't return this as API is frozen */
     219    }
    195220
    196221    return error;
  • trunk/poppler/freetype2/src/pcf/pcfdrivr.c

    r165 r251  
    33    FreeType font driver for pcf files
    44
    5     Copyright (C) 2000, 2001, 2002, 2003, 2004, 2006 by
     5    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008 by
    66    Francesco Zappa Nardelli
    77
     
    188188    pcf_cmap_done,
    189189    pcf_cmap_char_index,
    190     pcf_cmap_char_next
     190    pcf_cmap_char_next,
     191
     192    NULL, NULL, NULL, NULL, NULL
    191193  };
    192194
     
    272274      error = error2;
    273275      if ( error )
     276#ifdef FT_CONFIG_OPTION_USE_LZW
    274277      {
    275278        FT_Error  error3;
     
    294297          goto Fail;
    295298      }
     299#else
     300        goto Fail;
     301#endif
    296302      else
    297303      {
  • trunk/poppler/freetype2/src/pfr/pfrcmap.c

    r209 r251  
    2020#include "pfrobjs.h"
    2121#include FT_INTERNAL_DEBUG_H
     22
     23#include "pfrerror.h"
    2224
    2325
     
    157159    (FT_CMap_DoneFunc)     pfr_cmap_done,
    158160    (FT_CMap_CharIndexFunc)pfr_cmap_char_index,
    159     (FT_CMap_CharNextFunc) pfr_cmap_char_next
     161    (FT_CMap_CharNextFunc) pfr_cmap_char_next,
     162
     163    NULL, NULL, NULL, NULL, NULL
    160164  };
    161165
  • trunk/poppler/freetype2/src/pfr/pfrgload.c

    r209 r251  
    596596    if ( org_count + count > glyph->max_subs )
    597597    {
    598       FT_UInt  new_max = ( org_count + count + 3 ) & -4;
     598      FT_UInt  new_max = ( org_count + count + 3 ) & (FT_UInt)-4;
    599599
    600600
  • trunk/poppler/freetype2/src/psaux/psconv.c

    r165 r251  
    55/*    Some convenience conversions (body).                                 */
    66/*                                                                         */
    7 /*  Copyright 2006 by                                                      */
     7/*  Copyright 2006, 2008 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    188188          break;
    189189
    190         if ( divider < 10000000L )
     190        if ( !integral && power_ten > 0 )
    191191        {
     192          power_ten--;
    192193          decimal = decimal * 10 + c;
    193           divider *= 10;
     194        }
     195        else
     196        {
     197          if ( divider < 10000000L )
     198          {
     199            decimal = decimal * 10 + c;
     200            divider *= 10;
     201          }
    194202        }
    195203      }
  • trunk/poppler/freetype2/src/psaux/psobjs.c

    r209 r251  
    55/*    Auxiliary functions for PostScript fonts (body).                     */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    170170                FT_PtrDist  length )
    171171  {
    172     if ( idx < 0 || idx > table->max_elems )
     172    if ( idx < 0 || idx >= table->max_elems )
    173173    {
    174174      FT_ERROR(( "ps_table_add: invalid index\n" ));
     
    14841484    }
    14851485
    1486     if ( size )
    1487     {
    1488       builder->scale_x = size->metrics.x_scale;
    1489       builder->scale_y = size->metrics.y_scale;
    1490     }
    1491 
    14921486    builder->pos_x = 0;
    14931487    builder->pos_y = 0;
     
    16411635  {
    16421636    FT_Outline*  outline = builder->current;
     1637    FT_Int       first;
    16431638
    16441639
     
    16461641      return;
    16471642
    1648     /* XXXX: We must not include the last point in the path if it */
    1649     /*       is located on the first point.                       */
     1643    first = outline->n_contours <= 1
     1644            ? 0 : outline->contours[outline->n_contours - 2] + 1;
     1645
     1646    /* We must not include the last point in the path if it */
     1647    /* is located on the first point.                       */
    16501648    if ( outline->n_points > 1 )
    16511649    {
    1652       FT_Int      first   = 0;
    16531650      FT_Vector*  p1      = outline->points + first;
    16541651      FT_Vector*  p2      = outline->points + outline->n_points - 1;
    16551652      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points - 1;
    16561653
    1657 
    1658       if ( outline->n_contours > 1 )
    1659       {
    1660         first = outline->contours[outline->n_contours - 2] + 1;
    1661         p1    = outline->points + first;
    1662       }
    16631654
    16641655      /* `delete' last point only if it coincides with the first */
     
    16701661
    16711662    if ( outline->n_contours > 0 )
    1672       outline->contours[outline->n_contours - 1] =
    1673         (short)( outline->n_points - 1 );
     1663    {
     1664      /* Don't add contours only consisting of one point, i.e., */
     1665      /* check whether begin point and last point are the same. */
     1666      if ( first == outline->n_points - 1 )
     1667      {
     1668        outline->n_contours--;
     1669        outline->n_points--;
     1670      }
     1671      else
     1672        outline->contours[outline->n_contours - 1] =
     1673          (short)( outline->n_points - 1 );
     1674    }
    16741675  }
    16751676
  • trunk/poppler/freetype2/src/psaux/t1cmap.c

    r209 r251  
    55/*    Type 1 character map support (body).                                 */
    66/*                                                                         */
    7 /*  Copyright 2002, 2003, 2006 by                                          */
     7/*  Copyright 2002, 2003, 2006, 2007 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    136136    (FT_CMap_DoneFunc)     t1_cmap_std_done,
    137137    (FT_CMap_CharIndexFunc)t1_cmap_std_char_index,
    138     (FT_CMap_CharNextFunc) t1_cmap_std_char_next
     138    (FT_CMap_CharNextFunc) t1_cmap_std_char_next,
     139
     140    NULL, NULL, NULL, NULL, NULL
    139141  };
    140142
     
    155157    (FT_CMap_DoneFunc)     t1_cmap_std_done,
    156158    (FT_CMap_CharIndexFunc)t1_cmap_std_char_index,
    157     (FT_CMap_CharNextFunc) t1_cmap_std_char_next
     159    (FT_CMap_CharNextFunc) t1_cmap_std_char_next,
     160
     161    NULL, NULL, NULL, NULL, NULL
    158162  };
    159163
     
    246250    (FT_CMap_DoneFunc)     t1_cmap_custom_done,
    247251    (FT_CMap_CharIndexFunc)t1_cmap_custom_char_index,
    248     (FT_CMap_CharNextFunc) t1_cmap_custom_char_next
     252    (FT_CMap_CharNextFunc) t1_cmap_custom_char_next,
     253
     254    NULL, NULL, NULL, NULL, NULL
    249255  };
    250256
     
    327333    (FT_CMap_DoneFunc)     t1_cmap_unicode_done,
    328334    (FT_CMap_CharIndexFunc)t1_cmap_unicode_char_index,
    329     (FT_CMap_CharNextFunc) t1_cmap_unicode_char_next
     335    (FT_CMap_CharNextFunc) t1_cmap_unicode_char_next,
     336
     337    NULL, NULL, NULL, NULL, NULL
    330338  };
    331339
  • trunk/poppler/freetype2/src/psaux/t1decode.c

    r209 r251  
    55/*    PostScript Type 1 decoding routines (body).                          */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    10631063          FT_TRACE4(( " closepath" ));
    10641064
    1065           close_contour( builder );
    1066           if ( !( builder->parse_state == T1_Parse_Have_Path   ||
    1067                   builder->parse_state == T1_Parse_Have_Moveto ) )
    1068             goto Syntax_Error;
     1065          /* if there is no path, `closepath' is a no-op */
     1066          if ( builder->parse_state == T1_Parse_Have_Path   ||
     1067               builder->parse_state == T1_Parse_Have_Moveto )
     1068            close_contour( builder );
     1069
    10691070          builder->parse_state = T1_Parse_Have_Width;
    10701071          break;
  • trunk/poppler/freetype2/src/pshinter/pshalgo.c

    r209 r251  
    55/*    PostScript hinting algorithm (body).                                 */
    66/*                                                                         */
    7 /*  Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007 by                  */
     7/*  Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by            */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    22242224      FT_Fixed  y_scale = dim_y->scale_mult;
    22252225
     2226      FT_Fixed  old_x_scale = x_scale;
     2227      FT_Fixed  old_y_scale = y_scale;
     2228
    22262229      FT_Fixed  scaled;
    22272230      FT_Fixed  fitted;
    22282231
     2232      FT_Bool  rescale = FALSE;
     2233
    22292234
    22302235      scaled = FT_MulFix( globals->blues.normal_top.zones->org_ref, y_scale );
     
    22332238      if ( fitted != 0 && scaled != fitted )
    22342239      {
     2240        rescale = TRUE;
     2241
    22352242        y_scale = FT_MulDiv( y_scale, fitted, scaled );
    22362243
     
    22402247        psh_globals_set_scale( glyph->globals, x_scale, y_scale, 0, 0 );
    22412248      }
    2242     }
    2243 
    2244     glyph->do_horz_hints = 1;
    2245     glyph->do_vert_hints = 1;
    2246 
    2247     glyph->do_horz_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO ||
    2248                                        hint_mode == FT_RENDER_MODE_LCD  );
    2249 
    2250     glyph->do_vert_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO  ||
    2251                                        hint_mode == FT_RENDER_MODE_LCD_V );
    2252 
    2253     glyph->do_stem_adjust   = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT );
    2254 
    2255     for ( dimension = 0; dimension < 2; dimension++ )
    2256     {
    2257       /* load outline coordinates into glyph */
    2258       psh_glyph_load_points( glyph, dimension );
    2259 
    2260       /* compute local extrema */
    2261       psh_glyph_compute_extrema( glyph );
    2262 
    2263       /* compute aligned stem/hints positions */
    2264       psh_hint_table_align_hints( &glyph->hint_tables[dimension],
    2265                                   glyph->globals,
    2266                                   dimension,
    2267                                   glyph );
    2268 
    2269       /* find strong points, align them, then interpolate others */
    2270       psh_glyph_find_strong_points( glyph, dimension );
    2271       if ( dimension == 1 )
    2272         psh_glyph_find_blue_points( &globals->blues, glyph );
    2273       psh_glyph_interpolate_strong_points( glyph, dimension );
    2274       psh_glyph_interpolate_normal_points( glyph, dimension );
    2275       psh_glyph_interpolate_other_points( glyph, dimension );
    2276 
    2277       /* save hinted coordinates back to outline */
    2278       psh_glyph_save_points( glyph, dimension );
     2249
     2250      glyph->do_horz_hints = 1;
     2251      glyph->do_vert_hints = 1;
     2252
     2253      glyph->do_horz_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO ||
     2254                                         hint_mode == FT_RENDER_MODE_LCD  );
     2255
     2256      glyph->do_vert_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO  ||
     2257                                         hint_mode == FT_RENDER_MODE_LCD_V );
     2258
     2259      glyph->do_stem_adjust   = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT );
     2260
     2261      for ( dimension = 0; dimension < 2; dimension++ )
     2262      {
     2263        /* load outline coordinates into glyph */
     2264        psh_glyph_load_points( glyph, dimension );
     2265
     2266        /* compute local extrema */
     2267        psh_glyph_compute_extrema( glyph );
     2268
     2269        /* compute aligned stem/hints positions */
     2270        psh_hint_table_align_hints( &glyph->hint_tables[dimension],
     2271                                    glyph->globals,
     2272                                    dimension,
     2273                                    glyph );
     2274
     2275        /* find strong points, align them, then interpolate others */
     2276        psh_glyph_find_strong_points( glyph, dimension );
     2277        if ( dimension == 1 )
     2278          psh_glyph_find_blue_points( &globals->blues, glyph );
     2279        psh_glyph_interpolate_strong_points( glyph, dimension );
     2280        psh_glyph_interpolate_normal_points( glyph, dimension );
     2281        psh_glyph_interpolate_other_points( glyph, dimension );
     2282
     2283        /* save hinted coordinates back to outline */
     2284        psh_glyph_save_points( glyph, dimension );
     2285
     2286        if ( rescale )
     2287          psh_globals_set_scale( glyph->globals,
     2288                                 old_x_scale, old_y_scale, 0, 0 );
     2289      }
    22792290    }
    22802291
  • trunk/poppler/freetype2/src/pshinter/pshalgo.h

    r209 r251  
    55/*    PostScript hinting algorithm (specification).                        */
    66/*                                                                         */
    7 /*  Copyright 2001, 2002, 2003 by                                          */
     7/*  Copyright 2001, 2002, 2003, 2008 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    3333
    3434  /* hint bit-flags */
    35   typedef enum
     35  typedef enum  PSH_Hint_Flags_
    3636  {
    3737    PSH_HINT_GHOST  = PS_HINT_FLAG_GHOST,
  • trunk/poppler/freetype2/src/pshinter/pshrec.h

    r150 r251  
    55/*    Postscript (Type1/Type2) hints recorder (specification).             */
    66/*                                                                         */
    7 /*  Copyright 2001, 2002, 2003, 2006 by                                    */
     7/*  Copyright 2001, 2002, 2003, 2006, 2008 by                              */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5353
    5454  /* hint types */
    55   typedef enum
     55  typedef enum  PS_Hint_Type_
    5656  {
    5757    PS_HINT_TYPE_1 = 1,
     
    6262
    6363  /* hint flags */
    64   typedef enum
     64  typedef enum  PS_Hint_Flags_
    6565  {
    6666    PS_HINT_FLAG_GHOST  = 1,
  • trunk/poppler/freetype2/src/psnames/psmodule.c

    r209 r251  
    55/*    PSNames module implementation (body).                                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007, 2008 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2727
    2828
    29 #ifndef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES
     29#ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
    3030
    3131
     
    178178    else
    179179      return unicode1 - unicode2;
     180  }
     181
     182
     183  /* support for old WGL4 fonts */
     184
     185#define WGL_EXTRA_LIST_SIZE  8
     186
     187  static const FT_UInt32  ft_wgl_extra_unicodes[WGL_EXTRA_LIST_SIZE] =
     188  {
     189    0x0394,
     190    0x03A9,
     191    0x2215,
     192    0x00AD,
     193    0x02C9,
     194    0x03BC,
     195    0x2219,
     196    0x00A0
     197  };
     198
     199  static const char  ft_wgl_extra_glyph_names[] =
     200  {
     201    'D','e','l','t','a',0,
     202    'O','m','e','g','a',0,
     203    'f','r','a','c','t','i','o','n',0,
     204    'h','y','p','h','e','n',0,
     205    'm','a','c','r','o','n',0,
     206    'm','u',0,
     207    'p','e','r','i','o','d','c','e','n','t','e','r','e','d',0,
     208    's','p','a','c','e',0
     209  };
     210
     211  static const FT_Int
     212  ft_wgl_extra_glyph_name_offsets[WGL_EXTRA_LIST_SIZE] =
     213  {
     214     0,
     215     6,
     216    12,
     217    21,
     218    28,
     219    35,
     220    38,
     221    53
     222  };
     223
     224
     225  static void
     226  ps_check_wgl_name( const char*  gname,
     227                     FT_UInt      glyph,
     228                     FT_UInt*     wgl_glyphs,
     229                     FT_UInt     *states )
     230  {
     231    FT_UInt  n;
     232
     233
     234    for ( n = 0; n < WGL_EXTRA_LIST_SIZE; n++ )
     235    {
     236      if ( ft_strcmp( ft_wgl_extra_glyph_names +
     237                        ft_wgl_extra_glyph_name_offsets[n], gname ) == 0 )
     238      {
     239        if ( states[n] == 0 )
     240        {
     241          /* mark this WGL extra glyph as a candidate for the cmap */
     242          states[n]     = 1;
     243          wgl_glyphs[n] = glyph;
     244        }
     245
     246        return;
     247      }
     248    }
     249  }
     250
     251
     252  static void
     253  ps_check_wgl_unicode( FT_UInt32  uni_char,
     254                        FT_UInt   *states )
     255  {
     256    FT_UInt  n;
     257
     258
     259    for ( n = 0; n < WGL_EXTRA_LIST_SIZE; n++ )
     260    {
     261      if ( uni_char == ft_wgl_extra_unicodes[n] )
     262      {
     263        /* disable this WGL extra glyph from being added to the cmap */
     264        states[n] = 2;
     265
     266        return;
     267      }
     268    }
    180269  }
    181270
     
    192281    FT_Error  error;
    193282
     283    FT_UInt  wgl_list_states[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
     284    FT_UInt  wgl_glyphs[WGL_EXTRA_LIST_SIZE];
     285
    194286
    195287    /* we first allocate the table */
     
    197289    table->maps     = 0;
    198290
    199     if ( !FT_NEW_ARRAY( table->maps, num_glyphs ) )
     291    if ( !FT_NEW_ARRAY( table->maps, num_glyphs + WGL_EXTRA_LIST_SIZE ) )
    200292    {
    201293      FT_UInt     n;
     
    214306        if ( gname )
    215307        {
     308          ps_check_wgl_name( gname, n, wgl_glyphs, wgl_list_states );
    216309          uni_char = ps_unicode_value( gname );
    217310
    218311          if ( BASE_GLYPH( uni_char ) != 0 )
    219312          {
     313            ps_check_wgl_unicode( uni_char, wgl_list_states );
    220314            map->unicode     = uni_char;
    221315            map->glyph_index = n;
     
    225319          if ( free_glyph_name )
    226320            free_glyph_name( glyph_data, gname );
     321        }
     322      }
     323
     324      for ( n = 0; n < WGL_EXTRA_LIST_SIZE; n++ )
     325      {
     326        if ( wgl_list_states[n] == 1 )
     327        {
     328          /* This glyph name has an additional WGL4 representation. */
     329          /* Add it to the cmap.                                    */
     330
     331          map->unicode     = ft_wgl_extra_unicodes[n];
     332          map->glyph_index = wgl_glyphs[n];
     333          map++;
    227334        }
    228335      }
     
    428535  }
    429536
    430 #endif /* !FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES */
     537#endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
    431538
    432539
     
    442549    0x20000L,   /* driver requires FreeType 2 or above */
    443550
    444 #ifdef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES
     551#ifndef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
    445552    0,
    446553    (FT_Module_Constructor)0,
  • trunk/poppler/freetype2/src/raster/ftraster.c

    r200 r251  
    55/*    The FreeType glyph rasterizer (body).                                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2005, 2007 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2005, 2007, 2008 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    145145  /* undefine FT_RASTER_OPTION_ANTI_ALIASING if you do not want to support */
    146146  /* 5-levels anti-aliasing                                                */
    147 #ifdef FT_CONFIG_OPTION_5_GRAY_LEVELS
    148 #define FT_RASTER_OPTION_ANTI_ALIASING
    149 #endif
     147#undef FT_RASTER_OPTION_ANTI_ALIASING
    150148
    151149  /* The size of the two-lines intermediate bitmap used */
     
    543541#endif /* FT_STATIC_RASTER */
    544542
     543
     544#ifdef FT_RASTER_OPTION_ANTI_ALIASING
    545545
    546546static const char  count_table[256] =
     
    563563  4 , 5 , 5 , 6 , 5 , 6 , 6 , 7 , 5 , 6 , 6 , 7 , 6 , 7 , 7 , 8 };
    564564
     565#endif /* FT_RASTER_OPTION_ANTI_ALIASING */
     566
    565567
    566568
     
    21492151      f2 = (Byte) ~( 0x7F >> ( e2 & 7 ) );
    21502152
    2151       if ( ras.gray_min_x > c1 ) ras.gray_min_x = (short)c1;
    2152       if ( ras.gray_max_x < c2 ) ras.gray_max_x = (short)c2;
     2153      if ( ras.gray_min_x > c1 )
     2154        ras.gray_min_x = (short)c1;
     2155      if ( ras.gray_max_x < c2 )
     2156        ras.gray_max_x = (short)c2;
    21532157
    21542158      target = ras.bTarget + ras.traceOfs + c1;
     
    21832187                                PProfile    right )
    21842188  {
    2185     Long   e1, e2;
     2189    Long   e1, e2, pxl;
    21862190    Short  c1, f1;
    21872191
     
    21892193    /* Drop-out control */
    21902194
    2191     e1 = CEILING( x1 );
    2192     e2 = FLOOR  ( x2 );
     2195    /*   e2            x2                    x1           e1   */
     2196    /*                                                         */
     2197    /*                 ^                     |                 */
     2198    /*                 |                     |                 */
     2199    /*   +-------------+---------------------+------------+    */
     2200    /*                 |                     |                 */
     2201    /*                 |                     v                 */
     2202    /*                                                         */
     2203    /* pixel         contour              contour       pixel  */
     2204    /* center                                           center */
     2205
     2206    /* drop-out mode    scan conversion rules (as defined in OpenType) */
     2207    /* --------------------------------------------------------------- */
     2208    /*  0                1, 2, 3                                       */
     2209    /*  1                1, 2, 4                                       */
     2210    /*  2                1, 2                                          */
     2211    /*  3                same as mode 2                                */
     2212    /*  4                1, 2, 5                                       */
     2213    /*  5                1, 2, 6                                       */
     2214    /*  6, 7             same as mode 2                                */
     2215
     2216    e1  = CEILING( x1 );
     2217    e2  = FLOOR  ( x2 );
     2218    pxl = e1;
    21932219
    21942220    if ( e1 > e2 )
     
    21982224        switch ( ras.dropOutControl )
    21992225        {
    2200         case 1:
    2201           e1 = e2;
     2226        case 0: /* simple drop-outs including stubs */
     2227          pxl = e2;
    22022228          break;
    22032229
    2204         case 4:
    2205           e1 = CEILING( (x1 + x2 + 1) / 2 );
     2230        case 4: /* smart drop-outs including stubs */
     2231          pxl = FLOOR( ( x1 + x2 + 1 ) / 2 + ras.precision_half );
    22062232          break;
    22072233
    2208         case 2:
    2209         case 5:
    2210           /* Drop-out Control Rule #4 */
    2211 
    2212           /* The spec is not very clear regarding rule #4.  It      */
     2234        case 1: /* simple drop-outs excluding stubs */
     2235        case 5: /* smart drop-outs excluding stubs  */
     2236
     2237          /* Drop-out Control Rules #4 and #6 */
     2238
     2239          /* The spec is not very clear regarding those rules.  It  */
    22132240          /* presents a method that is way too costly to implement  */
    22142241          /* while the general idea seems to get rid of `stubs'.    */
     
    22322259          /*          bit problem in the `7' of verdana 10pts, but   */
    22332260          /*          makes a new one in the `C' of arial 14pts      */
    2234 
    22352261#if 0
    22362262          if ( x2 - x1 < ras.precision_half )
     
    22462272          }
    22472273
    2248           /* check that the rightmost pixel isn't set */
    2249 
    2250           e1 = TRUNC( e1 );
    2251 
    2252           c1 = (Short)( e1 >> 3 );
    2253           f1 = (Short)( e1 &  7 );
    2254 
    2255           if ( e1 >= 0 && e1 < ras.bWidth                      &&
    2256                ras.bTarget[ras.traceOfs + c1] & ( 0x80 >> f1 ) )
    2257             return;
    2258 
    2259           if ( ras.dropOutControl == 2 )
    2260             e1 = e2;
     2274          if ( ras.dropOutControl == 1 )
     2275            pxl = e2;
    22612276          else
    2262             e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
    2263 
     2277            pxl = FLOOR( ( x1 + x2 + 1 ) / 2 + ras.precision_half );
    22642278          break;
    22652279
    2266         default:
    2267           return;  /* unsupported mode */
     2280        default: /* modes 2, 3, 6, 7 */
     2281          return;  /* no drop-out control */
    22682282        }
     2283
     2284        /* check that the other pixel isn't set */
     2285        e1 = pxl == e1 ? e2 : e1;
     2286
     2287        e1 = TRUNC( e1 );
     2288
     2289        c1 = (Short)( e1 >> 3 );
     2290        f1 = (Short)( e1 &  7 );
     2291
     2292        if ( e1 >= 0 && e1 < ras.bWidth                      &&
     2293             ras.bTarget[ras.traceOfs + c1] & ( 0x80 >> f1 ) )
     2294          return;
    22692295      }
    22702296      else
     
    22722298    }
    22732299
    2274     e1 = TRUNC( e1 );
     2300    e1 = TRUNC( pxl );
    22752301
    22762302    if ( e1 >= 0 && e1 < ras.bWidth )
     
    22792305      f1 = (Short)( e1 & 7 );
    22802306
    2281       if ( ras.gray_min_x > c1 ) ras.gray_min_x = c1;
    2282       if ( ras.gray_max_x < c1 ) ras.gray_max_x = c1;
     2307      if ( ras.gray_min_x > c1 )
     2308        ras.gray_min_x = c1;
     2309      if ( ras.gray_max_x < c1 )
     2310        ras.gray_max_x = c1;
    22832311
    22842312      ras.bTarget[ras.traceOfs + c1] |= (char)( 0x80 >> f1 );
     
    23642392                                  PProfile    right )
    23652393  {
    2366     Long   e1, e2;
     2394    Long   e1, e2, pxl;
    23672395    PByte  bits;
    23682396    Byte   f1;
     
    23712399    /* During the horizontal sweep, we only take care of drop-outs */
    23722400
    2373     e1 = CEILING( x1 );
    2374     e2 = FLOOR  ( x2 );
     2401    /* e1     +       <-- pixel center */
     2402    /*        |                        */
     2403    /* x1  ---+-->    <-- contour      */
     2404    /*        |                        */
     2405    /*        |                        */
     2406    /* x2  <--+---    <-- contour      */
     2407    /*        |                        */
     2408    /*        |                        */
     2409    /* e2     +       <-- pixel center */
     2410
     2411    e1  = CEILING( x1 );
     2412    e2  = FLOOR  ( x2 );
     2413    pxl = e1;
    23752414
    23762415    if ( e1 > e2 )
     
    23802419        switch ( ras.dropOutControl )
    23812420        {
    2382         case 1:
    2383           e1 = e2;
     2421        case 0: /* simple drop-outs including stubs */
     2422          pxl = e2;
    23842423          break;
    23852424
    2386         case 4:
    2387           e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
     2425