Changeset 275 for trunk


Ignore:
Timestamp:
Dec 30, 2009, 5:26:39 PM (11 years ago)
Author:
rbri
Message:

PDF plugin: freetype library updated to version 2.3.11

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

Legend:

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

    r262 r275  
    55/*    Auto-fitter hinting routines for CJK script (body).                  */
    66/*                                                                         */
    7 /*  Copyright 2006, 2007, 2008 by                                          */
     7/*  Copyright 2006, 2007, 2008, 2009 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5959    if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
    6060      face->charmap = NULL;
    61 
    62     /* latin's version would suffice */
    63     af_latin_metrics_init_widths( metrics, face, 0x7530 );
     61    else
     62    {
     63      /* latin's version would suffice */
     64      af_latin_metrics_init_widths( metrics, face, 0x7530 );
     65      af_latin_metrics_check_digits( metrics, face );
     66    }
    6467
    6568    FT_Set_Charmap( face, oldmap );
     
    10181021    AF_Edge       edges      = axis->edges;
    10191022    AF_Edge       edge_limit = edges + axis->num_edges;
    1020     FT_Int        n_edges;
     1023    FT_PtrDist    n_edges;
    10211024    AF_Edge       edge;
    10221025    AF_Edge       anchor   = 0;
     
    14421445  {
    14431446#if 0
    1444     {  0x0100UL,  0xFFFFUL },  /* why this? */
     1447    AF_UNIRANGE_REC(  0x0100UL,  0xFFFFUL ),  /* why this? */
    14451448#endif
    1446     {  0x2E80UL,  0x2EFFUL },  /* CJK Radicals Supplement                 */
    1447     {  0x2F00UL,  0x2FDFUL },  /* Kangxi Radicals                         */
    1448     {  0x3000UL,  0x303FUL },  /* CJK Symbols and Punctuation             */
    1449     {  0x3040UL,  0x309FUL },  /* Hiragana                                */
    1450     {  0x30A0UL,  0x30FFUL },  /* Katakana                                */
    1451     {  0x3100UL,  0x312FUL },  /* Bopomofo                                */
    1452     {  0x3130UL,  0x318FUL },  /* Hangul Compatibility Jamo               */
    1453     {  0x31A0UL,  0x31BFUL },  /* Bopomofo Extended                       */
    1454     {  0x31C0UL,  0x31EFUL },  /* CJK Strokes                             */
    1455     {  0x31F0UL,  0x31FFUL },  /* Katakana Phonetic Extensions            */
    1456     {  0x3200UL,  0x32FFUL },  /* Enclosed CJK Letters and Months         */
    1457     {  0x3300UL,  0x33FFUL },  /* CJK Compatibility                       */
    1458     {  0x3400UL,  0x4DBFUL },  /* CJK Unified Ideographs Extension A      */
    1459     {  0x4DC0UL,  0x4DFFUL },  /* Yijing Hexagram Symbols                 */
    1460     {  0x4E00UL,  0x9FFFUL },  /* CJK Unified Ideographs                  */
    1461     {  0xF900UL,  0xFAFFUL },  /* CJK Compatibility Ideographs            */
    1462     {  0xFE30UL,  0xFE4FUL },  /* CJK Compatibility Forms                 */
    1463     {  0xFF00UL,  0xFFEFUL },  /* Halfwidth and Fullwidth Forms           */
    1464     { 0x20000UL, 0x2A6DFUL },  /* CJK Unified Ideographs Extension B      */
    1465     { 0x2F800UL, 0x2FA1FUL },  /* CJK Compatibility Ideographs Supplement */
    1466     {       0UL,       0UL }
     1449    AF_UNIRANGE_REC(  0x2E80UL,  0x2EFFUL ),  /* CJK Radicals Supplement                 */
     1450    AF_UNIRANGE_REC(  0x2F00UL,  0x2FDFUL ),  /* Kangxi Radicals                         */
     1451    AF_UNIRANGE_REC(  0x3000UL,  0x303FUL ),  /* CJK Symbols and Punctuation             */
     1452    AF_UNIRANGE_REC(  0x3040UL,  0x309FUL ),  /* Hiragana                                */
     1453    AF_UNIRANGE_REC(  0x30A0UL,  0x30FFUL ),  /* Katakana                                */
     1454    AF_UNIRANGE_REC(  0x3100UL,  0x312FUL ),  /* Bopomofo                                */
     1455    AF_UNIRANGE_REC(  0x3130UL,  0x318FUL ),  /* Hangul Compatibility Jamo               */
     1456    AF_UNIRANGE_REC(  0x31A0UL,  0x31BFUL ),  /* Bopomofo Extended                       */
     1457    AF_UNIRANGE_REC(  0x31C0UL,  0x31EFUL ),  /* CJK Strokes                             */
     1458    AF_UNIRANGE_REC(  0x31F0UL,  0x31FFUL ),  /* Katakana Phonetic Extensions            */
     1459    AF_UNIRANGE_REC(  0x3200UL,  0x32FFUL ),  /* Enclosed CJK Letters and Months         */
     1460    AF_UNIRANGE_REC(  0x3300UL,  0x33FFUL ),  /* CJK Compatibility                       */
     1461    AF_UNIRANGE_REC(  0x3400UL,  0x4DBFUL ),  /* CJK Unified Ideographs Extension A      */
     1462    AF_UNIRANGE_REC(  0x4DC0UL,  0x4DFFUL ),  /* Yijing Hexagram Symbols                 */
     1463    AF_UNIRANGE_REC(  0x4E00UL,  0x9FFFUL ),  /* CJK Unified Ideographs                  */
     1464    AF_UNIRANGE_REC(  0xF900UL,  0xFAFFUL ),  /* CJK Compatibility Ideographs            */
     1465    AF_UNIRANGE_REC(  0xFE30UL,  0xFE4FUL ),  /* CJK Compatibility Forms                 */
     1466    AF_UNIRANGE_REC(  0xFF00UL,  0xFFEFUL ),  /* Halfwidth and Fullwidth Forms           */
     1467    AF_UNIRANGE_REC( 0x20000UL, 0x2A6DFUL ),  /* CJK Unified Ideographs Extension B      */
     1468    AF_UNIRANGE_REC( 0x2F800UL, 0x2FA1FUL ),  /* CJK Compatibility Ideographs Supplement */
     1469    AF_UNIRANGE_REC(       0UL,       0UL )
    14671470  };
    14681471
    14691472
    1470   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    1471   af_cjk_script_class =
    1472   {
     1473  AF_DEFINE_SCRIPT_CLASS(af_cjk_script_class,
    14731474    AF_SCRIPT_CJK,
    14741475    af_cjk_uniranges,
     
    14821483    (AF_Script_InitHintsFunc)   af_cjk_hints_init,
    14831484    (AF_Script_ApplyHintsFunc)  af_cjk_hints_apply
     1485  )
     1486
     1487#else /* !AF_CONFIG_OPTION_CJK */
     1488
     1489  static const AF_Script_UniRangeRec  af_cjk_uniranges[] =
     1490  {
     1491    AF_UNIRANGE_REC( 0UL, 0UL )
    14841492  };
    14851493
    1486 #else /* !AF_CONFIG_OPTION_CJK */
    1487 
    1488   static const AF_Script_UniRangeRec  af_cjk_uniranges[] =
    1489   {
    1490     { 0, 0 }
    1491   };
    1492 
    1493 
    1494   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    1495   af_cjk_script_class =
    1496   {
     1494
     1495  AF_DEFINE_SCRIPT_CLASS(af_cjk_script_class,
    14971496    AF_SCRIPT_CJK,
    14981497    af_cjk_uniranges,
     
    15061505    (AF_Script_InitHintsFunc)   NULL,
    15071506    (AF_Script_ApplyHintsFunc)  NULL
    1508   };
     1507  )
    15091508
    15101509#endif /* !AF_CONFIG_OPTION_CJK */
  • trunk/poppler/freetype2/src/autofit/afcjk.h

    r251 r275  
    2828  /* the CJK-specific script class */
    2929
    30   FT_CALLBACK_TABLE const AF_ScriptClassRec
    31   af_cjk_script_class;
     30  AF_DECLARE_SCRIPT_CLASS(af_cjk_script_class)
    3231
    3332
  • trunk/poppler/freetype2/src/autofit/afdummy.c

    r150 r275  
    4343
    4444
    45   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    46   af_dummy_script_class =
    47   {
     45  AF_DEFINE_SCRIPT_CLASS(af_dummy_script_class,
    4846    AF_SCRIPT_NONE,
    4947    NULL,
     
    5755    (AF_Script_InitHintsFunc)   af_dummy_hints_init,
    5856    (AF_Script_ApplyHintsFunc)  af_dummy_hints_apply
    59   };
     57  )
    6058
    6159
  • trunk/poppler/freetype2/src/autofit/afdummy.h

    r150 r275  
    3030  */
    3131
    32   FT_CALLBACK_TABLE const AF_ScriptClassRec
    33   af_dummy_script_class;
     32  AF_DECLARE_SCRIPT_CLASS(af_dummy_script_class)
    3433
    3534/* */
  • trunk/poppler/freetype2/src/autofit/afglobal.c

    r251 r275  
    55/*    Auto-fitter routines to compute global hinting values (body).        */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by                  */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2222#include "afcjk.h"
    2323#include "afindic.h"
     24#include "afpic.h"
    2425
    2526#include "aferrors.h"
     
    2829#include "aflatin2.h"
    2930#endif
     31
     32#ifndef FT_CONFIG_OPTION_PIC
     33
     34/* when updating this table, don't forget to update
     35  AF_SCRIPT_CLASSES_COUNT and autofit_module_class_pic_init */
    3036
    3137  /* populate this list when you add new scripts */
     
    4248  };
    4349
     50#endif /* FT_CONFIG_OPTION_PIC */
     51
    4452  /* index of default script in `af_script_classes' */
    4553#define AF_SCRIPT_LIST_DEFAULT  2
    46   /* indicates an uncovered glyph                   */
    47 #define AF_SCRIPT_LIST_NONE   255
     54  /* a bit mask indicating an uncovered glyph       */
     55#define AF_SCRIPT_LIST_NONE     0x7F
     56  /* if this flag is set, we have an ASCII digit    */
     57#define AF_DIGIT                0x80
    4858
    4959
     
    5666  {
    5767    FT_Face           face;
    58     FT_UInt           glyph_count;    /* same as face->num_glyphs */
     68    FT_Long           glyph_count;    /* same as face->num_glyphs */
    5969    FT_Byte*          glyph_scripts;
    6070
     
    7383    FT_CharMap  old_charmap = face->charmap;
    7484    FT_Byte*    gscripts    = globals->glyph_scripts;
    75     FT_UInt     ss;
     85    FT_UInt     ss, i;
    7686
    7787
     
    93103
    94104    /* scan each script in a Unicode charmap */
    95     for ( ss = 0; af_script_classes[ss]; ss++ )
    96     {
    97       AF_ScriptClass      clazz = af_script_classes[ss];
     105    for ( ss = 0; AF_SCRIPT_CLASSES_GET[ss]; ss++ )
     106    {
     107      AF_ScriptClass      clazz = AF_SCRIPT_CLASSES_GET[ss];
    98108      AF_Script_UniRange  range;
    99109
     
    115125
    116126        if ( gindex != 0                             &&
    117              gindex < globals->glyph_count          &&
     127             gindex < (FT_ULong)globals->glyph_count &&
    118128             gscripts[gindex] == AF_SCRIPT_LIST_NONE )
    119129        {
     
    128138            break;
    129139
    130           if ( gindex < globals->glyph_count          &&
     140          if ( gindex < (FT_ULong)globals->glyph_count &&
    131141               gscripts[gindex] == AF_SCRIPT_LIST_NONE )
    132142          {
     
    137147    }
    138148
     149    /* mark ASCII digits */
     150    for ( i = 0x30; i <= 0x39; i++ )
     151    {
     152      FT_UInt  gindex = FT_Get_Char_Index( face, i );
     153
     154
     155      if ( gindex != 0 && gindex < (FT_ULong)globals->glyph_count )
     156        gscripts[gindex] |= AF_DIGIT;
     157    }
     158
    139159  Exit:
    140160    /*
     
    143163     */
    144164    {
    145       FT_UInt  nn;
     165      FT_Long  nn;
    146166
    147167
     
    202222        if ( globals->metrics[nn] )
    203223        {
    204           AF_ScriptClass  clazz = af_script_classes[nn];
     224          AF_ScriptClass  clazz = AF_SCRIPT_CLASSES_GET[nn];
    205225
    206226
     
    233253    AF_ScriptClass    clazz;
    234254    FT_UInt           script     = options & 15;
    235     const FT_UInt     script_max = sizeof ( af_script_classes ) /
    236                                      sizeof ( af_script_classes[0] );
     255    const FT_Offset   script_max = sizeof ( AF_SCRIPT_CLASSES_GET ) /
     256                                     sizeof ( AF_SCRIPT_CLASSES_GET[0] );
    237257    FT_Error          error      = AF_Err_Ok;
    238258
    239259
    240     if ( gindex >= globals->glyph_count )
     260    if ( gindex >= (FT_ULong)globals->glyph_count )
    241261    {
    242262      error = AF_Err_Invalid_Argument;
     
    246266    gidx = script;
    247267    if ( gidx == 0 || gidx + 1 >= script_max )
    248       gidx = globals->glyph_scripts[gindex];
    249 
    250     clazz = af_script_classes[gidx];
     268      gidx = globals->glyph_scripts[gindex] & AF_SCRIPT_LIST_NONE;
     269
     270    clazz = AF_SCRIPT_CLASSES_GET[gidx];
    251271    if ( script == 0 )
    252272      script = clazz->script;
     
    287307
    288308
     309  FT_LOCAL_DEF( FT_Bool )
     310  af_face_globals_is_digit( AF_FaceGlobals  globals,
     311                            FT_UInt         gindex )
     312  {
     313    if ( gindex < (FT_ULong)globals->glyph_count )
     314      return (FT_Bool)( globals->glyph_scripts[gindex] & AF_DIGIT );
     315
     316    return (FT_Bool)0;
     317  }
     318
     319
    289320/* END */
  • trunk/poppler/freetype2/src/autofit/afglobal.h

    r209 r275  
    66/*    (specification).                                                     */
    77/*                                                                         */
    8 /*  Copyright 2003, 2004, 2005, 2007 by                                    */
     8/*  Copyright 2003, 2004, 2005, 2007, 2009 by                              */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    5757  af_face_globals_free( AF_FaceGlobals  globals );
    5858
    59  /* */
     59  FT_LOCAL_DEF( FT_Bool )
     60  af_face_globals_is_digit( AF_FaceGlobals  globals,
     61                            FT_UInt         gindex );
     62
     63  /* */
    6064
    6165
  • trunk/poppler/freetype2/src/autofit/afhints.c

    r262 r275  
    3535      FT_Int  old_max = axis->max_segments;
    3636      FT_Int  new_max = old_max;
    37       FT_Int  big_max = FT_INT_MAX / sizeof ( *segment );
     37      FT_Int  big_max = (FT_Int)( FT_INT_MAX / sizeof ( *segment ) );
    3838
    3939
     
    7878      FT_Int  old_max = axis->max_edges;
    7979      FT_Int  new_max = old_max;
    80       FT_Int  big_max = FT_INT_MAX / sizeof ( *edge );
     80      FT_Int  big_max = (FT_Int)( FT_INT_MAX / sizeof ( *edge ) );
    8181
    8282
     
    646646
    647647
     648        FT_UNUSED( first );
    648649        for ( point = points; point < point_limit; point++, vec++, tag++ )
    649650        {
     
    941942
    942943        {
    943           FT_UInt  min, max, mid;
    944           FT_Pos   fpos;
     944          FT_PtrDist  min, max, mid;
     945          FT_Pos      fpos;
    945946
    946947
     
    953954          if ( max <= 8 )
    954955          {
    955             FT_UInt  nn;
     956            FT_PtrDist  nn;
    956957
    957958            for ( nn = 0; nn < max; nn++ )
  • trunk/poppler/freetype2/src/autofit/afindic.c

    r251 r275  
    8282  {
    8383#if 0
    84     { 0x0100,  0xFFFF },  /* why this? */
     84    AF_UNIRANGE_REC( 0x0100UL, 0xFFFFUL ),  /* why this? */
    8585#endif
    86     { 0x0900, 0x0DFF},    /* Indic Range */
    87     { 0,       0 }
     86    AF_UNIRANGE_REC( 0x0900UL, 0x0DFFUL),    /* Indic Range */
     87    AF_UNIRANGE_REC(      0UL,      0UL)
    8888  };
    8989
    9090
    91   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    92   af_indic_script_class =
    93   {
     91  AF_DEFINE_SCRIPT_CLASS(af_indic_script_class,
    9492    AF_SCRIPT_INDIC,
    9593    af_indic_uniranges,
     
    103101    (AF_Script_InitHintsFunc)   af_indic_hints_init,
    104102    (AF_Script_ApplyHintsFunc)  af_indic_hints_apply
    105   };
     103  )
    106104
    107105#else /* !AF_CONFIG_OPTION_INDIC */
     
    113111
    114112
    115   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    116   af_indic_script_class =
    117   {
     113  AF_DEFINE_SCRIPT_CLASS(af_indic_script_class,
    118114    AF_SCRIPT_INDIC,
    119115    af_indic_uniranges,
     
    127123    (AF_Script_InitHintsFunc)   NULL,
    128124    (AF_Script_ApplyHintsFunc)  NULL
    129   };
     125  )
    130126
    131127#endif /* !AF_CONFIG_OPTION_INDIC */
  • trunk/poppler/freetype2/src/autofit/afindic.h

    r209 r275  
    2828  /* the Indic-specific script class */
    2929
    30   FT_CALLBACK_TABLE const AF_ScriptClassRec
    31   af_indic_script_class;
     30  AF_DECLARE_SCRIPT_CLASS(af_indic_script_class)
    3231
    3332
  • trunk/poppler/freetype2/src/autofit/aflatin.c

    r262 r275  
    55/*    Auto-fitter hinting routines for latin script (body).                */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by                  */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    1717
    1818
     19#include <ft2build.h>
     20#include FT_ADVANCES_H
     21
    1922#include "aflatin.h"
    2023#include "aferrors.h"
     
    147150
    148151
    149   static const char* const  af_latin_blue_chars[AF_LATIN_MAX_BLUES] =
     152  static const char af_latin_blue_chars[AF_LATIN_MAX_BLUES]
     153                                       [AF_LATIN_MAX_TEST_CHARACTERS + 1] =
    150154  {
    151155    "THEZOCQS",
     
    196200      {
    197201        FT_UInt     glyph_index;
    198         FT_Int      best_point, best_y, best_first, best_last;
     202        FT_Pos      best_y; /* same as points.y */
     203        FT_Int      best_point, best_first, best_last;
    199204        FT_Vector*  points;
    200205        FT_Bool     round = 0;
     
    329334         *  we will simply ignore it then
    330335         */
    331         AF_LOG(( "empty!\n" ));
     336        AF_LOG(( "empty\n" ));
    332337        continue;
    333338      }
     
    380385
    381386      /*
    382        * The following flags is used later to adjust the y and x scales
     387       * The following flag is used later to adjust the y and x scales
    383388       * in order to optimize the pixel grid alignment of the top of small
    384389       * letters.
     
    391396
    392397    return;
     398  }
     399
     400
     401  FT_LOCAL_DEF( void )
     402  af_latin_metrics_check_digits( AF_LatinMetrics  metrics,
     403                                 FT_Face          face )
     404  {
     405    FT_UInt  i;
     406    FT_Bool  started = 0, same_width = 1;
     407
     408
     409    /* check whether all ASCII digits have the same advance width; */
     410    /* digit `0' is 0x30 in all supported charmaps                 */
     411    for ( i = 0x30; i <= 0x39; i++ )
     412    {
     413      FT_UInt   glyph_index;
     414      FT_Fixed  advance, old_advance = 0;
     415
     416
     417      glyph_index = FT_Get_Char_Index( face, i );
     418      if ( glyph_index == 0 )
     419        continue;
     420
     421      if ( FT_Get_Advance( face, glyph_index,
     422                           FT_LOAD_NO_SCALE         |
     423                           FT_LOAD_NO_HINTING       |
     424                           FT_LOAD_IGNORE_TRANSFORM,
     425                           &advance ) )
     426        continue;
     427
     428      if ( started )
     429      {
     430        if ( advance != old_advance )
     431        {
     432          same_width = 0;
     433          break;
     434        }
     435      }
     436      else
     437      {
     438        old_advance = advance;
     439        started     = 1;
     440      }
     441    }
     442
     443    metrics->root.digits_have_same_width = same_width;
    393444  }
    394445
     
    427478      af_latin_metrics_init_widths( metrics, face, 'o' );
    428479      af_latin_metrics_init_blues( metrics, face );
     480      af_latin_metrics_check_digits( metrics, face );
    429481    }
    430482
     
    15681620            /* vertical stems.                                        */
    15691621
    1570             FT_Int  delta;
     1622            FT_Pos  delta;
    15711623
    15721624
     
    16521704    AF_Edge       edges      = axis->edges;
    16531705    AF_Edge       edge_limit = edges + axis->num_edges;
    1654     FT_Int        n_edges;
     1706    FT_PtrDist    n_edges;
    16551707    AF_Edge       edge;
    16561708    AF_Edge       anchor     = 0;
     
    21282180  static const AF_Script_UniRangeRec  af_latin_uniranges[] =
    21292181  {
    2130     {  0x0020  ,  0x007F   },  /* Basic Latin (no control chars) */
    2131     {  0x00A0  ,  0x00FF   },  /* Latin-1 Supplement (no control chars) */
    2132     {  0x0100  ,  0x017F   },  /* Latin Extended-A */
    2133     {  0x0180  ,  0x024F   },  /* Latin Extended-B */
    2134     {  0x0250  ,  0x02AF   },  /* IPA Extensions */
    2135     {  0x02B0  ,  0x02FF   },  /* Spacing Modifier Letters */
    2136     {  0x0300  ,  0x036F   },  /* Combining Diacritical Marks */
    2137     {  0x0370  ,  0x03FF   },  /* Greek and Coptic */
    2138     {  0x0400  ,  0x04FF   },  /* Cyrillic */
    2139     {  0x0500  ,  0x052F   },  /* Cyrillic Supplement */
    2140     {  0x1D00  ,  0x1D7F   },  /* Phonetic Extensions */
    2141     {  0x1D80  ,  0x1DBF   },  /* Phonetic Extensions Supplement */
    2142     {  0x1DC0  ,  0x1DFF   },  /* Combining Diacritical Marks Supplement */
    2143     {  0x1E00  ,  0x1EFF   },  /* Latin Extended Additional */
    2144     {  0x1F00  ,  0x1FFF   },  /* Greek Extended */
    2145     {  0x2000  ,  0x206F   },  /* General Punctuation */
    2146     {  0x2070  ,  0x209F   },  /* Superscripts and Subscripts */
    2147     {  0x20A0  ,  0x20CF   },  /* Currency Symbols */
    2148     {  0x2150  ,  0x218F   },  /* Number Forms */
    2149     {  0x2460  ,  0x24FF   },  /* Enclosed Alphanumerics */
    2150     {  0x2C60  ,  0x2C7F   },  /* Latin Extended-C */
    2151     {  0x2DE0  ,  0x2DFF   },  /* Cyrillic Extended-A */
    2152     {  0xA640U ,  0xA69FU  },  /* Cyrillic Extended-B */
    2153     {  0xA720U ,  0xA7FFU  },  /* Latin Extended-D */
    2154     {  0xFB00U ,  0xFB06U  },  /* Alphab. Present. Forms (Latin Ligs) */
    2155     { 0x1D400UL, 0x1D7FFUL },  /* Mathematical Alphanumeric Symbols */
    2156     { 0        , 0         }
     2182    AF_UNIRANGE_REC(  0x0020UL,  0x007FUL ),  /* Basic Latin (no control chars) */
     2183    AF_UNIRANGE_REC(  0x00A0UL,  0x00FFUL ),  /* Latin-1 Supplement (no control chars) */
     2184    AF_UNIRANGE_REC(  0x0100UL,  0x017FUL ),  /* Latin Extended-A */
     2185    AF_UNIRANGE_REC(  0x0180UL,  0x024FUL ),  /* Latin Extended-B */
     2186    AF_UNIRANGE_REC(  0x0250UL,  0x02AFUL ),  /* IPA Extensions */
     2187    AF_UNIRANGE_REC(  0x02B0UL,  0x02FFUL ),  /* Spacing Modifier Letters */
     2188    AF_UNIRANGE_REC(  0x0300UL,  0x036FUL ),  /* Combining Diacritical Marks */
     2189    AF_UNIRANGE_REC(  0x0370UL,  0x03FFUL ),  /* Greek and Coptic */
     2190    AF_UNIRANGE_REC(  0x0400UL,  0x04FFUL ),  /* Cyrillic */
     2191    AF_UNIRANGE_REC(  0x0500UL,  0x052FUL ),  /* Cyrillic Supplement */
     2192    AF_UNIRANGE_REC(  0x1D00UL,  0x1D7FUL ),  /* Phonetic Extensions */
     2193    AF_UNIRANGE_REC(  0x1D80UL,  0x1DBFUL ),  /* Phonetic Extensions Supplement */
     2194    AF_UNIRANGE_REC(  0x1DC0UL,  0x1DFFUL ),  /* Combining Diacritical Marks Supplement */
     2195    AF_UNIRANGE_REC(  0x1E00UL,  0x1EFFUL ),  /* Latin Extended Additional */
     2196    AF_UNIRANGE_REC(  0x1F00UL,  0x1FFFUL ),  /* Greek Extended */
     2197    AF_UNIRANGE_REC(  0x2000UL,  0x206FUL ),  /* General Punctuation */
     2198    AF_UNIRANGE_REC(  0x2070UL,  0x209FUL ),  /* Superscripts and Subscripts */
     2199    AF_UNIRANGE_REC(  0x20A0UL,  0x20CFUL ),  /* Currency Symbols */
     2200    AF_UNIRANGE_REC(  0x2150UL,  0x218FUL ),  /* Number Forms */
     2201    AF_UNIRANGE_REC(  0x2460UL,  0x24FFUL ),  /* Enclosed Alphanumerics */
     2202    AF_UNIRANGE_REC(  0x2C60UL,  0x2C7FUL ),  /* Latin Extended-C */
     2203    AF_UNIRANGE_REC(  0x2DE0UL,  0x2DFFUL ),  /* Cyrillic Extended-A */
     2204    AF_UNIRANGE_REC(  0xA640UL,  0xA69FUL ),  /* Cyrillic Extended-B */
     2205    AF_UNIRANGE_REC(  0xA720UL,  0xA7FFUL ),  /* Latin Extended-D */
     2206    AF_UNIRANGE_REC(  0xFB00UL,  0xFB06UL ),  /* Alphab. Present. Forms (Latin Ligs) */
     2207    AF_UNIRANGE_REC( 0x1D400UL, 0x1D7FFUL ),  /* Mathematical Alphanumeric Symbols */
     2208    AF_UNIRANGE_REC(       0UL,       0UL )
    21572209  };
    21582210
    21592211
    2160   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    2161   af_latin_script_class =
    2162   {
     2212  AF_DEFINE_SCRIPT_CLASS(af_latin_script_class, 
    21632213    AF_SCRIPT_LATIN,
    21642214    af_latin_uniranges,
     
    21722222    (AF_Script_InitHintsFunc)   af_latin_hints_init,
    21732223    (AF_Script_ApplyHintsFunc)  af_latin_hints_apply
    2174   };
     2224  )
    21752225
    21762226
  • trunk/poppler/freetype2/src/autofit/aflatin.h

    r209 r275  
    55/*    Auto-fitter hinting routines for latin script (specification).       */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2009 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2828  /* the latin-specific script class */
    2929
    30   FT_CALLBACK_TABLE const AF_ScriptClassRec
    31   af_latin_script_class;
     30  AF_DECLARE_SCRIPT_CLASS(af_latin_script_class)
    3231
    3332
     
    138137                                FT_Face          face,
    139138                                FT_ULong         charcode );
     139
     140  FT_LOCAL( void )
     141  af_latin_metrics_check_digits( AF_LatinMetrics  metrics,
     142                                 FT_Face          face );
    140143
    141144
  • trunk/poppler/freetype2/src/autofit/aflatin2.c

    r262 r275  
    55/*    Auto-fitter hinting routines for latin script (body).                */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by                  */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    1717
    1818
     19#include FT_ADVANCES_H
     20
    1921#include "aflatin.h"
    2022#include "aflatin2.h"
     
    155157
    156158
    157   static const char* const  af_latin2_blue_chars[AF_LATIN_MAX_BLUES] =
     159  static const char af_latin2_blue_chars[AF_LATIN_MAX_BLUES][AF_LATIN_MAX_TEST_CHARACTERS+1] =
    158160  {
    159161    "THEZOCQS",
     
    337339         *  we will simply ignore it then
    338340         */
    339         AF_LOG(( "empty!\n" ));
     341        AF_LOG(( "empty\n" ));
    340342        continue;
    341343      }
     
    402404
    403405
     406  FT_LOCAL_DEF( void )
     407  af_latin2_metrics_check_digits( AF_LatinMetrics  metrics,
     408                                  FT_Face          face )
     409  {
     410    FT_UInt  i;
     411    FT_Bool  started = 0, same_width = 1;
     412
     413
     414    /* check whether all ASCII digits have the same advance width; */
     415    /* digit `0' is 0x30 in all supported charmaps                 */
     416    for ( i = 0x30; i <= 0x39; i++ )
     417    {
     418      FT_UInt   glyph_index;
     419      FT_Fixed  advance, old_advance;
     420
     421
     422      glyph_index = FT_Get_Char_Index( face, i );
     423      if ( glyph_index == 0 )
     424        continue;
     425
     426      if ( FT_Get_Advance( face, glyph_index,
     427                           FT_LOAD_NO_SCALE         |
     428                           FT_LOAD_NO_HINTING       |
     429                           FT_LOAD_IGNORE_TRANSFORM,
     430                           &advance ) )
     431        continue;
     432
     433      if ( started )
     434      {
     435        if ( advance != old_advance )
     436        {
     437          same_width = 0;
     438          break;
     439        }
     440      }
     441      else
     442      {
     443        old_advance = advance;
     444        started     = 1;
     445      }
     446    }
     447
     448    metrics->root.digits_have_same_width = same_width;
     449  }
     450
     451
    404452  FT_LOCAL_DEF( FT_Error )
    405453  af_latin2_metrics_init( AF_LatinMetrics  metrics,
     
    435483      af_latin2_metrics_init_widths( metrics, face, 'o' );
    436484      af_latin2_metrics_init_blues( metrics, face );
     485      af_latin2_metrics_check_digits( metrics, face );
    437486    }
    438487
     
    17401789    AF_Edge       edges      = axis->edges;
    17411790    AF_Edge       edge_limit = edges + axis->num_edges;
    1742     FT_Int        n_edges;
    17431791    AF_Edge       edge;
    17441792    AF_Edge       anchor     = 0;
     
    20512099    /* the third (lowest) stem aligns with the base line; it might end up */
    20522100    /* one pixel higher or lower.                                         */
     2101
    20532102#if 0
    2054     n_edges = edge_limit - edges;
    2055     if ( dim == AF_DIMENSION_HORZ && ( n_edges == 6 || n_edges == 12 ) )
    2056     {
    2057       AF_Edge  edge1, edge2, edge3;
    2058       FT_Pos   dist1, dist2, span, delta;
    2059 
    2060 
    2061       if ( n_edges == 6 )
    2062       {
    2063         edge1 = edges;
    2064         edge2 = edges + 2;
    2065         edge3 = edges + 4;
    2066       }
    2067       else
    2068       {
    2069         edge1 = edges + 1;
    2070         edge2 = edges + 5;
    2071         edge3 = edges + 9;
    2072       }
    2073 
    2074       dist1 = edge2->opos - edge1->opos;
    2075       dist2 = edge3->opos - edge2->opos;
    2076 
    2077       span = dist1 - dist2;
    2078       if ( span < 0 )
    2079         span = -span;
    2080 
    2081       if ( span < 8 )
    2082       {
    2083         delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
    2084         edge3->pos -= delta;
    2085         if ( edge3->link )
    2086           edge3->link->pos -= delta;
    2087 
    2088         /* move the serifs along with the stem */
    2089         if ( n_edges == 12 )
    2090         {
    2091           ( edges + 8 )->pos -= delta;
    2092           ( edges + 11 )->pos -= delta;
    2093         }
    2094 
    2095         edge3->flags |= AF_EDGE_DONE;
    2096         if ( edge3->link )
    2097           edge3->link->flags |= AF_EDGE_DONE;
     2103    {
     2104      FT_Int  n_edges = edge_limit - edges;
     2105
     2106
     2107      if ( dim == AF_DIMENSION_HORZ && ( n_edges == 6 || n_edges == 12 ) )
     2108      {
     2109        AF_Edge  edge1, edge2, edge3;
     2110        FT_Pos   dist1, dist2, span, delta;
     2111
     2112
     2113        if ( n_edges == 6 )
     2114        {
     2115          edge1 = edges;
     2116          edge2 = edges + 2;
     2117          edge3 = edges + 4;
     2118        }
     2119        else
     2120        {
     2121          edge1 = edges + 1;
     2122          edge2 = edges + 5;
     2123          edge3 = edges + 9;
     2124        }
     2125
     2126        dist1 = edge2->opos - edge1->opos;
     2127        dist2 = edge3->opos - edge2->opos;
     2128
     2129        span = dist1 - dist2;
     2130        if ( span < 0 )
     2131          span = -span;
     2132
     2133        if ( span < 8 )
     2134        {
     2135          delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
     2136          edge3->pos -= delta;
     2137          if ( edge3->link )
     2138            edge3->link->pos -= delta;
     2139
     2140          /* move the serifs along with the stem */
     2141          if ( n_edges == 12 )
     2142          {
     2143            ( edges + 8 )->pos -= delta;
     2144            ( edges + 11 )->pos -= delta;
     2145          }
     2146
     2147          edge3->flags |= AF_EDGE_DONE;
     2148          if ( edge3->link )
     2149            edge3->link->flags |= AF_EDGE_DONE;
     2150        }
    20982151      }
    20992152    }
    21002153#endif
     2154
    21012155    if ( has_serifs || !anchor )
    21022156    {
     
    22672321  static const AF_Script_UniRangeRec  af_latin2_uniranges[] =
    22682322  {
    2269     { 32,  127 },    /* XXX: TODO: Add new Unicode ranges here! */
    2270     { 160, 255 },
    2271     { 0,   0 }
     2323    AF_UNIRANGE_REC( 32UL,  127UL ),    /* XXX: TODO: Add new Unicode ranges here! */
     2324    AF_UNIRANGE_REC( 160UL, 255UL ),
     2325    AF_UNIRANGE_REC( 0UL,   0UL )
    22722326  };
    22732327
    22742328
    2275   FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
    2276   af_latin2_script_class =
    2277   {
     2329  AF_DEFINE_SCRIPT_CLASS(af_latin2_script_class,
    22782330    AF_SCRIPT_LATIN2,
    22792331    af_latin2_uniranges,
     
    22872339    (AF_Script_InitHintsFunc)   af_latin2_hints_init,
    22882340    (AF_Script_ApplyHintsFunc)  af_latin2_hints_apply
    2289   };
     2341  )
    22902342
    22912343
  • trunk/poppler/freetype2/src/autofit/aflatin2.h

    r209 r275  
    2828  /* the latin-specific script class */
    2929
    30   FT_CALLBACK_TABLE const AF_ScriptClassRec
    31   af_latin2_script_class;
     30  AF_DECLARE_SCRIPT_CLASS(af_latin2_script_class)
    3231
    3332/* */
  • trunk/poppler/freetype2/src/autofit/afloader.c

    r251 r275  
    55/*    Auto-fitter glyph loading routines (body).                           */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007, 2008 by                        */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by                  */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2020#include "afhints.h"
    2121#include "afglobal.h"
    22 #include "aflatin.h"
    2322#include "aferrors.h"
    2423
     
    185184        if ( axis->num_edges > 1 && AF_HINTS_DO_ADVANCE( hints ) )
    186185        {
    187           old_rsb     = loader->pp2.x - edge2->opos;
    188           old_lsb     = edge1->opos;
    189           new_lsb     = edge1->pos;
     186          old_rsb = loader->pp2.x - edge2->opos;
     187          old_lsb = edge1->opos;
     188          new_lsb = edge1->pos;
    190189
    191190          /* remember unhinted values to later account */
     
    218217        else
    219218        {
    220           FT_Pos   pp1x = loader->pp1.x;
    221           FT_Pos   pp2x = loader->pp2.x;
     219          FT_Pos  pp1x = loader->pp1.x;
     220          FT_Pos  pp2x = loader->pp2.x;
     221
    222222
    223223          loader->pp1.x = FT_PIX_ROUND( pp1x );
     
    230230      else
    231231      {
    232         FT_Pos   pp1x = loader->pp1.x;
    233         FT_Pos   pp2x = loader->pp2.x;
     232        FT_Pos  pp1x = loader->pp1.x;
     233        FT_Pos  pp2x = loader->pp2.x;
     234
    234235
    235236        loader->pp1.x = FT_PIX_ROUND( pp1x + hints->xmin_delta );
     
    414415
    415416      /* for mono-width fonts (like Andale, Courier, etc.) we need */
    416       /* to keep the original rounded advance width                */
     417      /* to keep the original rounded advance width; ditto for     */
     418      /* digits if all have the same advance width                 */
    417419#if 0
    418420      if ( !FT_IS_FIXED_WIDTH( slot->face ) )
     
    422424                                               x_scale );
    423425#else
    424       if ( !FT_IS_FIXED_WIDTH( slot->face ) )
    425       {
    426         /* non-spacing glyphs must stay as-is */
    427         if ( slot->metrics.horiAdvance )
    428           slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
    429       }
    430       else
     426      if ( FT_IS_FIXED_WIDTH( slot->face )                              ||
     427           ( af_face_globals_is_digit( loader->globals, glyph_index ) &&
     428             metrics->digits_have_same_width                          ) )
    431429      {
    432430        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
     
    437435        slot->lsb_delta = 0;
    438436        slot->rsb_delta = 0;
     437      }
     438      else
     439      {
     440        /* non-spacing glyphs must stay as-is */
     441        if ( slot->metrics.horiAdvance )
     442          slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
    439443      }
    440444#endif
  • trunk/poppler/freetype2/src/autofit/afmodule.c

    r251 r275  
    1919#include "afmodule.h"
    2020#include "afloader.h"
     21#include "afpic.h"
    2122
    2223#ifdef AF_DEBUG
     
    6768
    6869
    69   FT_CALLBACK_TABLE_DEF
    70   const FT_AutoHinter_ServiceRec  af_autofitter_service =
    71   {
     70  FT_DEFINE_AUTOHINTER_SERVICE(af_autofitter_service,
    7271    NULL,
    7372    NULL,
    7473    NULL,
    7574    (FT_AutoHinter_GlyphLoadFunc)af_autofitter_load_glyph
    76   };
     75  )
    7776
     77  FT_DEFINE_MODULE(autofit_module_class,
    7878
    79   FT_CALLBACK_TABLE_DEF
    80   const FT_Module_Class  autofit_module_class =
    81   {
    8279    FT_MODULE_HINTER,
    8380    sizeof ( FT_AutofitterRec ),
     
    8784    0x20000L,   /* requires FreeType 2.0 or above */
    8885
    89     (const void*)&af_autofitter_service,
     86    (const void*)&AF_AF_AUTOFITTER_SERVICE_GET,
    9087
    9188    (FT_Module_Constructor)af_autofitter_init,
    9289    (FT_Module_Destructor) af_autofitter_done,
    9390    (FT_Module_Requester)  NULL
    94   };
     91  )
    9592
    9693
  • trunk/poppler/freetype2/src/autofit/afmodule.h

    r150 r275  
    2121
    2222#include <ft2build.h>
     23#include FT_INTERNAL_OBJECTS_H
    2324#include FT_MODULE_H
    2425
     
    2627FT_BEGIN_HEADER
    2728
    28   FT_CALLBACK_TABLE
    29   const FT_Module_Class  autofit_module_class;
     29FT_DECLARE_MODULE(autofit_module_class)
    3030
    3131
  • trunk/poppler/freetype2/src/autofit/aftypes.h

    r262 r275  
    286286    AF_ScriptClass  clazz;
    287287    AF_ScalerRec    scaler;
     288    FT_Bool         digits_have_same_width;
    288289
    289290  } AF_ScriptMetricsRec, *AF_ScriptMetrics;
     
    322323  } AF_Script_UniRangeRec;
    323324
     325#define AF_UNIRANGE_REC( a, b ) { (FT_UInt32)(a), (FT_UInt32)(b) }
     326
    324327  typedef const AF_Script_UniRangeRec  *AF_Script_UniRange;
    325328
     
    330333    AF_Script_UniRange          script_uni_ranges; /* last must be { 0, 0 } */
    331334
    332     FT_UInt                     script_metrics_size;
     335    FT_Offset                   script_metrics_size;
    333336    AF_Script_InitMetricsFunc   script_metrics_init;
    334337    AF_Script_ScaleMetricsFunc  script_metrics_scale;
     
    340343  } AF_ScriptClassRec;
    341344
     345/* Declare and define vtables for classes */
     346#ifndef FT_CONFIG_OPTION_PIC
     347
     348#define AF_DECLARE_SCRIPT_CLASS(script_class)                                \
     349  FT_CALLBACK_TABLE const AF_ScriptClassRec                                  \
     350  script_class;
     351
     352#define AF_DEFINE_SCRIPT_CLASS(script_class, script_, ranges, m_size,        \
     353                               m_init, m_scale, m_done, h_init, h_apply)     \
     354  FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec                              \
     355  script_class =                                                             \
     356  {                                                                          \
     357    script_,                                                                 \
     358    ranges,                                                                  \
     359                                                                             \
     360    m_size,                                                                  \
     361                                                                             \
     362    m_init,                                                                  \
     363    m_scale,                                                                 \
     364    m_done,                                                                  \
     365                                                                             \
     366    h_init,                                                                  \
     367    h_apply                                                                  \
     368  };
     369
     370#else
     371
     372#define AF_DECLARE_SCRIPT_CLASS(script_class)                                \
     373  FT_LOCAL(void)                                                             \
     374  FT_Init_Class_##script_class(AF_ScriptClassRec* ac);
     375
     376#define AF_DEFINE_SCRIPT_CLASS(script_class, script_, ranges, m_size,        \
     377                               m_init, m_scale, m_done, h_init, h_apply)     \
     378  FT_LOCAL_DEF(void)                                                         \
     379  FT_Init_Class_##script_class(AF_ScriptClassRec* ac)                        \
     380  {                                                                          \
     381    ac->script                = script_;                                     \
     382    ac->script_uni_ranges     = ranges;                                      \
     383                                                                             \
     384    ac->script_metrics_size   = m_size;                                      \
     385                                                                             \
     386    ac->script_metrics_init   = m_init;                                      \
     387    ac->script_metrics_scale  = m_scale;                                     \
     388    ac->script_metrics_done   = m_done;                                      \
     389                                                                             \
     390    ac->script_hints_init     = h_init;                                      \
     391    ac->script_hints_apply    = h_apply;                                     \
     392  }
     393#endif
     394
    342395
    343396/* */
  • trunk/poppler/freetype2/src/autofit/autofit.c

    r209 r275  
    1919#define FT_MAKE_OPTION_SINGLE_OBJECT
    2020#include <ft2build.h>
     21#include "afpic.c"
    2122#include "afangles.c"
    2223#include "afglobal.c"
  • trunk/poppler/freetype2/src/base/ftadvanc.c

    r269 r275  
    141141      return FT_Err_Unimplemented_Feature;
    142142
    143     flags |= FT_LOAD_ADVANCE_ONLY;
     143    flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
    144144    for ( nn = 0; nn < count; nn++ )
    145145    {
  • trunk/poppler/freetype2/src/base/ftbase.c

    r262 r275  
    55/*    Single object library component (body only).                         */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2121#define  FT_MAKE_OPTION_SINGLE_OBJECT
    2222
     23#include "ftpic.c"
     24#include "basepic.c"
    2325#include "ftadvanc.c"
    2426#include "ftcalc.c"
    2527#include "ftdbgmem.c"
    2628#include "ftgloadr.c"
    27 #include "ftnames.c"
    2829#include "ftobjs.c"
    2930#include "ftoutln.c"
    3031#include "ftrfork.c"
     32#include "ftsnames.c"
    3133#include "ftstream.c"
    3234#include "fttrigon.c"
  • trunk/poppler/freetype2/src/base/ftbbox.c

    r251 r275  
    3030#include FT_OUTLINE_H
    3131#include FT_INTERNAL_CALC_H
     32#include FT_INTERNAL_OBJECTS_H
    3233
    3334
     
    560561  }
    561562
     563FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
     564    (FT_Outline_MoveTo_Func) BBox_Move_To,
     565    (FT_Outline_LineTo_Func) BBox_Move_To,
     566    (FT_Outline_ConicTo_Func)BBox_Conic_To,
     567    (FT_Outline_CubicTo_Func)BBox_Cubic_To,
     568    0, 0
     569  )
    562570
    563571  /* documentation is in ftbbox.h */
     
    629637      /* get the Bezier arc extrema.                               */
    630638
    631       static const FT_Outline_Funcs  bbox_interface =
    632       {
    633         (FT_Outline_MoveTo_Func) BBox_Move_To,
    634         (FT_Outline_LineTo_Func) BBox_Move_To,
    635         (FT_Outline_ConicTo_Func)BBox_Conic_To,
    636         (FT_Outline_CubicTo_Func)BBox_Cubic_To,
    637         0, 0
    638       };
    639 
    640639      FT_Error   error;
    641640      TBBox_Rec  user;
    642641
     642#ifdef FT_CONFIG_OPTION_PIC
     643      FT_Outline_Funcs bbox_interface;
     644      Init_Class_bbox_interface(&bbox_interface);
     645#endif
    643646
    644647      user.bbox = bbox;
  • trunk/poppler/freetype2/src/base/ftbitmap.c

    r262 r275  
    229229      return FT_Err_Invalid_Argument;
    230230
    231     xstr = FT_PIX_ROUND( xStrength ) >> 6;
    232     ystr = FT_PIX_ROUND( yStrength ) >> 6;
     231    if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) ||
     232         ( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) )
     233      return FT_Err_Invalid_Argument;
     234       
     235    xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6;
     236    ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6;
    233237
    234238    if ( xstr == 0 && ystr == 0 )
  • trunk/poppler/freetype2/src/base/ftcalc.c

    r262 r275  
    111111  FT_Sqrt32( FT_Int32  x )
    112112  {
    113     FT_ULong  val, root, newroot, mask;
     113    FT_UInt32  val, root, newroot, mask;
    114114
    115115
    116116    root = 0;
    117     mask = 0x40000000L;
    118     val  = (FT_ULong)x;
     117    mask = (FT_UInt32)0x40000000UL;
     118    val  = (FT_UInt32)x;
    119119
    120120    do
     
    363363
    364364
     365    /* XXX: this function does not allow 64-bit arguments */
    365366    if ( a == 0 || b == c )
    366367      return a;
     
    378379
    379380
    380       ft_multo64( a, b, &temp );
     381      ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
    381382
    382383      temp2.hi = 0;
    383384      temp2.lo = (FT_UInt32)(c >> 1);
    384385      FT_Add64( &temp, &temp2, &temp );
    385       a = ft_div64by32( temp.hi, temp.lo, c );
     386      a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
    386387    }
    387388    else
     
    417418
    418419
    419       ft_multo64( a, b, &temp );
    420       a = ft_div64by32( temp.hi, temp.lo, c );
     420      ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
     421      a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
    421422    }
    422423    else
     
    540541
    541542
    542     s  = a; a = FT_ABS( a );
    543     s ^= b; b = FT_ABS( b );
     543    /* XXX: this function does not allow 64-bit arguments */
     544    s  = (FT_Int32)a; a = FT_ABS( a );
     545    s ^= (FT_Int32)b; b = FT_ABS( b );
    544546
    545547    if ( b == 0 )
    546548    {
    547549      /* check for division by 0 */
    548       q = 0x7FFFFFFFL;
     550      q = (FT_UInt32)0x7FFFFFFFL;
    549551    }
    550552    else if ( ( a >> 16 ) == 0 )
     
    563565      temp2.lo = (FT_UInt32)( b >> 1 );
    564566      FT_Add64( &temp, &temp2, &temp );
    565       q = ft_div64by32( temp.hi, temp.lo, b );
     567      q = ft_div64by32( temp.hi, temp.lo, (FT_Int32)b );
    566568    }
    567569
     
    841843                         FT_Pos  out_y )
    842844  {
    843     FT_Int  result;
     845    FT_Long  result; /* avoid overflow on 16-bit system */
    844846
    845847
     
    890892
    891893
    892       ft_multo64( in_x, out_y, &z1 );
    893       ft_multo64( in_y, out_x, &z2 );
     894      /* XXX: this function does not allow 64-bit arguments */
     895      ft_multo64( (FT_Int32)in_x, (FT_Int32)out_y, &z1 );
     896      ft_multo64( (FT_Int32)in_y, (FT_Int32)out_x, &z2 );
    894897
    895898      if ( z1.hi > z2.hi )
     
    907910    }
    908911
    909     return result;
     912    /* XXX: only the sign of return value, +1/0/-1 must be used */
     913    return (FT_Int)result;
    910914  }
    911915
  • trunk/poppler/freetype2/src/base/ftdbgmem.c

    r262 r275  
    422422          leaks, leak_count );
    423423
    424       printf( "FreeType: No memory leaks detected!\n" );
     424      printf( "FreeType: no memory leaks detected\n" );
    425425    }
    426426  }
  • trunk/poppler/freetype2/src/base/ftgloadr.c

    r251 r275  
    219219      new_max = FT_PAD_CEIL( new_max, 8 );
    220220
     221      if ( new_max > FT_OUTLINE_POINTS_MAX )
     222        return FT_Err_Array_Too_Large;
     223
    221224      if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
    222225           FT_RENEW_ARRAY( base->tags,   old_max, new_max ) )
     
    247250    {
    248251      new_max = FT_PAD_CEIL( new_max, 4 );
     252
     253      if ( new_max > FT_OUTLINE_CONTOURS_MAX )
     254        return FT_Err_Array_Too_Large;
     255
    249256      if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
    250257        goto Exit;
  • trunk/poppler/freetype2/src/base/ftglyph.c

    r251 r275  
    3535#include FT_INTERNAL_OBJECTS_H
    3636
     37#include "basepic.h"
    3738
    3839  /*************************************************************************/
     
    130131
    131132
    132   FT_CALLBACK_TABLE_DEF
    133   const FT_Glyph_Class  ft_bitmap_glyph_class =
    134   {
     133  FT_DEFINE_GLYPH(ft_bitmap_glyph_class,
    135134    sizeof ( FT_BitmapGlyphRec ),
    136135    FT_GLYPH_FORMAT_BITMAP,
     
    142141    ft_bitmap_glyph_bbox,
    143142    0                           /* FT_Glyph_PrepareFunc   */
    144   };
     143  )
    145144
    146145
     
    256255
    257256
    258   FT_CALLBACK_TABLE_DEF
    259   const FT_Glyph_Class  ft_outline_glyph_class =
    260   {
     257  FT_DEFINE_GLYPH( ft_outline_glyph_class,
    261258    sizeof ( FT_OutlineGlyphRec ),
    262259    FT_GLYPH_FORMAT_OUTLINE,
     
    268265    ft_outline_glyph_bbox,
    269266    ft_outline_glyph_prepare
    270   };
     267  )
    271268
    272269
     
    374371    /* if it is a bitmap, that's easy :-) */
    375372    if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
    376       clazz = &ft_bitmap_glyph_class;
     373      clazz = FT_BITMAP_GLYPH_CLASS_GET;
    377374
    378375    /* it it is an outline too */
    379376    else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
    380       clazz = &ft_outline_glyph_class;
     377      clazz = FT_OUTLINE_GLYPH_CLASS_GET;
    381378
    382379    else
     
    534531
    535532    /* when called with a bitmap glyph, do nothing and return successfully */
    536     if ( clazz == &ft_bitmap_glyph_class )
     533    if ( clazz == FT_BITMAP_GLYPH_CLASS_GET )
    537534      goto Exit;
    538535
     
    547544
    548545    /* create result bitmap glyph */
    549     error = ft_new_glyph( glyph->library, &ft_bitmap_glyph_class,
     546    error = ft_new_glyph( glyph->library, FT_BITMAP_GLYPH_CLASS_GET,
    550547                          (FT_Glyph*)(void*)&bitmap );
    551548    if ( error )
  • trunk/poppler/freetype2/src/base/ftinit.c

    r262 r275  
    55/*    FreeType initialization layer (body).                                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2005, 2007 by                               */
     7/*  Copyright 1996-2001, 2002, 2005, 2007, 2009 by                         */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    4343#include FT_INTERNAL_DEBUG_H
    4444#include FT_MODULE_H
     45#include "basepic.h"
    4546
    4647
     
    5354#undef  FT_COMPONENT
    5455#define FT_COMPONENT  trace_init
     56
     57#ifndef FT_CONFIG_OPTION_PIC
    5558
    5659#undef  FT_USE_MODULE
     
    7578  };
    7679
     80#else /* FT_CONFIG_OPTION_PIC */
     81
     82#ifdef __cplusplus
     83#define FT_EXTERNC  extern "C"
     84#else
     85#define FT_EXTERNC  extern
     86#endif
     87
     88  /* declare the module's class creation/destruction functions */
     89#undef  FT_USE_MODULE
     90#define FT_USE_MODULE( type, x )  \
     91  FT_EXTERNC FT_Error FT_Create_Class_##x( FT_Library library, FT_Module_Class** output_class ); \
     92  FT_EXTERNC void     FT_Destroy_Class_##x( FT_Library library, FT_Module_Class*  clazz );
     93
     94#include FT_CONFIG_MODULES_H
     95
     96
     97  /* count all module classes */
     98#undef  FT_USE_MODULE
     99#define FT_USE_MODULE( type, x )  MODULE_CLASS_##x,
     100
     101  enum {
     102#include FT_CONFIG_MODULES_H
     103    FT_NUM_MODULE_CLASSES
     104  };
     105
     106  /* destroy all module classes */ 
     107#undef  FT_USE_MODULE
     108#define FT_USE_MODULE( type, x )  \
     109  if ( classes[i] ) { FT_Destroy_Class_##x(library, classes[i]); } \
     110  i++;                                                             \
     111
     112  FT_BASE_DEF( void )
     113  ft_destroy_default_module_classes( FT_Library  library )
     114  {
     115    FT_Module_Class** classes;
     116    FT_Memory         memory;
     117    FT_UInt           i;
     118    BasePIC*          pic_container = library->pic_container.base;
     119
     120    if ( !pic_container->default_module_classes )
     121      return;
     122
     123    memory = library->memory;
     124    classes = pic_container->default_module_classes;
     125    i = 0;
     126
     127#include FT_CONFIG_MODULES_H
     128
     129    FT_FREE( classes );
     130    pic_container->default_module_classes = 0;
     131  }
     132
     133  /* initialize all module classes and the pointer table */
     134#undef  FT_USE_MODULE
     135#define FT_USE_MODULE( type, x )                \
     136  error = FT_Create_Class_##x(library, &clazz); \
     137  if (error) goto Exit;                         \
     138  classes[i++] = clazz;
     139
     140  FT_BASE_DEF( FT_Error )
     141  ft_create_default_module_classes( FT_Library  library )
     142  {
     143    FT_Error          error;
     144    FT_Memory         memory;
     145    FT_Module_Class** classes;
     146    FT_Module_Class*  clazz;
     147    FT_UInt           i;
     148    BasePIC*          pic_container = library->pic_container.base;
     149
     150    memory = library->memory; 
     151    pic_container->default_module_classes = 0;
     152
     153    if ( FT_ALLOC(classes, sizeof(FT_Module_Class*) * (FT_NUM_MODULE_CLASSES + 1) ) )
     154      return error;
     155    /* initialize all pointers to 0, especially the last one */
     156    for (i = 0; i < FT_NUM_MODULE_CLASSES; i++)
     157      classes[i] = 0;
     158    classes[FT_NUM_MODULE_CLASSES] = 0;
     159
     160    i = 0;
     161
     162#include FT_CONFIG_MODULES_H
     163
     164Exit:   
     165    if (error) ft_destroy_default_module_classes( library );
     166    else pic_container->default_module_classes = classes;
     167
     168    return error;   
     169  }
     170
     171
     172#endif /* FT_CONFIG_OPTION_PIC */
    77173
    78174  /* documentation is in ftmodapi.h */
     
    87183    /* test for valid `library' delayed to FT_Add_Module() */
    88184
    89     cur = ft_default_modules;
     185    cur = FT_DEFAULT_MODULES_GET;
    90186    while ( *cur )
    91187    {
     
    93189      /* notify errors, but don't stop */
    94190      if ( error )
    95       {
    96         FT_ERROR(( "FT_Add_Default_Module: Cannot install `%s', error = 0x%x\n",
    97                    (*cur)->module_name, error ));
    98       }
     191        FT_TRACE0(( "FT_Add_Default_Module:"
     192                    " Cannot install `%s', error = 0x%x\n",
     193                    (*cur)->module_name, error ));
    99194      cur++;
    100195    }
     
    128223      FT_Done_Memory( memory );
    129224    else
    130     {
    131       (*alibrary)->version_major = FREETYPE_MAJOR;
    132       (*alibrary)->version_minor = FREETYPE_MINOR;
    133       (*alibrary)->version_patch = FREETYPE_PATCH;
    134 
    135225      FT_Add_Default_Modules( *alibrary );
    136     }
    137226
    138227    return error;
  • trunk/poppler/freetype2/src/base/ftobjs.c

    r269 r275  
    349349    ft_glyphslot_free_bitmap( slot );
    350350
    351     /* free glyph loader */
    352     if ( FT_DRIVER_USES_OUTLINES( driver ) )
    353     {
    354       FT_GlyphLoader_Done( slot->internal->loader );
    355       slot->internal->loader = 0;
    356     }
    357 
    358     FT_FREE( slot->internal );
     351    /* slot->internal might be NULL in out-of-memory situations */
     352    if ( slot->internal )
     353    {
     354      /* free glyph loader */
     355      if ( FT_DRIVER_USES_OUTLINES( driver ) )
     356      {
     357        FT_GlyphLoader_Done( slot->internal->loader );
     358        slot->internal->loader = 0;
     359      }
     360
     361      FT_FREE( slot->internal );
     362    }
    359363  }
    360364
     
    589593     * The general rules are:
    590594     *
    591      * - Do only auto-hinting if we have a hinter module,
    592      *   a scalable font format dealing with outlines,
    593      *   and no transforms except simple slants.
     595     * - Do only auto-hinting if we have a hinter module, a scalable font
     596     *   format dealing with outlines, and no transforms except simple
     597     *   slants and/or rotations by integer multiples of 90 degrees.
    594598     *
    595      * - Then, autohint if FT_LOAD_FORCE_AUTOHINT is set
    596      *   or if we don't have a native font hinter.
     599     * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't
     600     *   have a native font hinter.
    597601     *
    598602     * - Otherwise, auto-hint for LIGHT hinting mode.
    599603     *
    600      * - Exception: The font is `tricky' and requires
    601      *   the native hinter to load properly.
     604     * - Exception: The font is `tricky' and requires the native hinter to
     605     *   load properly.
    602606     */
    603607
    604     if ( hinter                                   &&
    605          !( load_flags & FT_LOAD_NO_HINTING )     &&
    606          !( load_flags & FT_LOAD_NO_AUTOHINT )    &&
    607          FT_DRIVER_IS_SCALABLE( driver )          &&
    608          FT_DRIVER_USES_OUTLINES( driver )        &&
    609          !FT_IS_TRICKY( face )                    &&
    610          face->internal->transform_matrix.yy > 0  &&
    611          face->internal->transform_matrix.yx == 0 )
     608    if ( hinter                                           &&
     609         !( load_flags & FT_LOAD_NO_HINTING )             &&
     610         !( load_flags & FT_LOAD_NO_AUTOHINT )            &&
     611         FT_DRIVER_IS_SCALABLE( driver )                  &&
     612         FT_DRIVER_USES_OUTLINES( driver )                &&
     613         !FT_IS_TRICKY( face )                            &&
     614         ( ( face->internal->transform_matrix.yx == 0 &&
     615             face->internal->transform_matrix.xx != 0 ) ||
     616           ( face->internal->transform_matrix.xx == 0 &&
     617             face->internal->transform_matrix.yx != 0 ) ) )
    612618    {
    613619      if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) ||
     
    23992405                                  FT_Pos             advance )
    24002406  {
     2407    FT_Pos  height = metrics->height;
     2408
     2409
     2410    /* compensate for glyph with bbox above/below the baseline */
     2411    if ( metrics->horiBearingY < 0 )
     2412    {
     2413      if ( height < metrics->horiBearingY )
     2414        height = metrics->horiBearingY;
     2415    }
     2416    else if ( metrics->horiBearingY > 0 )
     2417      height -= metrics->horiBearingY;
     2418
    24012419    /* the factor 1.2 is a heuristical value */
    24022420    if ( !advance )
    2403       advance = metrics->height * 12 / 10;
    2404 
    2405     metrics->vertBearingX = -( metrics->width / 2 );
    2406     metrics->vertBearingY = ( advance - metrics->height ) / 2;
     2421      advance = height * 12 / 10;
     2422
     2423    metrics->vertBearingX = metrics->horiBearingX - metrics->horiAdvance / 2;
     2424    metrics->vertBearingY = ( advance - height ) / 2;
    24072425    metrics->vertAdvance  = advance;
    24082426  }
     
    30493067
    30503068
    3051       result = cmap->clazz->char_index( cmap, charcode );
     3069      if ( charcode > 0xFFFFFFFFUL )
     3070      {
     3071        FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
     3072        FT_TRACE1(( " 0x%x is truncated\n", charcode ));
     3073      }
     3074      result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode );
    30523075    }
    30533076    return  result;
     
    31293152
    31303153
    3131         result = vcmap->clazz->char_var_index( vcmap, ucmap, charcode,
    3132                                                variantSelector );
     3154        if ( charcode > 0xFFFFFFFFUL )
     3155        {
     3156          FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
     3157          FT_TRACE1(( " 0x%x is truncated\n", charcode ));
     3158        }
     3159        if ( variantSelector > 0xFFFFFFFFUL )
     3160        {
     3161          FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
     3162          FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
     3163        }
     3164
     3165        result = vcmap->clazz->char_var_index( vcmap, ucmap,
     3166                                               (FT_UInt32)charcode,
     3167                                               (FT_UInt32)variantSelector );
    31333168      }
    31343169    }
     
    31583193
    31593194
    3160         result = vcmap->clazz->char_var_default( vcmap, charcode,
    3161                                                  variantSelector );
     3195        if ( charcode > 0xFFFFFFFFUL )
     3196        {
     3197          FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
     3198          FT_TRACE1(( " 0x%x is truncated\n", charcode ));
     3199        }
     3200        if ( variantSelector > 0xFFFFFFFFUL )
     3201        {
     3202          FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
     3203          FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
     3204        }
     3205
     3206        result = vcmap->clazz->char_var_default( vcmap,
     3207                                                 (FT_UInt32)charcode,
     3208                                                 (FT_UInt32)variantSelector );
    31623209      }
    31633210    }
     
    32143261
    32153262
    3216         result = vcmap->clazz->charvariant_list( vcmap, memory, charcode );
     3263        if ( charcode > 0xFFFFFFFFUL )
     3264        {
     3265          FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
     3266          FT_TRACE1(( " 0x%x is truncated\n", charcode ));
     3267        }
     3268
     3269        result = vcmap->clazz->charvariant_list( vcmap, memory,
     3270                                                 (FT_UInt32)charcode );
    32173271      }
    32183272    }
     
    32413295
    32423296
     3297        if ( variantSelector > 0xFFFFFFFFUL )
     3298        {
     3299          FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
     3300          FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
     3301        }
     3302
    32433303        result = vcmap->clazz->variantchar_list( vcmap, memory,
    3244                                                  variantSelector );
     3304                                                 (FT_UInt32)variantSelector );
    32453305      }
    32463306    }
     
    32923352
    32933353    if ( face                                     &&
    3294          glyph_index <= (FT_UInt)face->num_glyphs &&
     3354         (FT_Long)glyph_index <= face->num_glyphs &&
    32953355         FT_HAS_GLYPH_NAMES( face )               )
    32963356    {
     
    33923452  {
    33933453    FT_Service_SFNT_Table  service;
     3454    FT_ULong               offset;
    33943455
    33953456
     
    34013462      return FT_Err_Unimplemented_Feature;
    34023463
    3403     return service->table_info( face, table_index, tag, length );
     3464    return service->table_info( face, table_index, tag, &offset, length );
    34043465  }
    34053466
     
    37263787        {
    37273788          error = renderer->render( renderer, slot, render_mode, NULL );
    3728           if ( !error ||
     3789          if ( !error                                               ||
    37293790               FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )
    37303791            break;
     
    41244185    library->memory = memory;
    41254186
     4187#ifdef FT_CONFIG_OPTION_PIC
     4188    /* initialize position independent code containers */
     4189    error = ft_pic_container_init( library );
     4190    if ( error )
     4191      goto Fail;
     4192#endif
     4193
    41264194    /* allocate the render pool */
    41274195    library->raster_pool_size = FT_RENDER_POOL_SIZE;
     
    41314199#endif
    41324200
     4201    library->version_major = FREETYPE_MAJOR;
     4202    library->version_minor = FREETYPE_MINOR;
     4203    library->version_patch = FREETYPE_PATCH;
     4204
    41334205    /* That's ok now */
    41344206    *alibrary = library;
     
    41374209
    41384210  Fail:
     4211#ifdef FT_CONFIG_OPTION_PIC
     4212    ft_pic_container_destroy( library );
     4213#endif
    41394214    FT_FREE( library );
    41404215    return error;
     
    42174292          FT_Done_Face( FT_FACE( faces->head->data ) );
    42184293          if ( faces->head )
    4219             FT_ERROR(( "FT_Done_Library: failed to free some faces\n" ));
     4294            FT_TRACE0(( "FT_Done_Library: failed to free some faces\n" ));
    42204295        }
    42214296      }
     
    42534328    library->raster_pool_size = 0;
    42544329
     4330#ifdef FT_CONFIG_OPTION_PIC
     4331    /* Destroy pic container contents */
     4332    ft_pic_container_destroy( library );
     4333#endif
     4334
    42554335    FT_FREE( library );
    42564336    return FT_Err_Ok;
  • trunk/poppler/freetype2/src/base/ftpatent.c

    r262 r275  
    104104
    105105  Exit:
     106    FT_UNUSED( error );
    106107    FT_FRAME_EXIT();
    107108    return result;
     
    114115  {
    115116    FT_Stream              stream = face->stream;
    116     FT_Error               error;
     117    FT_Error               error = FT_Err_Ok;
    117118    FT_Service_SFNT_Table  service;
    118119    FT_Bool                result = FALSE;
     
    123124    if ( service )
    124125    {
    125       FT_ULong  offset, size;
    126 
    127 
    128       error = service->table_info( face, tag, &offset, &size );
     126      FT_UInt   i = 0;
     127      FT_ULong  tag_i = 0, offset_i, length_i;
     128
     129      for ( i = 0; !error && tag_i != tag ; i++ )
     130        error = service->table_info( face, i,
     131                                     &tag_i, &offset_i, &length_i );
     132
    129133      if ( error                    ||
    130            FT_STREAM_SEEK( offset ) )
    131         goto Exit;
    132 
    133       result = _tt_check_patents_in_range( stream, size );
     134           FT_STREAM_SEEK( offset_i ) )
     135        goto Exit;
     136
     137      result = _tt_check_patents_in_range( stream, length_i );
    134138    }
    135139
  • trunk/poppler/freetype2/src/base/ftrfork.c

    r269 r275  
    753753  {
    754754    char*        new_name;
    755     char*        tmp;
     755    const char*  tmp;
    756756    const char*  slash;
    757     unsigned     new_length;
     757    size_t       new_length;
    758758    FT_Error     error = FT_Err_Ok;
    759759
  • trunk/poppler/freetype2/src/base/ftstream.c

    r262 r275  
    55/*    I/O stream support (body).                                           */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2004, 2005, 2006, 2008 by                   */
     7/*  Copyright 2000-2001, 2002, 2004, 2005, 2006, 2008, 2009 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6161
    6262
    63     stream->pos = pos;
    64 
    6563    if ( stream->read )
    6664    {
    6765      if ( stream->read( stream, pos, 0, 0 ) )
    6866      {
    69         FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     67        FT_ERROR(( "FT_Stream_Seek:"
     68                   " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    7069                   pos, stream->size ));
    7170
     
    7675    else if ( pos > stream->size )
    7776    {
    78       FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     77      FT_ERROR(( "FT_Stream_Seek:"
     78                 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    7979                 pos, stream->size ));
    8080
    8181      error = FT_Err_Invalid_Stream_Operation;
    8282    }
     83
     84    if ( !error )
     85      stream->pos = pos;
    8386
    8487    return error;
     
    125128    if ( pos >= stream->size )
    126129    {
    127       FT_ERROR(( "FT_Stream_ReadAt: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     130      FT_ERROR(( "FT_Stream_ReadAt:"
     131                 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    128132                 pos, stream->size ));
    129133
     
    146150    if ( read_bytes < count )
    147151    {
    148       FT_ERROR(( "FT_Stream_ReadAt:" ));
    149       FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
     152      FT_ERROR(( "FT_Stream_ReadAt:"
     153                " invalid read; expected %lu bytes, got %lu\n",
    150154                 count, read_bytes ));
    151155
     
    212216                          FT_Byte**  pbytes )
    213217  {
    214     if ( stream->read )
     218    if ( stream && stream->read )
    215219    {
    216220      FT_Memory  memory = stream->memory;
     
    257261      if ( read_bytes < count )
    258262      {
    259         FT_ERROR(( "FT_Stream_EnterFrame:" ));
    260         FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
     263        FT_ERROR(( "FT_Stream_EnterFrame:"
     264                  " invalid read; expected %lu bytes, got %lu\n",
    261265                   count, read_bytes ));
    262266
     
    274278           stream->pos + count > stream->size )
    275279      {
    276         FT_ERROR(( "FT_Stream_EnterFrame:" ));
    277         FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
     280        FT_ERROR(( "FT_Stream_EnterFrame:"
     281                  " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
    278282                   stream->pos, count, stream->size ));
    279283
     
    460464  Fail:
    461465    *error = FT_Err_Invalid_Stream_Operation;
    462     FT_ERROR(( "FT_Stream_ReadChar: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     466    FT_ERROR(( "FT_Stream_ReadChar:"
     467               " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    463468               stream->pos, stream->size ));
    464469
     
    506511  Fail:
    507512    *error = FT_Err_Invalid_Stream_Operation;
    508     FT_ERROR(( "FT_Stream_ReadShort:" ));
    509     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     513    FT_ERROR(( "FT_Stream_ReadShort:"
     514              " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    510515               stream->pos, stream->size ));
    511516
     
    553558  Fail:
    554559    *error = FT_Err_Invalid_Stream_Operation;
    555     FT_ERROR(( "FT_Stream_ReadShortLE:" ));
    556     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     560    FT_ERROR(( "FT_Stream_ReadShortLE:"
     561              " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    557562               stream->pos, stream->size ));
    558563
     
    600605  Fail:
    601606    *error = FT_Err_Invalid_Stream_Operation;
    602     FT_ERROR(( "FT_Stream_ReadOffset:" ));
    603     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     607    FT_ERROR(( "FT_Stream_ReadOffset:"
     608              " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    604609               stream->pos, stream->size ));
    605610
     
    646651
    647652  Fail:
    648     FT_ERROR(( "FT_Stream_ReadLong: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     653    *error = FT_Err_Invalid_Stream_Operation;
     654    FT_ERROR(( "FT_Stream_ReadLong:"
     655               " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    649656               stream->pos, stream->size ));
    650     *error = FT_Err_Invalid_Stream_Operation;
    651657
    652658    return 0;
     
    692698
    693699  Fail:
    694     FT_ERROR(( "FT_Stream_ReadLongLE:" ));
    695     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
     700    *error = FT_Err_Invalid_Stream_Operation;
     701    FT_ERROR(( "FT_Stream_ReadLongLE:"
     702               " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
    696703               stream->pos, stream->size ));
    697     *error = FT_Err_Invalid_Stream_Operation;
    698704
    699705    return 0;
  • trunk/poppler/freetype2/src/base/ftstroke.c

    r269 r275  
    707707    FT_Bool              valid;
    708708    FT_StrokeBorderRec   borders[2];
    709     FT_Memory            memory;
     709    FT_Library           library;
    710710
    711711  } FT_StrokerRec;
     
    730730    if ( !FT_NEW( stroker ) )
    731731    {
    732       stroker->memory = memory;
     732      stroker->library = library;
    733733
    734734      ft_stroke_border_init( &stroker->borders[0], memory );
     
    778778    if ( stroker )
    779779    {
    780       FT_Memory  memory = stroker->memory;
     780      FT_Memory  memory = stroker->library->memory;
    781781
    782782
     
    784784      ft_stroke_border_done( &stroker->borders[1] );
    785785
    786       stroker->memory = NULL;
     786      stroker->library = NULL;
    787787      FT_FREE( stroker );
    788788    }
     
    859859
    860860      error = ft_stroke_border_lineto( border, &delta, FALSE );
     861    }
     862    else if ( stroker->line_cap == FT_STROKER_LINECAP_BUTT )
     863    {
     864      /* add a butt ending */
     865      FT_Vector        delta;
     866      FT_Angle         rotate = FT_SIDE_TO_ROTATE( side );
     867      FT_Fixed         radius = stroker->radius;
     868      FT_StrokeBorder  border = stroker->borders + side;
     869
     870
     871      FT_Vector_From_Polar( &delta, radius, angle + rotate );
     872
     873      delta.x += stroker->center.x;
     874      delta.y += stroker->center.y;
     875
     876      error = ft_stroke_border_lineto( border, &delta, FALSE );
     877      if ( error )
     878        goto Exit;
     879
     880      FT_Vector_From_Polar( &delta, radius, angle - rotate );
     881
     882      delta.x += stroker->center.x;
     883      delta.y += stroker->center.y;
     884
     885      error = ft_stroke_border_lineto( border, &delta, FALSE );   
    861886    }
    862887
     
    18451870  }
    18461871
    1847 
     1872/* declare an extern to access ft_outline_glyph_class global allocated
     1873   in ftglyph.c, and use the FT_OUTLINE_GLYPH_CLASS_GET macro to access
     1874   it when FT_CONFIG_OPTION_PIC is defined */
     1875#ifndef FT_CONFIG_OPTION_PIC
    18481876  extern const FT_Glyph_Class  ft_outline_glyph_class;
     1877#endif
     1878#include "basepic.h"
    18491879
    18501880
     
    18581888    FT_Error  error = FT_Err_Invalid_Argument;
    18591889    FT_Glyph  glyph = NULL;
    1860 
     1890    FT_Library library = stroker->library;
     1891    FT_UNUSED(library);
    18611892
    18621893    if ( pglyph == NULL )
     
    18641895
    18651896    glyph = *pglyph;
    1866     if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
     1897    if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
    18671898      goto Exit;
    18681899
     
    19311962    FT_Error  error = FT_Err_Invalid_Argument;
    19321963    FT_Glyph  glyph = NULL;
    1933 
     1964    FT_Library library = stroker->library;
     1965    FT_UNUSED(library);
    19341966
    19351967    if ( pglyph == NULL )
     
    19371969
    19381970    glyph = *pglyph;
    1939     if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
     1971    if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
    19401972      goto Exit;
    19411973
  • trunk/poppler/freetype2/src/base/ftsynth.c

    r262 r275  
    1919#include <ft2build.h>
    2020#include FT_SYNTHESIS_H
     21#include FT_INTERNAL_DEBUG_H
    2122#include FT_INTERNAL_OBJECTS_H
    2223#include FT_OUTLINE_H
    2324#include FT_BITMAP_H
    2425
     26
     27  /*************************************************************************/
     28  /*                                                                       */
     29  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
     30  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
     31  /* messages during execution.                                            */
     32  /*                                                                       */
     33#undef  FT_COMPONENT
     34#define FT_COMPONENT  trace_synth
    2535
    2636  /*************************************************************************/
     
    107117      ystr &= ~63;
    108118
     119      /*
     120       * XXX: overflow check for 16-bit system, for compatibility
     121       *      with FT_GlyphSlot_Embolden() since freetype-2.1.10.
     122       *      unfortunately, this function return no informations
     123       *      about the cause of error.
     124       */
     125      if ( ( ystr >> 6 ) > FT_INT_MAX || ( ystr >> 6 ) < FT_INT_MIN )
     126      {
     127        FT_TRACE1(( "FT_GlyphSlot_Embolden:" ));
     128        FT_TRACE1(( "too strong embolding parameter ystr=%d\n", ystr ));
     129        return;
     130      }
    109131      error = FT_GlyphSlot_Own_Bitmap( slot );
    110132      if ( error )
     
    130152    slot->metrics.vertAdvance  += ystr;
    131153
     154    /* XXX: 16-bit overflow case must be excluded before here */
    132155    if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
    133       slot->bitmap_top += ystr >> 6;
     156      slot->bitmap_top += (FT_Int)( ystr >> 6 );
    134157  }
    135158
  • trunk/poppler/freetype2/src/base/ftsystem.c

    r262 r275  
    55/*    ANSI-specific FreeType low-level system interface (body).            */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2006, 2008 by                               */
     7/*  Copyright 1996-2001, 2002, 2006, 2008, 2009 by                         */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    206206    file = STREAM_FILE( stream );
    207207
    208     ft_fseek( file, offset, SEEK_SET );
     208    if ( stream->pos != offset )
     209      ft_fseek( file, offset, SEEK_SET );
    209210
    210211    return (unsigned long)ft_fread( buffer, 1, count, file );
     
    227228    if ( !file )
    228229    {
    229       FT_ERROR(( "FT_Stream_Open:" ));
    230       FT_ERROR(( " could not open `%s'\n", filepathname ));
     230      FT_ERROR(( "FT_Stream_Open:"
     231                " could not open `%s'\n", filepathname ));
    231232
    232233      return FT_Err_Cannot_Open_Resource;
  • trunk/poppler/freetype2/src/base/fttrigon.c

    r150 r275  
    7373
    7474    v1 = (FT_UInt32)val >> 16;
    75     v2 = (FT_UInt32)val & 0xFFFFL;
    76 
    77     k1 = FT_TRIG_SCALE >> 16;       /* constant */
    78     k2 = FT_TRIG_SCALE & 0xFFFFL;   /* constant */
     75    v2 = (FT_UInt32)(val & 0xFFFFL);
     76
     77    k1 = (FT_UInt32)FT_TRIG_SCALE >> 16;       /* constant */
     78    k2 = (FT_UInt32)(FT_TRIG_SCALE & 0xFFFFL);   /* constant */
    7979
    8080    hi   = k1 * v1;
     
    8787    hi  += lo1 >> 16;
    8888    if ( lo1 < lo3 )
    89       hi += 0x10000UL;
     89      hi += (FT_UInt32)0x10000UL;
    9090
    9191    val  = (FT_Fixed)hi;
     
    434434      if ( shift > 0 )
    435435      {
    436         FT_Int32  half = 1L << ( shift - 1 );
     436        FT_Int32  half = (FT_Int32)1L << ( shift - 1 );
    437437
    438438
  • trunk/poppler/freetype2/src/bdf/bdf.h

    r251 r275  
    115115    {
    116116      char*          atom;
    117       long           int32;
    118       unsigned long  card32;
     117      long           l;
     118      unsigned long  ul;
    119119
    120120    } value;             /* Value of the property.  */
     
    161161  {
    162162    const char*  key;
    163     void*        data;
     163    size_t       data;
    164164
    165165  } _hashnode, *hashnode;
  • trunk/poppler/freetype2/src/bdf/bdfdrivr.c

    r262 r275  
    5454  {
    5555    FT_CMapRec        cmap;
    56     FT_UInt           num_encodings;
     56    FT_ULong          num_encodings; /* ftobjs.h: FT_CMap->clazz->size */
    5757    BDF_encoding_el*  encodings;
    5858
     
    9393    BDF_CMap          cmap      = (BDF_CMap)bdfcmap;
    9494    BDF_encoding_el*  encodings = cmap->encodings;
    95     FT_UInt           min, max, mid;
    96     FT_UInt           result    = 0;
     95    FT_ULong          min, max, mid; /* num_encodings */
     96    FT_UShort         result    = 0; /* encodings->glyph */
    9797
    9898
     
    102102    while ( min < max )
    103103    {
    104       FT_UInt32  code;
     104      FT_ULong  code;
    105105
    106106
     
    132132    BDF_CMap          cmap      = (BDF_CMap)bdfcmap;
    133133    BDF_encoding_el*  encodings = cmap->encodings;
    134     FT_UInt           min, max, mid;
    135     FT_UInt32         charcode = *acharcode + 1;
    136     FT_UInt           result   = 0;
     134    FT_ULong          min, max, mid; /* num_encodings */
     135    FT_UShort         result   = 0;  /* encodings->glyph */
     136    FT_ULong          charcode = *acharcode + 1;
    137137
    138138
     
    142142    while ( min < max )
    143143    {
    144       FT_UInt32  code;
     144      FT_ULong  code; /* same as BDF_encoding_el.enc */
    145145
    146146
     
    170170
    171171  Exit:
    172     *acharcode = charcode;
     172    if ( charcode > 0xFFFFFFFFUL )
     173    {
     174      FT_TRACE1(( "bdf_cmap_char_next: charcode 0x%x > 32bit API" ));
     175      *acharcode = 0;
     176      /* XXX: result should be changed to indicate an overflow error */
     177    }
     178    else
     179      *acharcode = (FT_UInt32)charcode;
    173180    return result;
    174181  }
     
    197204    bdf_property_t*  prop;
    198205
    199     int    nn, len;
    200     char*  strings[4] = { NULL, NULL, NULL, NULL };
    201     int    lengths[4];
     206    char*   strings[4] = { NULL, NULL, NULL, NULL };
     207    size_t  nn, len, lengths[4];
    202208
    203209
     
    285291        if ( nn == 0 || nn == 3 )
    286292        {
    287           int  mm;
     293          size_t  mm;
    288294
    289295
     
    427433        prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
    428434        if ( prop )
    429           bsize->width = (FT_Short)( ( prop->value.int32 + 5 ) / 10 );
     435          bsize->width = (FT_Short)( ( prop->value.l + 5 ) / 10 );
    430436        else
    431437          bsize->width = (FT_Short)( bsize->height * 2/3 );
     
    435441          /* convert from 722.7 decipoints to 72 points per inch */
    436442          bsize->size =
    437             (FT_Pos)( ( prop->value.int32 * 64 * 7200 + 36135L ) / 72270L );
     443            (FT_Pos)( ( prop->value.l * 64 * 7200 + 36135L ) / 72270L );
    438444        else
    439445          bsize->size = bsize->width << 6;
     
    441447        prop = bdf_get_font_property( font, "PIXEL_SIZE" );
    442448        if ( prop )
    443           bsize->y_ppem = (FT_Short)prop->value.int32 << 6;
     449          bsize->y_ppem = (FT_Short)prop->value.l << 6;
    444450
    445451        prop = bdf_get_font_property( font, "RESOLUTION_X" );
    446452        if ( prop )
    447           resolution_x = (FT_Short)prop->value.int32;
     453          resolution_x = (FT_Short)prop->value.l;
    448454
    449455        prop = bdf_get_font_property( font, "RESOLUTION_Y" );
    450456        if ( prop )
    451           resolution_y = (FT_Short)prop->value.int32;
     457          resolution_y = (FT_Short)prop->value.l;
    452458
    453459        if ( bsize->y_ppem == 0 )
     
    480486
    481487          if ( cur[n].encoding == font->default_char )
    482             face->default_glyph = n;
     488          {
     489            if ( n < FT_UINT_MAX )
     490              face->default_glyph = (FT_UInt)n;
     491            else
     492              FT_TRACE1(( "idx %d is too large for this system\n", n ));
     493          }
    483494        }
    484495      }
     
    672683    bitmap->rows  = glyph.bbx.height;
    673684    bitmap->width = glyph.bbx.width;
    674     bitmap->pitch = glyph.bpr;
     685    if ( glyph.bpr > INT_MAX )
     686      FT_TRACE1(( "BDF_Glyph_Load: too large pitch %d is truncated\n",
     687                   glyph.bpr ));
     688    bitmap->pitch = (int)glyph.bpr; /* same as FT_Bitmap.pitch */
    675689
    676690    /* note: we don't allocate a new array to hold the bitmap; */
     
    744758
    745759      case BDF_INTEGER:
     760        if ( prop->value.l > 0x7FFFFFFFL || prop->value.l < ( -1 - 0x7FFFFFFFL ) )
     761        {
     762          FT_TRACE1(( "bdf_get_bdf_property: " ));
     763          FT_TRACE1(( "too large integer 0x%x is truncated\n" ));
     764        }
    746765        aproperty->type      = BDF_PROPERTY_TYPE_INTEGER;
    747         aproperty->u.integer = prop->value.int32;
     766        aproperty->u.integer = (FT_Int32)prop->value.l;
    748767        break;
    749768
    750769      case BDF_CARDINAL:
     770        if ( prop->value.ul > 0xFFFFFFFFUL )
     771        {
     772          FT_TRACE1(( "bdf_get_bdf_property: " ));
     773          FT_TRACE1(( "too large cardinal 0x%x is truncated\n" ));
     774        }
    751775        aproperty->type       = BDF_PROPERTY_TYPE_CARDINAL;
    752         aproperty->u.cardinal = prop->value.card32;
     776        aproperty->u.cardinal = (FT_UInt32)prop->value.ul;
    753777        break;
    754778
  • trunk/poppler/freetype2/src/bdf/bdfdrivr.h

    r251 r275  
    3636
    3737FT_BEGIN_HEADER
     38
     39#ifdef FT_CONFIG_OPTION_PIC
     40#error "this module does not support PIC yet"
     41#endif
    3842
    3943
  • trunk/poppler/freetype2/src/bdf/bdflib.c

    r269 r275  
    282282  static FT_Error
    283283  hash_insert( char*       key,
    284                void*       data,
     284               size_t      data,
    285285               hashtable*  ht,
    286286               FT_Memory   memory )
     
    416416
    417417  static FT_Error
    418   _bdf_list_ensure( _bdf_list_t*  list,
    419                     int           num_items )
     418  _bdf_list_ensure( _bdf_list_t*   list,
     419                    unsigned long  num_items ) /* same as _bdf_list_t.used */
    420420  {
    421421    FT_Error  error = BDF_Err_Ok;
    422422
    423423
    424     if ( num_items > (int)list->size )
    425     {
    426       int        oldsize = list->size;
    427       int        newsize = oldsize + ( oldsize >> 1 ) + 4;
    428       int        bigsize = FT_INT_MAX / sizeof ( char* );
    429       FT_Memory  memory  = list->memory;
     424    if ( num_items > list->size )
     425    {
     426      unsigned long  oldsize = list->size; /* same as _bdf_list_t.size */
     427      unsigned long  newsize = oldsize + ( oldsize >> 1 ) + 4;
     428      unsigned long  bigsize = (unsigned long)( FT_INT_MAX / sizeof ( char* ) );
     429      FT_Memory      memory  = list->memory;
    430430
    431431
     
    615615    _bdf_line_func_t  cb;
    616616    unsigned long     lineno, buf_size;
    617     int               refill, bytes, hold, to_skip;
    618     int              start, end, cursor, avail;
     617    int               refill, hold, to_skip;
     618    ptrdiff_t         bytes, start, end, cursor, avail;
    619619    char*             buf = 0;
    620620    FT_Memory         memory = stream->memory;
     
    649649      if ( refill )
    650650      {
    651         bytes  = (int)FT_Stream_TryRead( stream, (FT_Byte*)buf + cursor,
    652                                          (FT_ULong)(buf_size - cursor) );
     651        bytes  = (ptrdiff_t)FT_Stream_TryRead( stream, (FT_Byte*)buf + cursor,
     652                                               (FT_ULong)(buf_size - cursor) );
    653653        avail  = cursor + bytes;
    654654        cursor = 0;
     
    972972                       bdf_font_t*  font )
    973973  {
    974     unsigned long    n;
     974    size_t           n;
    975975    bdf_property_t*  p;
    976976    FT_Memory        memory = font->memory;
     
    992992    FT_ZERO( p );
    993993
    994     n = (unsigned long)( ft_strlen( name ) + 1 );
     994    n = ft_strlen( name ) + 1;
     995    if ( n > FT_ULONG_MAX )
     996      return BDF_Err_Invalid_Argument;
    995997
    996998    if ( FT_NEW_ARRAY( p->name, n ) )
     
    10041006    n = _num_bdf_properties + font->nuser_props;
    10051007
    1006     error = hash_insert( p->name, (void *)n, &(font->proptbl), memory );
     1008    error = hash_insert( p->name, n, &(font->proptbl), memory );
    10071009    if ( error )
    10081010      goto Exit;
     
    10191021                    bdf_font_t*  font )
    10201022  {
    1021     hashnode       hn;
    1022     unsigned long  propid;
     1023    hashnode  hn;
     1024    size_t    propid;
    10231025
    10241026
     
    10291031      return 0;
    10301032
    1031     propid = (unsigned long)hn->data;
     1033    propid = hn->data;
    10321034    if ( propid >= _num_bdf_properties )
    10331035      return font->user_props + ( propid - _num_bdf_properties );
     
    11321134                            bdf_options_t*  opts )
    11331135  {
    1134     unsigned long  len;
    1135     char           name[256];
    1136     _bdf_list_t    list;
    1137     FT_Memory      memory;
    1138     FT_Error       error = BDF_Err_Ok;
     1136    size_t       len;
     1137    char         name[256];
     1138    _bdf_list_t  list;
     1139    FT_Memory    memory;
     1140    FT_Error     error = BDF_Err_Ok;
    11391141
    11401142
     
    11511153    font->spacing = opts->font_spacing;
    11521154
    1153     len = (unsigned long)( ft_strlen( font->name ) + 1 );
     1155    len = ft_strlen( font->name ) + 1;
    11541156    /* Limit ourselves to 256 characters in the font name. */
    11551157    if ( len >= 256 )
     
    12621264                     char*        value )
    12631265  {
    1264     unsigned long   propid;
     1266    size_t          propid;
    12651267    hashnode        hn;
    12661268    bdf_property_t  *prop, *fp;
     
    12741276      /* The property already exists in the font, so simply replace */
    12751277      /* the value of the property with the current value.          */
    1276       fp = font->props + (unsigned long)hn->data;
     1278      fp = font->props + hn->data;
    12771279
    12781280      switch ( fp->format )
     
    12901292
    12911293      case BDF_INTEGER:
    1292         fp->value.int32 = _bdf_atol( value, 0, 10 );
     1294        fp->value.l = _bdf_atol( value, 0, 10 );
    12931295        break;
    12941296
    12951297      case BDF_CARDINAL:
    1296         fp->value.card32 = _bdf_atoul( value, 0, 10 );
     1298        fp->value.ul = _bdf_atoul( value, 0, 10 );
    12971299        break;
    12981300
     
    13361338    }
    13371339
    1338     propid = (unsigned long)hn->data;
     1340    propid = hn->data;
    13391341    if ( propid >= _num_bdf_properties )
    13401342      prop = font->user_props + ( propid - _num_bdf_properties );
     
    13601362
    13611363    case BDF_INTEGER:
    1362       fp->value.int32 = _bdf_atol( value, 0, 10 );
     1364      fp->value.l = _bdf_atol( value, 0, 10 );
    13631365      break;
    13641366
    13651367    case BDF_CARDINAL:
    1366       fp->value.card32 = _bdf_atoul( value, 0, 10 );
     1368      fp->value.ul = _bdf_atoul( value, 0, 10 );
    13671369      break;
    13681370    }
     
    13731375      /* Add the property to the font property table. */
    13741376      error = hash_insert( fp->name,
    1375                            (void *)font->props_used,
     1377                           font->props_used,
    13761378                           (hashtable *)font->internal,
    13771379                           memory );
     
    13881390    /* spacing.                                                            */
    13891391    if ( ft_memcmp( name, "DEFAULT_CHAR", 12 ) == 0 )
    1390       font->default_char = fp->value.int32;
     1392      font->default_char = fp->value.l;
    13911393    else if ( ft_memcmp( name, "FONT_ASCENT", 11 ) == 0 )
    1392       font->font_ascent = fp->value.int32;
     1394      font->font_ascent = fp->value.l;
    13931395    else if ( ft_memcmp( name, "FONT_DESCENT", 12 ) == 0 )
    1394       font->font_descent = fp->value.int32;
     1396      font->font_descent = fp->value.l;
    13951397    else if ( ft_memcmp( name, "SPACING", 7 ) == 0 )
    13961398    {
     
    20452047
    20462048      { /* setup */
    2047         unsigned long    i;
     2049        size_t           i;
    20482050        bdf_property_t*  prop;
    20492051
     
    20552057              i < _num_bdf_properties; i++, prop++ )
    20562058        {
    2057           error = hash_insert( prop->name, (void *)i,
     2059          error = hash_insert( prop->name, i,
    20582060                               &(font->proptbl), memory );
    20592061          if ( error )
     
    24732475    hn = hash_lookup( name, (hashtable *)font->internal );
    24742476
    2475     return hn ? ( font->props + (unsigned long)hn->data ) : 0;
     2477    return hn ? ( font->props + hn->data ) : 0;
    24762478  }
    24772479
  • trunk/poppler/freetype2/src/cache/ftcbasic.c

    r251 r275  
    55/*    The FreeType basic cache interface (body).                           */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
     7/*  Copyright 2003, 2004, 2005, 2006, 2007, 2009 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    1818
    1919#include <ft2build.h>
     20#include FT_INTERNAL_DEBUG_H
    2021#include FT_CACHE_H
    2122#include "ftcglyph.h"
    2223#include "ftcimage.h"
    2324#include "ftcsbits.h"
    24 #include FT_INTERNAL_MEMORY_H
    2525
    2626#include "ftccback.h"
    2727#include "ftcerror.h"
     28
     29#define FT_COMPONENT  trace_cache
    2830
    2931
     
    141143    error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
    142144                                    &face );
     145
     146    if ( error || !face )
     147      return result;
     148
     149    if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
     150    {
     151      FT_TRACE1(( "ftc_basic_family_get_count: too large number of glyphs " ));
     152      FT_TRACE1(( "in this face, truncated\n", face->num_glyphs ));
     153    }
     154
    143155    if ( !error )
    144       result = face->num_glyphs;
     156      result = (FT_UInt)face->num_glyphs;
    145157
    146158    return result;
     
    305317  {
    306318    FTC_BasicQueryRec  query;
    307     FTC_INode          node = 0; /* make compiler happy */
     319    FTC_Node           node = 0; /* make compiler happy */
    308320    FT_Error           error;
    309321    FT_UInt32          hash;
     
    321333      *anode  = NULL;
    322334
    323 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
     335#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
    324336
    325337    /*
     
    327339     *  regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
    328340     */
    329     if ( type->width >= 0x10000 )
     341    if ( (FT_ULong)type->width >= 0x10000L )
    330342    {
    331343      FTC_OldImageDesc  desc = (FTC_OldImageDesc)type;
     
    342354
    343355    {
     356      if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
     357      {
     358        FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
     359        FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
     360      }
     361
    344362      query.attrs.scaler.face_id = type->face_id;
    345363      query.attrs.scaler.width   = type->width;
    346364      query.attrs.scaler.height  = type->height;
    347       query.attrs.load_flags     = type->flags;
     365      query.attrs.load_flags     = (FT_UInt)type->flags;
    348366    }
    349367
     
    366384                               hash, gindex,
    367385                               FTC_GQUERY( &query ),
    368                                (FTC_Node*) &node );
     386                               &node );
    369387#endif
    370388    if ( !error )
     
    374392      if ( anode )
    375393      {
    376         *anode = FTC_NODE( node );
    377         FTC_NODE( node )->ref_count++;
     394        *anode = node;
     395        node->ref_count++;
    378396      }
    379397    }
     
    395413  {
    396414    FTC_BasicQueryRec  query;
    397     FTC_INode          node = 0; /* make compiler happy */
     415    FTC_Node           node = 0; /* make compiler happy */
    398416    FT_Error           error;
    399417    FT_UInt32          hash;
     
    411429      *anode  = NULL;
    412430
     431    /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
     432    if ( load_flags > FT_UINT_MAX )
     433    {
     434      FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
     435      FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
     436    }
     437
    413438    query.attrs.scaler     = scaler[0];
    414     query.attrs.load_flags = load_flags;
     439    query.attrs.load_flags = (FT_UInt)load_flags;
    415440
    416441    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
     
    429454      if ( anode )
    430455      {
    431         *anode = FTC_NODE( node );
    432         FTC_NODE( node )->ref_count++;
     456        *anode = node;
     457        node->ref_count++;
    433458      }
    434459    }
     
    631656    FT_Error           error;
    632657    FTC_BasicQueryRec  query;
    633     FTC_SNode          node = 0; /* make compiler happy */
     658    FTC_Node           node = 0; /* make compiler happy */
    634659    FT_UInt32          hash;
    635660
     
    644669    *ansbit = NULL;
    645670
    646 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
     671#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
    647672
    648673    /*  This one is a major hack used to detect whether we are passed a
    649674     *  regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
    650675     */
    651     if ( type->width >= 0x10000 )
     676    if ( (FT_ULong)type->width >= 0x10000L )
    652677    {
    653678      FTC_OldImageDesc  desc = (FTC_OldImageDesc)type;
     
    664689
    665690    {
     691      if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
     692      {
     693        FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
     694        FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
     695      }
     696
    666697      query.attrs.scaler.face_id = type->face_id;
    667698      query.attrs.scaler.width   = type->width;
    668699      query.attrs.scaler.height  = type->height;
    669       query.attrs.load_flags     = type->flags;
     700      query.attrs.load_flags     = (FT_UInt)type->flags;
    670701    }
    671702
     
    691722                               gindex,
    692723                               FTC_GQUERY( &query ),
    693                                (FTC_Node*)&node );
     724                               &node );
    694725#endif
    695726    if ( error )
    696727      goto Exit;
    697728
    698     *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
     729    *ansbit = FTC_SNODE( node )->sbits +
     730              ( gindex - FTC_GNODE( node )->gindex );
    699731
    700732    if ( anode )
    701733    {
    702       *anode = FTC_NODE( node );
    703       FTC_NODE( node )->ref_count++;
     734      *anode = node;
     735      node->ref_count++;
    704736    }
    705737
     
    721753    FT_Error           error;
    722754    FTC_BasicQueryRec  query;
    723     FTC_SNode          node = 0; /* make compiler happy */
     755    FTC_Node           node = 0; /* make compiler happy */
    724756    FT_UInt32          hash;
    725757
     
    734766    *ansbit = NULL;
    735767
     768    /* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
     769    if ( load_flags > FT_UINT_MAX )
     770    {
     771      FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
     772      FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
     773    }
     774
    736775    query.attrs.scaler     = scaler[0];
    737     query.attrs.load_flags = load_flags;
     776    query.attrs.load_flags = (FT_UInt)load_flags;
    738777
    739778    /* beware, the hash must be the same for all glyph ranges! */
     
    751790      goto Exit;
    752791
    753     *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
     792    *ansbit = FTC_SNODE( node )->sbits +
     793              ( gindex - FTC_GNODE( node )->gindex );
    754794
    755795    if ( anode )
    756796    {
    757       *anode = FTC_NODE( node );
    758       FTC_NODE( node )->ref_count++;
     797      *anode = node;
     798      node->ref_count++;
    759799    }
    760800
  • trunk/poppler/freetype2/src/cache/ftccache.c

    r251 r275  
    55/*    The FreeType internal cache interface (body).                        */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2525#include "ftcerror.h"
    2626
     27#undef  FT_COMPONENT
     28#define FT_COMPONENT  trace_cache
     29
    2730
    2831#define FTC_HASH_MAX_LOAD  2
     
    9497    {
    9598      FTC_Node  node, *pnode;
    96       FT_UInt   p      = cache->p;
    97       FT_UInt   mask   = cache->mask;
    98       FT_UInt   count  = mask + p + 1;    /* number of buckets */
     99      FT_UFast  p      = cache->p;
     100      FT_UFast  mask   = cache->mask;
     101      FT_UFast  count  = mask + p + 1;    /* number of buckets */
    99102
    100103
     
    154157      else if ( cache->slack > (FT_Long)count * FTC_HASH_SUB_LOAD )
    155158      {
    156         FT_UInt    old_index = p + mask;
     159        FT_UFast   old_index = p + mask;
    157160        FTC_Node*  pold;
    158161
     
    217220      if ( node == NULL )
    218221      {
    219         FT_ERROR(( "ftc_node_hash_unlink: unknown node!\n" ));
     222        FT_TRACE0(( "ftc_node_hash_unlink: unknown node\n" ));
    220223        return;
    221224      }
     
    274277    if ( node->cache_index >= manager->num_caches )
    275278    {
    276       FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
     279      FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
    277280      return;
    278281    }
     
    284287    if ( cache == NULL )
    285288    {
    286       FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
     289      FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
    287290      return;
    288291    }
     
    303306    /* check, just in case of general corruption :-) */
    304307    if ( manager->num_nodes == 0 )
    305       FT_ERROR(( "ftc_node_destroy: invalid cache node count! = %d\n",
     308      FT_TRACE0(( "ftc_node_destroy: invalid cache node count (%d)\n",
    306309                  manager->num_nodes ));
    307310#endif
     
    348351      FTC_Manager  manager = cache->manager;
    349352      FT_UFast     i;
    350       FT_UInt      count;
     353      FT_UFast     count;
    351354
    352355
  • trunk/poppler/freetype2/src/cache/ftccache.h

    r251 r275  
    55/*    FreeType internal cache interface (specification).                   */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    9292                       FTC_Cache    cache );
    9393
    94   typedef FT_ULong
     94  typedef FT_Offset
    9595  (*FTC_Node_WeightFunc)( FTC_Node   node,
    9696                          FTC_Cache  cache );
     
    122122    FTC_Node_FreeFunc     node_free;
    123123
    124     FT_UInt               cache_size;
     124    FT_Offset             cache_size;
    125125    FTC_Cache_InitFunc    cache_init;
    126126    FTC_Cache_DoneFunc    cache_done;
     
    203203    FT_UInt32             _hash    = (FT_UInt32)(hash);                  \
    204204    FTC_Node_CompareFunc  _nodcomp = (FTC_Node_CompareFunc)(nodecmp);    \
    205     FT_UInt               _idx;                                          \
     205    FT_UFast              _idx;                                          \
    206206                                                                         \
    207207                                                                         \
     
    247247                                                                         \
    248248  _Ok:                                                                   \
    249     _pnode = (FTC_Node*)(void*)&(node);                                  \
    250     *_pnode = _node;                                                     \
     249    node = _node;                                                        \
    251250  FT_END_STMNT
    252251
  • trunk/poppler/freetype2/src/cache/ftccback.h

    r251 r275  
    3737                 FTC_Cache   cache );
    3838
    39   FT_LOCAL( FT_ULong )
     39  FT_LOCAL( FT_Offset )
    4040  ftc_inode_weight( FTC_Node   inode,
    4141                    FTC_Cache  cache );
     
    5151                 FTC_Cache   cache );
    5252
    53   FT_LOCAL( FT_ULong )
     53  FT_LOCAL( FT_Offset )
    5454  ftc_snode_weight( FTC_Node   snode,
    5555                    FTC_Cache  cache );
  • trunk/poppler/freetype2/src/cache/ftccmap.c

    r262 r275  
    55/*    FreeType CharMap cache (body)                                        */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by      */
     7/*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2323#include FT_INTERNAL_MEMORY_H
    2424#include FT_INTERNAL_DEBUG_H
    25 #include FT_TRUETYPE_IDS_H
    2625
    2726#include "ftccback.h"
     
    8786
    8887  /* compute a query/node hash */
    89 #define FTC_CMAP_HASH( faceid, index, charcode )           \
    90           ( FTC_FACE_ID_HASH( faceid ) + 211 * ( index ) + \
    91             ( (char_code) / FTC_CMAP_INDICES_MAX )       )
     88#define FTC_CMAP_HASH( faceid, index, charcode )         \
     89          ( FTC_FACE_ID_HASH( faceid ) + 211 * (index) + \
     90            ( (charcode) / FTC_CMAP_INDICES_MAX )      )
    9291
    9392  /* the charmap query */
     
    176175
    177176  /* compute the weight of a given cmap node */
    178   FT_CALLBACK_DEF( FT_ULong )
     177  FT_CALLBACK_DEF( FT_Offset )
    179178  ftc_cmap_node_weight( FTC_Node   cnode,
    180179                        FTC_Cache  cache )
     
    285284    FTC_Cache         cache = FTC_CACHE( cmap_cache );
    286285    FTC_CMapQueryRec  query;
    287     FTC_CMapNode      node;
     286    FTC_Node          node;
    288287    FT_Error          error;
    289288    FT_UInt           gindex = 0;
     
    305304    if ( !cache )
    306305    {
    307       FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0!\n" ));
     306      FT_TRACE0(( "FTC_CMapCache_Lookup: bad arguments, returning 0\n" ));
    308307      return 0;
    309308    }
     
    375374                          node, error );
    376375#else
    377     error = FTC_Cache_Lookup( cache, hash, &query, (FTC_Node*) &node );
     376    error = FTC_Cache_Lookup( cache, hash, &query, &node );
    378377#endif
    379378    if ( error )
    380379      goto Exit;
    381380
    382     FT_ASSERT( (FT_UInt)( char_code - node->first ) < FTC_CMAP_INDICES_MAX );
     381    FT_ASSERT( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first ) <
     382                FTC_CMAP_INDICES_MAX );
    383383
    384384    /* something rotten can happen with rogue clients */
    385     if ( (FT_UInt)( char_code - node->first >= FTC_CMAP_INDICES_MAX ) )
     385    if ( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first >=
     386                    FTC_CMAP_INDICES_MAX ) )
    386387      return 0;
    387388
    388     gindex = node->indices[char_code - node->first];
     389    gindex = FTC_CMAP_NODE( node )->indices[char_code -
     390                                            FTC_CMAP_NODE( node )->first];
    389391    if ( gindex == FTC_CMAP_UNKNOWN )
    390392    {
     
    394396      gindex = 0;
    395397
    396       error = FTC_Manager_LookupFace( cache->manager, node->face_id, &face );
     398      error = FTC_Manager_LookupFace( cache->manager,
     399                                      FTC_CMAP_NODE( node )->face_id,
     400                                      &face );
    397401      if ( error )
    398402        goto Exit;
     
    415419      }
    416420
    417       node->indices[char_code - node->first] = (FT_UShort)gindex;
     421      FTC_CMAP_NODE( node )->indices[char_code -
     422                                     FTC_CMAP_NODE( node )->first]
     423        = (FT_UShort)gindex;
    418424    }
    419425
  • trunk/poppler/freetype2/src/cache/ftcglyph.c

    r150 r275  
    55/*    FreeType Glyph Image (FT_Glyph) cache (body).                        */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2003, 2004, 2006 by                               */
     7/*  Copyright 2000-2001, 2003, 2004, 2006, 2009 by                         */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2121#include "ftcglyph.h"
    2222#include FT_ERRORS_H
    23 #include FT_INTERNAL_OBJECTS_H
    24 #include FT_INTERNAL_DEBUG_H
    2523
    2624#include "ftccback.h"
  • trunk/poppler/freetype2/src/cache/ftcglyph.h

    r251 r275  
    278278    FTC_GQuery               _gquery   = (FTC_GQuery)( query );             \
    279279    FTC_MruNode_CompareFunc  _fcompare = (FTC_MruNode_CompareFunc)(famcmp); \
     280    FTC_MruNode              _mrunode;                                      \
    280281                                                                            \
    281282                                                                            \
     
    283284                                                                            \
    284285    FTC_MRULIST_LOOKUP_CMP( &_gcache->families, _gquery, _fcompare,         \
    285                             _gquery->family, error );                       \
     286                            _mrunode, error );                              \
     287    _gquery->family = FTC_FAMILY( _mrunode );                               \
    286288    if ( !error )                                                           \
    287289    {                                                                       \
     
    304306                               gindex, query, node, error )           \
    305307   FT_BEGIN_STMNT                                                     \
    306      void*  _n = &(node);                                             \
    307                                                                       \
    308308                                                                      \
    309309     error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex,    \
    310                                 FTC_GQUERY( query ), (FTC_Node*)_n ); \
     310                                FTC_GQUERY( query ), node );          \
     311                                                                      \
    311312   FT_END_STMNT
    312313
  • trunk/poppler/freetype2/src/cache/ftcimage.c

    r251 r275  
    104104
    105105
    106   FT_LOCAL_DEF( FT_ULong )
     106  FT_LOCAL_DEF( FT_Offset )
    107107  ftc_inode_weight( FTC_Node   ftcinode,
    108108                    FTC_Cache  ftccache )
    109109  {
    110110    FTC_INode  inode = (FTC_INode)ftcinode;
    111     FT_ULong   size  = 0;
     111    FT_Offset  size  = 0;
    112112    FT_Glyph   glyph = inode->glyph;
    113113
     
    152152#if 0
    153153
    154   FT_LOCAL_DEF( FT_ULong )
     154  FT_LOCAL_DEF( FT_Offset )
    155155  FTC_INode_Weight( FTC_INode  inode )
    156156  {
  • trunk/poppler/freetype2/src/cache/ftcmanag.c

    r269 r275  
    2727#include "ftcerror.h"
    2828
     29#ifdef FT_CONFIG_OPTION_PIC
     30#error "cache system does not support PIC yet"
     31#endif
     32
    2933
    3034#undef  FT_COMPONENT
     
    7983  } FTC_SizeNodeRec, *FTC_SizeNode;
    8084
     85#define FTC_SIZE_NODE( x ) ( (FTC_SizeNode)( x ) )
     86
    8187
    8288  FT_CALLBACK_DEF( void )
     
    177183                          FT_Size     *asize )
    178184  {
    179     FT_Error      error;
    180     FTC_SizeNode  node;
     185    FT_Error     error;
     186    FTC_MruNode  mrunode;
    181187
    182188
     
    192198
    193199    FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
    194                             node, error );
     200                            mrunode, error );
    195201
    196202#else
    197     error = FTC_MruList_Lookup( &manager->sizes, scaler, (FTC_MruNode*)&node );
     203    error = FTC_MruList_Lookup( &manager->sizes, scaler, &mrunode );
    198204#endif
    199205
    200206    if ( !error )
    201       *asize = node->size;
     207      *asize = FTC_SIZE_NODE( mrunode )->size;
    202208
    203209    return error;
     
    221227  } FTC_FaceNodeRec, *FTC_FaceNode;
    222228
     229#define FTC_FACE_NODE( x ) ( ( FTC_FaceNode )( x ) )
     230
    223231
    224232  FT_CALLBACK_DEF( FT_Error )
     
    302310                          FT_Face     *aface )
    303311  {
    304     FT_Error      error;
    305     FTC_FaceNode  node;
     312    FT_Error     error;
     313    FTC_MruNode  mrunode;
    306314
    307315
     
    318326
    319327    FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
    320                             node, error );
     328                            mrunode, error );
    321329
    322330#else
    323     error = FTC_MruList_Lookup( &manager->faces, face_id, (FTC_MruNode*)&node );
     331    error = FTC_MruList_Lookup( &manager->faces, face_id, &mrunode );
    324332#endif
    325333
    326334    if ( !error )
    327       *aface = node->face;
     335      *aface = FTC_FACE_NODE( mrunode )->face;
    328336
    329337    return error;
     
    477485
    478486        if ( (FT_UInt)node->cache_index >= manager->num_caches )
    479           FT_ERROR(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
    480                      node->cache_index ));
     487          FT_TRACE0(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
     488                      node->cache_index ));
    481489        else
    482490          weight += cache->clazz.node_weight( node, cache );
     
    487495
    488496      if ( weight != manager->cur_weight )
    489         FT_ERROR(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
    490                    manager->cur_weight, weight ));
     497        FT_TRACE0(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
     498                    manager->cur_weight, weight ));
    491499    }
    492500
     
    506514
    507515      if ( count != manager->num_nodes )
    508         FT_ERROR((
    509           "FTC_Manager_Check: invalid cache node count %d instead of %d\n",
    510           manager->num_nodes, count ));
     516        FT_TRACE0(( "FTC_Manager_Check:"
     517                    " invalid cache node count %d instead of %d\n",
     518                    manager->num_nodes, count ));
    511519    }
    512520  }
     
    535543    FTC_Manager_Check( manager );
    536544
    537     FT_ERROR(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
    538                manager->cur_weight, manager->max_weight,
    539                manager->num_nodes ));
     545    FT_TRACE0(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
     546                manager->cur_weight, manager->max_weight,
     547                manager->num_nodes ));
    540548#endif
    541549
     
    580588      {
    581589        error = FTC_Err_Too_Many_Caches;
    582         FT_ERROR(( "%s: too many registered caches\n",
    583                    "FTC_Manager_Register_Cache" ));
     590        FT_ERROR(( "FTC_Manager_RegisterCache:"
     591                   " too many registered caches\n" ));
    584592        goto Exit;
    585593      }
     
    662670     * the face_id as well
    663671     */
    664     FTC_MruList_RemoveSelection( &manager->faces, NULL, face_id );
     672    FTC_MruList_RemoveSelection( &manager->faces,
     673                                 (FTC_MruNode_CompareFunc)NULL,
     674                                 face_id );
    665675
    666676    for ( nn = 0; nn < manager->num_caches; nn++ )
  • trunk/poppler/freetype2/src/cache/ftcmru.c

    r251 r275  
    55/*    FreeType MRU support (body).                                         */
    66/*                                                                         */
    7 /*  Copyright 2003, 2004, 2006 by                                          */
     7/*  Copyright 2003, 2004, 2006, 2009 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    4747          if ( cnode == node )
    4848          {
    49             fprintf( stderr, "FTC_MruNode_Prepend: invalid action!\n" );
     49            fprintf( stderr, "FTC_MruNode_Prepend: invalid action\n" );
    5050            exit( 2 );
    5151          }
     
    9595        } while ( cnode != first );
    9696
    97         fprintf( stderr, "FTC_MruNode_Up: invalid action!\n" );
     97        fprintf( stderr, "FTC_MruNode_Up: invalid action\n" );
    9898        exit( 2 );
    9999      Ok:
     
    142142        } while ( cnode != first );
    143143
    144         fprintf( stderr, "FTC_MruNode_Remove: invalid action!\n" );
     144        fprintf( stderr, "FTC_MruNode_Remove: invalid action\n" );
    145145        exit( 2 );
    146146      Ok:
  • trunk/poppler/freetype2/src/cache/ftcmru.h

    r251 r275  
    108108  typedef struct  FTC_MruListClassRec_
    109109  {
    110     FT_UInt                  node_size;
     110    FT_Offset                node_size;
    111111    FTC_MruNode_CompareFunc  node_compare;
    112112    FTC_MruNode_InitFunc     node_init;
     
    164164    FTC_MruNode*             _pfirst  = &(list)->nodes;                     \
    165165    FTC_MruNode_CompareFunc  _compare = (FTC_MruNode_CompareFunc)(compare); \
    166     FTC_MruNode              _first, _node, *_pnode;                        \
     166    FTC_MruNode              _first, _node;                                 \
    167167                                                                            \
    168168                                                                            \
     
    181181            FTC_MruNode_Up( _pfirst, _node );                               \
    182182                                                                            \
    183           _pnode = (FTC_MruNode*)(void*)&(node);                            \
    184           *_pnode = _node;                                                  \
     183          node = _node;                                                     \
    185184          goto _MruOk;                                                      \
    186185        }                                                                   \
  • trunk/poppler/freetype2/src/cache/ftcsbits.c

    r251 r275  
    55/*    FreeType sbits manager (body).                                       */
    66/*                                                                         */
    7 /*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2009 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2626#include "ftccback.h"
    2727#include "ftcerror.h"
     28
     29#undef  FT_COMPONENT
     30#define FT_COMPONENT  trace_cache
    2831
    2932
     
    130133      FT_GlyphSlot  slot   = face->glyph;
    131134      FT_Bitmap*    bitmap = &slot->bitmap;
    132       FT_Int        xadvance, yadvance;
     135      FT_Pos        xadvance, yadvance; /* FT_GlyphSlot->advance.{x|y} */
    133136
    134137
    135138      if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
    136139      {
    137         FT_ERROR(( "%s: glyph loaded didn't return a bitmap!\n",
    138                    "ftc_snode_load" ));
     140        FT_TRACE0(( "ftc_snode_load:"
     141                    " glyph loaded didn't return a bitmap\n" ));
    139142        goto BadGlyph;
    140143      }
     
    264267
    265268
    266   FT_LOCAL_DEF( FT_ULong )
     269  FT_LOCAL_DEF( FT_Offset )
    267270  ftc_snode_weight( FTC_Node   ftcsnode,
    268271                    FTC_Cache  cache )
     
    272275    FTC_SBit   sbit  = snode->sbits;
    273276    FT_Int     pitch;
    274     FT_ULong   size;
     277    FT_Offset  size;
    275278
    276279    FT_UNUSED( cache );
     
    301304#if 0
    302305
    303   FT_LOCAL_DEF( FT_ULong )
     306  FT_LOCAL_DEF( FT_Offset )
    304307  FTC_SNode_Weight( FTC_SNode  snode )
    305308  {
  • trunk/poppler/freetype2/src/cff/cff.c

    r150 r275  
    2020
    2121#include <ft2build.h>
     22#include "cffpic.c"
    2223#include "cffdrivr.c"
    2324#include "cffparse.c"
  • trunk/poppler/freetype2/src/cff/cffcmap.c

    r251 r275  
    6666
    6767
    68   FT_CALLBACK_DEF( FT_UInt )
     68  FT_CALLBACK_DEF( FT_UInt32 )
    6969  cff_cmap_encoding_char_next( CFF_CMapStd   cmap,
    7070                               FT_UInt32    *pchar_code )
     
    100100
    101101
    102   FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
    103   cff_cmap_encoding_class_rec =
    104   {
     102  FT_DEFINE_CMAP_CLASS(cff_cmap_encoding_class_rec,
    105103    sizeof ( CFF_CMapStdRec ),
    106104
     
    111109
    112110    NULL, NULL, NULL, NULL, NULL
    113   };
     111  )
    114112
    115113
     
    195193
    196194
    197   FT_CALLBACK_DEF( FT_UInt )
     195  FT_CALLBACK_DEF( FT_UInt32 )
    198196  cff_cmap_unicode_char_next( PS_Unicodes  unicodes,
    199197                              FT_UInt32   *pchar_code )
     
    208206
    209207
    210   FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
    211   cff_cmap_unicode_class_rec =
    212   {
     208  FT_DEFINE_CMAP_CLASS(cff_cmap_unicode_class_rec,
    213209    sizeof ( PS_UnicodesRec ),
    214210
     
    219215
    220216    NULL, NULL, NULL, NULL, NULL
    221   };
    222 
     217  )
    223218
    224219/* END */
  • trunk/poppler/freetype2/src/cff/cffcmap.h

    r251 r275  
    4444
    4545
    46   FT_CALLBACK_TABLE const FT_CMap_ClassRec
    47   cff_cmap_encoding_class_rec;
     46  FT_DECLARE_CMAP_CLASS(cff_cmap_encoding_class_rec)
    4847
    4948
     
    5857  /* unicode (synthetic) cmaps */
    5958
    60   FT_CALLBACK_TABLE const FT_CMap_ClassRec
    61   cff_cmap_unicode_class_rec;
     59  FT_DECLARE_CMAP_CLASS(cff_cmap_unicode_class_rec)
    6260
    6361
  • trunk/poppler/freetype2/src/cff/cffdrivr.c

    r269 r275  
    2222#include FT_INTERNAL_STREAM_H
    2323#include FT_INTERNAL_SFNT_H
    24 #include FT_TRUETYPE_IDS_H
    2524#include FT_SERVICE_CID_H
    2625#include FT_SERVICE_POSTSCRIPT_CMAPS_H
     
    3332#include "cffload.h"
    3433#include "cffcmap.h"
     34#include "cffparse.h"
    3535
    3636#include "cfferrs.h"
     37#include "cffpic.h"
    3738
    3839#include FT_SERVICE_XFREE86_NAME_H
     
    200201
    201202
    202     flags |= FT_LOAD_ADVANCE_ONLY;
     203    flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
    203204
    204205    for ( nn = 0; nn < count; nn++ )
     
    239240    if ( !psnames )
    240241    {
    241       FT_ERROR(( "cff_get_glyph_name:" ));
    242       FT_ERROR(( " cannot get glyph name from CFF & CEF fonts\n" ));
    243       FT_ERROR(( "                   " ));
    244       FT_ERROR(( " without the `PSNames' module\n" ));
     242      FT_ERROR(( "cff_get_glyph_name:"
     243                 " cannot get glyph name from CFF & CEF fonts\n"
     244                 "                   "
     245                " without the `PSNames' module\n" ));
    245246      error = CFF_Err_Unknown_File_Format;
    246247      goto Exit;
     
    310311
    311312
    312   static const FT_Service_GlyphDictRec  cff_service_glyph_dict =
    313   {
     313  FT_DEFINE_SERVICE_GLYPHDICTREC(cff_service_glyph_dict,
    314314    (FT_GlyphDict_GetNameFunc)  cff_get_glyph_name,
    315     (FT_GlyphDict_NameIndexFunc)cff_get_name_index,
    316   };
     315    (FT_GlyphDict_NameIndexFunc)cff_get_name_index
     316  )
    317317
    318318
     
    379379
    380380
    381   static const FT_Service_PsInfoRec  cff_service_ps_info =
    382   {
     381  FT_DEFINE_SERVICE_PSINFOREC(cff_service_ps_info,
    383382    (PS_GetFontInfoFunc)   cff_ps_get_font_info,
    384383    (PS_GetFontExtraFunc)  NULL,
    385384    (PS_HasGlyphNamesFunc) cff_ps_has_glyph_names,
    386385    (PS_GetFontPrivateFunc)NULL         /* unsupported with CFF fonts */
    387   };
     386  )
    388387
    389388
     
    403402
    404403
    405   static const FT_Service_PsFontNameRec  cff_service_ps_name =
    406   {
     404  FT_DEFINE_SERVICE_PSFONTNAMEREC(cff_service_ps_name,
    407405    (FT_PsName_GetFunc)cff_get_ps_name
    408   };
     406  )
    409407
    410408
     
    425423    FT_CMap   cmap  = FT_CMAP( charmap );
    426424    FT_Error  error = CFF_Err_Ok;
     425    FT_Face    face    = FT_CMAP_FACE( cmap );
     426    FT_Library library = FT_FACE_LIBRARY( face );
    427427
    428428
     
    430430    cmap_info->format   = 0;
    431431
    432     if ( cmap->clazz != &cff_cmap_encoding_class_rec &&
    433          cmap->clazz != &cff_cmap_unicode_class_rec  )
    434     {
    435       FT_Face             face    = FT_CMAP_FACE( cmap );
    436       FT_Library          library = FT_FACE_LIBRARY( face );
     432    if ( cmap->clazz != &FT_CFF_CMAP_ENCODING_CLASS_REC_GET &&
     433         cmap->clazz != &FT_CFF_CMAP_UNICODE_CLASS_REC_GET  )
     434    {
    437435      FT_Module           sfnt    = FT_Get_Module( library, "sfnt" );
    438436      FT_Service_TTCMaps  service =
     
    449447
    450448
    451   static const FT_Service_TTCMapsRec  cff_service_get_cmap_info =
    452   {
     449  FT_DEFINE_SERVICE_TTCMAPSREC(cff_service_get_cmap_info,
    453450    (TT_CMap_Info_GetFunc)cff_get_cmap_info
    454   };
     451  )
    455452
    456453
     
    499496      }
    500497
     498      /*
     499       * XXX: According to Adobe TechNote #5176, the supplement in CFF
     500       *      can be a real number. We truncate it to fit public API
     501       *      since freetype-2.3.6.
     502       */
    501503      if ( supplement )
    502         *supplement = dict->cid_supplement;
     504      {
     505        if ( dict->cid_supplement < FT_INT_MIN ||
     506             dict->cid_supplement > FT_INT_MAX )
     507          FT_TRACE1(( "cff_get_ros: too large supplement %d is truncated\n",
     508                      dict->cid_supplement ));
     509        *supplement = (FT_Int)dict->cid_supplement;
     510      }
    503511    }
    504512     
     
    571579
    572580
    573   static const FT_Service_CIDRec  cff_service_cid_info =
    574   {
     581  FT_DEFINE_SERVICE_CIDREC(cff_service_cid_info,
    575582    (FT_CID_GetRegistryOrderingSupplementFunc)cff_get_ros,
    576583    (FT_CID_GetIsInternallyCIDKeyedFunc)      cff_get_is_cid,
    577584    (FT_CID_GetCIDFromGlyphIndexFunc)         cff_get_cid_from_glyph_index
    578   };
     585  )
    579586
    580587
     
    590597  /*************************************************************************/
    591598  /*************************************************************************/
    592 
    593   static const FT_ServiceDescRec  cff_services[] =
    594   {
    595     { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF },
    596     { FT_SERVICE_ID_POSTSCRIPT_INFO,      &cff_service_ps_info },
    597     { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &cff_service_ps_name },
    598599#ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
    599     { FT_SERVICE_ID_GLYPH_DICT,           &cff_service_glyph_dict },
     600  FT_DEFINE_SERVICEDESCREC6(cff_services,
     601    FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF,
     602    FT_SERVICE_ID_POSTSCRIPT_INFO,      &FT_CFF_SERVICE_PS_INFO_GET,
     603    FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &FT_CFF_SERVICE_PS_NAME_GET,
     604    FT_SERVICE_ID_GLYPH_DICT,           &FT_CFF_SERVICE_GLYPH_DICT_GET,
     605    FT_SERVICE_ID_TT_CMAP,              &FT_CFF_SERVICE_GET_CMAP_INFO_GET,
     606    FT_SERVICE_ID_CID,                  &FT_CFF_SERVICE_CID_INFO_GET
     607  )
     608#else
     609  FT_DEFINE_SERVICEDESCREC5(cff_services,
     610    FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF,
     611    FT_SERVICE_ID_POSTSCRIPT_INFO,      &FT_CFF_SERVICE_PS_INFO_GET,
     612    FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &FT_CFF_SERVICE_PS_NAME_GET,
     613    FT_SERVICE_ID_TT_CMAP,              &FT_CFF_SERVICE_GET_CMAP_INFO_GET,
     614    FT_SERVICE_ID_CID,                  &FT_CFF_SERVICE_CID_INFO_GET
     615  )
    600616#endif
    601     { FT_SERVICE_ID_TT_CMAP,              &cff_service_get_cmap_info },
    602     { FT_SERVICE_ID_CID,                  &cff_service_cid_info },
    603     { NULL, NULL }
    604   };
    605 
    606617
    607618  FT_CALLBACK_DEF( FT_Module_Interface )
     
    611622    FT_Module            sfnt;
    612623    FT_Module_Interface  result;
    613 
    614 
    615     result = ft_service_list_lookup( cff_services, module_interface );
     624    FT_Library           library = driver->library;
     625    FT_UNUSED(library);
     626
     627
     628    result = ft_service_list_lookup( FT_CFF_SERVICES_GET, module_interface );
    616629    if ( result != NULL )
    617630      return  result;
     
    626639  /* The FT_DriverInterface structure is defined in ftdriver.h. */
    627640
    628   FT_CALLBACK_TABLE_DEF
    629   const FT_Driver_ClassRec  cff_driver_class =
    630   {
    631     /* begin with the FT_Module_Class fields */
    632     {
     641#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
     642#define CFF_SIZE_SELECT cff_size_select
     643#else
     644#define CFF_SIZE_SELECT 0
     645#endif
     646
     647  FT_DEFINE_DRIVER(cff_driver_class,
    633648      FT_MODULE_FONT_DRIVER       |
    634649      FT_MODULE_DRIVER_SCALABLE   |
     
    645660      cff_driver_done,
    646661      cff_get_interface,
    647     },
    648662
    649663    /* now the specific driver fields */
     
    659673    cff_slot_done,
    660674
    661 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
    662     ft_stub_set_char_sizes,
    663     ft_stub_set_pixel_sizes,
    664 #endif
     675    ft_stub_set_char_sizes, /* FT_CONFIG_OPTION_OLD_INTERNALS */
     676    ft_stub_set_pixel_sizes, /* FT_CONFIG_OPTION_OLD_INTERNALS */
    665677
    666678    Load_Glyph,
     
    672684    cff_size_request,
    673685
    674 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
    675     cff_size_select
    676 #else
    677     0                       /* FT_Size_SelectFunc      */
    678 #endif
    679   };
     686    CFF_SIZE_SELECT
     687  )
    680688
    681689
  • trunk/poppler/freetype2/src/cff/cffdrivr.h

    r251 r275  
    2828
    2929
    30   FT_CALLBACK_TABLE
    31   const FT_Driver_ClassRec  cff_driver_class;
     30  FT_DECLARE_DRIVER( cff_driver_class )
    3231
    3332
  • trunk/poppler/freetype2/src/cff/cffgload.c

    r269 r275  
    1919#include <ft2build.h>
    2020#include FT_INTERNAL_DEBUG_H
    21 #include FT_INTERNAL_CALC_H
    2221#include FT_INTERNAL_STREAM_H
    2322#include FT_INTERNAL_SFNT_H
    2423#include FT_OUTLINE_H
    25 #include FT_TRUETYPE_TAGS_H
    2624#include FT_INTERNAL_POSTSCRIPT_HINTS_H
    2725
     
    475473      point->y = y >> 16;
    476474      *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
    477 
    478       builder->last = *point;
    479475    }
    480476
     
    555551  {
    556552    FT_Outline*  outline = builder->current;
     553    FT_Int       first;
    557554
    558555
     
    560557      return;
    561558
    562     /* XXXX: We must not include the last point in the path if it */
    563     /*       is located on the first point.                       */
     559    first = outline->n_contours <= 1
     560            ? 0 : outline->contours[outline->n_contours - 2] + 1;
     561
     562    /* We must not include the last point in the path if it */
     563    /* is located on the first point.                       */
    564564    if ( outline->n_points > 1 )
    565565    {
    566       FT_Int      first   = 0;
    567566      FT_Vector*  p1      = outline->points + first;
    568567      FT_Vector*  p2      = outline->points + outline->n_points - 1;
    569568      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points - 1;
    570569
    571 
    572       if ( outline->n_contours > 1 )
    573       {
    574         first = outline->contours[outline->n_contours - 2] + 1;
    575         p1    = outline->points + first;
    576       }
    577570
    578571      /* `delete' last point only if it coincides with the first    */
     
    584577
    585578    if ( outline->n_contours > 0 )
    586       outline->contours[outline->n_contours - 1] =
    587         (short)( outline->n_points - 1 );
     579    {
     580      /* Don't add contours only consisting of one point, i.e., */
     581      /* check whether begin point and last point are the same. */
     582      if ( first == outline->n_points - 1 )
     583      {
     584        outline->n_contours--;
     585        outline->n_points--;
     586      }
     587      else
     588        outline->contours[outline->n_contours - 1] =
     589          (short)( outline->n_points - 1 );
     590    }
    588591  }
    589592
     
    705708
    706709
     710    if ( decoder->seac )
     711    {
     712      FT_ERROR(( "cff_operator_seac: invalid nested seac\n" ));
     713      return CFF_Err_Syntax_Error;
     714    }
     715
    707716#ifdef FT_CONFIG_OPTION_INCREMENTAL
    708717    /* Incremental fonts don't necessarily have valid charsets.        */
     
    725734    if ( bchar_index < 0 || achar_index < 0 )
    726735    {
    727       FT_ERROR(( "cff_operator_seac:" ));
    728       FT_ERROR(( " invalid seac character code arguments\n" ));
     736      FT_ERROR(( "cff_operator_seac:"
     737                " invalid seac character code arguments\n" ));
    729738      return CFF_Err_Syntax_Error;
    730739    }
     
    775784    if ( !error )
    776785    {
     786      /* the seac operator must not be nested */
     787      decoder->seac = TRUE;
    777788      error = cff_decoder_parse_charstrings( decoder, charstring,
    778789                                             charstring_len );
     790      decoder->seac = FALSE;
    779791
    780792      if ( error )
     
    801813    if ( !error )
    802814    {
     815      /* the seac operator must not be nested */
     816      decoder->seac = TRUE;
    803817      error = cff_decoder_parse_charstrings( decoder, charstring,
    804818                                             charstring_len );
     819      decoder->seac = FALSE;
    805820
    806821      if ( error )
     
    864879
    865880    /* compute random seed from stack address of parameter */
    866     seed = (FT_Fixed)(char*)&seed           ^
    867            (FT_Fixed)(char*)&decoder        ^
    868            (FT_Fixed)(char*)&charstring_base;
     881    seed = (FT_Fixed)( ( (FT_PtrDist)(char*)&seed              ^
     882                         (FT_PtrDist)(char*)&decoder           ^
     883                         (FT_PtrDist)(char*)&charstring_base ) &
     884                         FT_ULONG_MAX ) ;
    869885    seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
    870886    if ( seed == 0 )
     
    921937        }
    922938        else if ( v < 247 )
    923           val = (FT_Long)v - 139;
     939          val = (FT_Int32)v - 139;
    924940        else if ( v < 251 )
    925941        {
    926942          if ( ip >= limit )
    927943            goto Syntax_Error;
    928           val = ( (FT_Long)v - 247 ) * 256 + *ip++ + 108;
     944          val = ( (FT_Int32)v - 247 ) * 256 + *ip++ + 108;
    929945        }
    930946        else if ( v < 255 )
     
    932948          if ( ip >= limit )
    933949            goto Syntax_Error;
    934           val = -( (FT_Long)v - 251 ) * 256 - *ip++ - 108;
     950          val = -( (FT_Int32)v - 251 ) * 256 - *ip++ - 108;
    935951        }
    936952        else
     
    22422258            if ( idx >= decoder->num_locals )
    22432259            {
    2244               FT_ERROR(( "cff_decoder_parse_charstrings:" ));
    2245               FT_ERROR(( " invalid local subr index\n" ));
     2260              FT_ERROR(( "cff_decoder_parse_charstrings:"
     2261                        " invalid local subr index\n" ));
    22462262              goto Syntax_Error;
    22472263            }
     
    22642280            {
    22652281              FT_ERROR(( "cff_decoder_parse_charstrings:"
    2266                          " invoking empty subrs!\n" ));
     2282                         " invoking empty subrs\n" ));
    22672283              goto Syntax_Error;
    22682284            }
     
    22842300            if ( idx >= decoder->num_globals )
    22852301            {
    2286               FT_ERROR(( "cff_decoder_parse_charstrings:" ));
    2287               FT_ERROR(( " invalid global subr index\n" ));
     2302              FT_ERROR(( "cff_decoder_parse_charstrings:"
     2303                        " invalid global subr index\n" ));
    22882304              goto Syntax_Error;
    22892305            }
     
    23062322            {
    23072323              FT_ERROR(( "cff_decoder_parse_charstrings:"
    2308                          " invoking empty subrs!\n" ));
     2324                         " invoking empty subrs\n" ));
    23092325              goto Syntax_Error;
    23102326            }
     
    23552371
    23562372  Syntax_Error:
    2357     FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error!\n" ));
     2373    FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error\n" ));
    23582374    return CFF_Err_Invalid_File_Format;
    23592375
    23602376  Stack_Underflow:
    2361     FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow!\n" ));
     2377    FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow\n" ));
    23622378    return CFF_Err_Too_Few_Arguments;
    23632379
    23642380  Stack_Overflow:
    2365     FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow!\n" ));
     2381    FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow\n" ));
    23662382    return CFF_Err_Stack_Overflow;
    23672383  }
     
    25662582                                             glyph_index );
    25672583
    2568       FT_Int  top_upm = cff->top_font.font_dict.units_per_em;
    2569       FT_Int  sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
     2584      FT_ULong  top_upm = cff->top_font.font_dict.units_per_em;
     2585      FT_ULong  sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
    25702586
    25712587
     
    27122728        glyph->root.internal->glyph_transformed = 0;
    27132729
     2730#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
    27142731        has_vertical_info = FT_BOOL( face->vertical_info                   &&
    27152732                                     face->vertical.number_Of_VMetrics > 0 &&
    27162733                                     face->vertical.long_metrics           );
     2734#else
     2735        has_vertical_info = FT_BOOL( face->vertical_info                   &&
     2736                                     face->vertical.number_Of_VMetrics > 0 );
     2737#endif
    27172738
    27182739        /* get the vertical metrics from the vtmx table if we have one */
     
    27512772        glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
    27522773
    2753         /* apply the font matrix -- `xx' has already been normalized */
    2754         if ( !( font_matrix.yy == 0x10000L &&
     2774        if ( !( font_matrix.xx == 0x10000L &&
     2775                font_matrix.yy == 0x10000L &&
    27552776                font_matrix.xy == 0        &&
    27562777                font_matrix.yx == 0        ) )
     
    28052826
    28062827        if ( has_vertical_info )
    2807           metrics->vertBearingX = -metrics->width / 2;
     2828          metrics->vertBearingX = metrics->horiBearingX -
     2829                                    metrics->horiAdvance / 2;
    28082830        else
    28092831          ft_synthesize_vertical_metrics( metrics,
  • trunk/poppler/freetype2/src/cff/cffgload.h

    r262 r275  
    55/*    OpenType Glyph Loader (specification).                               */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    5353  /*                                                                       */
    5454  /*    current       :: The current glyph outline.                        */
    55   /*                                                                       */
    56   /*    last          :: The last point position.                          */
    5755  /*                                                                       */
    5856  /*    pos_x         :: The horizontal translation (if composite glyph).  */
     
    8987    FT_Outline*     current;
    9088
    91     FT_Vector       last;
    92 
    9389    FT_Pos          pos_x;
    9490    FT_Pos          pos_y;
     
    158154
    159155    FT_Render_Mode     hint_mode;
     156
     157    FT_Bool            seac;
    160158
    161159  } CFF_Decoder;
  • trunk/poppler/freetype2/src/cff/cffload.c

    r269 r275  
    737737    FT_Error   error   = FT_Err_Ok;
    738738    FT_UInt    i;
     739    FT_Long    j;
    739740    FT_UShort  max_cid = 0;
    740741
     
    751752      goto Exit;
    752753
    753     for ( i = 0; i < num_glyphs; i++ )
    754       charset->cids[charset->sids[i]] = (FT_UShort)i;
     754    /* When multiple GIDs map to the same CID, we choose the lowest */
     755    /* GID.  This is not described in any spec, but it matches the  */
     756    /* behaviour of recent Acroread versions.                       */
     757    for ( j = num_glyphs - 1; j >= 0 ; j-- )
     758      charset->cids[charset->sids[j]] = (FT_UShort)j;
    755759
    756760    charset->max_cid    = max_cid;
     
    843847
    844848          for ( j = 1; j < num_glyphs; j++ )
    845             charset->sids[j] = FT_GET_USHORT();
     849          {
     850            FT_UShort sid = FT_GET_USHORT();
     851
     852
     853            /* this constant is given in the CFF specification */
     854            if ( sid < 65000L )
     855              charset->sids[j] = sid;
     856            else
     857            {
     858              FT_TRACE0(( "cff_charset_load:"
     859                          " invalid SID value %d set to zero\n", sid ));
     860              charset->sids[j] = 0;
     861            }
     862          }
    846863
    847864          FT_FRAME_EXIT();
     
    876893            }
    877894
     895            /* check whether the range contains at least one valid glyph; */
     896            /* the constant is given in the CFF specification             */
     897            if ( glyph_sid >= 65000L ) {
     898              FT_ERROR(( "cff_charset_load: invalid SID range\n" ));
     899              error = CFF_Err_Invalid_File_Format;
     900              goto Exit;
     901            }
     902
     903            /* try to rescue some of the SIDs if `nleft' is too large */
     904            if ( nleft > 65000L - 1L || glyph_sid >= 65000L - nleft ) {
     905              FT_ERROR(( "cff_charset_load: invalid SID range trimmed\n" ));
     906              nleft = ( FT_UInt )( 65000L - 1L - glyph_sid );
     907            }
     908
    878909            /* Fill in the range of sids -- `nleft + 1' glyphs. */
    879910            for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
     
    884915
    885916      default:
    886         FT_ERROR(( "cff_charset_load: invalid table format!\n" ));
     917        FT_ERROR(( "cff_charset_load: invalid table format\n" ));
    887918        error = CFF_Err_Invalid_File_Format;
    888919        goto Exit;
     
    907938        {
    908939          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
    909                      "predefined charset (Adobe ISO-Latin)!\n" ));
     940                     "predefined charset (Adobe ISO-Latin)\n" ));
    910941          error = CFF_Err_Invalid_File_Format;
    911942          goto Exit;
     
    925956        {
    926957          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
    927                      "predefined charset (Adobe Expert)!\n" ));
     958                     "predefined charset (Adobe Expert)\n" ));
    928959          error = CFF_Err_Invalid_File_Format;
    929960          goto Exit;
     
    943974        {
    944975          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
    945                      "predefined charset (Adobe Expert Subset)!\n" ));
     976                     "predefined charset (Adobe Expert Subset)\n" ));
    946977          error = CFF_Err_Invalid_File_Format;
    947978          goto Exit;
     
    11281159
    11291160      default:
    1130         FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
     1161        FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
    11311162        error = CFF_Err_Invalid_File_Format;
    11321163        goto Exit;
     
    12231254
    12241255      default:
    1225         FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
     1256        FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
    12261257        error = CFF_Err_Invalid_File_Format;
    12271258        goto Exit;
     
    12411272                    FT_UInt      font_index,
    12421273                    FT_Stream    stream,
    1243                     FT_ULong     base_offset )
     1274                    FT_ULong     base_offset,
     1275                    FT_Library   library )
    12441276  {
    12451277    FT_Error         error;
     
    12511283
    12521284
    1253     cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict );
     1285    cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library );
    12541286
    12551287    /* set defaults */
     
    13021334      priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
    13031335
    1304       cff_parser_init( &parser, CFF_CODE_PRIVATE, priv );
     1336      cff_parser_init( &parser, CFF_CODE_PRIVATE, priv, library );
    13051337
    13061338      if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
     
    13551387
    13561388  FT_LOCAL_DEF( FT_Error )
    1357   cff_font_load( FT_Stream  stream,
     1389  cff_font_load( FT_Library library,
     1390                 FT_Stream  stream,
    13581391                 FT_Int     face_index,
    13591392                 CFF_Font   font,
     
    13951428         font->absolute_offsize > 4 )
    13961429    {
    1397       FT_TRACE2(( "[not a CFF font header!]\n" ));
     1430      FT_TRACE2(( "[not a CFF font header]\n" ));
    13981431      error = CFF_Err_Unknown_File_Format;
    13991432      goto Exit;
     
    14331466                              face_index,
    14341467                              stream,
    1435                               base_offset );
     1468                              base_offset,
     1469                              library );
    14361470    if ( error )
    14371471      goto Exit;
     
    14631497      if ( fd_index.count > CFF_MAX_CID_FONTS )
    14641498      {
    1465         FT_ERROR(( "cff_font_load: FD array too large in CID font\n" ));
     1499        FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
    14661500        goto Fail_CID;
    14671501      }
     
    14811515        sub = font->subfonts[idx];
    14821516        error = cff_subfont_load( sub, &fd_index, idx,
    1483                                   stream, base_offset );
     1517                                  stream, base_offset, library );
    14841518        if ( error )
    14851519          goto Fail_CID;
     
    15041538    if ( dict->charstrings_offset == 0 )
    15051539    {
    1506       FT_ERROR(( "cff_font_load: no charstrings offset!\n" ));
     1540      FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
    15071541      error = CFF_Err_Unknown_File_Format;
    15081542      goto Exit;
  • trunk/poppler/freetype2/src/cff/cffload.h

    r262 r275  
    5959
    6060  FT_LOCAL( FT_Error )
    61   cff_font_load( FT_Stream  stream,
     61  cff_font_load( FT_Library library,
     62                 FT_Stream  stream,
    6263                 FT_Int     face_index,
    6364                 CFF_Font   font,
  • trunk/poppler/freetype2/src/cff/cffobjs.c

    r262 r275  
    55/*    OpenType objects manager (body).                                     */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by      */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    3131#include "cffcmap.h"
    3232#include "cfferrs.h"
     33#include "cffpic.h"
    3334
    3435
     
    224225      CFF_Internal  internal = (CFF_Internal)size->internal;
    225226
    226       FT_Int   top_upm  = font->top_font.font_dict.units_per_em;
    227       FT_UInt  i;
     227      FT_ULong  top_upm  = font->top_font.font_dict.units_per_em;
     228      FT_UInt   i;
    228229
    229230
     
    235236      {
    236237        CFF_SubFont  sub     = font->subfonts[i - 1];
    237         FT_Int       sub_upm = sub->font_dict.units_per_em;
     238        FT_ULong     sub_upm = sub->font_dict.units_per_em;
    238239        FT_Pos       x_scale, y_scale;
    239240
     
    296297      CFF_Internal  internal = (CFF_Internal)size->internal;
    297298
    298       FT_Int   top_upm  = font->top_font.font_dict.units_per_em;
    299       FT_UInt  i;
     299      FT_ULong  top_upm  = font->top_font.font_dict.units_per_em;
     300      FT_UInt   i;
    300301
    301302
     
    307308      {
    308309        CFF_SubFont  sub     = font->subfonts[i - 1];
    309         FT_Int       sub_upm = sub->font_dict.units_per_em;
     310        FT_ULong     sub_upm = sub->font_dict.units_per_em;
    310311        FT_Pos       x_scale, y_scale;
    311312
     
    409410    FT_Bool             pure_cff    = 1;
    410411    FT_Bool             sfnt_format = 0;
     412    FT_Library library = cffface->driver->root.library;
    411413
    412414
     
    420422#else
    421423    sfnt = (SFNT_Service)FT_Get_Module_Interface(
    422              cffface->driver->root.library, "sfnt" );
     424             library, "sfnt" );
    423425    if ( !sfnt )
    424426      goto Bad_Format;
     
    427429
    428430    pshinter = (PSHinter_Service)FT_Get_Module_Interface(
    429                  cffface->driver->root.library, "pshinter" );
     431                 library, "pshinter" );
    430432#endif
    431433
     
    508510
    509511      face->extra.data = cff;
    510       error = cff_font_load( stream, face_index, cff, pure_cff );
     512      error = cff_font_load( library, stream, face_index, cff, pure_cff );
    511513      if ( error )
    512514        goto Exit;
     
    529531      if ( dict->cid_registry == 0xFFFFU && !psnames )
    530532      {
    531         FT_ERROR(( "cff_face_init:" ));
    532         FT_ERROR(( " cannot open CFF & CEF fonts\n" ));
    533         FT_ERROR(( "              " ));
    534         FT_ERROR(( " without the `PSNames' module\n" ));
     533        FT_ERROR(( "cff_face_init:"
     534                   " cannot open CFF & CEF fonts\n"
     535                   "              "
     536                  " without the `PSNames' module\n" ));
    535537        goto Bad_Format;
    536538      }
     
    583585        if ( sub->units_per_em )
    584586        {
    585           FT_Int  scaling;
     587          FT_Long  scaling;
    586588
    587589
     
    765767        /* Compute face flags.                                             */
    766768        /*                                                                 */
    767         flags = FT_FACE_FLAG_SCALABLE   |      /* scalable outlines */
    768                 FT_FACE_FLAG_HORIZONTAL |      /* horizontal data   */
    769                 FT_FACE_FLAG_HINTER;            /* has native hinter */
     769        flags = (FT_UInt32)( FT_FACE_FLAG_SCALABLE   | /* scalable outlines */
     770                             FT_FACE_FLAG_HORIZONTAL | /* horizontal data   */
     771                             FT_FACE_FLAG_HINTER );    /* has native hinter */
    770772
    771773        if ( sfnt_format )
    772           flags |= FT_FACE_FLAG_SFNT;
     774          flags |= (FT_UInt32)FT_FACE_FLAG_SFNT;
    773775
    774776        /* fixed width font? */
    775777        if ( dict->is_fixed_pitch )
    776           flags |= FT_FACE_FLAG_FIXED_WIDTH;
     778          flags |= (FT_UInt32)FT_FACE_FLAG_FIXED_WIDTH;
    777779
    778780  /* XXX: WE DO NOT SUPPORT KERNING METRICS IN THE GPOS TABLE FOR NOW */
     
    780782        /* kerning available? */
    781783        if ( face->kern_pairs )
    782           flags |= FT_FACE_FLAG_KERNING;
     784          flags |= (FT_UInt32)FT_FACE_FLAG_KERNING;
    783785#endif
    784786
     
    869871        nn = (FT_UInt)cffface->num_charmaps;
    870872
    871         FT_CMap_New( &cff_cmap_unicode_class_rec, NULL, &cmaprec, NULL );
     873        FT_CMap_New( &FT_CFF_CMAP_UNICODE_CLASS_REC_GET, NULL, &cmaprec, NULL );
    872874
    873875        /* if no Unicode charmap was previously selected, select this one */
     
    888890            cmaprec.encoding_id = TT_ADOBE_ID_STANDARD;
    889891            cmaprec.encoding    = FT_ENCODING_ADOBE_STANDARD;
    890             clazz               = &cff_cmap_encoding_class_rec;
     892            clazz               = &FT_CFF_CMAP_ENCODING_CLASS_REC_GET;
    891893          }
    892894          else if ( encoding->offset == 1 )
     
    894896            cmaprec.encoding_id = TT_ADOBE_ID_EXPERT;
    895897            cmaprec.encoding    = FT_ENCODING_ADOBE_EXPERT;
    896             clazz               = &cff_cmap_encoding_class_rec;
     898            clazz               = &FT_CFF_CMAP_ENCODING_CLASS_REC_GET;
    897899          }
    898900          else
     
    900902            cmaprec.encoding_id = TT_ADOBE_ID_CUSTOM;
    901903            cmaprec.encoding    = FT_ENCODING_ADOBE_CUSTOM;
    902             clazz               = &cff_cmap_encoding_class_rec;
     904            clazz               = &FT_CFF_CMAP_ENCODING_CLASS_REC_GET;
    903905          }
    904906
  • trunk/poppler/freetype2/src/cff/cffparse.c

    r269 r275  
    2323
    2424#include "cfferrs.h"
     25#include "cffpic.h"
    2526
    2627
     
    3536
    3637
    37   enum
    38   {
    39     cff_kind_none = 0,
    40     cff_kind_num,
    41     cff_kind_fixed,
    42     cff_kind_fixed_thousand,
    43     cff_kind_string,
    44     cff_kind_bool,
    45     cff_kind_delta,
    46     cff_kind_callback,
    47 
    48     cff_kind_max  /* do not remove */
    49   };
    50 
    51 
    52   /* now generate handlers for the most simple fields */
    53   typedef FT_Error  (*CFF_Field_Reader)( CFF_Parser  parser );
    54 
    55   typedef struct  CFF_Field_Handler_
    56   {
    57     int               kind;
    58     int               code;
    59     FT_UInt           offset;
    60     FT_Byte           size;
    61     CFF_Field_Reader  reader;
    62     FT_UInt           array_max;
    63     FT_UInt           count_offset;
    64 
    65   } CFF_Field_Handler;
    6638
    6739
     
    6941  cff_parser_init( CFF_Parser  parser,
    7042                   FT_UInt     code,
    71                    void*       object )
     43                   void*       object,
     44                   FT_Library  library)
    7245  {
    7346    FT_MEM_ZERO( parser, sizeof ( *parser ) );
     
    7649    parser->object_code = code;
    7750    parser->object      = object;
     51    parser->library     = library;
    7852  }
    7953
     
    157131  cff_parse_real( FT_Byte*  start,
    158132                  FT_Byte*  limit,
    159                   FT_Int    power_ten,
    160                   FT_Int*   scaling )
     133                  FT_Long   power_ten,
     134                  FT_Long*  scaling )
    161135  {
    162136    FT_Byte*  p = start;
     
    166140    FT_Long   result, number, rest, exponent;
    167141    FT_Int    sign = 0, exponent_sign = 0;
    168     FT_Int    exponent_add, integer_length, fraction_length;
     142    FT_Long   exponent_add, integer_length, fraction_length;
    169143
    170144
     
    181155    integer_length  = 0;
    182156    fraction_length = 0;
     157
     158    FT_UNUSED( rest );
    183159
    184160    /* First of all, read the integer part. */
     
    311287          if ( exponent > 0 )
    312288          {
    313             FT_Int  new_fraction_length, shift;
     289            FT_Long  new_fraction_length, shift;
    314290
    315291
     
    411387  static FT_Fixed
    412388  cff_parse_fixed_scaled( FT_Byte**  d,
    413                           FT_Int     scaling )
     389                          FT_Long    scaling )
    414390  {
    415391    return **d == 30 ? cff_parse_real( d[0], d[1], scaling, NULL )
     
    424400  static FT_Fixed
    425401  cff_parse_fixed_dynamic( FT_Byte**  d,
    426                            FT_Int*    scaling )
     402                           FT_Long*   scaling )
    427403  {
    428404    FT_ASSERT( scaling );
     
    477453    if ( parser->top >= parser->stack + 6 )
    478454    {
    479       FT_Int  scaling;
     455      FT_Long  scaling;
    480456
    481457
     
    579555      dict->cid_registry   = (FT_UInt)cff_parse_num ( data++ );
    580556      dict->cid_ordering   = (FT_UInt)cff_parse_num ( data++ );
    581       dict->cid_supplement = (FT_ULong)cff_parse_num( data );
     557      if ( **data == 30 )
     558        FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
     559      dict->cid_supplement = cff_parse_num( data );
     560      if ( dict->cid_supplement < 0 )
     561        FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n",
     562                   dict->cid_supplement ));
    582563      error = CFF_Err_Ok;
    583564    }
     
    600581          CFF_FIELD( code, name, cff_kind_delta )
    601582
     583#define CFFCODE_TOPDICT  0x1000
     584#define CFFCODE_PRIVATE  0x2000
     585
     586#ifndef FT_CONFIG_OPTION_PIC
     587
    602588#define CFF_FIELD_CALLBACK( code, name ) \
    603589          {                              \
     
    631617        },
    632618
    633 #define CFFCODE_TOPDICT  0x1000
    634 #define CFFCODE_PRIVATE  0x2000
    635 
    636619  static const CFF_Field_Handler  cff_field_handlers[] =
    637620  {
     
    641624    { 0, 0, 0, 0, 0, 0, 0 }
    642625  };
     626
     627
     628#else /* FT_CONFIG_OPTION_PIC */
     629
     630  void FT_Destroy_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler* clazz)
     631  {
     632    FT_Memory memory = library->memory;
     633    if ( clazz )
     634      FT_FREE( clazz );
     635  }
     636
     637  FT_Error FT_Create_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler** output_class)
     638  {
     639    CFF_Field_Handler*  clazz;
     640    FT_Error          error;
     641    FT_Memory memory = library->memory;
     642    int i=0;
     643
     644#undef CFF_FIELD
     645#undef CFF_FIELD_DELTA
     646#undef CFF_FIELD_CALLBACK
     647#define CFF_FIELD_CALLBACK( code, name ) i++;
     648#define CFF_FIELD( code, name, kind ) i++;
     649#define CFF_FIELD_DELTA( code, name, max ) i++;
     650
     651#include "cfftoken.h"
     652    i++;/*{ 0, 0, 0, 0, 0, 0, 0 }*/
     653
     654    if ( FT_ALLOC( clazz, sizeof(CFF_Field_Handler)*i ) )
     655      return error;
     656
     657    i=0;
     658#undef CFF_FIELD
     659#undef CFF_FIELD_DELTA
     660#undef CFF_FIELD_CALLBACK
     661
     662#define CFF_FIELD_CALLBACK( code_, name_ )                                   \
     663    clazz[i].kind = cff_kind_callback;                                       \
     664    clazz[i].code = code_ | CFFCODE;                                         \
     665    clazz[i].offset = 0;                                                     \
     666    clazz[i].size = 0;                                                       \
     667    clazz[i].reader = cff_parse_ ## name_;                                   \
     668    clazz[i].array_max = 0;                                                  \
     669    clazz[i].count_offset = 0;                                               \
     670    i++;
     671
     672#undef  CFF_FIELD
     673#define CFF_FIELD( code_, name_, kind_ )                                     \
     674    clazz[i].kind = kind_;                                                   \
     675    clazz[i].code = code_ | CFFCODE;                                         \
     676    clazz[i].offset = FT_FIELD_OFFSET( name_ );                              \
     677    clazz[i].size = FT_FIELD_SIZE( name_ );                                  \
     678    clazz[i].reader = 0;                                                     \
     679    clazz[i].array_max = 0;                                                  \
     680    clazz[i].count_offset = 0;                                               \
     681    i++;                                                                     \
     682
     683#undef  CFF_FIELD_DELTA
     684#define CFF_FIELD_DELTA( code_, name_, max_ )                                \
     685    clazz[i].kind = cff_kind_delta;                                          \
     686    clazz[i].code = code_ | CFFCODE;                                         \
     687    clazz[i].offset = FT_FIELD_OFFSET( name_ );                              \
     688    clazz[i].size = FT_FIELD_SIZE_DELTA( name_ );                            \
     689    clazz[i].reader = 0;                                                     \
     690    clazz[i].array_max = max_;                                               \
     691    clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ );                \
     692    i++;
     693
     694#include "cfftoken.h"
     695
     696    clazz[i].kind = 0;
     697    clazz[i].code = 0;
     698    clazz[i].offset = 0;
     699    clazz[i].size = 0;
     700    clazz[i].reader = 0;
     701    clazz[i].array_max = 0;
     702    clazz[i].count_offset = 0;
     703
     704    *output_class = clazz;
     705    return FT_Err_Ok;
     706  }
     707
     708