Changeset 274 for trunk


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

PDF plugin: freetype library updated to version 2.3.11

Location:
trunk/poppler/freetype2/include/freetype
Files:
1 added
32 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/include/freetype/config/ftoption.h

    r262 r274  
    55/*    User-selectable configuration macros (specification only).           */
    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/*                                                                         */
     
    397397
    398398
     399  /*************************************************************************/
     400  /*                                                                       */
     401  /* Position Independent Code                                             */
     402  /*                                                                       */
     403  /*   If this macro is set (which is _not_ the default), FreeType2 will   */
     404  /*   avoid creating constants that require address fixups. Instead the   */
     405  /*   constants will be moved into a struct and additional intialization  */
     406  /*   code will be used.                                                  */
     407  /*                                                                       */
     408  /*   Setting this macro is needed for systems that prohibit address      */
     409  /*   fixups, such as BREW.                                               */
     410  /*                                                                       */
     411/* #define FT_CONFIG_OPTION_PIC */
     412
    399413
    400414  /*************************************************************************/
     
    440454  /*                                                                       */
    441455  /* Accessing SFNT names is done through the functions declared in        */
    442   /* `freetype/ftnames.h'.                                                 */
     456  /* `freetype/ftsnames.h'.                                                */
    443457  /*                                                                       */
    444458#define TT_CONFIG_OPTION_SFNT_NAMES
     
    458472#define TT_CONFIG_CMAP_FORMAT_10
    459473#define TT_CONFIG_CMAP_FORMAT_12
     474#define TT_CONFIG_CMAP_FORMAT_13
    460475#define TT_CONFIG_CMAP_FORMAT_14
    461476
  • trunk/poppler/freetype2/include/freetype/config/ftstdlib.h

    r262 r274  
    6262#define FT_CHAR_BIT   CHAR_BIT
    6363#define FT_INT_MAX    INT_MAX
     64#define FT_INT_MIN    INT_MIN
    6465#define FT_UINT_MAX   UINT_MAX
    6566#define FT_ULONG_MAX  ULONG_MAX
  • trunk/poppler/freetype2/include/freetype/freetype.h

    r269 r274  
    520520  /*    Despite the name, this enumeration lists specific character        */
    521521  /*    repertories (i.e., charsets), and not text encoding methods (e.g., */
    522   /*    UTF-8, UTF-16, GB2312_EUC, etc.).                                  */
    523   /*                                                                       */
    524   /*    Because of 32-bit charcodes defined in Unicode (i.e., surrogates), */
    525   /*    all character codes must be expressed as FT_Longs.                 */
     522  /*    UTF-8, UTF-16, etc.).                                              */
    526523  /*                                                                       */
    527524  /*    Other encodings might be defined in the future.                    */
     
    536533  /*      Latin-1.  Most fonts include a Unicode charmap, but not all      */
    537534  /*      of them.                                                         */
     535  /*                                                                       */
     536  /*      For example, if you want to access Unicode value U+1F028 (and    */
     537  /*      the font contains it), use value 0x1F028 as the input value for  */
     538  /*      @FT_Get_Char_Index.                                              */
    538539  /*                                                                       */
    539540  /*    FT_ENCODING_MS_SYMBOL ::                                           */
     
    16511652  /* <Return>                                                              */
    16521653  /*    FreeType error code.  0~means success.                             */
     1654  /*                                                                       */
     1655  /* <Note>                                                                */
     1656  /*    In case you want to provide your own memory allocating routines,   */
     1657  /*    use @FT_New_Library instead, followed by a call to                 */
     1658  /*    @FT_Add_Default_Modules (or a series of calls to @FT_Add_Module).  */
    16531659  /*                                                                       */
    16541660  FT_EXPORT( FT_Error )
     
    37583764#define FREETYPE_MAJOR  2
    37593765#define FREETYPE_MINOR  3
    3760 #define FREETYPE_PATCH  9
     3766#define FREETYPE_PATCH  11
    37613767
    37623768
  • trunk/poppler/freetype2/include/freetype/ftimage.h

    r262 r274  
    66/*    (specification).                                                     */
    77/*                                                                         */
    8 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by      */
     8/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
    99/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1010/*                                                                         */
     
    319319  /*                                                                       */
    320320  /*    tags       :: A pointer to an array of `n_points' chars, giving    */
    321   /*                  each outline point's type.  If bit~0 is unset, the   */
    322   /*                  point is `off' the curve, i.e., a Bézier control     */
    323   /*                  point, while it is `on' when set.                    */
     321  /*                  each outline point's type.                           */
     322  /*                                                                       */
     323  /*                  If bit~0 is unset, the point is `off' the curve,     */
     324  /*                  i.e., a Bézier control point, while it is `on' if    */
     325  /*                  set.                                                 */
    324326  /*                                                                       */
    325327  /*                  Bit~1 is meaningful for `off' points only.  If set,  */
    326328  /*                  it indicates a third-order Bézier arc control point; */
    327329  /*                  and a second-order control point if unset.           */
     330  /*                                                                       */
     331  /*                  If bit~2 is set, bits 5-7 contain the drop-out mode  */
     332  /*                  (as defined in the OpenType specification; the value */
     333  /*                  is the same as the argument to the SCANMODE          */
     334  /*                  instruction).                                        */
     335  /*                                                                       */
     336  /*                  Bits 3 and~4 are reserved for internal purposes.     */
    328337  /*                                                                       */
    329338  /*    contours   :: An array of `n_contours' shorts, giving the end      */
     
    337346  /*                  how to convert/grid-fit it.  See @FT_OUTLINE_FLAGS.  */
    338347  /*                                                                       */
     348  /* <Note>                                                                */
     349  /*    The B/W rasterizer only checks bit~2 in the `tags' array for the   */
     350  /*    first point of each contour.  The drop-out mode as given with      */
     351  /*    @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and       */
     352  /*    @FT_OUTLINE_INCLUDE_STUBS in `flags' is then overridden.           */
     353  /*                                                                       */
    339354  typedef struct  FT_Outline_
    340355  {
     
    350365  } FT_Outline;
    351366
     367  /* Following limits must be consistent with */
     368  /* FT_Outline.{n_contours,n_points}         */
     369#define FT_OUTLINE_CONTOURS_MAX  SHRT_MAX
     370#define FT_OUTLINE_POINTS_MAX    SHRT_MAX
     371
    352372
    353373  /*************************************************************************/
     
    372392  /*      By default, outlines are filled using the non-zero winding rule. */
    373393  /*      If set to 1, the outline will be filled using the even-odd fill  */
    374   /*      rule (only works with the smooth raster).                        */
     394  /*      rule (only works with the smooth rasterizer).                    */
    375395  /*                                                                       */
    376396  /*    FT_OUTLINE_REVERSE_FILL ::                                         */
     
    385405  /*      an outline and correct the glyph bitmap to ensure consistent     */
    386406  /*      shape continuity.  If set, this flag hints the scan-line         */
    387   /*      converter to ignore such cases.                                  */
     407  /*      converter to ignore such cases.  See below for more information. */
    388408  /*                                                                       */
    389409  /*    FT_OUTLINE_SMART_DROPOUTS ::                                       */
    390410  /*      Select smart dropout control.  If unset, use simple dropout      */
    391   /*      control.  Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.         */
     411  /*      control.  Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.  See    */
     412  /*      below for more information.                                      */
    392413  /*                                                                       */
    393414  /*    FT_OUTLINE_INCLUDE_STUBS ::                                        */
    394415  /*      If set, turn pixels on for `stubs', otherwise exclude them.      */
    395   /*      Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.                   */
     416  /*      Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.  See below for    */
     417  /*      more information.                                                */
    396418  /*                                                                       */
    397419  /*    FT_OUTLINE_HIGH_PRECISION ::                                       */
     
    410432  /*                                                                       */
    411433  /* <Note>                                                                */
     434  /*    The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, */
     435  /*    and @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth            */
     436  /*    rasterizer.                                                        */
     437  /*                                                                       */
     438  /*    There exists a second mechanism to pass the drop-out mode to the   */
     439  /*    B/W rasterizer; see the `tags' field in @FT_Outline.               */
     440  /*                                                                       */
    412441  /*    Please refer to the description of the `SCANTYPE' instruction in   */
    413442  /*    the OpenType specification (in file `ttinst1.doc') how simple      */
     
    456485#define FT_CURVE_TAG( flag )  ( flag & 3 )
    457486
    458 #define FT_CURVE_TAG_ON           1
    459 #define FT_CURVE_TAG_CONIC        0
    460 #define FT_CURVE_TAG_CUBIC        2
    461 
    462 #define FT_CURVE_TAG_TOUCH_X      8  /* reserved for the TrueType hinter */
    463 #define FT_CURVE_TAG_TOUCH_Y     16  /* reserved for the TrueType hinter */
    464 
    465 #define FT_CURVE_TAG_TOUCH_BOTH  ( FT_CURVE_TAG_TOUCH_X | \
    466                                    FT_CURVE_TAG_TOUCH_Y )
     487#define FT_CURVE_TAG_ON            1
     488#define FT_CURVE_TAG_CONIC         0
     489#define FT_CURVE_TAG_CUBIC         2
     490
     491#define FT_CURVE_TAG_HAS_SCANMODE  4
     492
     493#define FT_CURVE_TAG_TOUCH_X       8  /* reserved for the TrueType hinter */
     494#define FT_CURVE_TAG_TOUCH_Y      16  /* reserved for the TrueType hinter */
     495
     496#define FT_CURVE_TAG_TOUCH_BOTH    ( FT_CURVE_TAG_TOUCH_X | \
     497                                     FT_CURVE_TAG_TOUCH_Y )
    467498
    468499#define FT_Curve_Tag_On       FT_CURVE_TAG_ON
     
    10121043  /*    gray_spans  :: The gray span drawing callback.                     */
    10131044  /*                                                                       */
    1014   /*    black_spans :: The black span drawing callback.                    */
     1045  /*    black_spans :: The black span drawing callback.  UNIMPLEMENTED!    */
    10151046  /*                                                                       */
    10161047  /*    bit_test    :: The bit test callback.  UNIMPLEMENTED!              */
     
    10491080    int                     flags;
    10501081    FT_SpanFunc             gray_spans;
    1051     FT_SpanFunc             black_spans;
     1082    FT_SpanFunc             black_spans;  /* doesn't work! */
    10521083    FT_Raster_BitTest_Func  bit_test;     /* doesn't work! */
    10531084    FT_Raster_BitSet_Func   bit_set;      /* doesn't work! */
  • trunk/poppler/freetype2/include/freetype/ftmodapi.h

    r262 r274  
    55/*    FreeType modules public interface (specification).                   */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2006, 2008 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2006, 2008, 2009 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    260260  /*    with distinct memory allocators within the same program.           */
    261261  /*                                                                       */
     262  /*    Normally, you would call this function (followed by a call to      */
     263  /*    @FT_Add_Default_Modules or a series of calls to @FT_Add_Module)    */
     264  /*    instead of @FT_Init_FreeType to initialize the FreeType library.   */
     265  /*                                                                       */
    262266  /* <Input>                                                               */
    263267  /*    memory   :: A handle to the original memory object.                */
  • trunk/poppler/freetype2/include/freetype/ftsnames.h

    r251 r274  
    88/*    This is _not_ used to retrieve glyph names!                          */
    99/*                                                                         */
    10 /*  Copyright 1996-2001, 2002, 2003, 2006 by                               */
     10/*  Copyright 1996-2001, 2002, 2003, 2006, 2009 by                         */
    1111/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1212/*                                                                         */
     
    148148  /* <Note>                                                                */
    149149  /*    The `string' array returned in the `aname' structure is not        */
    150   /*    null-terminated.                                                   */
     150  /*    null-terminated.  The application should deallocate it if it is no */
     151  /*    longer in use.                                                     */
    151152  /*                                                                       */
    152153  /*    Use @FT_Get_Sfnt_Name_Count to get the total number of available   */
  • trunk/poppler/freetype2/include/freetype/ftstroke.h

    r269 r274  
    599599   * @description:
    600600   *   Call this function after @FT_Stroker_GetBorderCounts to
    601    *   export the all borders to your own @FT_Outline structure.
     601   *   export all borders to your own @FT_Outline structure.
    602602   *
    603603   *   Note that this function appends the border points and
  • trunk/poppler/freetype2/include/freetype/fttypes.h

    r251 r274  
    168168  /*                                                                       */
    169169  /* <Description>                                                         */
    170   /*    A typedef for 32-bit tags (as used in the SFNT format).             */
     170  /*    A typedef for 32-bit tags (as used in the SFNT format).            */
    171171  /*                                                                       */
    172172  typedef FT_UInt32  FT_Tag;
     
    475475  /*                                                                       */
    476476#define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
     477          (FT_Tag)                        \
    477478          ( ( (FT_ULong)_x1 << 24 ) |     \
    478479            ( (FT_ULong)_x2 << 16 ) |     \
  • trunk/poppler/freetype2/include/freetype/ftxf86.h

    r251 r274  
    5050  /*   important to differentiate, in spite of FreeType's uniform API.     */
    5151  /*                                                                       */
     52  /*   This function is in the X11/xf86 namespace for historical reasons   */
     53  /*   and in no way depends on that windowing system.                     */
     54  /*                                                                       */
    5255  /*************************************************************************/
    5356
  • trunk/poppler/freetype2/include/freetype/internal/autohint.h

    r200 r274  
    197197  } FT_AutoHinter_ServiceRec, *FT_AutoHinter_Service;
    198198
     199#ifndef FT_CONFIG_OPTION_PIC
     200
     201#define FT_DEFINE_AUTOHINTER_SERVICE(class_, reset_face_, get_global_hints_, \
     202                                     done_global_hints_, load_glyph_)        \
     203  FT_CALLBACK_TABLE_DEF                                                      \
     204  const FT_AutoHinter_ServiceRec class_ =                                    \
     205  {                                                                          \
     206    reset_face_, get_global_hints_, done_global_hints_, load_glyph_          \
     207  };
     208
     209#else /* FT_CONFIG_OPTION_PIC */
     210
     211#define FT_DEFINE_AUTOHINTER_SERVICE(class_, reset_face_, get_global_hints_, \
     212                                     done_global_hints_, load_glyph_)        \
     213  void                                                                       \
     214  FT_Init_Class_##class_( FT_Library library,                                \
     215                          FT_AutoHinter_ServiceRec* clazz)                   \
     216  {                                                                          \
     217    FT_UNUSED(library);                                                      \
     218    clazz->reset_face = reset_face_;                                         \
     219    clazz->get_global_hints = get_global_hints_;                             \
     220    clazz->done_global_hints = done_global_hints_;                           \
     221    clazz->load_glyph = load_glyph_;                                         \
     222  }
     223
     224#endif /* FT_CONFIG_OPTION_PIC */
    199225
    200226FT_END_HEADER
  • trunk/poppler/freetype2/include/freetype/internal/ftcalc.h

    r251 r274  
    55/*    Arithmetic computations (specification).                             */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    166166#define F2DOT14_TO_FIXED( x )  ( (FT_Long)(x) << 2  )
    167167#define FLOAT_TO_FIXED( x )    ( (FT_Long)( x * 65536.0 ) )
     168#define FIXED_TO_INT( x )      ( FT_RoundFix( x ) >> 16 )
    168169
    169170#define ROUND_F26DOT6( x )     ( x >= 0 ? (    ( (x) + 32 ) & -64 )     \
  • trunk/poppler/freetype2/include/freetype/internal/ftdriver.h

    r262 r274  
    241241#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
    242242
     243  /*************************************************************************/
     244  /*                                                                       */
     245  /* <Macro>                                                               */
     246  /*    FT_DECLARE_DRIVER                                                  */
     247  /*                                                                       */
     248  /* <Description>                                                         */
     249  /*    Used to create a forward declaration of a                          */
     250  /*    FT_Driver_ClassRec stract instance.                                */
     251  /*                                                                       */
     252  /* <Macro>                                                               */
     253  /*    FT_DEFINE_DRIVER                                                   */
     254  /*                                                                       */
     255  /* <Description>                                                         */
     256  /*    Used to initialize an instance of FT_Driver_ClassRec struct.       */
     257  /*                                                                       */
     258  /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
     259  /*    to called with a pointer where the allocated stracture is returned.*/
     260  /*    And when it is no longer needed a Destroy function needs           */
     261  /*    to be called to release that allocation.                           */
     262  /*    fcinit.c (ft_create_default_module_classes) already contains       */
     263  /*    a mechanism to call these functions for the default modules        */
     264  /*    described in ftmodule.h                                            */
     265  /*                                                                       */
     266  /*    Notice that the created Create and Destroy functions call          */
     267  /*    pic_init and pic_free function to allow you to manually allocate   */
     268  /*    and initialize any additional global data, like module specific    */
     269  /*    interface, and put them in the global pic container defined in     */
     270  /*    ftpic.h. if you don't need them just implement the functions as    */
     271  /*    empty to resolve the link error.                                   */
     272  /*                                                                       */
     273  /*    When FT_CONFIG_OPTION_PIC is not defined the struct will be        */
     274  /*    allocated in the global scope (or the scope where the macro        */
     275  /*    is used).                                                          */
     276  /*                                                                       */
     277#ifndef FT_CONFIG_OPTION_PIC
     278
     279#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
     280#define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_) \
     281  a_, b_,
     282#else
     283  #define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_)
     284#endif
     285
     286#define FT_DECLARE_DRIVER(class_)    \
     287  FT_CALLBACK_TABLE                  \
     288  const FT_Driver_ClassRec  class_; 
     289
     290#define FT_DEFINE_DRIVER(class_,                                             \
     291                         flags_, size_, name_, version_, requires_,          \
     292                         interface_, init_, done_, get_interface_,           \
     293                         face_object_size_, size_object_size_,               \
     294                         slot_object_size_, init_face_, done_face_,          \
     295                         init_size_, done_size_, init_slot_, done_slot_,     \
     296                         old_set_char_sizes_, old_set_pixel_sizes_,          \
     297                         load_glyph_, get_kerning_, attach_file_,            \
     298                         get_advances_, request_size_, select_size_ )        \
     299  FT_CALLBACK_TABLE_DEF                                                      \
     300  const FT_Driver_ClassRec class_ =                                          \
     301  {                                                                          \
     302    FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_,interface_,  \
     303                          init_,done_,get_interface_)                        \
     304                                                                             \
     305    face_object_size_,                                                       \
     306    size_object_size_,                                                       \
     307    slot_object_size_,                                                       \
     308                                                                             \
     309    init_face_,                                                              \
     310    done_face_,                                                              \
     311                                                                             \
     312    init_size_,                                                              \
     313    done_size_,                                                              \
     314                                                                             \
     315    init_slot_,                                                              \
     316    done_slot_,                                                              \
     317                                                                             \
     318    FT_DEFINE_DRIVERS_OLD_INTERNALS(old_set_char_sizes_, old_set_pixel_sizes_) \
     319                                                                             \
     320    load_glyph_,                                                             \
     321                                                                             \
     322    get_kerning_,                                                            \
     323    attach_file_,                                                            \
     324    get_advances_,                                                           \
     325                                                                             \
     326    request_size_,                                                           \
     327    select_size_                                                             \
     328  };
     329
     330#else /* FT_CONFIG_OPTION_PIC */
     331
     332#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
     333#define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_) \
     334  clazz->set_char_sizes = a_; \
     335  clazz->set_pixel_sizes = b_;
     336#else
     337  #define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_)
     338#endif
     339
     340#define FT_DECLARE_DRIVER(class_)    FT_DECLARE_MODULE(class_)
     341
     342#define FT_DEFINE_DRIVER(class_,                                             \
     343                         flags_, size_, name_, version_, requires_,          \
     344                         interface_, init_, done_, get_interface_,           \
     345                         face_object_size_, size_object_size_,               \
     346                         slot_object_size_, init_face_, done_face_,          \
     347                         init_size_, done_size_, init_slot_, done_slot_,     \
     348                         old_set_char_sizes_, old_set_pixel_sizes_,          \
     349                         load_glyph_, get_kerning_, attach_file_,            \
     350                         get_advances_, request_size_, select_size_ )        \
     351  void class_##_pic_free( FT_Library library );                              \
     352  FT_Error class_##_pic_init( FT_Library library );                          \
     353                                                                             \
     354  void                                                                       \
     355  FT_Destroy_Class_##class_( FT_Library        library,                      \
     356                             FT_Module_Class*  clazz )                       \
     357  {                                                                          \
     358    FT_Memory       memory = library->memory;                                \
     359    FT_Driver_Class dclazz = (FT_Driver_Class)clazz;                         \
     360    class_##_pic_free( library );                                            \
     361    if ( dclazz )                                                            \
     362      FT_FREE( dclazz );                                                     \
     363  }                                                                          \
     364                                                                             \
     365  FT_Error                                                                   \
     366  FT_Create_Class_##class_( FT_Library        library,                       \
     367                            FT_Module_Class**  output_class )                \
     368  {                                                                          \
     369    FT_Driver_Class  clazz;                                                  \
     370    FT_Error         error;                                                  \
     371    FT_Memory        memory = library->memory;                               \
     372                                                                             \
     373    if ( FT_ALLOC( clazz, sizeof(*clazz) ) )                                 \
     374      return error;                                                          \
     375                                                                             \
     376    error = class_##_pic_init( library );                                    \
     377    if(error)                                                                \
     378    {                                                                        \
     379      FT_FREE( clazz );                                                      \
     380      return error;                                                          \
     381    }                                                                        \
     382                                                                             \
     383    FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_,interface_,  \
     384                          init_,done_,get_interface_)                        \
     385                                                                             \
     386    clazz->face_object_size    = face_object_size_;                          \
     387    clazz->size_object_size    = size_object_size_;                          \
     388    clazz->slot_object_size    = slot_object_size_;                          \
     389                                                                             \
     390    clazz->init_face           = init_face_;                                 \
     391    clazz->done_face           = done_face_;                                 \
     392                                                                             \
     393    clazz->init_size           = init_size_;                                 \
     394    clazz->done_size           = done_size_;                                 \
     395                                                                             \
     396    clazz->init_slot           = init_slot_;                                 \
     397    clazz->done_slot           = done_slot_;                                 \
     398                                                                             \
     399    FT_DEFINE_DRIVERS_OLD_INTERNALS(old_set_char_sizes_, old_set_pixel_sizes_) \
     400                                                                             \
     401    clazz->load_glyph          = load_glyph_;                                \
     402                                                                             \
     403    clazz->get_kerning         = get_kerning_;                               \
     404    clazz->attach_file         = attach_file_;                               \
     405    clazz->get_advances        = get_advances_;                              \
     406                                                                             \
     407    clazz->request_size        = request_size_;                              \
     408    clazz->select_size         = select_size_;                               \
     409                                                                             \
     410    *output_class = (FT_Module_Class*)clazz;                                 \
     411    return FT_Err_Ok;                                                        \
     412  }               
     413
     414
     415#endif /* FT_CONFIG_OPTION_PIC */
    243416
    244417FT_END_HEADER
  • trunk/poppler/freetype2/include/freetype/internal/ftgloadr.h

    r251 r274  
    122122
    123123
    124 #define FT_GLYPHLOADER_CHECK_P( _loader, _count )                    \
    125    ( (_count) == 0 || (int)((_loader)->base.outline.n_points    +    \
    126                             (_loader)->current.outline.n_points +    \
    127                             (_count)) <= (int)(_loader)->max_points )
     124#define FT_GLYPHLOADER_CHECK_P( _loader, _count )                         \
     125   ( (_count) == 0 || ((_loader)->base.outline.n_points    +              \
     126                       (_loader)->current.outline.n_points +              \
     127                       (unsigned long)(_count)) <= (_loader)->max_points )
    128128
    129 #define FT_GLYPHLOADER_CHECK_C( _loader, _count )                     \
    130   ( (_count) == 0 || (int)((_loader)->base.outline.n_contours    +    \
    131                            (_loader)->current.outline.n_contours +    \
    132                            (_count)) <= (int)(_loader)->max_contours )
     129#define FT_GLYPHLOADER_CHECK_C( _loader, _count )                          \
     130  ( (_count) == 0 || ((_loader)->base.outline.n_contours    +              \
     131                      (_loader)->current.outline.n_contours +              \
     132                      (unsigned long)(_count)) <= (_loader)->max_contours )
    133133
    134134#define FT_GLYPHLOADER_CHECK_POINTS( _loader, _points,_contours )      \
  • trunk/poppler/freetype2/include/freetype/internal/ftobjs.h

    r251 r274  
    3636#include FT_INTERNAL_AUTOHINT_H
    3737#include FT_INTERNAL_SERVICE_H
     38#include FT_INTERNAL_PIC_H
    3839
    3940#ifdef FT_CONFIG_OPTION_INCREMENTAL
     
    206207  } FT_CMap_ClassRec;
    207208
     209#ifndef FT_CONFIG_OPTION_PIC
     210
     211#define FT_DECLARE_CMAP_CLASS(class_) \
     212    FT_CALLBACK_TABLE const FT_CMap_ClassRec class_;
     213
     214#define FT_DEFINE_CMAP_CLASS(class_, size_, init_, done_, char_index_,       \
     215        char_next_, char_var_index_, char_var_default_, variant_list_,       \
     216        charvariant_list_, variantchar_list_)                                \
     217  FT_CALLBACK_TABLE_DEF                                                      \
     218  const FT_CMap_ClassRec class_ =                                            \
     219  {                                                                          \
     220    size_, init_, done_, char_index_, char_next_, char_var_index_,           \
     221    char_var_default_, variant_list_, charvariant_list_, variantchar_list_   \
     222  };
     223#else /* FT_CONFIG_OPTION_PIC */
     224
     225#define FT_DECLARE_CMAP_CLASS(class_) \
     226    void FT_Init_Class_##class_( FT_Library library, FT_CMap_ClassRec*  clazz);
     227
     228#define FT_DEFINE_CMAP_CLASS(class_, size_, init_, done_, char_index_,       \
     229        char_next_, char_var_index_, char_var_default_, variant_list_,       \
     230        charvariant_list_, variantchar_list_)                                \
     231  void                                                                       \
     232  FT_Init_Class_##class_( FT_Library library,                                \
     233                          FT_CMap_ClassRec*  clazz)                          \
     234  {                                                                          \
     235    FT_UNUSED(library);                                                      \
     236    clazz->size = size_;                                                     \
     237    clazz->init = init_;                                                     \
     238    clazz->done = done_;                                                     \
     239    clazz->char_index = char_index_;                                         \
     240    clazz->char_next = char_next_;                                           \
     241    clazz->char_var_index = char_var_index_;                                 \
     242    clazz->char_var_default = char_var_default_;                             \
     243    clazz->variant_list = variant_list_;                                     \
     244    clazz->charvariant_list = charvariant_list_;                             \
     245    clazz->variantchar_list = variantchar_list_;                             \
     246  }
     247#endif /* FT_CONFIG_OPTION_PIC */
    208248
    209249  /* create a new charmap and add it to charmap->face */
     
    766806  /*    debug_hooks      :: XXX                                            */
    767807  /*                                                                       */
     808  /*    pic_container    :: Contains global structs and tables, instead    */
     809  /*                        of defining them globallly.                    */
     810  /*                                                                       */
     811
    768812  typedef struct  FT_LibraryRec_
    769813  {
     
    796840#endif
    797841
     842#ifdef FT_CONFIG_OPTION_PIC
     843    FT_PIC_Container   pic_container;
     844#endif
     845
    798846  } FT_LibraryRec;
    799847
     
    867915#endif
    868916
     917  /*************************************************************************/
     918  /*************************************************************************/
     919  /*************************************************************************/
     920  /****                                                                 ****/
     921  /****                                                                 ****/
     922  /****              PIC-Support Macros for ftimage.h                   ****/
     923  /****                                                                 ****/
     924  /****                                                                 ****/
     925  /*************************************************************************/
     926  /*************************************************************************/
     927  /*************************************************************************/
     928
     929
     930  /*************************************************************************/
     931  /*                                                                       */
     932  /* <Macro>                                                               */
     933  /*    FT_DEFINE_OUTLINE_FUNCS                                            */
     934  /*                                                                       */
     935  /* <Description>                                                         */
     936  /*    Used to initialize an instance of FT_Outline_Funcs struct.         */
     937  /*    When FT_CONFIG_OPTION_PIC is defined an init funtion will need to  */
     938  /*    called with a pre-allocated stracture to be filled.                */
     939  /*    When FT_CONFIG_OPTION_PIC is not defined the struct will be        */
     940  /*    allocated in the global scope (or the scope where the macro        */
     941  /*    is used).                                                          */
     942  /*                                                                       */
     943#ifndef FT_CONFIG_OPTION_PIC
     944
     945#define FT_DEFINE_OUTLINE_FUNCS(class_, move_to_, line_to_, conic_to_,       \
     946                                cubic_to_, shift_, delta_)                   \
     947  static const FT_Outline_Funcs class_ =                                     \
     948  {                                                                          \
     949    move_to_, line_to_, conic_to_, cubic_to_, shift_, delta_                 \
     950  };
     951
     952#else /* FT_CONFIG_OPTION_PIC */
     953
     954#define FT_DEFINE_OUTLINE_FUNCS(class_, move_to_, line_to_, conic_to_,       \
     955                                cubic_to_, shift_, delta_)                   \
     956  static FT_Error                                                            \
     957  Init_Class_##class_( FT_Outline_Funcs*  clazz )                            \
     958  {                                                                          \
     959    clazz->move_to = move_to_;                                               \
     960    clazz->line_to = line_to_;                                               \
     961    clazz->conic_to = conic_to_;                                             \
     962    clazz->cubic_to = cubic_to_;                                             \
     963    clazz->shift = shift_;                                                   \
     964    clazz->delta = delta_;                                                   \
     965    return FT_Err_Ok;                                                        \
     966  }
     967
     968#endif /* FT_CONFIG_OPTION_PIC */
     969
     970  /*************************************************************************/
     971  /*                                                                       */
     972  /* <Macro>                                                               */
     973  /*    FT_DEFINE_RASTER_FUNCS                                             */
     974  /*                                                                       */
     975  /* <Description>                                                         */
     976  /*    Used to initialize an instance of FT_Raster_Funcs struct.          */
     977  /*    When FT_CONFIG_OPTION_PIC is defined an init funtion will need to  */
     978  /*    called with a pre-allocated stracture to be filled.                */
     979  /*    When FT_CONFIG_OPTION_PIC is not defined the struct will be        */
     980  /*    allocated in the global scope (or the scope where the macro        */
     981  /*    is used).                                                          */
     982  /*                                                                       */
     983#ifndef FT_CONFIG_OPTION_PIC
     984
     985#define FT_DEFINE_RASTER_FUNCS(class_, glyph_format_, raster_new_,           \
     986                               raster_reset_, raster_set_mode_,              \
     987                               raster_render_, raster_done_)                 \
     988  const FT_Raster_Funcs class_ =                                      \
     989  {                                                                          \
     990    glyph_format_, raster_new_, raster_reset_,                               \
     991    raster_set_mode_, raster_render_, raster_done_                           \
     992  };
     993
     994#else /* FT_CONFIG_OPTION_PIC */
     995
     996#define FT_DEFINE_RASTER_FUNCS(class_, glyph_format_, raster_new_,           \
     997    raster_reset_, raster_set_mode_, raster_render_, raster_done_)           \
     998  void                                                                       \
     999  FT_Init_Class_##class_( FT_Raster_Funcs*  clazz )                          \
     1000  {                                                                          \
     1001    clazz->glyph_format = glyph_format_;                                     \
     1002    clazz->raster_new = raster_new_;                                         \
     1003    clazz->raster_reset = raster_reset_;                                     \
     1004    clazz->raster_set_mode = raster_set_mode_;                               \
     1005    clazz->raster_render = raster_render_;                                   \
     1006    clazz->raster_done = raster_done_;                                       \
     1007  }
     1008
     1009#endif /* FT_CONFIG_OPTION_PIC */
     1010
     1011  /*************************************************************************/
     1012  /*************************************************************************/
     1013  /*************************************************************************/
     1014  /****                                                                 ****/
     1015  /****                                                                 ****/
     1016  /****              PIC-Support Macros for ftrender.h                  ****/
     1017  /****                                                                 ****/
     1018  /****                                                                 ****/
     1019  /*************************************************************************/
     1020  /*************************************************************************/
     1021  /*************************************************************************/
     1022
     1023
     1024
     1025  /*************************************************************************/
     1026  /*                                                                       */
     1027  /* <Macro>                                                               */
     1028  /*    FT_DEFINE_GLYPH                                                    */
     1029  /*                                                                       */
     1030  /* <Description>                                                         */
     1031  /*    Used to initialize an instance of FT_Glyph_Class struct.           */
     1032  /*    When FT_CONFIG_OPTION_PIC is defined an init funtion will need to  */
     1033  /*    called with a pre-allocated stracture to be filled.                */
     1034  /*    When FT_CONFIG_OPTION_PIC is not defined the struct will be        */
     1035  /*    allocated in the global scope (or the scope where the macro        */
     1036  /*    is used).                                                          */
     1037  /*                                                                       */
     1038#ifndef FT_CONFIG_OPTION_PIC
     1039
     1040#define FT_DEFINE_GLYPH(class_, size_, format_, init_, done_, copy_,         \
     1041                        transform_, bbox_, prepare_)                         \
     1042  FT_CALLBACK_TABLE_DEF                                                      \
     1043  const FT_Glyph_Class class_ =                                              \
     1044  {                                                                          \
     1045    size_, format_, init_, done_, copy_, transform_, bbox_, prepare_         \
     1046  };
     1047
     1048#else /* FT_CONFIG_OPTION_PIC */
     1049
     1050#define FT_DEFINE_GLYPH(class_, size_, format_, init_, done_, copy_,         \
     1051                        transform_, bbox_, prepare_)                         \
     1052  void                                                                       \
     1053  FT_Init_Class_##class_( FT_Glyph_Class*  clazz )                           \
     1054  {                                                                          \
     1055    clazz->glyph_size = size_;                                               \
     1056    clazz->glyph_format = format_;                                           \
     1057    clazz->glyph_init = init_;                                               \
     1058    clazz->glyph_done = done_;                                               \
     1059    clazz->glyph_copy = copy_;                                               \
     1060    clazz->glyph_transform = transform_;                                     \
     1061    clazz->glyph_bbox = bbox_;                                               \
     1062    clazz->glyph_prepare = prepare_;                                         \
     1063  }
     1064
     1065#endif /* FT_CONFIG_OPTION_PIC */
     1066
     1067  /*************************************************************************/
     1068  /*                                                                       */
     1069  /* <Macro>                                                               */
     1070  /*    FT_DECLARE_RENDERER                                                */
     1071  /*                                                                       */
     1072  /* <Description>                                                         */
     1073  /*    Used to create a forward declaration of a                          */
     1074  /*    FT_Renderer_Class stract instance.                                 */
     1075  /*                                                                       */
     1076  /* <Macro>                                                               */
     1077  /*    FT_DEFINE_RENDERER                                                 */
     1078  /*                                                                       */
     1079  /* <Description>                                                         */
     1080  /*    Used to initialize an instance of FT_Renderer_Class struct.        */
     1081  /*                                                                       */
     1082  /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
     1083  /*    to called with a pointer where the allocated stracture is returned.*/
     1084  /*    And when it is no longer needed a Destroy function needs           */
     1085  /*    to be called to release that allocation.                           */
     1086  /*    fcinit.c (ft_create_default_module_classes) already contains       */
     1087  /*    a mechanism to call these functions for the default modules        */
     1088  /*    described in ftmodule.h                                            */
     1089  /*                                                                       */
     1090  /*    Notice that the created Create and Destroy functions call          */
     1091  /*    pic_init and pic_free function to allow you to manually allocate   */
     1092  /*    and initialize any additional global data, like module specific    */
     1093  /*    interface, and put them in the global pic container defined in     */
     1094  /*    ftpic.h. if you don't need them just implement the functions as    */
     1095  /*    empty to resolve the link error.                                   */
     1096  /*                                                                       */
     1097  /*    When FT_CONFIG_OPTION_PIC is not defined the struct will be        */
     1098  /*    allocated in the global scope (or the scope where the macro        */
     1099  /*    is used).                                                          */
     1100  /*                                                                       */
     1101#ifndef FT_CONFIG_OPTION_PIC
     1102
     1103#define FT_DECLARE_RENDERER(class_)                                          \
     1104    FT_EXPORT_VAR( const FT_Renderer_Class ) class_;
     1105
     1106#define FT_DEFINE_RENDERER(class_,                                           \
     1107                           flags_, size_, name_, version_, requires_,        \
     1108                           interface_, init_, done_, get_interface_,         \
     1109                           glyph_format_, render_glyph_, transform_glyph_,   \
     1110                           get_glyph_cbox_, set_mode_, raster_class_ )       \
     1111  FT_CALLBACK_TABLE_DEF                                                      \
     1112  const FT_Renderer_Class  class_ =                                          \
     1113  {                                                                          \
     1114    FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_,             \
     1115                          interface_,init_,done_,get_interface_)             \
     1116    glyph_format_,                                                           \
     1117                                                                             \
     1118    render_glyph_,                                                           \
     1119    transform_glyph_,                                                        \
     1120    get_glyph_cbox_,                                                         \
     1121    set_mode_,                                                               \
     1122                                                                             \
     1123    raster_class_                                                            \
     1124  };
     1125
     1126#else /* FT_CONFIG_OPTION_PIC */
     1127
     1128#define FT_DECLARE_RENDERER(class_)  FT_DECLARE_MODULE(class_)
     1129
     1130#define FT_DEFINE_RENDERER(class_, \
     1131                           flags_, size_, name_, version_, requires_,        \
     1132                           interface_, init_, done_, get_interface_,         \
     1133                           glyph_format_, render_glyph_, transform_glyph_,   \
     1134                           get_glyph_cbox_, set_mode_, raster_class_ )       \
     1135  void class_##_pic_free( FT_Library library );                              \
     1136  FT_Error class_##_pic_init( FT_Library library );                          \
     1137                                                                             \
     1138  void                                                                       \
     1139  FT_Destroy_Class_##class_( FT_Library        library,                      \
     1140                        FT_Module_Class*  clazz )                            \
     1141  {                                                                          \
     1142    FT_Renderer_Class* rclazz = (FT_Renderer_Class*)clazz;                   \
     1143    FT_Memory         memory = library->memory;                              \
     1144    class_##_pic_free( library );                                            \
     1145    if ( rclazz )                                                            \
     1146      FT_FREE( rclazz );                                                     \
     1147  }                                                                          \
     1148                                                                             \
     1149  FT_Error                                                                   \
     1150  FT_Create_Class_##class_( FT_Library         library,                      \
     1151                            FT_Module_Class**  output_class )                \
     1152  {                                                                          \
     1153    FT_Renderer_Class*  clazz;                                               \
     1154    FT_Error            error;                                               \
     1155    FT_Memory           memory = library->memory;                            \
     1156                                                                             \
     1157    if ( FT_ALLOC( clazz, sizeof(*clazz) ) )                                 \
     1158      return error;                                                          \
     1159                                                                             \
     1160    error = class_##_pic_init( library );                                    \
     1161    if(error)                                                                \
     1162    {                                                                        \
     1163      FT_FREE( clazz );                                                      \
     1164      return error;                                                          \
     1165    }                                                                        \
     1166                                                                             \
     1167    FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_,             \
     1168                          interface_,init_,done_,get_interface_)             \
     1169                                                                             \
     1170    clazz->glyph_format       = glyph_format_;                               \
     1171                                                                             \
     1172    clazz->render_glyph       = render_glyph_;                               \
     1173    clazz->transform_glyph    = transform_glyph_;                            \
     1174    clazz->get_glyph_cbox     = get_glyph_cbox_;                             \
     1175    clazz->set_mode           = set_mode_;                                   \
     1176                                                                             \
     1177    clazz->raster_class       = raster_class_;                               \
     1178                                                                             \
     1179    *output_class = (FT_Module_Class*)clazz;                                 \
     1180    return FT_Err_Ok;                                                        \
     1181  }
     1182
     1183
     1184
     1185#endif /* FT_CONFIG_OPTION_PIC */
     1186
     1187  /*************************************************************************/
     1188  /*************************************************************************/
     1189  /*************************************************************************/
     1190  /****                                                                 ****/
     1191  /****                                                                 ****/
     1192  /****              PIC-Support Macros for ftmodapi.h                  ****/
     1193  /****                                                                 ****/
     1194  /****                                                                 ****/
     1195  /*************************************************************************/
     1196  /*************************************************************************/
     1197  /*************************************************************************/
     1198
     1199
     1200#ifdef FT_CONFIG_OPTION_PIC
     1201
     1202  /*************************************************************************/
     1203  /*                                                                       */
     1204  /* <FuncType>                                                            */
     1205  /*    FT_Module_Creator                                                  */
     1206  /*                                                                       */
     1207  /* <Description>                                                         */
     1208  /*    A function used to create (allocate) a new module class object.    */
     1209  /*    The object's members are initialized, but the module itself is     */
     1210  /*    not.                                                               */
     1211  /*                                                                       */
     1212  /* <Input>                                                               */
     1213  /*    memory       :: A handle to the memory manager.                    */
     1214  /*    output_class :: Initialized with the newly allocated class.        */
     1215  /*                                                                       */
     1216  typedef FT_Error
     1217  (*FT_Module_Creator)( FT_Memory          memory,
     1218                        FT_Module_Class**  output_class );
     1219
     1220  /*************************************************************************/
     1221  /*                                                                       */
     1222  /* <FuncType>                                                            */
     1223  /*    FT_Module_Destroyer                                                */
     1224  /*                                                                       */
     1225  /* <Description>                                                         */
     1226  /*    A function used to destroy (deallocate) a module class object.     */
     1227  /*                                                                       */
     1228  /* <Input>                                                               */
     1229  /*    memory :: A handle to the memory manager.                          */
     1230  /*    clazz  :: Module class to destroy.                                 */
     1231  /*                                                                       */
     1232  typedef void
     1233  (*FT_Module_Destroyer)( FT_Memory         memory,
     1234                          FT_Module_Class*  clazz );
     1235
     1236#endif
     1237
     1238  /*************************************************************************/
     1239  /*                                                                       */
     1240  /* <Macro>                                                               */
     1241  /*    FT_DECLARE_MODULE                                                  */
     1242  /*                                                                       */
     1243  /* <Description>                                                         */
     1244  /*    Used to create a forward declaration of a                          */
     1245  /*    FT_Module_Class stract instance.                                   */
     1246  /*                                                                       */
     1247  /* <Macro>                                                               */
     1248  /*    FT_DEFINE_MODULE                                                   */
     1249  /*                                                                       */
     1250  /* <Description>                                                         */
     1251  /*    Used to initialize an instance of FT_Module_Class struct.          */
     1252  /*                                                                       */
     1253  /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
     1254  /*    to called with a pointer where the allocated stracture is returned.*/
     1255  /*    And when it is no longer needed a Destroy function needs           */
     1256  /*    to be called to release that allocation.                           */
     1257  /*    fcinit.c (ft_create_default_module_classes) already contains       */
     1258  /*    a mechanism to call these functions for the default modules        */
     1259  /*    described in ftmodule.h                                            */
     1260  /*                                                                       */
     1261  /*    Notice that the created Create and Destroy functions call          */
     1262  /*    pic_init and pic_free function to allow you to manually allocate   */
     1263  /*    and initialize any additional global data, like module specific    */
     1264  /*    interface, and put them in the global pic container defined in     */
     1265  /*    ftpic.h. if you don't need them just implement the functions as    */
     1266  /*    empty to resolve the link error.                                   */
     1267  /*                                                                       */
     1268  /*    When FT_CONFIG_OPTION_PIC is not defined the struct will be        */
     1269  /*    allocated in the global scope (or the scope where the macro        */
     1270  /*    is used).                                                          */
     1271  /*                                                                       */
     1272  /* <Macro>                                                               */
     1273  /*    FT_DEFINE_ROOT_MODULE                                              */
     1274  /*                                                                       */
     1275  /* <Description>                                                         */
     1276  /*    Used to initialize an instance of FT_Module_Class struct inside    */
     1277  /*    another stract that contains it or in a function that initializes  */
     1278  /*    that containing stract                                             */
     1279  /*                                                                       */
     1280#ifndef FT_CONFIG_OPTION_PIC
     1281
     1282#define FT_DECLARE_MODULE(class_)                                            \
     1283  FT_CALLBACK_TABLE                                                          \
     1284  const FT_Module_Class  class_;                                             \
     1285
     1286#define FT_DEFINE_ROOT_MODULE(flags_, size_, name_, version_, requires_,     \
     1287                              interface_, init_, done_, get_interface_)      \
     1288  {                                                                          \
     1289    flags_,                                                                  \
     1290    size_,                                                                   \
     1291                                                                             \
     1292    name_,                                                                   \
     1293    version_,                                                                \
     1294    requires_,                                                               \
     1295                                                                             \
     1296    interface_,                                                              \
     1297                                                                             \
     1298    init_,                                                                   \
     1299    done_,                                                                   \
     1300    get_interface_,                                                          \
     1301  },
     1302
     1303#define FT_DEFINE_MODULE(class_, flags_, size_, name_, version_, requires_,  \
     1304                         interface_, init_, done_, get_interface_)           \
     1305  FT_CALLBACK_TABLE_DEF                                                      \
     1306  const FT_Module_Class class_ =                                             \
     1307  {                                                                          \
     1308    flags_,                                                                  \
     1309    size_,                                                                   \
     1310                                                                             \
     1311    name_,                                                                   \
     1312    version_,                                                                \
     1313    requires_,                                                               \
     1314                                                                             \
     1315    interface_,                                                              \
     1316                                                                             \
     1317    init_,                                                                   \
     1318    done_,                                                                   \
     1319    get_interface_,                                                          \
     1320  };
     1321
     1322
     1323#else /* FT_CONFIG_OPTION_PIC */
     1324
     1325#define FT_DECLARE_MODULE(class_)                                            \
     1326  FT_Error FT_Create_Class_##class_( FT_Library library,                     \
     1327                                     FT_Module_Class** output_class );       \
     1328  void     FT_Destroy_Class_##class_( FT_Library library,                    \
     1329                                      FT_Module_Class*  clazz );
     1330
     1331#define FT_DEFINE_ROOT_MODULE(flags_, size_, name_, version_, requires_,     \
     1332                              interface_, init_, done_, get_interface_)      \
     1333    clazz->root.module_flags       = flags_;                                 \
     1334    clazz->root.module_size        = size_;                                  \
     1335    clazz->root.module_name        = name_;                                  \
     1336    clazz->root.module_version     = version_;                               \
     1337    clazz->root.module_requires    = requires_;                              \
     1338                                                                             \
     1339    clazz->root.module_interface   = interface_;                             \
     1340                                                                             \
     1341    clazz->root.module_init        = init_;                                  \
     1342    clazz->root.module_done        = done_;                                  \
     1343    clazz->root.get_interface      = get_interface_;               
     1344
     1345#define FT_DEFINE_MODULE(class_, flags_, size_, name_, version_, requires_,  \
     1346                         interface_, init_, done_, get_interface_)           \
     1347  void class_##_pic_free( FT_Library library );                              \
     1348  FT_Error class_##_pic_init( FT_Library library );                          \
     1349                                                                             \
     1350  void                                                                       \
     1351  FT_Destroy_Class_##class_( FT_Library library,                             \
     1352                             FT_Module_Class*  clazz )                       \
     1353  {                                                                          \
     1354    FT_Memory memory = library->memory;                                      \
     1355    class_##_pic_free( library );                                            \
     1356    if ( clazz )                                                             \
     1357      FT_FREE( clazz );                                                      \
     1358  }                                                                          \
     1359                                                                             \
     1360  FT_Error                                                                   \
     1361  FT_Create_Class_##class_( FT_Library library,                              \
     1362                            FT_Module_Class**  output_class )                \
     1363  {                                                                          \
     1364    FT_Memory memory = library->memory;                                      \
     1365    FT_Module_Class*  clazz;                                                 \
     1366    FT_Error          error;                                                 \
     1367                                                                             \
     1368    if ( FT_ALLOC( clazz, sizeof(*clazz) ) )                                 \
     1369      return error;                                                          \
     1370    error = class_##_pic_init( library );                                    \
     1371    if(error)                                                                \
     1372    {                                                                        \
     1373      FT_FREE( clazz );                                                      \
     1374      return error;                                                          \
     1375    }                                                                        \
     1376                                                                             \
     1377    clazz->module_flags       = flags_;                                      \
     1378    clazz->module_size        = size_;                                       \
     1379    clazz->module_name        = name_;                                       \
     1380    clazz->module_version     = version_;                                    \
     1381    clazz->module_requires    = requires_;                                   \
     1382                                                                             \
     1383    clazz->module_interface   = interface_;                                  \
     1384                                                                             \
     1385    clazz->module_init        = init_;                                       \
     1386    clazz->module_done        = done_;                                       \
     1387    clazz->get_interface      = get_interface_;                              \
     1388                                                                             \
     1389    *output_class = clazz;                                                   \
     1390    return FT_Err_Ok;                                                        \
     1391  }
     1392
     1393#endif /* FT_CONFIG_OPTION_PIC */
     1394
    8691395
    8701396FT_END_HEADER
  • trunk/poppler/freetype2/include/freetype/internal/ftserv.h

    r251 r274  
    164164  typedef const FT_ServiceDescRec*  FT_ServiceDesc;
    165165
     166  /*************************************************************************/
     167  /*                                                                       */
     168  /* <Macro>                                                               */
     169  /*    FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6             */
     170  /*                                                                       */
     171  /* <Description>                                                         */
     172  /*    Used to initialize an array of FT_ServiceDescRec structs.          */
     173  /*                                                                       */
     174  /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
     175  /*    to called with a pointer where the allocated array is returned.    */
     176  /*    And when it is no longer needed a Destroy function needs           */
     177  /*    to be called to release that allocation.                           */
     178  /*                                                                       */
     179  /*    These functions should be manyally called from the pic_init and    */
     180  /*    pic_free functions of your module (see FT_DEFINE_MODULE)           */
     181  /*                                                                       */
     182  /*    When FT_CONFIG_OPTION_PIC is not defined the array will be         */
     183  /*    allocated in the global scope (or the scope where the macro        */
     184  /*    is used).                                                          */
     185  /*                                                                       */
     186#ifndef FT_CONFIG_OPTION_PIC
     187
     188#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
     189  static const FT_ServiceDescRec class_[] =                                  \
     190  {                                                                          \
     191  {serv_id_1, serv_data_1},                                                  \
     192  {NULL, NULL}                                                               \
     193  };
     194#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
     195        serv_id_2, serv_data_2)                                              \
     196  static const FT_ServiceDescRec class_[] =                                  \
     197  {                                                                          \
     198  {serv_id_1, serv_data_1},                                                  \
     199  {serv_id_2, serv_data_2},                                                  \
     200  {NULL, NULL}                                                               \
     201  };
     202#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
     203        serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
     204  static const FT_ServiceDescRec class_[] =                                  \
     205  {                                                                          \
     206  {serv_id_1, serv_data_1},                                                  \
     207  {serv_id_2, serv_data_2},                                                  \
     208  {serv_id_3, serv_data_3},                                                  \
     209  {NULL, NULL}                                                               \
     210  };
     211#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
     212        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
     213        serv_id_4, serv_data_4)                                              \
     214  static const FT_ServiceDescRec class_[] =                                  \
     215  {                                                                          \
     216  {serv_id_1, serv_data_1},                                                  \
     217  {serv_id_2, serv_data_2},                                                  \
     218  {serv_id_3, serv_data_3},                                                  \
     219  {serv_id_4, serv_data_4},                                                  \
     220  {NULL, NULL}                                                               \
     221  };
     222#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
     223        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
     224        serv_id_4, serv_data_4, serv_id_5, serv_data_5)                      \
     225  static const FT_ServiceDescRec class_[] =                                  \
     226  {                                                                          \
     227  {serv_id_1, serv_data_1},                                                  \
     228  {serv_id_2, serv_data_2},                                                  \
     229  {serv_id_3, serv_data_3},                                                  \
     230  {serv_id_4, serv_data_4},                                                  \
     231  {serv_id_5, serv_data_5},                                                  \
     232  {NULL, NULL}                                                               \
     233  };
     234#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
     235        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
     236        serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
     237        serv_id_6, serv_data_6)                                              \
     238  static const FT_ServiceDescRec class_[] =                                  \
     239  {                                                                          \
     240  {serv_id_1, serv_data_1},                                                  \
     241  {serv_id_2, serv_data_2},                                                  \
     242  {serv_id_3, serv_data_3},                                                  \
     243  {serv_id_4, serv_data_4},                                                  \
     244  {serv_id_5, serv_data_5},                                                  \
     245  {serv_id_6, serv_data_6},                                                  \
     246  {NULL, NULL}                                                               \
     247  };
     248
     249#else /* FT_CONFIG_OPTION_PIC */
     250
     251#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
     252  void                                                                       \
     253  FT_Destroy_Class_##class_( FT_Library library,                             \
     254                             FT_ServiceDescRec* clazz )                      \
     255  {                                                                          \
     256    FT_Memory memory = library->memory;                                      \
     257    if ( clazz )                                                             \
     258      FT_FREE( clazz );                                                      \
     259  }                                                                          \
     260                                                                             \
     261  FT_Error                                                                   \
     262  FT_Create_Class_##class_( FT_Library library,                              \
     263                            FT_ServiceDescRec** output_class)                \
     264  {                                                                          \
     265    FT_ServiceDescRec*  clazz;                                               \
     266    FT_Error          error;                                                 \
     267    FT_Memory memory = library->memory;                                      \
     268                                                                             \
     269    if ( FT_ALLOC( clazz, sizeof(*clazz)*2 ) )                               \
     270      return error;                                                          \
     271    clazz[0].serv_id = serv_id_1;                                            \
     272    clazz[0].serv_data = serv_data_1;                                        \
     273    clazz[1].serv_id = NULL;                                                 \
     274    clazz[1].serv_data = NULL;                                               \
     275    *output_class = clazz;                                                   \
     276    return FT_Err_Ok;                                                        \
     277  }
     278
     279#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
     280        serv_id_2, serv_data_2)                                              \
     281  void                                                                       \
     282  FT_Destroy_Class_##class_( FT_Library library,                             \
     283                             FT_ServiceDescRec* clazz )                      \
     284  {                                                                          \
     285    FT_Memory memory = library->memory;                                      \
     286    if ( clazz )                                                             \
     287      FT_FREE( clazz );                                                      \
     288  }                                                                          \
     289                                                                             \
     290  FT_Error                                                                   \
     291  FT_Create_Class_##class_( FT_Library library,                              \
     292                            FT_ServiceDescRec** output_class)                \
     293  {                                                                          \
     294    FT_ServiceDescRec*  clazz;                                               \
     295    FT_Error          error;                                                 \
     296    FT_Memory memory = library->memory;                                      \
     297                                                                             \
     298    if ( FT_ALLOC( clazz, sizeof(*clazz)*3 ) )                               \
     299      return error;                                                          \
     300    clazz[0].serv_id = serv_id_1;                                            \
     301    clazz[0].serv_data = serv_data_1;                                        \
     302    clazz[1].serv_id = serv_id_2;                                            \
     303    clazz[1].serv_data = serv_data_2;                                        \
     304    clazz[2].serv_id = NULL;                                                 \
     305    clazz[2].serv_data = NULL;                                               \
     306    *output_class = clazz;                                                   \
     307    return FT_Err_Ok;                                                        \
     308  }
     309
     310#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
     311        serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
     312  void                                                                       \
     313  FT_Destroy_Class_##class_( FT_Library library,                             \
     314                             FT_ServiceDescRec* clazz )                      \
     315  {                                                                          \
     316    FT_Memory memory = library->memory;                                      \
     317    if ( clazz )                                                             \
     318      FT_FREE( clazz );                                                      \
     319  }                                                                          \
     320                                                                             \
     321  FT_Error                                                                   \
     322  FT_Create_Class_##class_( FT_Library library,                              \
     323                            FT_ServiceDescRec** output_class)                \
     324  {                                                                          \
     325    FT_ServiceDescRec*  clazz;                                               \
     326    FT_Error          error;                                                 \
     327    FT_Memory memory = library->memory;                                      \
     328                                                                             \
     329    if ( FT_ALLOC( clazz, sizeof(*clazz)*4 ) )                               \
     330      return error;                                                          \
     331    clazz[0].serv_id = serv_id_1;                                            \
     332    clazz[0].serv_data = serv_data_1;                                        \
     333    clazz[1].serv_id = serv_id_2;                                            \
     334    clazz[1].serv_data = serv_data_2;                                        \
     335    clazz[2].serv_id = serv_id_3;                                            \
     336    clazz[2].serv_data = serv_data_3;                                        \
     337    clazz[3].serv_id = NULL;                                                 \
     338    clazz[3].serv_data = NULL;                                               \
     339    *output_class = clazz;                                                   \
     340    return FT_Err_Ok;                                                        \
     341  }
     342
     343#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
     344        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
     345        serv_id_4, serv_data_4)                                              \
     346  void                                                                       \
     347  FT_Destroy_Class_##class_( FT_Library library,                             \
     348                             FT_ServiceDescRec* clazz )                      \
     349  {                                                                          \
     350    FT_Memory memory = library->memory;                                      \
     351    if ( clazz )                                                             \
     352      FT_FREE( clazz );                                                      \
     353  }                                                                          \
     354                                                                             \
     355  FT_Error                                                                   \
     356  FT_Create_Class_##class_( FT_Library library,                              \
     357                            FT_ServiceDescRec** output_class)                \
     358  {                                                                          \
     359    FT_ServiceDescRec*  clazz;                                               \
     360    FT_Error          error;                                                 \
     361    FT_Memory memory = library->memory;                                      \
     362                                                                             \
     363    if ( FT_ALLOC( clazz, sizeof(*clazz)*5 ) )                               \
     364      return error;                                                          \
     365    clazz[0].serv_id = serv_id_1;                                            \
     366    clazz[0].serv_data = serv_data_1;                                        \
     367    clazz[1].serv_id = serv_id_2;                                            \
     368    clazz[1].serv_data = serv_data_2;                                        \
     369    clazz[2].serv_id = serv_id_3;                                            \
     370    clazz[2].serv_data = serv_data_3;                                        \
     371    clazz[3].serv_id = serv_id_4;                                            \
     372    clazz[3].serv_data = serv_data_4;                                        \
     373    clazz[4].serv_id = NULL;                                                 \
     374    clazz[4].serv_data = NULL;                                               \
     375    *output_class = clazz;                                                   \
     376    return FT_Err_Ok;                                                        \
     377  }
     378
     379#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
     380        serv_id_2, serv_data_2, serv_id_3, serv_data_3, serv_id_4,           \
     381        serv_data_4, serv_id_5, serv_data_5)                                 \
     382  void                                                                       \
     383  FT_Destroy_Class_##class_( FT_Library library,                             \
     384                             FT_ServiceDescRec* clazz )                      \
     385  {                                                                          \
     386    FT_Memory memory = library->memory;                                      \
     387    if ( clazz )                                                             \
     388      FT_FREE( clazz );                                                      \
     389  }                                                                          \
     390                                                                             \
     391  FT_Error                                                                   \
     392  FT_Create_Class_##class_( FT_Library library,                              \
     393                            FT_ServiceDescRec** output_class)                \
     394  {                                                                          \
     395    FT_ServiceDescRec*  clazz;                                               \
     396    FT_Error          error;                                                 \
     397    FT_Memory memory = library->memory;                                      \
     398                                                                             \
     399    if ( FT_ALLOC( clazz, sizeof(*clazz)*6 ) )                               \
     400      return error;                                                          \
     401    clazz[0].serv_id = serv_id_1;                                            \
     402    clazz[0].serv_data = serv_data_1;                                        \
     403    clazz[1].serv_id = serv_id_2;                                            \
     404    clazz[1].serv_data = serv_data_2;                                        \
     405    clazz[2].serv_id = serv_id_3;                                            \
     406    clazz[2].serv_data = serv_data_3;                                        \
     407    clazz[3].serv_id = serv_id_4;                                            \
     408    clazz[3].serv_data = serv_data_4;                                        \
     409    clazz[4].serv_id = serv_id_5;                                            \
     410    clazz[4].serv_data = serv_data_5;                                        \
     411    clazz[5].serv_id = NULL;                                                 \
     412    clazz[5].serv_data = NULL;                                               \
     413    *output_class = clazz;                                                   \
     414    return FT_Err_Ok;                                                        \
     415  }
     416
     417#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
     418        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
     419        serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
     420        serv_id_6, serv_data_6)                                              \
     421  void                                                                       \
     422  FT_Destroy_Class_##class_( FT_Library library,                             \
     423                             FT_ServiceDescRec* clazz )                      \
     424  {                                                                          \
     425    FT_Memory memory = library->memory;                                      \
     426    if ( clazz )                                                             \
     427      FT_FREE( clazz );                                                      \
     428  }                                                                          \
     429                                                                             \
     430  FT_Error                                                                   \
     431  FT_Create_Class_##class_( FT_Library library,                              \
     432                            FT_ServiceDescRec** output_class)                \
     433  {                                                                          \
     434    FT_ServiceDescRec*  clazz;                                               \
     435    FT_Error          error;                                                 \
     436    FT_Memory memory = library->memory;                                      \
     437                                                                             \
     438    if ( FT_ALLOC( clazz, sizeof(*clazz)*7 ) )                               \
     439      return error;                                                          \
     440    clazz[0].serv_id = serv_id_1;                                            \
     441    clazz[0].serv_data = serv_data_1;                                        \
     442    clazz[1].serv_id = serv_id_2;                                            \
     443    clazz[1].serv_data = serv_data_2;                                        \
     444    clazz[2].serv_id = serv_id_3;                                            \
     445    clazz[2].serv_data = serv_data_3;                                        \
     446    clazz[3].serv_id = serv_id_4;                                            \
     447    clazz[3].serv_data = serv_data_4;                                        \
     448    clazz[4].serv_id = serv_id_5;                                            \
     449    clazz[4].serv_data = serv_data_5;                                        \
     450    clazz[5].serv_id = serv_id_6;                                            \
     451    clazz[5].serv_data = serv_data_6;                                        \
     452    clazz[6].serv_id = NULL;                                                 \
     453    clazz[6].serv_data = NULL;                                               \
     454    *output_class = clazz;                                                   \
     455    return FT_Err_Ok;                                                        \
     456  }
     457#endif /* FT_CONFIG_OPTION_PIC */
    166458
    167459  /*
  • trunk/poppler/freetype2/include/freetype/internal/fttrace.h

    r251 r274  
    3232FT_TRACE_DEF( outline )   /* outline management      (ftoutln.c)  */
    3333FT_TRACE_DEF( glyph )     /* glyph management        (ftglyph.c)  */
     34FT_TRACE_DEF( gloader )   /* glyph loader            (ftgloadr.c) */
    3435
    3536FT_TRACE_DEF( raster )    /* monochrome rasterizer   (ftraster.c) */
     
    3738FT_TRACE_DEF( mm )        /* MM interface            (ftmm.c)     */
    3839FT_TRACE_DEF( raccess )   /* resource fork accessor  (ftrfork.c)  */
     40FT_TRACE_DEF( synth )     /* bold/slant synthesizer  (ftsynth.c)  */
    3941
    4042  /* Cache sub-system */
     
    4244
    4345  /* SFNT driver components */
     46FT_TRACE_DEF( sfdriver )  /* SFNT font driver        (sfdriver.c) */
    4447FT_TRACE_DEF( sfobjs )    /* SFNT object handler     (sfobjs.c)   */
    4548FT_TRACE_DEF( ttcmap )    /* charmap handler         (ttcmap.c)   */
     
    4952FT_TRACE_DEF( ttpost )    /* PS table processing     (ttpost.c)   */
    5053FT_TRACE_DEF( ttsbit )    /* TrueType sbit handling  (ttsbit.c)   */
     54FT_TRACE_DEF( ttbdf )     /* TrueType embedded BDF   (ttbdf.c)    */
    5155
    5256  /* TrueType driver components */
     
    5963
    6064  /* Type 1 driver components */
     65FT_TRACE_DEF( t1afm )
    6166FT_TRACE_DEF( t1driver )
    6267FT_TRACE_DEF( t1gload )
  • trunk/poppler/freetype2/include/freetype/internal/internal.h

    r251 r274  
    2626
    2727#define FT_INTERNAL_OBJECTS_H             <freetype/internal/ftobjs.h>
     28#define FT_INTERNAL_PIC_H                 <freetype/internal/ftpic.h>
    2829#define FT_INTERNAL_STREAM_H              <freetype/internal/ftstream.h>
    2930#define FT_INTERNAL_MEMORY_H              <freetype/internal/ftmemory.h>
  • trunk/poppler/freetype2/include/freetype/internal/psaux.h

    r269 r274  
    361361    (*to_bytes)( PS_Parser  parser,
    362362                 FT_Byte*   bytes,
    363                  FT_Long    max_bytes,
     363                 FT_Offset  max_bytes,
    364364                 FT_Long*   pnum_bytes,
    365365                 FT_Bool    delimiters );
     
    534534  /*    max_contours :: Maximal number of contours in builder outline.     */
    535535  /*                                                                       */
    536   /*    last         :: The last point position.                           */
    537   /*                                                                       */
    538536  /*    pos_x        :: The horizontal translation (if composite glyph).   */
    539537  /*                                                                       */
     
    568566    FT_Outline*     current;
    569567
    570     FT_Vector       last;
    571 
    572568    FT_Pos          pos_x;
    573569    FT_Pos          pos_y;
     
    580576    FT_Bool         load_points;
    581577    FT_Bool         no_recurse;
    582     FT_Bool         shift;
    583578
    584579    FT_Bool         metrics_only;
     
    695690    T1_Decoder_FuncsRec  funcs;
    696691
    697     FT_Int*              buildchar;
     692    FT_Long*             buildchar;
    698693    FT_UInt              len_buildchar;
     694
     695    FT_Bool              seac;
    699696
    700697  } T1_DecoderRec;
     
    759756    FT_Int
    760757    (*get_index)( const char*  name,
    761                   FT_UInt      len,
     758                  FT_Offset    len,
    762759                  void*        user_data );
    763760
  • trunk/poppler/freetype2/include/freetype/internal/pshints.h

    r251 r274  
    77/*    T1/T2 hints in the `type1', `cid', and `cff' font drivers.           */
    88/*                                                                         */
    9 /*  Copyright 2001, 2002, 2003, 2005, 2006, 2007 by                        */
     9/*  Copyright 2001, 2002, 2003, 2005, 2006, 2007, 2009 by                  */
    1010/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    1111/*                                                                         */
     
    158158   *
    159159   *   coords ::
    160    *     Array of 2 integers, used as (position,length) stem descriptor.
     160   *     Array of 2 coordinates in 16.16 format, used as (position,length)
     161   *     stem descriptor.
    161162   *
    162163   * @note:
     
    176177   */
    177178  typedef void
    178   (*T1_Hints_SetStemFunc)( T1_Hints  hints,
    179                            FT_UInt   dimension,
    180                            FT_Long*  coords );
     179  (*T1_Hints_SetStemFunc)( T1_Hints   hints,
     180                           FT_UInt    dimension,
     181                           FT_Fixed*  coords );
    181182
    182183
     
    198199   *
    199200   *   coords ::
    200    *     An array of 6 integers, holding 3 (position,length) pairs for the
    201    *     counter-controlled stems.
     201   *     An array of 6 values in 16.16 format, holding 3 (position,length)
     202   *     pairs for the counter-controlled stems.
    202203   *
    203204   * @note:
     
    210211   */
    211212  typedef void
    212   (*T1_Hints_SetStem3Func)( T1_Hints  hints,
    213                             FT_UInt   dimension,
    214                             FT_Long*  coords );
     213  (*T1_Hints_SetStem3Func)( T1_Hints   hints,
     214                            FT_UInt    dimension,
     215                            FT_Fixed*  coords );
    215216
    216217
     
    447448   *
    448449   *   coords ::
    449    *     An array of `count' (position,length) pairs.
     450   *     An array of `count' (position,length) pairs in 16.16 format.
    450451   *
    451452   * @note:
     
    679680  typedef PSHinter_Interface*  PSHinter_Service;
    680681
     682#ifndef FT_CONFIG_OPTION_PIC
     683
     684#define FT_DEFINE_PSHINTER_INTERFACE(class_, get_globals_funcs_,             \
     685                                     get_t1_funcs_, get_t2_funcs_)           \
     686  static const PSHinter_Interface class_ =                                   \
     687  {                                                                          \
     688    get_globals_funcs_, get_t1_funcs_, get_t2_funcs_                         \
     689  };
     690
     691#else /* FT_CONFIG_OPTION_PIC */
     692
     693#define FT_DEFINE_PSHINTER_INTERFACE(class_, get_globals_funcs_,             \
     694                                     get_t1_funcs_, get_t2_funcs_)           \
     695  void                                                                       \
     696  FT_Init_Class_##class_( FT_Library library,                                \
     697                          PSHinter_Interface*  clazz)                        \
     698  {                                                                          \
     699    FT_UNUSED(library);                                                      \
     700    clazz->get_globals_funcs = get_globals_funcs_;                           \
     701    clazz->get_t1_funcs = get_t1_funcs_;                                     \
     702    clazz->get_t2_funcs = get_t2_funcs_;                                     \
     703  }
     704
     705#endif /* FT_CONFIG_OPTION_PIC */
    681706
    682707FT_END_HEADER
  • trunk/poppler/freetype2/include/freetype/internal/services/svbdf.h

    r251 r274  
    4646  };
    4747
     48#ifndef FT_CONFIG_OPTION_PIC
     49
     50#define FT_DEFINE_SERVICE_BDFRec(class_, get_charset_id_, get_property_) \
     51  static const FT_Service_BDFRec class_ =                                \
     52  {                                                                      \
     53    get_charset_id_, get_property_                                       \
     54  };
     55
     56#else /* FT_CONFIG_OPTION_PIC */
     57
     58#define FT_DEFINE_SERVICE_BDFRec(class_, get_charset_id_, get_property_) \
     59  void                                                                   \
     60  FT_Init_Class_##class_( FT_Service_BDFRec*  clazz )                    \
     61  {                                                                      \
     62    clazz->get_charset_id = get_charset_id_;                             \
     63    clazz->get_property = get_property_;                                 \
     64  }
     65
     66#endif /* FT_CONFIG_OPTION_PIC */
     67
    4868  /* */
    4969
  • trunk/poppler/freetype2/include/freetype/internal/services/svcid.h

    r269 r274  
    4747  };
    4848
     49#ifndef FT_CONFIG_OPTION_PIC
     50
     51#define FT_DEFINE_SERVICE_CIDREC(class_, get_ros_,                           \
     52        get_is_cid_, get_cid_from_glyph_index_ )                             \
     53  static const FT_Service_CIDRec class_ =                                    \
     54  {                                                                          \
     55    get_ros_, get_is_cid_, get_cid_from_glyph_index_                         \
     56  };
     57
     58#else /* FT_CONFIG_OPTION_PIC */
     59
     60#define FT_DEFINE_SERVICE_CIDREC(class_, get_ros_,                           \
     61        get_is_cid_, get_cid_from_glyph_index_ )                             \
     62  void                                                                       \
     63  FT_Init_Class_##class_( FT_Library library,                                \
     64                          FT_Service_CIDRec* clazz)                          \
     65  {                                                                          \
     66    FT_UNUSED(library);                                                      \
     67    clazz->get_ros = get_ros_;                                               \
     68    clazz->get_is_cid = get_is_cid_;                                         \
     69    clazz->get_cid_from_glyph_index = get_cid_from_glyph_index_;             \
     70  }
     71
     72#endif /* FT_CONFIG_OPTION_PIC */
     73
    4974  /* */
    5075
  • trunk/poppler/freetype2/include/freetype/internal/services/svgldict.h

    r251 r274  
    5252  };
    5353
     54#ifndef FT_CONFIG_OPTION_PIC
     55
     56#define FT_DEFINE_SERVICE_GLYPHDICTREC(class_, get_name_, name_index_) \
     57  static const FT_Service_GlyphDictRec class_ =                        \
     58  {                                                                    \
     59    get_name_, name_index_                                             \
     60  };
     61
     62#else /* FT_CONFIG_OPTION_PIC */
     63
     64#define FT_DEFINE_SERVICE_GLYPHDICTREC(class_, get_name_, name_index_) \
     65  void                                                                 \
     66  FT_Init_Class_##class_( FT_Library library,                          \
     67                          FT_Service_GlyphDictRec* clazz)              \
     68  {                                                                    \
     69    FT_UNUSED(library);                                                \
     70    clazz->get_name = get_name_;                                       \
     71    clazz->name_index = name_index_;                                   \
     72  }
     73
     74#endif /* FT_CONFIG_OPTION_PIC */
     75
    5476  /* */
    5577
  • trunk/poppler/freetype2/include/freetype/internal/services/svmm.h

    r251 r274  
    6969  };
    7070
     71#ifndef FT_CONFIG_OPTION_PIC
     72
     73#define FT_DEFINE_SERVICE_MULTIMASTERSREC(class_, get_mm_, set_mm_design_,   \
     74        set_mm_blend_, get_mm_var_, set_var_design_)                         \
     75  static const FT_Service_MultiMastersRec class_ =                           \
     76  {                                                                          \
     77    get_mm_, set_mm_design_, set_mm_blend_, get_mm_var_, set_var_design_     \
     78  };
     79
     80#else /* FT_CONFIG_OPTION_PIC */
     81
     82#define FT_DEFINE_SERVICE_MULTIMASTERSREC(class_, get_mm_, set_mm_design_,   \
     83        set_mm_blend_, get_mm_var_, set_var_design_)                         \
     84  void                                                                       \
     85  FT_Init_Class_##class_( FT_Service_MultiMastersRec*  clazz )               \
     86  {                                                                          \
     87    clazz->get_mm = get_mm_;                                                 \
     88    clazz->set_mm_design = set_mm_design_;                                   \
     89    clazz->set_mm_blend = set_mm_blend_;                                     \
     90    clazz->get_mm_var = get_mm_var_;                                         \
     91    clazz->set_var_design = set_var_design_;                                 \
     92  }
     93
     94#endif /* FT_CONFIG_OPTION_PIC */
     95
    7196  /* */
    7297
  • trunk/poppler/freetype2/include/freetype/internal/services/svpostnm.h

    r200 r274  
    4747  };
    4848
     49#ifndef FT_CONFIG_OPTION_PIC
     50
     51#define FT_DEFINE_SERVICE_PSFONTNAMEREC(class_, get_ps_font_name_) \
     52  static const FT_Service_PsFontNameRec class_ =                   \
     53  {                                                                \
     54    get_ps_font_name_                                              \
     55  };
     56
     57#else /* FT_CONFIG_OPTION_PIC */
     58
     59#define FT_DEFINE_SERVICE_PSFONTNAMEREC(class_, get_ps_font_name_) \
     60  void                                                             \
     61  FT_Init_Class_##class_( FT_Library library,                      \
     62                          FT_Service_PsFontNameRec* clazz)         \
     63  {                                                                \
     64    FT_UNUSED(library);                                            \
     65    clazz->get_ps_font_name = get_ps_font_name_;                   \
     66  }
     67
     68#endif /* FT_CONFIG_OPTION_PIC */
     69
    4970  /* */
    5071
  • trunk/poppler/freetype2/include/freetype/internal/services/svpscmap.h

    r251 r274  
    9999                                FT_UInt32    unicode );
    100100
    101   typedef FT_ULong
     101  typedef FT_UInt32
    102102  (*PS_Unicodes_CharNextFunc)( PS_Unicodes  unicodes,
    103103                               FT_UInt32   *unicode );
     
    118118  };
    119119
     120
     121#ifndef FT_CONFIG_OPTION_PIC
     122
     123#define FT_DEFINE_SERVICE_PSCMAPSREC(class_, unicode_value_, unicodes_init_, \
     124        unicodes_char_index_, unicodes_char_next_, macintosh_name_,          \
     125        adobe_std_strings_, adobe_std_encoding_, adobe_expert_encoding_)     \
     126  static const FT_Service_PsCMapsRec class_ =                                \
     127  {                                                                          \
     128    unicode_value_, unicodes_init_,                                          \
     129    unicodes_char_index_, unicodes_char_next_, macintosh_name_,              \
     130    adobe_std_strings_, adobe_std_encoding_, adobe_expert_encoding_          \
     131  };
     132
     133#else /* FT_CONFIG_OPTION_PIC */
     134
     135#define FT_DEFINE_SERVICE_PSCMAPSREC(class_, unicode_value_, unicodes_init_, \
     136        unicodes_char_index_, unicodes_char_next_, macintosh_name_,          \
     137        adobe_std_strings_, adobe_std_encoding_, adobe_expert_encoding_)     \
     138  void                                                                       \
     139  FT_Init_Class_##class_( FT_Library library,                                \
     140                          FT_Service_PsCMapsRec* clazz)                      \
     141  {                                                                          \
     142    FT_UNUSED(library);                                                      \
     143    clazz->unicode_value = unicode_value_;                                   \
     144    clazz->unicodes_init = unicodes_init_;                                   \
     145    clazz->unicodes_char_index = unicodes_char_index_;                       \
     146    clazz->unicodes_char_next = unicodes_char_next_;                         \
     147    clazz->macintosh_name = macintosh_name_;                                 \
     148    clazz->adobe_std_strings = adobe_std_strings_;                           \
     149    clazz->adobe_std_encoding = adobe_std_encoding_;                         \
     150    clazz->adobe_expert_encoding = adobe_expert_encoding_;                   \
     151  }
     152
     153#endif /* FT_CONFIG_OPTION_PIC */
     154
    120155  /* */
    121156
  • trunk/poppler/freetype2/include/freetype/internal/services/svpsinfo.h

    r269 r274  
    5454  };
    5555
     56#ifndef FT_CONFIG_OPTION_PIC
     57
     58#define FT_DEFINE_SERVICE_PSINFOREC(class_, get_font_info_,      \
     59        ps_get_font_extra_, has_glyph_names_, get_font_private_) \
     60  static const FT_Service_PsInfoRec class_ =                     \
     61  {                                                              \
     62    get_font_info_, ps_get_font_extra_, has_glyph_names_,        \
     63    get_font_private_                                            \
     64  };
     65
     66#else /* FT_CONFIG_OPTION_PIC */
     67
     68#define FT_DEFINE_SERVICE_PSINFOREC(class_, get_font_info_,      \
     69        ps_get_font_extra_, has_glyph_names_, get_font_private_) \
     70  void                                                           \
     71  FT_Init_Class_##class_( FT_Library library,                    \
     72                          FT_Service_PsInfoRec*  clazz)          \
     73  {                                                              \
     74    FT_UNUSED(library);                                          \
     75    clazz->ps_get_font_info = get_font_info_;                    \
     76    clazz->ps_get_font_extra = ps_get_font_extra_;               \
     77    clazz->ps_has_glyph_names = has_glyph_names_;                \
     78    clazz->ps_get_font_private = get_font_private_;              \
     79  }
     80
     81#endif /* FT_CONFIG_OPTION_PIC */
     82
    5683  /* */
    5784
  • trunk/poppler/freetype2/include/freetype/internal/services/svsfnt.h

    r150 r274  
    5959                            FT_UInt    idx,
    6060                            FT_ULong  *tag,
     61                            FT_ULong  *offset,
    6162                            FT_ULong  *length );
    6263
     
    6869    FT_SFNT_TableInfoFunc  table_info;
    6970  };
     71
     72#ifndef FT_CONFIG_OPTION_PIC
     73
     74#define FT_DEFINE_SERVICE_SFNT_TABLEREC(class_, load_, get_, info_)  \
     75  static const FT_Service_SFNT_TableRec class_ =                     \
     76  {                                                                  \
     77    load_, get_, info_                                               \
     78  };
     79
     80#else /* FT_CONFIG_OPTION_PIC */
     81
     82#define FT_DEFINE_SERVICE_SFNT_TABLEREC(class_, load_, get_, info_) \
     83  void                                                              \
     84  FT_Init_Class_##class_( FT_Service_SFNT_TableRec*  clazz )        \
     85  {                                                                 \
     86    clazz->load_table = load_;                                      \
     87    clazz->get_table = get_;                                        \
     88    clazz->table_info = info_;                                      \
     89  }
     90
     91#endif /* FT_CONFIG_OPTION_PIC */
    7092
    7193  /* */
  • trunk/poppler/freetype2/include/freetype/internal/services/svttcmap.h

    r262 r274  
    11/***************************************************************************/
    22/*                                                                         */
    3 /*  svsttcmap.h                                                            */
     3/*  svttcmap.h                                                             */
    44/*                                                                         */
    55/*    The FreeType TrueType/sfnt cmap extra information service.           */
     
    7575  };
    7676
     77#ifndef FT_CONFIG_OPTION_PIC
     78
     79#define FT_DEFINE_SERVICE_TTCMAPSREC(class_, get_cmap_info_)  \
     80  static const FT_Service_TTCMapsRec class_ =                 \
     81  {                                                           \
     82    get_cmap_info_                                            \
     83  };
     84
     85#else /* FT_CONFIG_OPTION_PIC */
     86
     87#define FT_DEFINE_SERVICE_TTCMAPSREC(class_, get_cmap_info_) \
     88  void                                                       \
     89  FT_Init_Class_##class_( FT_Library library,                \
     90                          FT_Service_TTCMapsRec*  clazz)     \
     91  {                                                          \
     92    FT_UNUSED(library);                                      \
     93    clazz->get_cmap_info = get_cmap_info_;                   \
     94  }
     95
     96#endif /* FT_CONFIG_OPTION_PIC */
     97
    7798  /* */
    7899
  • trunk/poppler/freetype2/include/freetype/internal/services/svttglyf.h

    r251 r274  
    3838  };
    3939
     40#ifndef FT_CONFIG_OPTION_PIC
     41
     42#define FT_DEFINE_SERVICE_TTGLYFREC(class_, get_location_ )   \
     43  static const FT_Service_TTGlyfRec class_ =                  \
     44  {                                                           \
     45    get_location_                                             \
     46  };
     47
     48#else /* FT_CONFIG_OPTION_PIC */
     49
     50#define FT_DEFINE_SERVICE_TTGLYFREC(class_, get_location_ )   \
     51  void                                                        \
     52  FT_Init_Class_##class_( FT_Service_TTGlyfRec*  clazz )      \
     53  {                                                           \
     54    clazz->get_location = get_location_;                      \
     55  }
     56
     57#endif /* FT_CONFIG_OPTION_PIC */
     58
    4059  /* */
    4160
  • trunk/poppler/freetype2/include/freetype/internal/sfnt.h

    r251 r274  
    754754  typedef SFNT_Interface*   SFNT_Service;
    755755
     756#ifndef FT_CONFIG_OPTION_PIC
     757
     758#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
     759#define FT_DEFINE_DRIVERS_OLD_INTERNAL(a) \
     760  a,
     761#else
     762  #define FT_DEFINE_DRIVERS_OLD_INTERNAL(a)
     763#endif
     764#define FT_INTERNAL(a) \
     765  a,
     766
     767#define FT_DEFINE_SFNT_INTERFACE(class_,                                     \
     768    goto_table_, init_face_, load_face_, done_face_, get_interface_,         \
     769    load_any_, load_sfnt_header_, load_directory_, load_head_,               \
     770    load_hhea_, load_cmap_, load_maxp_, load_os2_, load_post_,               \
     771    load_name_, free_name_, load_hdmx_stub_, free_hdmx_stub_,                \
     772    load_kern_, load_gasp_, load_pclt_, load_bhed_,                          \
     773    set_sbit_strike_stub_, load_sbits_stub_, find_sbit_image_,               \
     774    load_sbit_metrics_, load_sbit_image_, free_sbits_stub_,                  \
     775    get_psname_, free_psnames_, load_charmap_stub_, free_charmap_stub_,      \
     776    get_kerning_, load_font_dir_, load_hmtx_, load_eblc_, free_eblc_,        \
     777    set_sbit_strike_, load_strike_metrics_, get_metrics_ )                   \
     778  static const SFNT_Interface class_ =                                       \
     779  {                                                                          \
     780    FT_INTERNAL(goto_table_) \
     781    FT_INTERNAL(init_face_) \
     782    FT_INTERNAL(load_face_) \
     783    FT_INTERNAL(done_face_) \
     784    FT_INTERNAL(get_interface_) \
     785    FT_INTERNAL(load_any_) \
     786    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sfnt_header_) \
     787    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_directory_) \
     788    FT_INTERNAL(load_head_) \
     789    FT_INTERNAL(load_hhea_) \
     790    FT_INTERNAL(load_cmap_) \
     791    FT_INTERNAL(load_maxp_) \
     792    FT_INTERNAL(load_os2_) \
     793    FT_INTERNAL(load_post_) \
     794    FT_INTERNAL(load_name_) \
     795    FT_INTERNAL(free_name_) \
     796    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_hdmx_stub_) \
     797    FT_DEFINE_DRIVERS_OLD_INTERNAL(free_hdmx_stub_) \
     798    FT_INTERNAL(load_kern_) \
     799    FT_INTERNAL(load_gasp_) \
     800    FT_INTERNAL(load_pclt_) \
     801    FT_INTERNAL(load_bhed_) \
     802    FT_DEFINE_DRIVERS_OLD_INTERNAL(set_sbit_strike_stub_) \
     803    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbits_stub_) \
     804    FT_DEFINE_DRIVERS_OLD_INTERNAL(find_sbit_image_) \
     805    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbit_metrics_) \
     806    FT_INTERNAL(load_sbit_image_) \
     807    FT_DEFINE_DRIVERS_OLD_INTERNAL(free_sbits_stub_) \
     808    FT_INTERNAL(get_psname_) \
     809    FT_INTERNAL(free_psnames_) \
     810    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_charmap_stub_) \
     811    FT_DEFINE_DRIVERS_OLD_INTERNAL(free_charmap_stub_) \
     812    FT_INTERNAL(get_kerning_) \
     813    FT_INTERNAL(load_font_dir_) \
     814    FT_INTERNAL(load_hmtx_) \
     815    FT_INTERNAL(load_eblc_) \
     816    FT_INTERNAL(free_eblc_) \
     817    FT_INTERNAL(set_sbit_strike_) \
     818    FT_INTERNAL(load_strike_metrics_) \
     819    FT_INTERNAL(get_metrics_) \
     820  };
     821
     822#else /* FT_CONFIG_OPTION_PIC */
     823
     824#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
     825#define FT_DEFINE_DRIVERS_OLD_INTERNAL(a, a_) \
     826  clazz->a = a_;
     827#else
     828  #define FT_DEFINE_DRIVERS_OLD_INTERNAL(a, a_)
     829#endif
     830#define FT_INTERNAL(a, a_) \
     831  clazz->a = a_;
     832
     833#define FT_DEFINE_SFNT_INTERFACE(class_,                                     \
     834    goto_table_, init_face_, load_face_, done_face_, get_interface_,         \
     835    load_any_, load_sfnt_header_, load_directory_, load_head_,               \
     836    load_hhea_, load_cmap_, load_maxp_, load_os2_, load_post_,               \
     837    load_name_, free_name_, load_hdmx_stub_, free_hdmx_stub_,                \
     838    load_kern_, load_gasp_, load_pclt_, load_bhed_,                          \
     839    set_sbit_strike_stub_, load_sbits_stub_, find_sbit_image_,               \
     840    load_sbit_metrics_, load_sbit_image_, free_sbits_stub_,                  \
     841    get_psname_, free_psnames_, load_charmap_stub_, free_charmap_stub_,      \
     842    get_kerning_, load_font_dir_, load_hmtx_, load_eblc_, free_eblc_,        \
     843    set_sbit_strike_, load_strike_metrics_, get_metrics_ )                   \
     844  void                                                                       \
     845  FT_Init_Class_##class_( FT_Library library, SFNT_Interface*  clazz )       \
     846  {                                                                          \
     847    FT_UNUSED(library);                                                      \
     848    FT_INTERNAL(goto_table,goto_table_) \
     849    FT_INTERNAL(init_face,init_face_) \
     850    FT_INTERNAL(load_face,load_face_) \
     851    FT_INTERNAL(done_face,done_face_) \
     852    FT_INTERNAL(get_interface,get_interface_) \
     853    FT_INTERNAL(load_any,load_any_) \
     854    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sfnt_header,load_sfnt_header_) \
     855    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_directory,load_directory_) \
     856    FT_INTERNAL(load_head,load_head_) \
     857    FT_INTERNAL(load_hhea,load_hhea_) \
     858    FT_INTERNAL(load_cmap,load_cmap_) \
     859    FT_INTERNAL(load_maxp,load_maxp_) \
     860    FT_INTERNAL(load_os2,load_os2_) \
     861    FT_INTERNAL(load_post,load_post_) \
     862    FT_INTERNAL(load_name,load_name_) \
     863    FT_INTERNAL(free_name,free_name_) \
     864    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_hdmx_stub,load_hdmx_stub_) \
     865    FT_DEFINE_DRIVERS_OLD_INTERNAL(free_hdmx_stub,free_hdmx_stub_) \
     866    FT_INTERNAL(load_kern,load_kern_) \
     867    FT_INTERNAL(load_gasp,load_gasp_) \
     868    FT_INTERNAL(load_pclt,load_pclt_) \
     869    FT_INTERNAL(load_bhed,load_bhed_) \
     870    FT_DEFINE_DRIVERS_OLD_INTERNAL(set_sbit_strike_stub,set_sbit_strike_stub_) \
     871    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbits_stub,load_sbits_stub_) \
     872    FT_DEFINE_DRIVERS_OLD_INTERNAL(find_sbit_image,find_sbit_image_) \
     873    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbit_metrics,load_sbit_metrics_) \
     874    FT_INTERNAL(load_sbit_image,load_sbit_image_) \
     875    FT_DEFINE_DRIVERS_OLD_INTERNAL(free_sbits_stub,free_sbits_stub_) \
     876    FT_INTERNAL(get_psname,get_psname_) \
     877    FT_INTERNAL(free_psnames,free_psnames_) \
     878    FT_DEFINE_DRIVERS_OLD_INTERNAL(load_charmap_stub,load_charmap_stub_) \
     879    FT_DEFINE_DRIVERS_OLD_INTERNAL(free_charmap_stub,free_charmap_stub_) \
     880    FT_INTERNAL(get_kerning,get_kerning_) \
     881    FT_INTERNAL(load_font_dir,load_font_dir_) \
     882    FT_INTERNAL(load_hmtx,load_hmtx_) \
     883    FT_INTERNAL(load_eblc,load_eblc_) \
     884    FT_INTERNAL(free_eblc,free_eblc_) \
     885    FT_INTERNAL(set_sbit_strike,set_sbit_strike_) \
     886    FT_INTERNAL(load_strike_metrics,load_strike_metrics_) \
     887    FT_INTERNAL(get_metrics,get_metrics_) \
     888  }
     889
     890#endif /* FT_CONFIG_OPTION_PIC */
    756891
    757892FT_END_HEADER
  • trunk/poppler/freetype2/include/freetype/internal/t1types.h

    r269 r274  
    5959  /*    code_first :: The lowest valid character code in the encoding.     */
    6060  /*                                                                       */
    61   /*    code_last  :: The highest valid character code in the encoding.    */
     61  /*    code_last  :: The highest valid character code in the encoding     */
     62  /*                  + 1. When equal to code_first there are no valid     */
     63  /*                  character codes.                                     */
    6264  /*                                                                       */
    6365  /*    char_index :: An array of corresponding glyph indices.             */
     
    231233    /* for Type 2 fonts; manipulated by othersubrs 19, 24, and 25    */
    232234    FT_UInt          len_buildchar;
    233     FT_Int*          buildchar;
     235    FT_Long*         buildchar;
    234236
    235237    /* since version 2.1 - interface to PostScript hinter */
  • trunk/poppler/freetype2/include/freetype/internal/tttypes.h

    r251 r274  
    903903    FT_Byte*   table_end;
    904904    FT_Byte*   strings;
    905     FT_UInt32  strings_size;
     905    FT_ULong   strings_size;
    906906    FT_UInt    num_strikes;
    907907    FT_Bool    loaded;
     
    14021402    FT_ULong              vert_metrics_size;
    14031403
    1404     FT_UInt               num_locations;
     1404    FT_ULong              num_locations; /* in broken TTF, gid > 0xFFFF */
    14051405    FT_Byte*              glyph_locations;
    14061406
Note: See TracChangeset for help on using the changeset viewer.