Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

updated freetype to 2.3.11

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33650 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Scott McCreary 2009-10-19 07:03:46 +00:00
parent 3221645ea1
commit f1b1e2fc9a
208 changed files with 6763 additions and 2125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
headers/libs/freetype2/freetype/config/ftoption.h
View File

@ -4,7 +4,7 @@
/* */
/* User-selectable configuration macros (specification only). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -92,9 +92,7 @@ FT_BEGIN_HEADER
/* This is done to allow FreeType clients to run unmodified, forcing */
/* them to display normal gray-level anti-aliased glyphs. */
/* */
#if HAIKU_INCLUDE_PATENTED_CODE
# define FT_CONFIG_OPTION_SUBPIXEL_RENDERING
#endif
/* #define FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
/*************************************************************************/
@ -398,6 +396,20 @@ FT_BEGIN_HEADER
#undef FT_CONFIG_OPTION_USE_MODULE_ERRORS
/*************************************************************************/
/* */
/* Position Independent Code */
/* */
/* If this macro is set (which is _not_ the default), FreeType2 will */
/* avoid creating constants that require address fixups. Instead the */
/* constants will be moved into a struct and additional intialization */
/* code will be used. */
/* */
/* Setting this macro is needed for systems that prohibit address */
/* fixups, such as BREW. */
/* */
/* #define FT_CONFIG_OPTION_PIC */
/*************************************************************************/
/*************************************************************************/
@ -441,7 +453,7 @@ FT_BEGIN_HEADER
/* does not contain any glyph name though. */
/* */
/* Accessing SFNT names is done through the functions declared in */
/* `freetype/ftnames.h'. */
/* `freetype/ftsnames.h'. */
/* */
#define TT_CONFIG_OPTION_SFNT_NAMES
@ -459,6 +471,7 @@ FT_BEGIN_HEADER
#define TT_CONFIG_CMAP_FORMAT_8
#define TT_CONFIG_CMAP_FORMAT_10
#define TT_CONFIG_CMAP_FORMAT_12
#define TT_CONFIG_CMAP_FORMAT_13
#define TT_CONFIG_CMAP_FORMAT_14
@ -482,9 +495,7 @@ FT_BEGIN_HEADER
/* Do not #undef this macro here, since the build system might */
/* define it for certain configurations only. */
/* */
#if HAIKU_INCLUDE_PATENTED_CODE
# define TT_CONFIG_OPTION_BYTECODE_INTERPRETER
#endif
/* #define TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
/*************************************************************************/

1
headers/libs/freetype2/freetype/config/ftstdlib.h
View File

@ -61,6 +61,7 @@
#define FT_CHAR_BIT CHAR_BIT
#define FT_INT_MAX INT_MAX
#define FT_INT_MIN INT_MIN
#define FT_UINT_MAX UINT_MAX
#define FT_ULONG_MAX ULONG_MAX

16
headers/libs/freetype2/freetype/freetype.h
View File

@ -519,10 +519,7 @@ FT_BEGIN_HEADER
/* <Note> */
/* Despite the name, this enumeration lists specific character */
/* repertories (i.e., charsets), and not text encoding methods (e.g., */
/* UTF-8, UTF-16, GB2312_EUC, etc.). */
/* */
/* Because of 32-bit charcodes defined in Unicode (i.e., surrogates), */
/* all character codes must be expressed as FT_Longs. */
/* UTF-8, UTF-16, etc.). */
/* */
/* Other encodings might be defined in the future. */
/* */
@ -536,6 +533,10 @@ FT_BEGIN_HEADER
/* Latin-1. Most fonts include a Unicode charmap, but not all */
/* of them. */
/* */
/* For example, if you want to access Unicode value U+1F028 (and */
/* the font contains it), use value 0x1F028 as the input value for */
/* @FT_Get_Char_Index. */
/* */
/* FT_ENCODING_MS_SYMBOL :: */
/* Corresponds to the Microsoft Symbol encoding, used to encode */
/* mathematical symbols in the 32..255 character code range. For */
@ -1651,6 +1652,11 @@ FT_BEGIN_HEADER
/* <Return> */
/* FreeType error code. 0~means success. */
/* */
/* <Note> */
/* In case you want to provide your own memory allocating routines, */
/* use @FT_New_Library instead, followed by a call to */
/* @FT_Add_Default_Modules (or a series of calls to @FT_Add_Module). */
/* */
FT_EXPORT( FT_Error )
FT_Init_FreeType( FT_Library *alibrary );
@ -3757,7 +3763,7 @@ FT_BEGIN_HEADER
*/
#define FREETYPE_MAJOR 2
#define FREETYPE_MINOR 3
#define FREETYPE_PATCH 9
#define FREETYPE_PATCH 11
/*************************************************************************/

65
headers/libs/freetype2/freetype/ftimage.h
View File

@ -5,7 +5,7 @@
/* FreeType glyph image formats and default raster interface */
/* (specification). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -318,14 +318,23 @@ FT_BEGIN_HEADER
/* elements, giving the outline's point coordinates. */
/* */
/* tags :: A pointer to an array of `n_points' chars, giving */
/* each outline point's type. If bit~0 is unset, the */
/* point is `off' the curve, i.e., a Bézier control */
/* point, while it is `on' when set. */
/* each outline point's type. */
/* */
/* If bit~0 is unset, the point is `off' the curve, */
/* i.e., a Bézier control point, while it is `on' if */
/* set. */
/* */
/* Bit~1 is meaningful for `off' points only. If set, */
/* it indicates a third-order Bézier arc control point; */
/* and a second-order control point if unset. */
/* */
/* If bit~2 is set, bits 5-7 contain the drop-out mode */
/* (as defined in the OpenType specification; the value */
/* is the same as the argument to the SCANMODE */
/* instruction). */
/* */
/* Bits 3 and~4 are reserved for internal purposes. */
/* */
/* contours :: An array of `n_contours' shorts, giving the end */
/* point of each contour within the outline. For */
/* example, the first contour is defined by the points */
@ -336,6 +345,12 @@ FT_BEGIN_HEADER
/* and give hints to the scan-converter and hinter on */
/* how to convert/grid-fit it. See @FT_OUTLINE_FLAGS. */
/* */
/* <Note> */
/* The B/W rasterizer only checks bit~2 in the `tags' array for the */
/* first point of each contour. The drop-out mode as given with */
/* @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and */
/* @FT_OUTLINE_INCLUDE_STUBS in `flags' is then overridden. */
/* */
typedef struct FT_Outline_
{
short n_contours; /* number of contours in glyph */
@ -349,6 +364,11 @@ FT_BEGIN_HEADER
} FT_Outline;
/* Following limits must be consistent with */
/* FT_Outline.{n_contours,n_points} */
#define FT_OUTLINE_CONTOURS_MAX SHRT_MAX
#define FT_OUTLINE_POINTS_MAX SHRT_MAX
/*************************************************************************/
/* */
@ -371,7 +391,7 @@ FT_BEGIN_HEADER
/* FT_OUTLINE_EVEN_ODD_FILL :: */
/* By default, outlines are filled using the non-zero winding rule. */
/* If set to 1, the outline will be filled using the even-odd fill */
/* rule (only works with the smooth raster). */
/* rule (only works with the smooth rasterizer). */
/* */
/* FT_OUTLINE_REVERSE_FILL :: */
/* By default, outside contours of an outline are oriented in */
@ -384,15 +404,17 @@ FT_BEGIN_HEADER
/* By default, the scan converter will try to detect drop-outs in */
/* an outline and correct the glyph bitmap to ensure consistent */
/* shape continuity. If set, this flag hints the scan-line */
/* converter to ignore such cases. */
/* converter to ignore such cases. See below for more information. */
/* */
/* FT_OUTLINE_SMART_DROPOUTS :: */
/* Select smart dropout control. If unset, use simple dropout */
/* control. Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. */
/* control. Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See */
/* below for more information. */
/* */
/* FT_OUTLINE_INCLUDE_STUBS :: */
/* If set, turn pixels on for `stubs', otherwise exclude them. */
/* Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. */
/* Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See below for */
/* more information. */
/* */
/* FT_OUTLINE_HIGH_PRECISION :: */
/* This flag indicates that the scan-line converter should try to */
@ -409,6 +431,13 @@ FT_BEGIN_HEADER
/* scan-converter. */
/* */
/* <Note> */
/* The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, */
/* and @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth */
/* rasterizer. */
/* */
/* There exists a second mechanism to pass the drop-out mode to the */
/* B/W rasterizer; see the `tags' field in @FT_Outline. */
/* */
/* Please refer to the description of the `SCANTYPE' instruction in */
/* the OpenType specification (in file `ttinst1.doc') how simple */
/* drop-outs, smart drop-outs, and stubs are defined. */
@ -455,15 +484,17 @@ FT_BEGIN_HEADER
#define FT_CURVE_TAG( flag ) ( flag & 3 )
#define FT_CURVE_TAG_ON 1
#define FT_CURVE_TAG_CONIC 0
#define FT_CURVE_TAG_CUBIC 2
#define FT_CURVE_TAG_ON 1
#define FT_CURVE_TAG_CONIC 0
#define FT_CURVE_TAG_CUBIC 2
#define FT_CURVE_TAG_TOUCH_X 8 /* reserved for the TrueType hinter */
#define FT_CURVE_TAG_TOUCH_Y 16 /* reserved for the TrueType hinter */
#define FT_CURVE_TAG_HAS_SCANMODE 4
#define FT_CURVE_TAG_TOUCH_BOTH ( FT_CURVE_TAG_TOUCH_X | \
FT_CURVE_TAG_TOUCH_Y )
#define FT_CURVE_TAG_TOUCH_X 8 /* reserved for the TrueType hinter */
#define FT_CURVE_TAG_TOUCH_Y 16 /* reserved for the TrueType hinter */
#define FT_CURVE_TAG_TOUCH_BOTH ( FT_CURVE_TAG_TOUCH_X | \
FT_CURVE_TAG_TOUCH_Y )
#define FT_Curve_Tag_On FT_CURVE_TAG_ON
#define FT_Curve_Tag_Conic FT_CURVE_TAG_CONIC
@ -1011,7 +1042,7 @@ FT_BEGIN_HEADER
/* */
/* gray_spans :: The gray span drawing callback. */
/* */
/* black_spans :: The black span drawing callback. */
/* black_spans :: The black span drawing callback. UNIMPLEMENTED! */
/* */
/* bit_test :: The bit test callback. UNIMPLEMENTED! */
/* */
@ -1048,7 +1079,7 @@ FT_BEGIN_HEADER
const void* source;
int flags;
FT_SpanFunc gray_spans;
FT_SpanFunc black_spans;
FT_SpanFunc black_spans; /* doesn't work! */
FT_Raster_BitTest_Func bit_test; /* doesn't work! */
FT_Raster_BitSet_Func bit_set; /* doesn't work! */
void* user;

6
headers/libs/freetype2/freetype/ftmodapi.h
View File

@ -4,7 +4,7 @@
/* */
/* FreeType modules public interface (specification). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2006, 2008 by */
/* Copyright 1996-2001, 2002, 2003, 2006, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -259,6 +259,10 @@ FT_BEGIN_HEADER
/* from a given memory object. It is thus possible to use libraries */
/* with distinct memory allocators within the same program. */
/* */
/* Normally, you would call this function (followed by a call to */
/* @FT_Add_Default_Modules or a series of calls to @FT_Add_Module) */
/* instead of @FT_Init_FreeType to initialize the FreeType library. */
/* */
/* <Input> */
/* memory :: A handle to the original memory object. */
/* */

5
headers/libs/freetype2/freetype/ftsnames.h
View File

@ -7,7 +7,7 @@
/* */
/* This is _not_ used to retrieve glyph names! */
/* */
/* Copyright 1996-2001, 2002, 2003, 2006 by */
/* Copyright 1996-2001, 2002, 2003, 2006, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -147,7 +147,8 @@ FT_BEGIN_HEADER
/* */
/* <Note> */
/* The `string' array returned in the `aname' structure is not */
/* null-terminated. */
/* null-terminated. The application should deallocate it if it is no */
/* longer in use. */
/* */
/* Use @FT_Get_Sfnt_Name_Count to get the total number of available */
/* `name' table entries, then do a loop until you get the right */

2
headers/libs/freetype2/freetype/ftstroke.h
View File

@ -598,7 +598,7 @@ FT_BEGIN_HEADER
*
* @description:
* Call this function after @FT_Stroker_GetBorderCounts to
* export the all borders to your own @FT_Outline structure.
* export all borders to your own @FT_Outline structure.
*
* Note that this function appends the border points and
* contours to your outline, but does not try to resize its

3
headers/libs/freetype2/freetype/fttypes.h
View File

@ -167,7 +167,7 @@ FT_BEGIN_HEADER
/* FT_Tag */
/* */
/* <Description> */
/* A typedef for 32-bit tags (as used in the SFNT format). */
/* A typedef for 32-bit tags (as used in the SFNT format). */
/* */
typedef FT_UInt32 FT_Tag;
@ -474,6 +474,7 @@ FT_BEGIN_HEADER
/* this macro. */
/* */
#define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
(FT_Tag) \
( ( (FT_ULong)_x1 << 24 ) | \
( (FT_ULong)_x2 << 16 ) | \
( (FT_ULong)_x3 << 8 ) | \

3
headers/libs/freetype2/freetype/ftxf86.h
View File

@ -49,6 +49,9 @@ FT_BEGIN_HEADER
/* however, there are special cases (like in PDF devices) where it is */
/* important to differentiate, in spite of FreeType's uniform API. */
/* */
/* This function is in the X11/xf86 namespace for historical reasons */
/* and in no way depends on that windowing system. */
/* */
/*************************************************************************/

26
headers/libs/freetype2/freetype/internal/autohint.h
View File

@ -196,6 +196,32 @@ FT_BEGIN_HEADER
} FT_AutoHinter_ServiceRec, *FT_AutoHinter_Service;
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_AUTOHINTER_SERVICE(class_, reset_face_, get_global_hints_, \
done_global_hints_, load_glyph_) \
FT_CALLBACK_TABLE_DEF \
const FT_AutoHinter_ServiceRec class_ = \
{ \
reset_face_, get_global_hints_, done_global_hints_, load_glyph_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_AUTOHINTER_SERVICE(class_, reset_face_, get_global_hints_, \
done_global_hints_, load_glyph_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_AutoHinter_ServiceRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->reset_face = reset_face_; \
clazz->get_global_hints = get_global_hints_; \
clazz->done_global_hints = done_global_hints_; \
clazz->load_glyph = load_glyph_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
FT_END_HEADER

3
headers/libs/freetype2/freetype/internal/ftcalc.h
View File

@ -4,7 +4,7 @@
/* */
/* Arithmetic computations (specification). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008 by */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -165,6 +165,7 @@ FT_BEGIN_HEADER
#define INT_TO_FIXED( x ) ( (FT_Long)(x) << 16 )
#define F2DOT14_TO_FIXED( x ) ( (FT_Long)(x) << 2 )
#define FLOAT_TO_FIXED( x ) ( (FT_Long)( x * 65536.0 ) )
#define FIXED_TO_INT( x ) ( FT_RoundFix( x ) >> 16 )
#define ROUND_F26DOT6( x ) ( x >= 0 ? ( ( (x) + 32 ) & -64 ) \
: ( -( ( 32 - (x) ) & -64 ) ) )

173
headers/libs/freetype2/freetype/internal/ftdriver.h
View File

@ -240,6 +240,179 @@ FT_BEGIN_HEADER
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DECLARE_DRIVER */
/* */
/* <Description> */
/* Used to create a forward declaration of a */
/* FT_Driver_ClassRec stract instance. */
/* */
/* <Macro> */
/* FT_DEFINE_DRIVER */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Driver_ClassRec struct. */
/* */
/* When FT_CONFIG_OPTION_PIC is defined a Create funtion will need */
/* to called with a pointer where the allocated stracture is returned.*/
/* And when it is no longer needed a Destroy function needs */
/* to be called to release that allocation. */
/* fcinit.c (ft_create_default_module_classes) already contains */
/* a mechanism to call these functions for the default modules */
/* described in ftmodule.h */
/* */
/* Notice that the created Create and Destroy functions call */
/* pic_init and pic_free function to allow you to manually allocate */
/* and initialize any additional global data, like module specific */
/* interface, and put them in the global pic container defined in */
/* ftpic.h. if you don't need them just implement the functions as */
/* empty to resolve the link error. */
/* */
/* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
#define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_) \
a_, b_,
#else
#define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_)
#endif
#define FT_DECLARE_DRIVER(class_) \
FT_CALLBACK_TABLE \
const FT_Driver_ClassRec class_;
#define FT_DEFINE_DRIVER(class_, \
flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_, \
face_object_size_, size_object_size_, \
slot_object_size_, init_face_, done_face_, \
init_size_, done_size_, init_slot_, done_slot_, \
old_set_char_sizes_, old_set_pixel_sizes_, \
load_glyph_, get_kerning_, attach_file_, \
get_advances_, request_size_, select_size_ ) \
FT_CALLBACK_TABLE_DEF \
const FT_Driver_ClassRec class_ = \
{ \
FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_,interface_, \
init_,done_,get_interface_) \
\
face_object_size_, \
size_object_size_, \
slot_object_size_, \
\
init_face_, \
done_face_, \
\
init_size_, \
done_size_, \
\
init_slot_, \
done_slot_, \
\
FT_DEFINE_DRIVERS_OLD_INTERNALS(old_set_char_sizes_, old_set_pixel_sizes_) \
\
load_glyph_, \
\
get_kerning_, \
attach_file_, \
get_advances_, \
\
request_size_, \
select_size_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
#define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_) \
clazz->set_char_sizes = a_; \
clazz->set_pixel_sizes = b_;
#else
#define FT_DEFINE_DRIVERS_OLD_INTERNALS(a_,b_)
#endif
#define FT_DECLARE_DRIVER(class_) FT_DECLARE_MODULE(class_)
#define FT_DEFINE_DRIVER(class_, \
flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_, \
face_object_size_, size_object_size_, \
slot_object_size_, init_face_, done_face_, \
init_size_, done_size_, init_slot_, done_slot_, \
old_set_char_sizes_, old_set_pixel_sizes_, \
load_glyph_, get_kerning_, attach_file_, \
get_advances_, request_size_, select_size_ ) \
void class_##_pic_free( FT_Library library ); \
FT_Error class_##_pic_init( FT_Library library ); \
\
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_Module_Class* clazz ) \
{ \
FT_Memory memory = library->memory; \
FT_Driver_Class dclazz = (FT_Driver_Class)clazz; \
class_##_pic_free( library ); \
if ( dclazz ) \
FT_FREE( dclazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_Module_Class** output_class ) \
{ \
FT_Driver_Class clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz) ) ) \
return error; \
\
error = class_##_pic_init( library ); \
if(error) \
{ \
FT_FREE( clazz ); \
return error; \
} \
\
FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_,interface_, \
init_,done_,get_interface_) \
\
clazz->face_object_size = face_object_size_; \
clazz->size_object_size = size_object_size_; \
clazz->slot_object_size = slot_object_size_; \
\
clazz->init_face = init_face_; \
clazz->done_face = done_face_; \
\
clazz->init_size = init_size_; \
clazz->done_size = done_size_; \
\
clazz->init_slot = init_slot_; \
clazz->done_slot = done_slot_; \
\
FT_DEFINE_DRIVERS_OLD_INTERNALS(old_set_char_sizes_, old_set_pixel_sizes_) \
\
clazz->load_glyph = load_glyph_; \
\
clazz->get_kerning = get_kerning_; \
clazz->attach_file = attach_file_; \
clazz->get_advances = get_advances_; \
\
clazz->request_size = request_size_; \
clazz->select_size = select_size_; \
\
*output_class = (FT_Module_Class*)clazz; \
return FT_Err_Ok; \
}
#endif /* FT_CONFIG_OPTION_PIC */
FT_END_HEADER

16
headers/libs/freetype2/freetype/internal/ftgloadr.h
View File

@ -121,15 +121,15 @@ FT_BEGIN_HEADER
FT_UInt n_contours );
#define FT_GLYPHLOADER_CHECK_P( _loader, _count ) \
( (_count) == 0 || (int)((_loader)->base.outline.n_points + \
(_loader)->current.outline.n_points + \
(_count)) <= (int)(_loader)->max_points )
#define FT_GLYPHLOADER_CHECK_P( _loader, _count ) \
( (_count) == 0 || ((_loader)->base.outline.n_points + \
(_loader)->current.outline.n_points + \
(unsigned long)(_count)) <= (_loader)->max_points )
#define FT_GLYPHLOADER_CHECK_C( _loader, _count ) \
( (_count) == 0 || (int)((_loader)->base.outline.n_contours + \
(_loader)->current.outline.n_contours + \
(_count)) <= (int)(_loader)->max_contours )
#define FT_GLYPHLOADER_CHECK_C( _loader, _count ) \
( (_count) == 0 || ((_loader)->base.outline.n_contours + \
(_loader)->current.outline.n_contours + \
(unsigned long)(_count)) <= (_loader)->max_contours )
#define FT_GLYPHLOADER_CHECK_POINTS( _loader, _points,_contours ) \
( ( FT_GLYPHLOADER_CHECK_P( _loader, _points ) && \

526
headers/libs/freetype2/freetype/internal/ftobjs.h
View File

@ -35,6 +35,7 @@
#include FT_INTERNAL_DRIVER_H
#include FT_INTERNAL_AUTOHINT_H
#include FT_INTERNAL_SERVICE_H
#include FT_INTERNAL_PIC_H
#ifdef FT_CONFIG_OPTION_INCREMENTAL
#include FT_INCREMENTAL_H
@ -205,6 +206,45 @@ FT_BEGIN_HEADER
} FT_CMap_ClassRec;
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DECLARE_CMAP_CLASS(class_) \
FT_CALLBACK_TABLE const FT_CMap_ClassRec class_;
#define FT_DEFINE_CMAP_CLASS(class_, size_, init_, done_, char_index_, \
char_next_, char_var_index_, char_var_default_, variant_list_, \
charvariant_list_, variantchar_list_) \
FT_CALLBACK_TABLE_DEF \
const FT_CMap_ClassRec class_ = \
{ \
size_, init_, done_, char_index_, char_next_, char_var_index_, \
char_var_default_, variant_list_, charvariant_list_, variantchar_list_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DECLARE_CMAP_CLASS(class_) \
void FT_Init_Class_##class_( FT_Library library, FT_CMap_ClassRec* clazz);
#define FT_DEFINE_CMAP_CLASS(class_, size_, init_, done_, char_index_, \
char_next_, char_var_index_, char_var_default_, variant_list_, \
charvariant_list_, variantchar_list_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_CMap_ClassRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->size = size_; \
clazz->init = init_; \
clazz->done = done_; \
clazz->char_index = char_index_; \
clazz->char_next = char_next_; \
clazz->char_var_index = char_var_index_; \
clazz->char_var_default = char_var_default_; \
clazz->variant_list = variant_list_; \
clazz->charvariant_list = charvariant_list_; \
clazz->variantchar_list = variantchar_list_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* create a new charmap and add it to charmap->face */
FT_BASE( FT_Error )
@ -765,6 +805,10 @@ FT_BEGIN_HEADER
/* */
/* debug_hooks :: XXX */
/* */
/* pic_container :: Contains global structs and tables, instead */
/* of defining them globallly. */
/* */
typedef struct FT_LibraryRec_
{
FT_Memory memory; /* library's memory manager */
@ -795,6 +839,10 @@ FT_BEGIN_HEADER
FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */
#endif
#ifdef FT_CONFIG_OPTION_PIC
FT_PIC_Container pic_container;
#endif
} FT_LibraryRec;
@ -866,6 +914,484 @@ FT_BEGIN_HEADER
FT_EXPORT_VAR( FT_Raster_Funcs ) ft_default_raster;
#endif
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/**** ****/
/**** ****/
/**** PIC-Support Macros for ftimage.h ****/
/**** ****/
/**** ****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DEFINE_OUTLINE_FUNCS */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Outline_Funcs struct. */
/* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */
/* called with a pre-allocated stracture to be filled. */
/* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_OUTLINE_FUNCS(class_, move_to_, line_to_, conic_to_, \
cubic_to_, shift_, delta_) \
static const FT_Outline_Funcs class_ = \
{ \
move_to_, line_to_, conic_to_, cubic_to_, shift_, delta_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_OUTLINE_FUNCS(class_, move_to_, line_to_, conic_to_, \
cubic_to_, shift_, delta_) \
static FT_Error \
Init_Class_##class_( FT_Outline_Funcs* clazz ) \
{ \
clazz->move_to = move_to_; \
clazz->line_to = line_to_; \
clazz->conic_to = conic_to_; \
clazz->cubic_to = cubic_to_; \
clazz->shift = shift_; \
clazz->delta = delta_; \
return FT_Err_Ok; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DEFINE_RASTER_FUNCS */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Raster_Funcs struct. */
/* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */
/* called with a pre-allocated stracture to be filled. */
/* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_RASTER_FUNCS(class_, glyph_format_, raster_new_, \
raster_reset_, raster_set_mode_, \
raster_render_, raster_done_) \
const FT_Raster_Funcs class_ = \
{ \
glyph_format_, raster_new_, raster_reset_, \
raster_set_mode_, raster_render_, raster_done_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_RASTER_FUNCS(class_, glyph_format_, raster_new_, \
raster_reset_, raster_set_mode_, raster_render_, raster_done_) \
void \
FT_Init_Class_##class_( FT_Raster_Funcs* clazz ) \
{ \
clazz->glyph_format = glyph_format_; \
clazz->raster_new = raster_new_; \
clazz->raster_reset = raster_reset_; \
clazz->raster_set_mode = raster_set_mode_; \
clazz->raster_render = raster_render_; \
clazz->raster_done = raster_done_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/**** ****/
/**** ****/
/**** PIC-Support Macros for ftrender.h ****/
/**** ****/
/**** ****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DEFINE_GLYPH */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Glyph_Class struct. */
/* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */
/* called with a pre-allocated stracture to be filled. */
/* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_GLYPH(class_, size_, format_, init_, done_, copy_, \
transform_, bbox_, prepare_) \
FT_CALLBACK_TABLE_DEF \
const FT_Glyph_Class class_ = \
{ \
size_, format_, init_, done_, copy_, transform_, bbox_, prepare_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_GLYPH(class_, size_, format_, init_, done_, copy_, \
transform_, bbox_, prepare_) \
void \
FT_Init_Class_##class_( FT_Glyph_Class* clazz ) \
{ \
clazz->glyph_size = size_; \
clazz->glyph_format = format_; \
clazz->glyph_init = init_; \
clazz->glyph_done = done_; \
clazz->glyph_copy = copy_; \
clazz->glyph_transform = transform_; \
clazz->glyph_bbox = bbox_; \
clazz->glyph_prepare = prepare_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DECLARE_RENDERER */
/* */
/* <Description> */
/* Used to create a forward declaration of a */
/* FT_Renderer_Class stract instance. */
/* */
/* <Macro> */
/* FT_DEFINE_RENDERER */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Renderer_Class struct. */
/* */
/* When FT_CONFIG_OPTION_PIC is defined a Create funtion will need */
/* to called with a pointer where the allocated stracture is returned.*/
/* And when it is no longer needed a Destroy function needs */
/* to be called to release that allocation. */
/* fcinit.c (ft_create_default_module_classes) already contains */
/* a mechanism to call these functions for the default modules */
/* described in ftmodule.h */
/* */
/* Notice that the created Create and Destroy functions call */
/* pic_init and pic_free function to allow you to manually allocate */
/* and initialize any additional global data, like module specific */
/* interface, and put them in the global pic container defined in */
/* ftpic.h. if you don't need them just implement the functions as */
/* empty to resolve the link error. */
/* */
/* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DECLARE_RENDERER(class_) \
FT_EXPORT_VAR( const FT_Renderer_Class ) class_;
#define FT_DEFINE_RENDERER(class_, \
flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_, \
glyph_format_, render_glyph_, transform_glyph_, \
get_glyph_cbox_, set_mode_, raster_class_ ) \
FT_CALLBACK_TABLE_DEF \
const FT_Renderer_Class class_ = \
{ \
FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_, \
interface_,init_,done_,get_interface_) \
glyph_format_, \
\
render_glyph_, \
transform_glyph_, \
get_glyph_cbox_, \
set_mode_, \
\
raster_class_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DECLARE_RENDERER(class_) FT_DECLARE_MODULE(class_)
#define FT_DEFINE_RENDERER(class_, \
flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_, \
glyph_format_, render_glyph_, transform_glyph_, \
get_glyph_cbox_, set_mode_, raster_class_ ) \
void class_##_pic_free( FT_Library library ); \
FT_Error class_##_pic_init( FT_Library library ); \
\
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_Module_Class* clazz ) \
{ \
FT_Renderer_Class* rclazz = (FT_Renderer_Class*)clazz; \
FT_Memory memory = library->memory; \
class_##_pic_free( library ); \
if ( rclazz ) \
FT_FREE( rclazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_Module_Class** output_class ) \
{ \
FT_Renderer_Class* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz) ) ) \
return error; \
\
error = class_##_pic_init( library ); \
if(error) \
{ \
FT_FREE( clazz ); \
return error; \
} \
\
FT_DEFINE_ROOT_MODULE(flags_,size_,name_,version_,requires_, \
interface_,init_,done_,get_interface_) \
\
clazz->glyph_format = glyph_format_; \
\
clazz->render_glyph = render_glyph_; \
clazz->transform_glyph = transform_glyph_; \
clazz->get_glyph_cbox = get_glyph_cbox_; \
clazz->set_mode = set_mode_; \
\
clazz->raster_class = raster_class_; \
\
*output_class = (FT_Module_Class*)clazz; \
return FT_Err_Ok; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/**** ****/
/**** ****/
/**** PIC-Support Macros for ftmodapi.h ****/
/**** ****/
/**** ****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
#ifdef FT_CONFIG_OPTION_PIC
/*************************************************************************/
/* */
/* <FuncType> */
/* FT_Module_Creator */
/* */
/* <Description> */
/* A function used to create (allocate) a new module class object. */
/* The object's members are initialized, but the module itself is */
/* not. */
/* */
/* <Input> */
/* memory :: A handle to the memory manager. */
/* output_class :: Initialized with the newly allocated class. */
/* */
typedef FT_Error
(*FT_Module_Creator)( FT_Memory memory,
FT_Module_Class** output_class );
/*************************************************************************/
/* */
/* <FuncType> */
/* FT_Module_Destroyer */
/* */
/* <Description> */
/* A function used to destroy (deallocate) a module class object. */
/* */
/* <Input> */
/* memory :: A handle to the memory manager. */
/* clazz :: Module class to destroy. */
/* */
typedef void
(*FT_Module_Destroyer)( FT_Memory memory,
FT_Module_Class* clazz );
#endif
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DECLARE_MODULE */
/* */
/* <Description> */
/* Used to create a forward declaration of a */
/* FT_Module_Class stract instance. */
/* */
/* <Macro> */
/* FT_DEFINE_MODULE */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Module_Class struct. */
/* */
/* When FT_CONFIG_OPTION_PIC is defined a Create funtion will need */
/* to called with a pointer where the allocated stracture is returned.*/
/* And when it is no longer needed a Destroy function needs */
/* to be called to release that allocation. */
/* fcinit.c (ft_create_default_module_classes) already contains */
/* a mechanism to call these functions for the default modules */
/* described in ftmodule.h */
/* */
/* Notice that the created Create and Destroy functions call */
/* pic_init and pic_free function to allow you to manually allocate */
/* and initialize any additional global data, like module specific */
/* interface, and put them in the global pic container defined in */
/* ftpic.h. if you don't need them just implement the functions as */
/* empty to resolve the link error. */
/* */
/* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
/* <Macro> */
/* FT_DEFINE_ROOT_MODULE */
/* */
/* <Description> */
/* Used to initialize an instance of FT_Module_Class struct inside */
/* another stract that contains it or in a function that initializes */
/* that containing stract */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DECLARE_MODULE(class_) \
FT_CALLBACK_TABLE \
const FT_Module_Class class_; \
#define FT_DEFINE_ROOT_MODULE(flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_) \
{ \
flags_, \
size_, \
\
name_, \
version_, \
requires_, \
\
interface_, \
\
init_, \
done_, \
get_interface_, \
},
#define FT_DEFINE_MODULE(class_, flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_) \
FT_CALLBACK_TABLE_DEF \
const FT_Module_Class class_ = \
{ \
flags_, \
size_, \
\
name_, \
version_, \
requires_, \
\
interface_, \
\
init_, \
done_, \
get_interface_, \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DECLARE_MODULE(class_) \
FT_Error FT_Create_Class_##class_( FT_Library library, \
FT_Module_Class** output_class ); \
void FT_Destroy_Class_##class_( FT_Library library, \
FT_Module_Class* clazz );
#define FT_DEFINE_ROOT_MODULE(flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_) \
clazz->root.module_flags = flags_; \
clazz->root.module_size = size_; \
clazz->root.module_name = name_; \
clazz->root.module_version = version_; \
clazz->root.module_requires = requires_; \
\
clazz->root.module_interface = interface_; \
\
clazz->root.module_init = init_; \
clazz->root.module_done = done_; \
clazz->root.get_interface = get_interface_;
#define FT_DEFINE_MODULE(class_, flags_, size_, name_, version_, requires_, \
interface_, init_, done_, get_interface_) \
void class_##_pic_free( FT_Library library ); \
FT_Error class_##_pic_init( FT_Library library ); \
\
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_Module_Class* clazz ) \
{ \
FT_Memory memory = library->memory; \
class_##_pic_free( library ); \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_Module_Class** output_class ) \
{ \
FT_Memory memory = library->memory; \
FT_Module_Class* clazz; \
FT_Error error; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz) ) ) \
return error; \
error = class_##_pic_init( library ); \
if(error) \
{ \
FT_FREE( clazz ); \
return error; \
} \
\
clazz->module_flags = flags_; \
clazz->module_size = size_; \
clazz->module_name = name_; \
clazz->module_version = version_; \
clazz->module_requires = requires_; \
\
clazz->module_interface = interface_; \
\
clazz->module_init = init_; \
clazz->module_done = done_; \
clazz->get_interface = get_interface_; \
\
*output_class = clazz; \
return FT_Err_Ok; \
}
#endif /* FT_CONFIG_OPTION_PIC */
FT_END_HEADER

67
headers/libs/freetype2/freetype/internal/ftpic.h Normal file
View File

@ -0,0 +1,67 @@
/***************************************************************************/
/* */
/* ftpic.h */
/* */
/* The FreeType position independent code services (declaration). */
/* */
/* Copyright 2009 by */
/* Oran Agra and Mickey Gabel. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
/*************************************************************************/
/* */
/* Modules that ordinarily have const global data that need address */
/* can instead define pointers here. */
/* */
/*************************************************************************/
#ifndef __FTPIC_H__
#define __FTPIC_H__
FT_BEGIN_HEADER
#ifdef FT_CONFIG_OPTION_PIC
typedef struct FT_PIC_Container_
{
/* pic containers for base */
void* base;
/* pic containers for modules */
void* autofit;
void* cff;
void* pshinter;
void* psnames;
void* raster;
void* sfnt;
void* smooth;
void* truetype;
} FT_PIC_Container;
/* Initialize the various function tables, structs, etc. stored in the container. */
FT_BASE( FT_Error )
ft_pic_container_init( FT_Library library );
/* Destroy the contents of the container. */
FT_BASE( void )
ft_pic_container_destroy( FT_Library library );
#endif /* FT_CONFIG_OPTION_PIC */
/* */
FT_END_HEADER
#endif /* __FTPIC_H__ */
/* END */

292
headers/libs/freetype2/freetype/internal/ftserv.h
View File

@ -163,6 +163,298 @@ FT_BEGIN_HEADER
typedef const FT_ServiceDescRec* FT_ServiceDesc;
/*************************************************************************/
/* */
/* <Macro> */
/* FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6 */
/* */
/* <Description> */
/* Used to initialize an array of FT_ServiceDescRec structs. */
/* */
/* When FT_CONFIG_OPTION_PIC is defined a Create funtion will need */
/* to called with a pointer where the allocated array is returned. */
/* And when it is no longer needed a Destroy function needs */
/* to be called to release that allocation. */
/* */
/* These functions should be manyally called from the pic_init and */
/* pic_free functions of your module (see FT_DEFINE_MODULE) */
/* */
/* When FT_CONFIG_OPTION_PIC is not defined the array will be */
/* allocated in the global scope (or the scope where the macro */
/* is used). */
/* */
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1) \
static const FT_ServiceDescRec class_[] = \
{ \
{serv_id_1, serv_data_1}, \
{NULL, NULL} \
};
#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2) \
static const FT_ServiceDescRec class_[] = \
{ \
{serv_id_1, serv_data_1}, \
{serv_id_2, serv_data_2}, \
{NULL, NULL} \
};
#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3) \
static const FT_ServiceDescRec class_[] = \
{ \
{serv_id_1, serv_data_1}, \
{serv_id_2, serv_data_2}, \
{serv_id_3, serv_data_3}, \
{NULL, NULL} \
};
#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3, \
serv_id_4, serv_data_4) \
static const FT_ServiceDescRec class_[] = \
{ \
{serv_id_1, serv_data_1}, \
{serv_id_2, serv_data_2}, \
{serv_id_3, serv_data_3}, \
{serv_id_4, serv_data_4}, \
{NULL, NULL} \
};
#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3, \
serv_id_4, serv_data_4, serv_id_5, serv_data_5) \
static const FT_ServiceDescRec class_[] = \
{ \
{serv_id_1, serv_data_1}, \
{serv_id_2, serv_data_2}, \
{serv_id_3, serv_data_3}, \
{serv_id_4, serv_data_4}, \
{serv_id_5, serv_data_5}, \
{NULL, NULL} \
};
#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3, \
serv_id_4, serv_data_4, serv_id_5, serv_data_5, \
serv_id_6, serv_data_6) \
static const FT_ServiceDescRec class_[] = \
{ \
{serv_id_1, serv_data_1}, \
{serv_id_2, serv_data_2}, \
{serv_id_3, serv_data_3}, \
{serv_id_4, serv_data_4}, \
{serv_id_5, serv_data_5}, \
{serv_id_6, serv_data_6}, \
{NULL, NULL} \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1) \
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_ServiceDescRec* clazz ) \
{ \
FT_Memory memory = library->memory; \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_ServiceDescRec** output_class) \
{ \
FT_ServiceDescRec* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz)*2 ) ) \
return error; \
clazz[0].serv_id = serv_id_1; \
clazz[0].serv_data = serv_data_1; \
clazz[1].serv_id = NULL; \
clazz[1].serv_data = NULL; \
*output_class = clazz; \
return FT_Err_Ok; \
}
#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2) \
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_ServiceDescRec* clazz ) \
{ \
FT_Memory memory = library->memory; \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_ServiceDescRec** output_class) \
{ \
FT_ServiceDescRec* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz)*3 ) ) \
return error; \
clazz[0].serv_id = serv_id_1; \
clazz[0].serv_data = serv_data_1; \
clazz[1].serv_id = serv_id_2; \
clazz[1].serv_data = serv_data_2; \
clazz[2].serv_id = NULL; \
clazz[2].serv_data = NULL; \
*output_class = clazz; \
return FT_Err_Ok; \
}
#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3) \
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_ServiceDescRec* clazz ) \
{ \
FT_Memory memory = library->memory; \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_ServiceDescRec** output_class) \
{ \
FT_ServiceDescRec* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz)*4 ) ) \
return error; \
clazz[0].serv_id = serv_id_1; \
clazz[0].serv_data = serv_data_1; \
clazz[1].serv_id = serv_id_2; \
clazz[1].serv_data = serv_data_2; \
clazz[2].serv_id = serv_id_3; \
clazz[2].serv_data = serv_data_3; \
clazz[3].serv_id = NULL; \
clazz[3].serv_data = NULL; \
*output_class = clazz; \
return FT_Err_Ok; \
}
#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3, \
serv_id_4, serv_data_4) \
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_ServiceDescRec* clazz ) \
{ \
FT_Memory memory = library->memory; \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_ServiceDescRec** output_class) \
{ \
FT_ServiceDescRec* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz)*5 ) ) \
return error; \
clazz[0].serv_id = serv_id_1; \
clazz[0].serv_data = serv_data_1; \
clazz[1].serv_id = serv_id_2; \
clazz[1].serv_data = serv_data_2; \
clazz[2].serv_id = serv_id_3; \
clazz[2].serv_data = serv_data_3; \
clazz[3].serv_id = serv_id_4; \
clazz[3].serv_data = serv_data_4; \
clazz[4].serv_id = NULL; \
clazz[4].serv_data = NULL; \
*output_class = clazz; \
return FT_Err_Ok; \
}
#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3, serv_id_4, \
serv_data_4, serv_id_5, serv_data_5) \
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_ServiceDescRec* clazz ) \
{ \
FT_Memory memory = library->memory; \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_ServiceDescRec** output_class) \
{ \
FT_ServiceDescRec* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz)*6 ) ) \
return error; \
clazz[0].serv_id = serv_id_1; \
clazz[0].serv_data = serv_data_1; \
clazz[1].serv_id = serv_id_2; \
clazz[1].serv_data = serv_data_2; \
clazz[2].serv_id = serv_id_3; \
clazz[2].serv_data = serv_data_3; \
clazz[3].serv_id = serv_id_4; \
clazz[3].serv_data = serv_data_4; \
clazz[4].serv_id = serv_id_5; \
clazz[4].serv_data = serv_data_5; \
clazz[5].serv_id = NULL; \
clazz[5].serv_data = NULL; \
*output_class = clazz; \
return FT_Err_Ok; \
}
#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1, \
serv_id_2, serv_data_2, serv_id_3, serv_data_3, \
serv_id_4, serv_data_4, serv_id_5, serv_data_5, \
serv_id_6, serv_data_6) \
void \
FT_Destroy_Class_##class_( FT_Library library, \
FT_ServiceDescRec* clazz ) \
{ \
FT_Memory memory = library->memory; \
if ( clazz ) \
FT_FREE( clazz ); \
} \
\
FT_Error \
FT_Create_Class_##class_( FT_Library library, \
FT_ServiceDescRec** output_class) \
{ \
FT_ServiceDescRec* clazz; \
FT_Error error; \
FT_Memory memory = library->memory; \
\
if ( FT_ALLOC( clazz, sizeof(*clazz)*7 ) ) \
return error; \
clazz[0].serv_id = serv_id_1; \
clazz[0].serv_data = serv_data_1; \
clazz[1].serv_id = serv_id_2; \
clazz[1].serv_data = serv_data_2; \
clazz[2].serv_id = serv_id_3; \
clazz[2].serv_data = serv_data_3; \
clazz[3].serv_id = serv_id_4; \
clazz[3].serv_data = serv_data_4; \
clazz[4].serv_id = serv_id_5; \
clazz[4].serv_data = serv_data_5; \
clazz[5].serv_id = serv_id_6; \
clazz[5].serv_data = serv_data_6; \
clazz[6].serv_id = NULL; \
clazz[6].serv_data = NULL; \
*output_class = clazz; \
return FT_Err_Ok; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/*
* Parse a list of FT_ServiceDescRec descriptors and look for

5
headers/libs/freetype2/freetype/internal/fttrace.h
View File

@ -31,16 +31,19 @@ FT_TRACE_DEF( init ) /* initialization (ftinit.c) */
FT_TRACE_DEF( objs ) /* base objects (ftobjs.c) */
FT_TRACE_DEF( outline ) /* outline management (ftoutln.c) */
FT_TRACE_DEF( glyph ) /* glyph management (ftglyph.c) */
FT_TRACE_DEF( gloader ) /* glyph loader (ftgloadr.c) */
FT_TRACE_DEF( raster ) /* monochrome rasterizer (ftraster.c) */
FT_TRACE_DEF( smooth ) /* anti-aliasing raster (ftgrays.c) */
FT_TRACE_DEF( mm ) /* MM interface (ftmm.c) */
FT_TRACE_DEF( raccess ) /* resource fork accessor (ftrfork.c) */
FT_TRACE_DEF( synth ) /* bold/slant synthesizer (ftsynth.c) */
/* Cache sub-system */
FT_TRACE_DEF( cache ) /* cache sub-system (ftcache.c, etc.) */
/* SFNT driver components */
FT_TRACE_DEF( sfdriver ) /* SFNT font driver (sfdriver.c) */
FT_TRACE_DEF( sfobjs ) /* SFNT object handler (sfobjs.c) */
FT_TRACE_DEF( ttcmap ) /* charmap handler (ttcmap.c) */
FT_TRACE_DEF( ttkern ) /* kerning handler (ttkern.c) */
@ -48,6 +51,7 @@ FT_TRACE_DEF( ttload ) /* basic TrueType tables (ttload.c) */
FT_TRACE_DEF( ttmtx ) /* metrics-related tables (ttmtx.c) */
FT_TRACE_DEF( ttpost ) /* PS table processing (ttpost.c) */
FT_TRACE_DEF( ttsbit ) /* TrueType sbit handling (ttsbit.c) */
FT_TRACE_DEF( ttbdf ) /* TrueType embedded BDF (ttbdf.c) */
/* TrueType driver components */
FT_TRACE_DEF( ttdriver ) /* TT font driver (ttdriver.c) */
@ -58,6 +62,7 @@ FT_TRACE_DEF( ttpload ) /* TT data/program loader (ttpload.c) */
FT_TRACE_DEF( ttgxvar ) /* TrueType GX var handler (ttgxvar.c) */
/* Type 1 driver components */
FT_TRACE_DEF( t1afm )
FT_TRACE_DEF( t1driver )
FT_TRACE_DEF( t1gload )
FT_TRACE_DEF( t1hint )

1
headers/libs/freetype2/freetype/internal/internal.h
View File

@ -25,6 +25,7 @@
#define FT_INTERNAL_OBJECTS_H <freetype/internal/ftobjs.h>
#define FT_INTERNAL_PIC_H <freetype/internal/ftpic.h>
#define FT_INTERNAL_STREAM_H <freetype/internal/ftstream.h>
#define FT_INTERNAL_MEMORY_H <freetype/internal/ftmemory.h>
#define FT_INTERNAL_DEBUG_H <freetype/internal/ftdebug.h>

13
headers/libs/freetype2/freetype/internal/psaux.h
View File

@ -360,7 +360,7 @@ FT_BEGIN_HEADER
FT_Error
(*to_bytes)( PS_Parser parser,
FT_Byte* bytes,
FT_Long max_bytes,
FT_Offset max_bytes,
FT_Long* pnum_bytes,
FT_Bool delimiters );
@ -533,8 +533,6 @@ FT_BEGIN_HEADER
/* */
/* max_contours :: Maximal number of contours in builder outline. */
/* */
/* last :: The last point position. */
/* */
/* pos_x :: The horizontal translation (if composite glyph). */
/* */
/* pos_y :: The vertical translation (if composite glyph). */
@ -567,8 +565,6 @@ FT_BEGIN_HEADER
FT_Outline* base;
FT_Outline* current;
FT_Vector last;
FT_Pos pos_x;
FT_Pos pos_y;
@ -579,7 +575,6 @@ FT_BEGIN_HEADER
T1_ParseState parse_state;
FT_Bool load_points;
FT_Bool no_recurse;
FT_Bool shift;
FT_Bool metrics_only;
@ -694,9 +689,11 @@ FT_BEGIN_HEADER
T1_Decoder_Callback parse_callback;
T1_Decoder_FuncsRec funcs;
FT_Int* buildchar;
FT_Long* buildchar;
FT_UInt len_buildchar;
FT_Bool seac;
} T1_DecoderRec;
@ -758,7 +755,7 @@ FT_BEGIN_HEADER
FT_Int
(*get_index)( const char* name,
FT_UInt len,
FT_Offset len,
void* user_data );
void* user_data;

47
headers/libs/freetype2/freetype/internal/pshints.h
View File

@ -6,7 +6,7 @@
/* recorders (specification only). These are used to support native */
/* T1/T2 hints in the `type1', `cid', and `cff' font drivers. */
/* */
/* Copyright 2001, 2002, 2003, 2005, 2006, 2007 by */
/* Copyright 2001, 2002, 2003, 2005, 2006, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -157,7 +157,8 @@ FT_BEGIN_HEADER
* 0 for horizontal stems (hstem), 1 for vertical ones (vstem).
*
* coords ::
* Array of 2 integers, used as (position,length) stem descriptor.
* Array of 2 coordinates in 16.16 format, used as (position,length)
* stem descriptor.
*
* @note:
* Use vertical coordinates (y) for horizontal stems (dim=0). Use
@ -175,9 +176,9 @@ FT_BEGIN_HEADER
*
*/
typedef void
(*T1_Hints_SetStemFunc)( T1_Hints hints,
FT_UInt dimension,
FT_Long* coords );
(*T1_Hints_SetStemFunc)( T1_Hints hints,
FT_UInt dimension,
FT_Fixed* coords );
/*************************************************************************
@ -197,8 +198,8 @@ FT_BEGIN_HEADER
* 0 for horizontal stems, 1 for vertical ones.
*
* coords ::
* An array of 6 integers, holding 3 (position,length) pairs for the
* counter-controlled stems.
* An array of 6 values in 16.16 format, holding 3 (position,length)
* pairs for the counter-controlled stems.
*
* @note:
* Use vertical coordinates (y) for horizontal stems (dim=0). Use
@ -209,9 +210,9 @@ FT_BEGIN_HEADER
*
*/
typedef void
(*T1_Hints_SetStem3Func)( T1_Hints hints,
FT_UInt dimension,
FT_Long* coords );
(*T1_Hints_SetStem3Func)( T1_Hints hints,
FT_UInt dimension,
FT_Fixed* coords );
/*************************************************************************
@ -446,7 +447,7 @@ FT_BEGIN_HEADER
* The number of stems.
*
* coords ::
* An array of `count' (position,length) pairs.
* An array of `count' (position,length) pairs in 16.16 format.
*
* @note:
* Use vertical coordinates (y) for horizontal stems (dim=0). Use
@ -678,6 +679,30 @@ FT_BEGIN_HEADER
typedef PSHinter_Interface* PSHinter_Service;
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_PSHINTER_INTERFACE(class_, get_globals_funcs_, \
get_t1_funcs_, get_t2_funcs_) \
static const PSHinter_Interface class_ = \
{ \
get_globals_funcs_, get_t1_funcs_, get_t2_funcs_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_PSHINTER_INTERFACE(class_, get_globals_funcs_, \
get_t1_funcs_, get_t2_funcs_) \
void \
FT_Init_Class_##class_( FT_Library library, \
PSHinter_Interface* clazz) \
{ \
FT_UNUSED(library); \
clazz->get_globals_funcs = get_globals_funcs_; \
clazz->get_t1_funcs = get_t1_funcs_; \
clazz->get_t2_funcs = get_t2_funcs_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
FT_END_HEADER

20
headers/libs/freetype2/freetype/internal/services/svbdf.h
View File

@ -45,6 +45,26 @@ FT_BEGIN_HEADER
FT_BDF_GetPropertyFunc get_property;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_BDFRec(class_, get_charset_id_, get_property_) \
static const FT_Service_BDFRec class_ = \
{ \
get_charset_id_, get_property_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_BDFRec(class_, get_charset_id_, get_property_) \
void \
FT_Init_Class_##class_( FT_Service_BDFRec* clazz ) \
{ \
clazz->get_charset_id = get_charset_id_; \
clazz->get_property = get_property_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

25
headers/libs/freetype2/freetype/internal/services/svcid.h
View File

@ -46,6 +46,31 @@ FT_BEGIN_HEADER
FT_CID_GetCIDFromGlyphIndexFunc get_cid_from_glyph_index;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_CIDREC(class_, get_ros_, \
get_is_cid_, get_cid_from_glyph_index_ ) \
static const FT_Service_CIDRec class_ = \
{ \
get_ros_, get_is_cid_, get_cid_from_glyph_index_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_CIDREC(class_, get_ros_, \
get_is_cid_, get_cid_from_glyph_index_ ) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_Service_CIDRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->get_ros = get_ros_; \
clazz->get_is_cid = get_is_cid_; \
clazz->get_cid_from_glyph_index = get_cid_from_glyph_index_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

22
headers/libs/freetype2/freetype/internal/services/svgldict.h
View File

@ -51,6 +51,28 @@ FT_BEGIN_HEADER
FT_GlyphDict_NameIndexFunc name_index; /* optional */
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_GLYPHDICTREC(class_, get_name_, name_index_) \
static const FT_Service_GlyphDictRec class_ = \
{ \
get_name_, name_index_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_GLYPHDICTREC(class_, get_name_, name_index_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_Service_GlyphDictRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->get_name = get_name_; \
clazz->name_index = name_index_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

25
headers/libs/freetype2/freetype/internal/services/svmm.h
View File

@ -68,6 +68,31 @@ FT_BEGIN_HEADER
FT_Set_Var_Design_Func set_var_design;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_MULTIMASTERSREC(class_, get_mm_, set_mm_design_, \
set_mm_blend_, get_mm_var_, set_var_design_) \
static const FT_Service_MultiMastersRec class_ = \
{ \
get_mm_, set_mm_design_, set_mm_blend_, get_mm_var_, set_var_design_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_MULTIMASTERSREC(class_, get_mm_, set_mm_design_, \
set_mm_blend_, get_mm_var_, set_var_design_) \
void \
FT_Init_Class_##class_( FT_Service_MultiMastersRec* clazz ) \
{ \
clazz->get_mm = get_mm_; \
clazz->set_mm_design = set_mm_design_; \
clazz->set_mm_blend = set_mm_blend_; \
clazz->get_mm_var = get_mm_var_; \
clazz->set_var_design = set_var_design_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

21
headers/libs/freetype2/freetype/internal/services/svpostnm.h
View File

@ -46,6 +46,27 @@ FT_BEGIN_HEADER
FT_PsName_GetFunc get_ps_font_name;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_PSFONTNAMEREC(class_, get_ps_font_name_) \
static const FT_Service_PsFontNameRec class_ = \
{ \
get_ps_font_name_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_PSFONTNAMEREC(class_, get_ps_font_name_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_Service_PsFontNameRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->get_ps_font_name = get_ps_font_name_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

37
headers/libs/freetype2/freetype/internal/services/svpscmap.h
View File

@ -98,7 +98,7 @@ FT_BEGIN_HEADER
(*PS_Unicodes_CharIndexFunc)( PS_Unicodes unicodes,
FT_UInt32 unicode );
typedef FT_ULong
typedef FT_UInt32
(*PS_Unicodes_CharNextFunc)( PS_Unicodes unicodes,
FT_UInt32 *unicode );
@ -117,6 +117,41 @@ FT_BEGIN_HEADER
const unsigned short* adobe_expert_encoding;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_PSCMAPSREC(class_, unicode_value_, unicodes_init_, \
unicodes_char_index_, unicodes_char_next_, macintosh_name_, \
adobe_std_strings_, adobe_std_encoding_, adobe_expert_encoding_) \
static const FT_Service_PsCMapsRec class_ = \
{ \
unicode_value_, unicodes_init_, \
unicodes_char_index_, unicodes_char_next_, macintosh_name_, \
adobe_std_strings_, adobe_std_encoding_, adobe_expert_encoding_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_PSCMAPSREC(class_, unicode_value_, unicodes_init_, \
unicodes_char_index_, unicodes_char_next_, macintosh_name_, \
adobe_std_strings_, adobe_std_encoding_, adobe_expert_encoding_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_Service_PsCMapsRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->unicode_value = unicode_value_; \
clazz->unicodes_init = unicodes_init_; \
clazz->unicodes_char_index = unicodes_char_index_; \
clazz->unicodes_char_next = unicodes_char_next_; \
clazz->macintosh_name = macintosh_name_; \
clazz->adobe_std_strings = adobe_std_strings_; \
clazz->adobe_std_encoding = adobe_std_encoding_; \
clazz->adobe_expert_encoding = adobe_expert_encoding_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

27
headers/libs/freetype2/freetype/internal/services/svpsinfo.h
View File

@ -53,6 +53,33 @@ FT_BEGIN_HEADER
PS_GetFontPrivateFunc ps_get_font_private;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_PSINFOREC(class_, get_font_info_, \
ps_get_font_extra_, has_glyph_names_, get_font_private_) \
static const FT_Service_PsInfoRec class_ = \
{ \
get_font_info_, ps_get_font_extra_, has_glyph_names_, \
get_font_private_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_PSINFOREC(class_, get_font_info_, \
ps_get_font_extra_, has_glyph_names_, get_font_private_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_Service_PsInfoRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->ps_get_font_info = get_font_info_; \
clazz->ps_get_font_extra = ps_get_font_extra_; \
clazz->ps_has_glyph_names = has_glyph_names_; \
clazz->ps_get_font_private = get_font_private_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

22
headers/libs/freetype2/freetype/internal/services/svsfnt.h
View File

@ -58,6 +58,7 @@ FT_BEGIN_HEADER
(*FT_SFNT_TableInfoFunc)( FT_Face face,
FT_UInt idx,
FT_ULong *tag,
FT_ULong *offset,
FT_ULong *length );
@ -68,6 +69,27 @@ FT_BEGIN_HEADER
FT_SFNT_TableInfoFunc table_info;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_SFNT_TABLEREC(class_, load_, get_, info_) \
static const FT_Service_SFNT_TableRec class_ = \
{ \
load_, get_, info_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_SFNT_TABLEREC(class_, load_, get_, info_) \
void \
FT_Init_Class_##class_( FT_Service_SFNT_TableRec* clazz ) \
{ \
clazz->load_table = load_; \
clazz->get_table = get_; \
clazz->table_info = info_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

23
headers/libs/freetype2/freetype/internal/services/svttcmap.h
View File

@ -1,6 +1,6 @@
/***************************************************************************/
/* */
/* svsttcmap.h */
/* svttcmap.h */
/* */
/* The FreeType TrueType/sfnt cmap extra information service. */
/* */
@ -74,6 +74,27 @@ FT_BEGIN_HEADER
TT_CMap_Info_GetFunc get_cmap_info;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_TTCMAPSREC(class_, get_cmap_info_) \
static const FT_Service_TTCMapsRec class_ = \
{ \
get_cmap_info_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_TTCMAPSREC(class_, get_cmap_info_) \
void \
FT_Init_Class_##class_( FT_Library library, \
FT_Service_TTCMapsRec* clazz) \
{ \
FT_UNUSED(library); \
clazz->get_cmap_info = get_cmap_info_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

19
headers/libs/freetype2/freetype/internal/services/svttglyf.h
View File

@ -37,6 +37,25 @@ FT_BEGIN_HEADER
TT_Glyf_GetLocationFunc get_location;
};
#ifndef FT_CONFIG_OPTION_PIC
#define FT_DEFINE_SERVICE_TTGLYFREC(class_, get_location_ ) \
static const FT_Service_TTGlyfRec class_ = \
{ \
get_location_ \
};
#else /* FT_CONFIG_OPTION_PIC */
#define FT_DEFINE_SERVICE_TTGLYFREC(class_, get_location_ ) \
void \
FT_Init_Class_##class_( FT_Service_TTGlyfRec* clazz ) \
{ \
clazz->get_location = get_location_; \
}
#endif /* FT_CONFIG_OPTION_PIC */
/* */

135
headers/libs/freetype2/freetype/internal/sfnt.h
View File

@ -753,6 +753,141 @@ FT_BEGIN_HEADER
/* transitional */
typedef SFNT_Interface* SFNT_Service;
#ifndef FT_CONFIG_OPTION_PIC
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
#define FT_DEFINE_DRIVERS_OLD_INTERNAL(a) \
a,
#else
#define FT_DEFINE_DRIVERS_OLD_INTERNAL(a)
#endif
#define FT_INTERNAL(a) \
a,
#define FT_DEFINE_SFNT_INTERFACE(class_, \
goto_table_, init_face_, load_face_, done_face_, get_interface_, \
load_any_, load_sfnt_header_, load_directory_, load_head_, \
load_hhea_, load_cmap_, load_maxp_, load_os2_, load_post_, \
load_name_, free_name_, load_hdmx_stub_, free_hdmx_stub_, \
load_kern_, load_gasp_, load_pclt_, load_bhed_, \
set_sbit_strike_stub_, load_sbits_stub_, find_sbit_image_, \
load_sbit_metrics_, load_sbit_image_, free_sbits_stub_, \
get_psname_, free_psnames_, load_charmap_stub_, free_charmap_stub_, \
get_kerning_, load_font_dir_, load_hmtx_, load_eblc_, free_eblc_, \
set_sbit_strike_, load_strike_metrics_, get_metrics_ ) \
static const SFNT_Interface class_ = \
{ \
FT_INTERNAL(goto_table_) \
FT_INTERNAL(init_face_) \
FT_INTERNAL(load_face_) \
FT_INTERNAL(done_face_) \
FT_INTERNAL(get_interface_) \
FT_INTERNAL(load_any_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sfnt_header_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_directory_) \
FT_INTERNAL(load_head_) \
FT_INTERNAL(load_hhea_) \
FT_INTERNAL(load_cmap_) \
FT_INTERNAL(load_maxp_) \
FT_INTERNAL(load_os2_) \
FT_INTERNAL(load_post_) \
FT_INTERNAL(load_name_) \
FT_INTERNAL(free_name_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_hdmx_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(free_hdmx_stub_) \
FT_INTERNAL(load_kern_) \
FT_INTERNAL(load_gasp_) \
FT_INTERNAL(load_pclt_) \
FT_INTERNAL(load_bhed_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(set_sbit_strike_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbits_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(find_sbit_image_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbit_metrics_) \
FT_INTERNAL(load_sbit_image_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(free_sbits_stub_) \
FT_INTERNAL(get_psname_) \
FT_INTERNAL(free_psnames_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_charmap_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(free_charmap_stub_) \
FT_INTERNAL(get_kerning_) \
FT_INTERNAL(load_font_dir_) \
FT_INTERNAL(load_hmtx_) \
FT_INTERNAL(load_eblc_) \
FT_INTERNAL(free_eblc_) \
FT_INTERNAL(set_sbit_strike_) \
FT_INTERNAL(load_strike_metrics_) \
FT_INTERNAL(get_metrics_) \
};
#else /* FT_CONFIG_OPTION_PIC */
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
#define FT_DEFINE_DRIVERS_OLD_INTERNAL(a, a_) \
clazz->a = a_;
#else
#define FT_DEFINE_DRIVERS_OLD_INTERNAL(a, a_)
#endif
#define FT_INTERNAL(a, a_) \
clazz->a = a_;
#define FT_DEFINE_SFNT_INTERFACE(class_, \
goto_table_, init_face_, load_face_, done_face_, get_interface_, \
load_any_, load_sfnt_header_, load_directory_, load_head_, \
load_hhea_, load_cmap_, load_maxp_, load_os2_, load_post_, \
load_name_, free_name_, load_hdmx_stub_, free_hdmx_stub_, \
load_kern_, load_gasp_, load_pclt_, load_bhed_, \
set_sbit_strike_stub_, load_sbits_stub_, find_sbit_image_, \
load_sbit_metrics_, load_sbit_image_, free_sbits_stub_, \
get_psname_, free_psnames_, load_charmap_stub_, free_charmap_stub_, \
get_kerning_, load_font_dir_, load_hmtx_, load_eblc_, free_eblc_, \
set_sbit_strike_, load_strike_metrics_, get_metrics_ ) \
void \
FT_Init_Class_##class_( FT_Library library, SFNT_Interface* clazz ) \
{ \
FT_UNUSED(library); \
FT_INTERNAL(goto_table,goto_table_) \
FT_INTERNAL(init_face,init_face_) \
FT_INTERNAL(load_face,load_face_) \
FT_INTERNAL(done_face,done_face_) \
FT_INTERNAL(get_interface,get_interface_) \
FT_INTERNAL(load_any,load_any_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sfnt_header,load_sfnt_header_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_directory,load_directory_) \
FT_INTERNAL(load_head,load_head_) \
FT_INTERNAL(load_hhea,load_hhea_) \
FT_INTERNAL(load_cmap,load_cmap_) \
FT_INTERNAL(load_maxp,load_maxp_) \
FT_INTERNAL(load_os2,load_os2_) \
FT_INTERNAL(load_post,load_post_) \
FT_INTERNAL(load_name,load_name_) \
FT_INTERNAL(free_name,free_name_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_hdmx_stub,load_hdmx_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(free_hdmx_stub,free_hdmx_stub_) \
FT_INTERNAL(load_kern,load_kern_) \
FT_INTERNAL(load_gasp,load_gasp_) \
FT_INTERNAL(load_pclt,load_pclt_) \
FT_INTERNAL(load_bhed,load_bhed_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(set_sbit_strike_stub,set_sbit_strike_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbits_stub,load_sbits_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(find_sbit_image,find_sbit_image_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_sbit_metrics,load_sbit_metrics_) \
FT_INTERNAL(load_sbit_image,load_sbit_image_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(free_sbits_stub,free_sbits_stub_) \
FT_INTERNAL(get_psname,get_psname_) \
FT_INTERNAL(free_psnames,free_psnames_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(load_charmap_stub,load_charmap_stub_) \
FT_DEFINE_DRIVERS_OLD_INTERNAL(free_charmap_stub,free_charmap_stub_) \
FT_INTERNAL(get_kerning,get_kerning_) \
FT_INTERNAL(load_font_dir,load_font_dir_) \
FT_INTERNAL(load_hmtx,load_hmtx_) \
FT_INTERNAL(load_eblc,load_eblc_) \
FT_INTERNAL(free_eblc,free_eblc_) \
FT_INTERNAL(set_sbit_strike,set_sbit_strike_) \
FT_INTERNAL(load_strike_metrics,load_strike_metrics_) \
FT_INTERNAL(get_metrics,get_metrics_) \
}
#endif /* FT_CONFIG_OPTION_PIC */
FT_END_HEADER

6
headers/libs/freetype2/freetype/internal/t1types.h
View File

@ -58,7 +58,9 @@ FT_BEGIN_HEADER
/* */
/* code_first :: The lowest valid character code in the encoding. */
/* */
/* code_last :: The highest valid character code in the encoding. */
/* code_last :: The highest valid character code in the encoding */
/* + 1. When equal to code_first there are no valid */
/* character codes. */
/* */
/* char_index :: An array of corresponding glyph indices. */
/* */
@ -230,7 +232,7 @@ FT_BEGIN_HEADER
/* undocumented, optional: has the same meaning as len_buildchar */
/* for Type 2 fonts; manipulated by othersubrs 19, 24, and 25 */
FT_UInt len_buildchar;
FT_Int* buildchar;
FT_Long* buildchar;
/* since version 2.1 - interface to PostScript hinter */
const void* pshinter;

4
headers/libs/freetype2/freetype/internal/tttypes.h
View File

@ -902,7 +902,7 @@ FT_BEGIN_HEADER
FT_Byte* table;
FT_Byte* table_end;
FT_Byte* strings;
FT_UInt32 strings_size;
FT_ULong strings_size;
FT_UInt num_strikes;
FT_Bool loaded;
@ -1401,7 +1401,7 @@ FT_BEGIN_HEADER
FT_Byte* vert_metrics;
FT_ULong vert_metrics_size;
FT_UInt num_locations;
FT_ULong num_locations; /* in broken TTF, gid > 0xFFFF */
FT_Byte* glyph_locations;
FT_Byte* hdmx_table;

71
src/libs/freetype2/autofit/afcjk.c
View File

@ -4,7 +4,7 @@
/* */
/* Auto-fitter hinting routines for CJK script (body). */
/* */
/* Copyright 2006, 2007, 2008 by */
/* Copyright 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -58,9 +58,12 @@
if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
face->charmap = NULL;
/* latin's version would suffice */
af_latin_metrics_init_widths( metrics, face, 0x7530 );
else
{
/* latin's version would suffice */
af_latin_metrics_init_widths( metrics, face, 0x7530 );
af_latin_metrics_check_digits( metrics, face );
}
FT_Set_Charmap( face, oldmap );
@ -1017,7 +1020,7 @@
AF_AxisHints axis = &hints->axis[dim];
AF_Edge edges = axis->edges;
AF_Edge edge_limit = edges + axis->num_edges;
FT_Int n_edges;
FT_PtrDist n_edges;
AF_Edge edge;
AF_Edge anchor = 0;
FT_Pos delta = 0;
@ -1441,35 +1444,33 @@
static const AF_Script_UniRangeRec af_cjk_uniranges[] =
{
#if 0
{ 0x0100UL, 0xFFFFUL }, /* why this? */
AF_UNIRANGE_REC( 0x0100UL, 0xFFFFUL ), /* why this? */
#endif
{ 0x2E80UL, 0x2EFFUL }, /* CJK Radicals Supplement */
{ 0x2F00UL, 0x2FDFUL }, /* Kangxi Radicals */
{ 0x3000UL, 0x303FUL }, /* CJK Symbols and Punctuation */
{ 0x3040UL, 0x309FUL }, /* Hiragana */
{ 0x30A0UL, 0x30FFUL }, /* Katakana */
{ 0x3100UL, 0x312FUL }, /* Bopomofo */
{ 0x3130UL, 0x318FUL }, /* Hangul Compatibility Jamo */
{ 0x31A0UL, 0x31BFUL }, /* Bopomofo Extended */
{ 0x31C0UL, 0x31EFUL }, /* CJK Strokes */
{ 0x31F0UL, 0x31FFUL }, /* Katakana Phonetic Extensions */
{ 0x3200UL, 0x32FFUL }, /* Enclosed CJK Letters and Months */
{ 0x3300UL, 0x33FFUL }, /* CJK Compatibility */
{ 0x3400UL, 0x4DBFUL }, /* CJK Unified Ideographs Extension A */
{ 0x4DC0UL, 0x4DFFUL }, /* Yijing Hexagram Symbols */
{ 0x4E00UL, 0x9FFFUL }, /* CJK Unified Ideographs */
{ 0xF900UL, 0xFAFFUL }, /* CJK Compatibility Ideographs */
{ 0xFE30UL, 0xFE4FUL }, /* CJK Compatibility Forms */
{ 0xFF00UL, 0xFFEFUL }, /* Halfwidth and Fullwidth Forms */
{ 0x20000UL, 0x2A6DFUL }, /* CJK Unified Ideographs Extension B */
{ 0x2F800UL, 0x2FA1FUL }, /* CJK Compatibility Ideographs Supplement */
{ 0UL, 0UL }
AF_UNIRANGE_REC( 0x2E80UL, 0x2EFFUL ), /* CJK Radicals Supplement */
AF_UNIRANGE_REC( 0x2F00UL, 0x2FDFUL ), /* Kangxi Radicals */
AF_UNIRANGE_REC( 0x3000UL, 0x303FUL ), /* CJK Symbols and Punctuation */
AF_UNIRANGE_REC( 0x3040UL, 0x309FUL ), /* Hiragana */
AF_UNIRANGE_REC( 0x30A0UL, 0x30FFUL ), /* Katakana */
AF_UNIRANGE_REC( 0x3100UL, 0x312FUL ), /* Bopomofo */
AF_UNIRANGE_REC( 0x3130UL, 0x318FUL ), /* Hangul Compatibility Jamo */
AF_UNIRANGE_REC( 0x31A0UL, 0x31BFUL ), /* Bopomofo Extended */
AF_UNIRANGE_REC( 0x31C0UL, 0x31EFUL ), /* CJK Strokes */
AF_UNIRANGE_REC( 0x31F0UL, 0x31FFUL ), /* Katakana Phonetic Extensions */
AF_UNIRANGE_REC( 0x3200UL, 0x32FFUL ), /* Enclosed CJK Letters and Months */
AF_UNIRANGE_REC( 0x3300UL, 0x33FFUL ), /* CJK Compatibility */
AF_UNIRANGE_REC( 0x3400UL, 0x4DBFUL ), /* CJK Unified Ideographs Extension A */
AF_UNIRANGE_REC( 0x4DC0UL, 0x4DFFUL ), /* Yijing Hexagram Symbols */
AF_UNIRANGE_REC( 0x4E00UL, 0x9FFFUL ), /* CJK Unified Ideographs */
AF_UNIRANGE_REC( 0xF900UL, 0xFAFFUL ), /* CJK Compatibility Ideographs */
AF_UNIRANGE_REC( 0xFE30UL, 0xFE4FUL ), /* CJK Compatibility Forms */
AF_UNIRANGE_REC( 0xFF00UL, 0xFFEFUL ), /* Halfwidth and Fullwidth Forms */
AF_UNIRANGE_REC( 0x20000UL, 0x2A6DFUL ), /* CJK Unified Ideographs Extension B */
AF_UNIRANGE_REC( 0x2F800UL, 0x2FA1FUL ), /* CJK Compatibility Ideographs Supplement */
AF_UNIRANGE_REC( 0UL, 0UL )
};
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_cjk_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_cjk_script_class,
AF_SCRIPT_CJK,
af_cjk_uniranges,
@ -1481,19 +1482,17 @@
(AF_Script_InitHintsFunc) af_cjk_hints_init,
(AF_Script_ApplyHintsFunc) af_cjk_hints_apply
};
)
#else /* !AF_CONFIG_OPTION_CJK */
static const AF_Script_UniRangeRec af_cjk_uniranges[] =
{
{ 0, 0 }
AF_UNIRANGE_REC( 0UL, 0UL )
};
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_cjk_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_cjk_script_class,
AF_SCRIPT_CJK,
af_cjk_uniranges,
@ -1505,7 +1504,7 @@
(AF_Script_InitHintsFunc) NULL,
(AF_Script_ApplyHintsFunc) NULL
};
)
#endif /* !AF_CONFIG_OPTION_CJK */

3
src/libs/freetype2/autofit/afcjk.h
View File

@ -27,8 +27,7 @@ FT_BEGIN_HEADER
/* the CJK-specific script class */
FT_CALLBACK_TABLE const AF_ScriptClassRec
af_cjk_script_class;
AF_DECLARE_SCRIPT_CLASS(af_cjk_script_class)
FT_LOCAL( FT_Error )

6
src/libs/freetype2/autofit/afdummy.c
View File

@ -42,9 +42,7 @@
}
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_dummy_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_dummy_script_class,
AF_SCRIPT_NONE,
NULL,
@ -56,7 +54,7 @@
(AF_Script_InitHintsFunc) af_dummy_hints_init,
(AF_Script_ApplyHintsFunc) af_dummy_hints_apply
};
)
/* END */

3
src/libs/freetype2/autofit/afdummy.h
View File

@ -29,8 +29,7 @@ FT_BEGIN_HEADER
* be performed. This is the default for non-latin glyphs!
*/
FT_CALLBACK_TABLE const AF_ScriptClassRec
af_dummy_script_class;
AF_DECLARE_SCRIPT_CLASS(af_dummy_script_class)
/* */

63
src/libs/freetype2/autofit/afglobal.c
View File

@ -4,7 +4,7 @@
/* */
/* Auto-fitter routines to compute global hinting values (body). */
/* */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -21,6 +21,7 @@
#include "aflatin.h"
#include "afcjk.h"
#include "afindic.h"
#include "afpic.h"
#include "aferrors.h"
@ -28,6 +29,11 @@
#include "aflatin2.h"
#endif
#ifndef FT_CONFIG_OPTION_PIC
/* when updating this table, don't forget to update
AF_SCRIPT_CLASSES_COUNT and autofit_module_class_pic_init */
/* populate this list when you add new scripts */
static AF_ScriptClass const af_script_classes[] =
{
@ -41,10 +47,14 @@
NULL /* do not remove */
};
#endif /* FT_CONFIG_OPTION_PIC */
/* index of default script in `af_script_classes' */
#define AF_SCRIPT_LIST_DEFAULT 2
/* indicates an uncovered glyph */
#define AF_SCRIPT_LIST_NONE 255
/* a bit mask indicating an uncovered glyph */
#define AF_SCRIPT_LIST_NONE 0x7F
/* if this flag is set, we have an ASCII digit */
#define AF_DIGIT 0x80
/*
@ -55,7 +65,7 @@
typedef struct AF_FaceGlobalsRec_
{
FT_Face face;
FT_UInt glyph_count; /* same as face->num_glyphs */
FT_Long glyph_count; /* same as face->num_glyphs */
FT_Byte* glyph_scripts;
AF_ScriptMetrics metrics[AF_SCRIPT_MAX];
@ -72,7 +82,7 @@
FT_Face face = globals->face;
FT_CharMap old_charmap = face->charmap;
FT_Byte* gscripts = globals->glyph_scripts;
FT_UInt ss;
FT_UInt ss, i;
/* the value 255 means `uncovered glyph' */
@ -92,9 +102,9 @@
}
/* scan each script in a Unicode charmap */
for ( ss = 0; af_script_classes[ss]; ss++ )
for ( ss = 0; AF_SCRIPT_CLASSES_GET[ss]; ss++ )
{
AF_ScriptClass clazz = af_script_classes[ss];
AF_ScriptClass clazz = AF_SCRIPT_CLASSES_GET[ss];
AF_Script_UniRange range;
@ -114,7 +124,7 @@
gindex = FT_Get_Char_Index( face, charcode );
if ( gindex != 0 &&
gindex < globals->glyph_count &&
gindex < (FT_ULong)globals->glyph_count &&
gscripts[gindex] == AF_SCRIPT_LIST_NONE )
{
gscripts[gindex] = (FT_Byte)ss;
@ -127,7 +137,7 @@
if ( gindex == 0 || charcode > range->last )
break;
if ( gindex < globals->glyph_count &&
if ( gindex < (FT_ULong)globals->glyph_count &&
gscripts[gindex] == AF_SCRIPT_LIST_NONE )
{
gscripts[gindex] = (FT_Byte)ss;
@ -136,13 +146,23 @@
}
}
/* mark ASCII digits */
for ( i = 0x30; i <= 0x39; i++ )
{
FT_UInt gindex = FT_Get_Char_Index( face, i );
if ( gindex != 0 && gindex < (FT_ULong)globals->glyph_count )
gscripts[gindex] |= AF_DIGIT;
}
Exit:
/*
* By default, all uncovered glyphs are set to the latin script.
* XXX: Shouldn't we disable hinting or do something similar?
*/
{
FT_UInt nn;
FT_Long nn;
for ( nn = 0; nn < globals->glyph_count; nn++ )
@ -201,7 +221,7 @@
{
if ( globals->metrics[nn] )
{
AF_ScriptClass clazz = af_script_classes[nn];
AF_ScriptClass clazz = AF_SCRIPT_CLASSES_GET[nn];
FT_ASSERT( globals->metrics[nn]->clazz == clazz );
@ -232,12 +252,12 @@
FT_UInt gidx;
AF_ScriptClass clazz;
FT_UInt script = options & 15;
const FT_UInt script_max = sizeof ( af_script_classes ) /
sizeof ( af_script_classes[0] );
const FT_Offset script_max = sizeof ( AF_SCRIPT_CLASSES_GET ) /
sizeof ( AF_SCRIPT_CLASSES_GET[0] );
FT_Error error = AF_Err_Ok;
if ( gindex >= globals->glyph_count )
if ( gindex >= (FT_ULong)globals->glyph_count )
{
error = AF_Err_Invalid_Argument;
goto Exit;
@ -245,9 +265,9 @@
gidx = script;
if ( gidx == 0 || gidx + 1 >= script_max )
gidx = globals->glyph_scripts[gindex];
gidx = globals->glyph_scripts[gindex] & AF_SCRIPT_LIST_NONE;
clazz = af_script_classes[gidx];
clazz = AF_SCRIPT_CLASSES_GET[gidx];
if ( script == 0 )
script = clazz->script;
@ -286,4 +306,15 @@
}
FT_LOCAL_DEF( FT_Bool )
af_face_globals_is_digit( AF_FaceGlobals globals,
FT_UInt gindex )
{
if ( gindex < (FT_ULong)globals->glyph_count )
return (FT_Bool)( globals->glyph_scripts[gindex] & AF_DIGIT );
return (FT_Bool)0;
}
/* END */

8
src/libs/freetype2/autofit/afglobal.h
View File

@ -5,7 +5,7 @@
/* Auto-fitter routines to compute global hinting values */
/* (specification). */
/* */
/* Copyright 2003, 2004, 2005, 2007 by */
/* Copyright 2003, 2004, 2005, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -56,7 +56,11 @@ FT_BEGIN_HEADER
FT_LOCAL( void )
af_face_globals_free( AF_FaceGlobals globals );
/* */
FT_LOCAL_DEF( FT_Bool )
af_face_globals_is_digit( AF_FaceGlobals globals,
FT_UInt gindex );
/* */
FT_END_HEADER

11
src/libs/freetype2/autofit/afhints.c
View File

@ -34,7 +34,7 @@
{
FT_Int old_max = axis->max_segments;
FT_Int new_max = old_max;
FT_Int big_max = FT_INT_MAX / sizeof ( *segment );
FT_Int big_max = (FT_Int)( FT_INT_MAX / sizeof ( *segment ) );
if ( old_max >= big_max )
@ -77,7 +77,7 @@
{
FT_Int old_max = axis->max_edges;
FT_Int new_max = old_max;
FT_Int big_max = FT_INT_MAX / sizeof ( *edge );
FT_Int big_max = (FT_Int)( FT_INT_MAX / sizeof ( *edge ) );
if ( old_max >= big_max )
@ -645,6 +645,7 @@
FT_Int contour_index = 0;
FT_UNUSED( first );
for ( point = points; point < point_limit; point++, vec++, tag++ )
{
point->fx = (FT_Short)vec->x;
@ -940,8 +941,8 @@
}
{
FT_UInt min, max, mid;
FT_Pos fpos;
FT_PtrDist min, max, mid;
FT_Pos fpos;
/* find enclosing edges */
@ -952,7 +953,7 @@
/* for small edge counts, a linear search is better */
if ( max <= 8 )
{
FT_UInt nn;
FT_PtrDist nn;
for ( nn = 0; nn < max; nn++ )
if ( edges[nn].fpos >= u )

18
src/libs/freetype2/autofit/afindic.c
View File

@ -81,16 +81,14 @@
static const AF_Script_UniRangeRec af_indic_uniranges[] =
{
#if 0
{ 0x0100, 0xFFFF }, /* why this? */
AF_UNIRANGE_REC( 0x0100UL, 0xFFFFUL ), /* why this? */
#endif
{ 0x0900, 0x0DFF}, /* Indic Range */
{ 0, 0 }
AF_UNIRANGE_REC( 0x0900UL, 0x0DFFUL), /* Indic Range */
AF_UNIRANGE_REC( 0UL, 0UL)
};
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_indic_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_indic_script_class,
AF_SCRIPT_INDIC,
af_indic_uniranges,
@ -102,7 +100,7 @@
(AF_Script_InitHintsFunc) af_indic_hints_init,
(AF_Script_ApplyHintsFunc) af_indic_hints_apply
};
)
#else /* !AF_CONFIG_OPTION_INDIC */
@ -112,9 +110,7 @@
};
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_indic_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_indic_script_class,
AF_SCRIPT_INDIC,
af_indic_uniranges,
@ -126,7 +122,7 @@
(AF_Script_InitHintsFunc) NULL,
(AF_Script_ApplyHintsFunc) NULL
};
)
#endif /* !AF_CONFIG_OPTION_INDIC */

3
src/libs/freetype2/autofit/afindic.h
View File

@ -27,8 +27,7 @@ FT_BEGIN_HEADER
/* the Indic-specific script class */
FT_CALLBACK_TABLE const AF_ScriptClassRec
af_indic_script_class;
AF_DECLARE_SCRIPT_CLASS(af_indic_script_class)
/* */

126
src/libs/freetype2/autofit/aflatin.c
View File

@ -4,7 +4,7 @@
/* */
/* Auto-fitter hinting routines for latin script (body). */
/* */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -16,6 +16,9 @@
/***************************************************************************/
#include <ft2build.h>
#include FT_ADVANCES_H
#include "aflatin.h"
#include "aferrors.h"
@ -146,7 +149,8 @@
#define AF_LATIN_MAX_TEST_CHARACTERS 12
static const char* const af_latin_blue_chars[AF_LATIN_MAX_BLUES] =
static const char af_latin_blue_chars[AF_LATIN_MAX_BLUES]
[AF_LATIN_MAX_TEST_CHARACTERS + 1] =
{
"THEZOCQS",
"HEZLOCUS",
@ -195,7 +199,8 @@
for ( ; p < limit && *p; p++ )
{
FT_UInt glyph_index;
FT_Int best_point, best_y, best_first, best_last;
FT_Pos best_y; /* same as points.y */
FT_Int best_point, best_first, best_last;
FT_Vector* points;
FT_Bool round = 0;
@ -328,7 +333,7 @@
* we couldn't find a single glyph to compute this blue zone,
* we will simply ignore it then
*/
AF_LOG(( "empty!\n" ));
AF_LOG(( "empty\n" ));
continue;
}
@ -379,7 +384,7 @@
blue->flags |= AF_LATIN_BLUE_TOP;
/*
* The following flags is used later to adjust the y and x scales
* The following flag is used later to adjust the y and x scales
* in order to optimize the pixel grid alignment of the top of small
* letters.
*/
@ -393,6 +398,52 @@
}
FT_LOCAL_DEF( void )
af_latin_metrics_check_digits( AF_LatinMetrics metrics,
FT_Face face )
{
FT_UInt i;
FT_Bool started = 0, same_width = 1;
/* check whether all ASCII digits have the same advance width; */
/* digit `0' is 0x30 in all supported charmaps */
for ( i = 0x30; i <= 0x39; i++ )
{
FT_UInt glyph_index;
FT_Fixed advance, old_advance = 0;
glyph_index = FT_Get_Char_Index( face, i );
if ( glyph_index == 0 )
continue;
if ( FT_Get_Advance( face, glyph_index,
FT_LOAD_NO_SCALE |
FT_LOAD_NO_HINTING |
FT_LOAD_IGNORE_TRANSFORM,
&advance ) )
continue;
if ( started )
{
if ( advance != old_advance )
{
same_width = 0;
break;
}
}
else
{
old_advance = advance;
started = 1;
}
}
metrics->root.digits_have_same_width = same_width;
}
FT_LOCAL_DEF( FT_Error )
af_latin_metrics_init( AF_LatinMetrics metrics,
FT_Face face )
@ -426,6 +477,7 @@
/* For now, compute the standard width and height from the `o'. */
af_latin_metrics_init_widths( metrics, face, 'o' );
af_latin_metrics_init_blues( metrics, face );
af_latin_metrics_check_digits( metrics, face );
}
FT_Set_Charmap( face, oldmap );
@ -1567,7 +1619,7 @@
/* not hinted, appear a lot bolder or thinner than the */
/* vertical stems. */
FT_Int delta;
FT_Pos delta;
dist = ( dist + 22 ) & ~63;
@ -1651,7 +1703,7 @@
AF_AxisHints axis = &hints->axis[dim];
AF_Edge edges = axis->edges;
AF_Edge edge_limit = edges + axis->num_edges;
FT_Int n_edges;
FT_PtrDist n_edges;
AF_Edge edge;
AF_Edge anchor = 0;
FT_Int has_serifs = 0;
@ -2127,39 +2179,37 @@
static const AF_Script_UniRangeRec af_latin_uniranges[] =
{
{ 0x0020 , 0x007F }, /* Basic Latin (no control chars) */
{ 0x00A0 , 0x00FF }, /* Latin-1 Supplement (no control chars) */
{ 0x0100 , 0x017F }, /* Latin Extended-A */
{ 0x0180 , 0x024F }, /* Latin Extended-B */
{ 0x0250 , 0x02AF }, /* IPA Extensions */
{ 0x02B0 , 0x02FF }, /* Spacing Modifier Letters */
{ 0x0300 , 0x036F }, /* Combining Diacritical Marks */
{ 0x0370 , 0x03FF }, /* Greek and Coptic */
{ 0x0400 , 0x04FF }, /* Cyrillic */
{ 0x0500 , 0x052F }, /* Cyrillic Supplement */
{ 0x1D00 , 0x1D7F }, /* Phonetic Extensions */
{ 0x1D80 , 0x1DBF }, /* Phonetic Extensions Supplement */
{ 0x1DC0 , 0x1DFF }, /* Combining Diacritical Marks Supplement */
{ 0x1E00 , 0x1EFF }, /* Latin Extended Additional */
{ 0x1F00 , 0x1FFF }, /* Greek Extended */
{ 0x2000 , 0x206F }, /* General Punctuation */
{ 0x2070 , 0x209F }, /* Superscripts and Subscripts */
{ 0x20A0 , 0x20CF }, /* Currency Symbols */
{ 0x2150 , 0x218F }, /* Number Forms */
{ 0x2460 , 0x24FF }, /* Enclosed Alphanumerics */
{ 0x2C60 , 0x2C7F }, /* Latin Extended-C */
{ 0x2DE0 , 0x2DFF }, /* Cyrillic Extended-A */
{ 0xA640U , 0xA69FU }, /* Cyrillic Extended-B */
{ 0xA720U , 0xA7FFU }, /* Latin Extended-D */
{ 0xFB00U , 0xFB06U }, /* Alphab. Present. Forms (Latin Ligs) */
{ 0x1D400UL, 0x1D7FFUL }, /* Mathematical Alphanumeric Symbols */
{ 0 , 0 }
AF_UNIRANGE_REC( 0x0020UL, 0x007FUL ), /* Basic Latin (no control chars) */
AF_UNIRANGE_REC( 0x00A0UL, 0x00FFUL ), /* Latin-1 Supplement (no control chars) */
AF_UNIRANGE_REC( 0x0100UL, 0x017FUL ), /* Latin Extended-A */
AF_UNIRANGE_REC( 0x0180UL, 0x024FUL ), /* Latin Extended-B */
AF_UNIRANGE_REC( 0x0250UL, 0x02AFUL ), /* IPA Extensions */
AF_UNIRANGE_REC( 0x02B0UL, 0x02FFUL ), /* Spacing Modifier Letters */
AF_UNIRANGE_REC( 0x0300UL, 0x036FUL ), /* Combining Diacritical Marks */
AF_UNIRANGE_REC( 0x0370UL, 0x03FFUL ), /* Greek and Coptic */
AF_UNIRANGE_REC( 0x0400UL, 0x04FFUL ), /* Cyrillic */
AF_UNIRANGE_REC( 0x0500UL, 0x052FUL ), /* Cyrillic Supplement */
AF_UNIRANGE_REC( 0x1D00UL, 0x1D7FUL ), /* Phonetic Extensions */
AF_UNIRANGE_REC( 0x1D80UL, 0x1DBFUL ), /* Phonetic Extensions Supplement */
AF_UNIRANGE_REC( 0x1DC0UL, 0x1DFFUL ), /* Combining Diacritical Marks Supplement */
AF_UNIRANGE_REC( 0x1E00UL, 0x1EFFUL ), /* Latin Extended Additional */
AF_UNIRANGE_REC( 0x1F00UL, 0x1FFFUL ), /* Greek Extended */
AF_UNIRANGE_REC( 0x2000UL, 0x206FUL ), /* General Punctuation */
AF_UNIRANGE_REC( 0x2070UL, 0x209FUL ), /* Superscripts and Subscripts */
AF_UNIRANGE_REC( 0x20A0UL, 0x20CFUL ), /* Currency Symbols */
AF_UNIRANGE_REC( 0x2150UL, 0x218FUL ), /* Number Forms */
AF_UNIRANGE_REC( 0x2460UL, 0x24FFUL ), /* Enclosed Alphanumerics */
AF_UNIRANGE_REC( 0x2C60UL, 0x2C7FUL ), /* Latin Extended-C */
AF_UNIRANGE_REC( 0x2DE0UL, 0x2DFFUL ), /* Cyrillic Extended-A */
AF_UNIRANGE_REC( 0xA640UL, 0xA69FUL ), /* Cyrillic Extended-B */
AF_UNIRANGE_REC( 0xA720UL, 0xA7FFUL ), /* Latin Extended-D */
AF_UNIRANGE_REC( 0xFB00UL, 0xFB06UL ), /* Alphab. Present. Forms (Latin Ligs) */
AF_UNIRANGE_REC( 0x1D400UL, 0x1D7FFUL ), /* Mathematical Alphanumeric Symbols */
AF_UNIRANGE_REC( 0UL, 0UL )
};
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_latin_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_latin_script_class,
AF_SCRIPT_LATIN,
af_latin_uniranges,
@ -2171,7 +2221,7 @@
(AF_Script_InitHintsFunc) af_latin_hints_init,
(AF_Script_ApplyHintsFunc) af_latin_hints_apply
};
)
/* END */

9
src/libs/freetype2/autofit/aflatin.h
View File

@ -4,7 +4,7 @@
/* */
/* Auto-fitter hinting routines for latin script (specification). */
/* */
/* Copyright 2003, 2004, 2005, 2006, 2007 by */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -27,8 +27,7 @@ FT_BEGIN_HEADER
/* the latin-specific script class */
FT_CALLBACK_TABLE const AF_ScriptClassRec
af_latin_script_class;
AF_DECLARE_SCRIPT_CLASS(af_latin_script_class)
/* constants are given with units_per_em == 2048 in mind */
@ -138,6 +137,10 @@ FT_BEGIN_HEADER
FT_Face face,
FT_ULong charcode );
FT_LOCAL( void )
af_latin_metrics_check_digits( AF_LatinMetrics metrics,
FT_Face face );
/*************************************************************************/
/*************************************************************************/

144
src/libs/freetype2/autofit/aflatin2.c
View File

@ -4,7 +4,7 @@
/* */
/* Auto-fitter hinting routines for latin script (body). */
/* */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -16,6 +16,8 @@
/***************************************************************************/
#include FT_ADVANCES_H
#include "aflatin.h"
#include "aflatin2.h"
#include "aferrors.h"
@ -154,7 +156,7 @@
#define AF_LATIN_MAX_TEST_CHARACTERS 12
static const char* const af_latin2_blue_chars[AF_LATIN_MAX_BLUES] =
static const char af_latin2_blue_chars[AF_LATIN_MAX_BLUES][AF_LATIN_MAX_TEST_CHARACTERS+1] =
{
"THEZOCQS",
"HEZLOCUS",
@ -336,7 +338,7 @@
* we couldn't find a single glyph to compute this blue zone,
* we will simply ignore it then
*/
AF_LOG(( "empty!\n" ));
AF_LOG(( "empty\n" ));
continue;
}
@ -401,6 +403,52 @@
}
FT_LOCAL_DEF( void )
af_latin2_metrics_check_digits( AF_LatinMetrics metrics,
FT_Face face )
{
FT_UInt i;
FT_Bool started = 0, same_width = 1;
/* check whether all ASCII digits have the same advance width; */
/* digit `0' is 0x30 in all supported charmaps */
for ( i = 0x30; i <= 0x39; i++ )
{
FT_UInt glyph_index;
FT_Fixed advance, old_advance;
glyph_index = FT_Get_Char_Index( face, i );
if ( glyph_index == 0 )
continue;
if ( FT_Get_Advance( face, glyph_index,
FT_LOAD_NO_SCALE |
FT_LOAD_NO_HINTING |
FT_LOAD_IGNORE_TRANSFORM,
&advance ) )
continue;
if ( started )
{
if ( advance != old_advance )
{
same_width = 0;
break;
}
}
else
{
old_advance = advance;
started = 1;
}
}
metrics->root.digits_have_same_width = same_width;
}
FT_LOCAL_DEF( FT_Error )
af_latin2_metrics_init( AF_LatinMetrics metrics,
FT_Face face )
@ -434,6 +482,7 @@
/* For now, compute the standard width and height from the `o'. */
af_latin2_metrics_init_widths( metrics, face, 'o' );
af_latin2_metrics_init_blues( metrics, face );
af_latin2_metrics_check_digits( metrics, face );
}
FT_Set_Charmap( face, oldmap );
@ -1739,7 +1788,6 @@
AF_AxisHints axis = &hints->axis[dim];
AF_Edge edges = axis->edges;
AF_Edge edge_limit = edges + axis->num_edges;
FT_Int n_edges;
AF_Edge edge;
AF_Edge anchor = 0;
FT_Int has_serifs = 0;
@ -2050,54 +2098,60 @@
/* We don't handle horizontal edges since we can't easily assure that */
/* the third (lowest) stem aligns with the base line; it might end up */
/* one pixel higher or lower. */
#if 0
n_edges = edge_limit - edges;
if ( dim == AF_DIMENSION_HORZ && ( n_edges == 6 || n_edges == 12 ) )
{
AF_Edge edge1, edge2, edge3;
FT_Pos dist1, dist2, span, delta;
FT_Int n_edges = edge_limit - edges;
if ( n_edges == 6 )
if ( dim == AF_DIMENSION_HORZ && ( n_edges == 6 || n_edges == 12 ) )
{
edge1 = edges;
edge2 = edges + 2;
edge3 = edges + 4;
}
else
{
edge1 = edges + 1;
edge2 = edges + 5;
edge3 = edges + 9;
}
AF_Edge edge1, edge2, edge3;
FT_Pos dist1, dist2, span, delta;
dist1 = edge2->opos - edge1->opos;
dist2 = edge3->opos - edge2->opos;
span = dist1 - dist2;
if ( span < 0 )
span = -span;
if ( span < 8 )
{
delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
edge3->pos -= delta;
if ( edge3->link )
edge3->link->pos -= delta;
/* move the serifs along with the stem */
if ( n_edges == 12 )
if ( n_edges == 6 )
{
( edges + 8 )->pos -= delta;
( edges + 11 )->pos -= delta;
edge1 = edges;
edge2 = edges + 2;
edge3 = edges + 4;
}
else
{
edge1 = edges + 1;
edge2 = edges + 5;
edge3 = edges + 9;
}
edge3->flags |= AF_EDGE_DONE;
if ( edge3->link )
edge3->link->flags |= AF_EDGE_DONE;
dist1 = edge2->opos - edge1->opos;
dist2 = edge3->opos - edge2->opos;
span = dist1 - dist2;
if ( span < 0 )
span = -span;
if ( span < 8 )
{
delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
edge3->pos -= delta;
if ( edge3->link )
edge3->link->pos -= delta;
/* move the serifs along with the stem */
if ( n_edges == 12 )
{
( edges + 8 )->pos -= delta;
( edges + 11 )->pos -= delta;
}
edge3->flags |= AF_EDGE_DONE;
if ( edge3->link )
edge3->link->flags |= AF_EDGE_DONE;
}
}
}
#endif
if ( has_serifs || !anchor )
{
/*
@ -2266,15 +2320,13 @@
static const AF_Script_UniRangeRec af_latin2_uniranges[] =
{
{ 32, 127 }, /* XXX: TODO: Add new Unicode ranges here! */
{ 160, 255 },
{ 0, 0 }
AF_UNIRANGE_REC( 32UL, 127UL ), /* XXX: TODO: Add new Unicode ranges here! */
AF_UNIRANGE_REC( 160UL, 255UL ),
AF_UNIRANGE_REC( 0UL, 0UL )
};
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
af_latin2_script_class =
{
AF_DEFINE_SCRIPT_CLASS(af_latin2_script_class,
AF_SCRIPT_LATIN2,
af_latin2_uniranges,
@ -2286,7 +2338,7 @@
(AF_Script_InitHintsFunc) af_latin2_hints_init,
(AF_Script_ApplyHintsFunc) af_latin2_hints_apply
};
)
/* END */

3
src/libs/freetype2/autofit/aflatin2.h
View File

@ -27,8 +27,7 @@ FT_BEGIN_HEADER
/* the latin-specific script class */
FT_CALLBACK_TABLE const AF_ScriptClassRec
af_latin2_script_class;
AF_DECLARE_SCRIPT_CLASS(af_latin2_script_class)
/* */

38
src/libs/freetype2/autofit/afloader.c
View File

@ -4,7 +4,7 @@
/* */
/* Auto-fitter glyph loading routines (body). */
/* */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -19,7 +19,6 @@
#include "afloader.h"
#include "afhints.h"
#include "afglobal.h"
#include "aflatin.h"
#include "aferrors.h"
@ -184,9 +183,9 @@
if ( axis->num_edges > 1 && AF_HINTS_DO_ADVANCE( hints ) )
{
old_rsb = loader->pp2.x - edge2->opos;
old_lsb = edge1->opos;
new_lsb = edge1->pos;
old_rsb = loader->pp2.x - edge2->opos;
old_lsb = edge1->opos;
new_lsb = edge1->pos;
/* remember unhinted values to later account */
/* for rounding errors */
@ -217,8 +216,9 @@
}
else
{
FT_Pos pp1x = loader->pp1.x;
FT_Pos pp2x = loader->pp2.x;
FT_Pos pp1x = loader->pp1.x;
FT_Pos pp2x = loader->pp2.x;
loader->pp1.x = FT_PIX_ROUND( pp1x );
loader->pp2.x = FT_PIX_ROUND( pp2x );
@ -229,8 +229,9 @@
}
else
{
FT_Pos pp1x = loader->pp1.x;
FT_Pos pp2x = loader->pp2.x;
FT_Pos pp1x = loader->pp1.x;
FT_Pos pp2x = loader->pp2.x;
loader->pp1.x = FT_PIX_ROUND( pp1x + hints->xmin_delta );
loader->pp2.x = FT_PIX_ROUND( pp2x + hints->xmax_delta );
@ -413,7 +414,8 @@
slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );
/* for mono-width fonts (like Andale, Courier, etc.) we need */
/* to keep the original rounded advance width */
/* to keep the original rounded advance width; ditto for */
/* digits if all have the same advance width */
#if 0
if ( !FT_IS_FIXED_WIDTH( slot->face ) )
slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
@ -421,13 +423,9 @@
slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
x_scale );
#else
if ( !FT_IS_FIXED_WIDTH( slot->face ) )
{
/* non-spacing glyphs must stay as-is */
if ( slot->metrics.horiAdvance )
slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
}
else
if ( FT_IS_FIXED_WIDTH( slot->face ) ||
( af_face_globals_is_digit( loader->globals, glyph_index ) &&
metrics->digits_have_same_width ) )
{
slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
metrics->scaler.x_scale );
@ -437,6 +435,12 @@
slot->lsb_delta = 0;
slot->rsb_delta = 0;
}
else
{
/* non-spacing glyphs must stay as-is */
if ( slot->metrics.horiAdvance )
slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
}
#endif
slot->metrics.vertAdvance = FT_MulFix( slot->metrics.vertAdvance,

15
src/libs/freetype2/autofit/afmodule.c
View File

@ -18,6 +18,7 @@
#include "afmodule.h"
#include "afloader.h"
#include "afpic.h"
#ifdef AF_DEBUG
int _af_debug;
@ -66,19 +67,15 @@
}
FT_CALLBACK_TABLE_DEF
const FT_AutoHinter_ServiceRec af_autofitter_service =
{
FT_DEFINE_AUTOHINTER_SERVICE(af_autofitter_service,
NULL,
NULL,
NULL,
(FT_AutoHinter_GlyphLoadFunc)af_autofitter_load_glyph
};
)
FT_DEFINE_MODULE(autofit_module_class,
FT_CALLBACK_TABLE_DEF
const FT_Module_Class autofit_module_class =
{
FT_MODULE_HINTER,
sizeof ( FT_AutofitterRec ),
@ -86,12 +83,12 @@
0x10000L, /* version 1.0 of the autofitter */
0x20000L, /* requires FreeType 2.0 or above */
(const void*)&af_autofitter_service,
(const void*)&AF_AF_AUTOFITTER_SERVICE_GET,
(FT_Module_Constructor)af_autofitter_init,
(FT_Module_Destructor) af_autofitter_done,
(FT_Module_Requester) NULL
};
)
/* END */

4
src/libs/freetype2/autofit/afmodule.h
View File

@ -20,13 +20,13 @@
#define __AFMODULE_H__
#include <ft2build.h>
#include FT_INTERNAL_OBJECTS_H
#include FT_MODULE_H
FT_BEGIN_HEADER
FT_CALLBACK_TABLE
const FT_Module_Class autofit_module_class;
FT_DECLARE_MODULE(autofit_module_class)
FT_END_HEADER

92
src/libs/freetype2/autofit/afpic.c Normal file
View File

@ -0,0 +1,92 @@
/***************************************************************************/
/* */
/* afpic.c */
/* */
/* The FreeType position independent code services for autofit module. */
/* */
/* Copyright 2009 by */
/* Oran Agra and Mickey Gabel. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_INTERNAL_OBJECTS_H
#include "afpic.h"
#ifdef FT_CONFIG_OPTION_PIC
/* forward declaration of PIC init functions from afmodule.c */
void FT_Init_Class_af_autofitter_service( FT_Library, FT_AutoHinter_ServiceRec*);
/* forward declaration of PIC init functions from script classes */
#include "aflatin.h"
#include "aflatin2.h"
#include "afcjk.h"
#include "afdummy.h"
#include "afindic.h"
void
autofit_module_class_pic_free( FT_Library library )
{
FT_PIC_Container* pic_container = &library->pic_container;
FT_Memory memory = library->memory;
if ( pic_container->autofit )
{
FT_FREE( pic_container->autofit );
pic_container->autofit = NULL;
}
}
FT_Error
autofit_module_class_pic_init( FT_Library library )
{
FT_PIC_Container* pic_container = &library->pic_container;
FT_UInt ss;
FT_Error error = FT_Err_Ok;
AFModulePIC* container;
FT_Memory memory = library->memory;
/* allocate pointer, clear and set global container pointer */
if ( FT_ALLOC ( container, sizeof ( *container ) ) )
return error;
FT_MEM_SET( container, 0, sizeof(*container) );
pic_container->autofit = container;
/* initialize pointer table - this is how the module usually expects this data */
for ( ss = 0 ; ss < AF_SCRIPT_CLASSES_REC_COUNT ; ss++ )
{
container->af_script_classes[ss] = &container->af_script_classes_rec[ss];
}
container->af_script_classes[AF_SCRIPT_CLASSES_COUNT-1] = NULL;
/* add call to initialization function when you add new scripts */
ss = 0;
FT_Init_Class_af_dummy_script_class(&container->af_script_classes_rec[ss++]);
#ifdef FT_OPTION_AUTOFIT2
FT_Init_Class_af_latin2_script_class(&container->af_script_classes_rec[ss++]);
#endif
FT_Init_Class_af_latin_script_class(&container->af_script_classes_rec[ss++]);
FT_Init_Class_af_cjk_script_class(&container->af_script_classes_rec[ss++]);
FT_Init_Class_af_indic_script_class(&container->af_script_classes_rec[ss++]);
FT_Init_Class_af_autofitter_service(library, &container->af_autofitter_service);
/*Exit:*/
if(error)
autofit_module_class_pic_free(library);
return error;
}
#endif /* FT_CONFIG_OPTION_PIC */
/* END */

64
src/libs/freetype2/autofit/afpic.h Normal file
View File

@ -0,0 +1,64 @@
/***************************************************************************/
/* */
/* afpic.h */
/* */
/* The FreeType position independent code services for autofit module. */
/* */
/* Copyright 2009 by */
/* Oran Agra and Mickey Gabel. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __AFPIC_H__
#define __AFPIC_H__
FT_BEGIN_HEADER
#include FT_INTERNAL_PIC_H
#ifndef FT_CONFIG_OPTION_PIC
#define AF_SCRIPT_CLASSES_GET af_script_classes
#define AF_AF_AUTOFITTER_SERVICE_GET af_autofitter_service
#else /* FT_CONFIG_OPTION_PIC */
#include "aftypes.h"
/* increase these when you add new scripts, and update autofit_module_class_pic_init */
#ifdef FT_OPTION_AUTOFIT2
#define AF_SCRIPT_CLASSES_COUNT 6
#else
#define AF_SCRIPT_CLASSES_COUNT 5
#endif
#define AF_SCRIPT_CLASSES_REC_COUNT (AF_SCRIPT_CLASSES_COUNT-1)
typedef struct AFModulePIC_
{
AF_ScriptClass af_script_classes[AF_SCRIPT_CLASSES_COUNT];
AF_ScriptClassRec af_script_classes_rec[AF_SCRIPT_CLASSES_REC_COUNT];
FT_AutoHinter_ServiceRec af_autofitter_service;
} AFModulePIC;
#define GET_PIC(lib) ((AFModulePIC*)((lib)->pic_container.autofit))
#define AF_SCRIPT_CLASSES_GET (GET_PIC(FT_FACE_LIBRARY(globals->face))->af_script_classes)
#define AF_AF_AUTOFITTER_SERVICE_GET (GET_PIC(library)->af_autofitter_service)
#endif /* FT_CONFIG_OPTION_PIC */
/* */
FT_END_HEADER
#endif /* __AFPIC_H__ */
/* END */

55
src/libs/freetype2/autofit/aftypes.h
View File

@ -285,6 +285,7 @@ extern void* _af_debug_hints;
{
AF_ScriptClass clazz;
AF_ScalerRec scaler;
FT_Bool digits_have_same_width;
} AF_ScriptMetricsRec, *AF_ScriptMetrics;
@ -321,6 +322,8 @@ extern void* _af_debug_hints;
} AF_Script_UniRangeRec;
#define AF_UNIRANGE_REC( a, b ) { (FT_UInt32)(a), (FT_UInt32)(b) }
typedef const AF_Script_UniRangeRec *AF_Script_UniRange;
@ -329,7 +332,7 @@ extern void* _af_debug_hints;
AF_Script script;
AF_Script_UniRange script_uni_ranges; /* last must be { 0, 0 } */
FT_UInt script_metrics_size;
FT_Offset script_metrics_size;
AF_Script_InitMetricsFunc script_metrics_init;
AF_Script_ScaleMetricsFunc script_metrics_scale;
AF_Script_DoneMetricsFunc script_metrics_done;
@ -339,6 +342,56 @@ extern void* _af_debug_hints;
} AF_ScriptClassRec;
/* Declare and define vtables for classes */
#ifndef FT_CONFIG_OPTION_PIC
#define AF_DECLARE_SCRIPT_CLASS(script_class) \
FT_CALLBACK_TABLE const AF_ScriptClassRec \
script_class;
#define AF_DEFINE_SCRIPT_CLASS(script_class, script_, ranges, m_size, \
m_init, m_scale, m_done, h_init, h_apply) \
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec \
script_class = \
{ \
script_, \
ranges, \
\
m_size, \
\
m_init, \
m_scale, \
m_done, \
\
h_init, \
h_apply \
};
#else
#define AF_DECLARE_SCRIPT_CLASS(script_class) \
FT_LOCAL(void) \
FT_Init_Class_##script_class(AF_ScriptClassRec* ac);
#define AF_DEFINE_SCRIPT_CLASS(script_class, script_, ranges, m_size, \
m_init, m_scale, m_done, h_init, h_apply) \
FT_LOCAL_DEF(void) \
FT_Init_Class_##script_class(AF_ScriptClassRec* ac) \
{ \
ac->script = script_; \
ac->script_uni_ranges = ranges; \
\
ac->script_metrics_size = m_size; \
\
ac->script_metrics_init = m_init; \
ac->script_metrics_scale = m_scale; \
ac->script_metrics_done = m_done; \
\
ac->script_hints_init = h_init; \
ac->script_hints_apply = h_apply; \
}
#endif
/* */

1
src/libs/freetype2/autofit/autofit.c
View File

@ -18,6 +18,7 @@
#define FT_MAKE_OPTION_SINGLE_OBJECT
#include <ft2build.h>
#include "afpic.c"
#include "afangles.c"
#include "afglobal.c"
#include "afhints.c"

83
src/libs/freetype2/base/basepic.c Normal file
View File

@ -0,0 +1,83 @@
/***************************************************************************/
/* */
/* basepic.c */
/* */
/* The FreeType position independent code services for base. */
/* */
/* Copyright 2009 by */
/* Oran Agra and Mickey Gabel. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_INTERNAL_OBJECTS_H
#include "basepic.h"
#ifdef FT_CONFIG_OPTION_PIC
/* forward declaration of PIC init functions from ftglyph.c */
void FT_Init_Class_ft_outline_glyph_class(FT_Glyph_Class*);
void FT_Init_Class_ft_bitmap_glyph_class(FT_Glyph_Class*);
/* forward declaration of PIC init functions from ftinit.c */
FT_Error ft_create_default_module_classes(FT_Library);
void ft_destroy_default_module_classes(FT_Library);
void
ft_base_pic_free( FT_Library library )
{
FT_PIC_Container* pic_container = &library->pic_container;
FT_Memory memory = library->memory;
if ( pic_container->base )
{
/* Destroy default module classes (in case FT_Add_Default_Modules was used) */
ft_destroy_default_module_classes( library );
FT_FREE( pic_container->base );
pic_container->base = NULL;
}
}
FT_Error
ft_base_pic_init( FT_Library library )
{
FT_PIC_Container* pic_container = &library->pic_container;
FT_Error error = FT_Err_Ok;
BasePIC* container;
FT_Memory memory = library->memory;
/* allocate pointer, clear and set global container pointer */
if ( FT_ALLOC ( container, sizeof ( *container ) ) )
return error;
FT_MEM_SET( container, 0, sizeof(*container) );
pic_container->base = container;
/* initialize default modules list and pointers */
error = ft_create_default_module_classes( library );
if ( error )
goto Exit;
/* initialize pointer table - this is how the module usually expects this data */
FT_Init_Class_ft_outline_glyph_class(&container->ft_outline_glyph_class);
FT_Init_Class_ft_bitmap_glyph_class(&container->ft_bitmap_glyph_class);
Exit:
if(error)
ft_base_pic_free(library);
return error;
}
#endif /* FT_CONFIG_OPTION_PIC */
/* END */

62
src/libs/freetype2/base/basepic.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************************************/
/* */
/* basepic.h */
/* */
/* The FreeType position independent code services for base. */
/* */
/* Copyright 2009 by */
/* Oran Agra and Mickey Gabel. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __BASEPIC_H__
#define __BASEPIC_H__
FT_BEGIN_HEADER
#include FT_INTERNAL_PIC_H
#ifndef FT_CONFIG_OPTION_PIC
#define FT_OUTLINE_GLYPH_CLASS_GET &ft_outline_glyph_class
#define FT_BITMAP_GLYPH_CLASS_GET &ft_bitmap_glyph_class
#define FT_DEFAULT_MODULES_GET ft_default_modules
#else /* FT_CONFIG_OPTION_PIC */
#include FT_GLYPH_H
typedef struct BasePIC_
{
FT_Module_Class** default_module_classes;
FT_Glyph_Class ft_outline_glyph_class;
FT_Glyph_Class ft_bitmap_glyph_class;
} BasePIC;
#define GET_PIC(lib) ((BasePIC*)((lib)->pic_container.base))
#define FT_OUTLINE_GLYPH_CLASS_GET (&GET_PIC(library)->ft_outline_glyph_class)
#define FT_BITMAP_GLYPH_CLASS_GET (&GET_PIC(library)->ft_bitmap_glyph_class)
#define FT_DEFAULT_MODULES_GET (GET_PIC(library)->default_module_classes)
void
ft_base_pic_free( FT_Library library );
FT_Error
ft_base_pic_init( FT_Library library );
#endif /* FT_CONFIG_OPTION_PIC */
/* */
FT_END_HEADER
#endif /* __BASEPIC_H__ */
/* END */

2
src/libs/freetype2/base/ftadvanc.c
View File

@ -140,7 +140,7 @@
if ( flags & FT_ADVANCE_FLAG_FAST_ONLY )
return FT_Err_Unimplemented_Feature;
flags |= FT_LOAD_ADVANCE_ONLY;
flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
for ( nn = 0; nn < count; nn++ )
{
error = FT_Load_Glyph( face, start + nn, flags );

6
src/libs/freetype2/base/ftbase.c
View File

@ -4,7 +4,7 @@
/* */
/* Single object library component (body only). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by */
/* Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -20,14 +20,16 @@
#define FT_MAKE_OPTION_SINGLE_OBJECT
#include "ftpic.c"
#include "basepic.c"
#include "ftadvanc.c"
#include "ftcalc.c"
#include "ftdbgmem.c"
#include "ftgloadr.c"
#include "ftnames.c"
#include "ftobjs.c"
#include "ftoutln.c"
#include "ftrfork.c"
#include "ftsnames.c"
#include "ftstream.c"
#include "fttrigon.c"
#include "ftutil.c"

21
src/libs/freetype2/base/ftbbox.c
View File

@ -29,6 +29,7 @@
#include FT_IMAGE_H
#include FT_OUTLINE_H
#include FT_INTERNAL_CALC_H
#include FT_INTERNAL_OBJECTS_H
typedef struct TBBox_Rec_
@ -559,6 +560,13 @@
return 0;
}
FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
(FT_Outline_MoveTo_Func) BBox_Move_To,
(FT_Outline_LineTo_Func) BBox_Move_To,
(FT_Outline_ConicTo_Func)BBox_Conic_To,
(FT_Outline_CubicTo_Func)BBox_Cubic_To,
0, 0
)
/* documentation is in ftbbox.h */
@ -628,18 +636,13 @@
/* the two boxes are different, now walk over the outline to */
/* get the Bezier arc extrema. */
static const FT_Outline_Funcs bbox_interface =
{
(FT_Outline_MoveTo_Func) BBox_Move_To,
(FT_Outline_LineTo_Func) BBox_Move_To,
(FT_Outline_ConicTo_Func)BBox_Conic_To,
(FT_Outline_CubicTo_Func)BBox_Cubic_To,
0, 0
};
FT_Error error;
TBBox_Rec user;
#ifdef FT_CONFIG_OPTION_PIC
FT_Outline_Funcs bbox_interface;
Init_Class_bbox_interface(&bbox_interface);
#endif
user.bbox = bbox;

8
src/libs/freetype2/base/ftbitmap.c
View File

@ -228,8 +228,12 @@
if ( !bitmap || !bitmap->buffer )
return FT_Err_Invalid_Argument;
xstr = FT_PIX_ROUND( xStrength ) >> 6;
ystr = FT_PIX_ROUND( yStrength ) >> 6;
if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) ||
( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) )
return FT_Err_Invalid_Argument;
xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6;
ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6;
if ( xstr == 0 && ystr == 0 )
return FT_Err_Ok;

34
src/libs/freetype2/base/ftcalc.c
View File

@ -110,12 +110,12 @@
FT_EXPORT_DEF( FT_Int32 )
FT_Sqrt32( FT_Int32 x )
{
FT_ULong val, root, newroot, mask;
FT_UInt32 val, root, newroot, mask;
root = 0;
mask = 0x40000000L;
val = (FT_ULong)x;
mask = (FT_UInt32)0x40000000UL;
val = (FT_UInt32)x;
do
{
@ -362,6 +362,7 @@
long s;
/* XXX: this function does not allow 64-bit arguments */
if ( a == 0 || b == c )
return a;
@ -377,12 +378,12 @@
FT_Int64 temp, temp2;
ft_multo64( a, b, &temp );
ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
temp2.hi = 0;
temp2.lo = (FT_UInt32)(c >> 1);
FT_Add64( &temp, &temp2, &temp );
a = ft_div64by32( temp.hi, temp.lo, c );
a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
}
else
a = 0x7FFFFFFFL;
@ -416,8 +417,8 @@
FT_Int64 temp;
ft_multo64( a, b, &temp );
a = ft_div64by32( temp.hi, temp.lo, c );
ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
}
else
a = 0x7FFFFFFFL;
@ -539,13 +540,14 @@
FT_UInt32 q;
s = a; a = FT_ABS( a );
s ^= b; b = FT_ABS( b );
/* XXX: this function does not allow 64-bit arguments */
s = (FT_Int32)a; a = FT_ABS( a );
s ^= (FT_Int32)b; b = FT_ABS( b );
if ( b == 0 )
{
/* check for division by 0 */
q = 0x7FFFFFFFL;
q = (FT_UInt32)0x7FFFFFFFL;
}
else if ( ( a >> 16 ) == 0 )
{
@ -562,7 +564,7 @@
temp2.hi = 0;
temp2.lo = (FT_UInt32)( b >> 1 );
FT_Add64( &temp, &temp2, &temp );
q = ft_div64by32( temp.hi, temp.lo, b );
q = ft_div64by32( temp.hi, temp.lo, (FT_Int32)b );
}
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
@ -840,7 +842,7 @@
FT_Pos out_x,
FT_Pos out_y )
{
FT_Int result;
FT_Long result; /* avoid overflow on 16-bit system */
/* deal with the trivial cases quickly */
@ -889,8 +891,9 @@
FT_Int64 z1, z2;
ft_multo64( in_x, out_y, &z1 );
ft_multo64( in_y, out_x, &z2 );
/* XXX: this function does not allow 64-bit arguments */
ft_multo64( (FT_Int32)in_x, (FT_Int32)out_y, &z1 );
ft_multo64( (FT_Int32)in_y, (FT_Int32)out_x, &z2 );
if ( z1.hi > z2.hi )
result = +1;
@ -906,7 +909,8 @@
#endif
}
return result;
/* XXX: only the sign of return value, +1/0/-1 must be used */
return (FT_Int)result;
}

2
src/libs/freetype2/base/ftdbgmem.c
View File

@ -421,7 +421,7 @@
"FreeType: %ld bytes of memory leaked in %ld blocks\n",
leaks, leak_count );
printf( "FreeType: No memory leaks detected!\n" );
printf( "FreeType: no memory leaks detected\n" );
}
}

7
src/libs/freetype2/base/ftgloadr.c
View File

@ -218,6 +218,9 @@
{
new_max = FT_PAD_CEIL( new_max, 8 );
if ( new_max > FT_OUTLINE_POINTS_MAX )
return FT_Err_Array_Too_Large;
if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
FT_RENEW_ARRAY( base->tags, old_max, new_max ) )
goto Exit;
@ -246,6 +249,10 @@
if ( new_max > old_max )
{
new_max = FT_PAD_CEIL( new_max, 4 );
if ( new_max > FT_OUTLINE_CONTOURS_MAX )
return FT_Err_Array_Too_Large;
if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
goto Exit;

21
src/libs/freetype2/base/ftglyph.c
View File

@ -34,6 +34,7 @@
#include FT_BITMAP_H
#include FT_INTERNAL_OBJECTS_H
#include "basepic.h"
/*************************************************************************/
/* */
@ -129,9 +130,7 @@
}
FT_CALLBACK_TABLE_DEF
const FT_Glyph_Class ft_bitmap_glyph_class =
{
FT_DEFINE_GLYPH(ft_bitmap_glyph_class,
sizeof ( FT_BitmapGlyphRec ),
FT_GLYPH_FORMAT_BITMAP,
@ -141,7 +140,7 @@
0, /* FT_Glyph_TransformFunc */
ft_bitmap_glyph_bbox,
0 /* FT_Glyph_PrepareFunc */
};
)
/*************************************************************************/
@ -255,9 +254,7 @@
}
FT_CALLBACK_TABLE_DEF
const FT_Glyph_Class ft_outline_glyph_class =
{
FT_DEFINE_GLYPH( ft_outline_glyph_class,
sizeof ( FT_OutlineGlyphRec ),
FT_GLYPH_FORMAT_OUTLINE,
@ -267,7 +264,7 @@
ft_outline_glyph_transform,
ft_outline_glyph_bbox,
ft_outline_glyph_prepare
};
)
/*************************************************************************/
@ -373,11 +370,11 @@
/* if it is a bitmap, that's easy :-) */
if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
clazz = &ft_bitmap_glyph_class;
clazz = FT_BITMAP_GLYPH_CLASS_GET;
/* it it is an outline too */
else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
clazz = &ft_outline_glyph_class;
clazz = FT_OUTLINE_GLYPH_CLASS_GET;
else
{
@ -533,7 +530,7 @@
clazz = glyph->clazz;
/* when called with a bitmap glyph, do nothing and return successfully */
if ( clazz == &ft_bitmap_glyph_class )
if ( clazz == FT_BITMAP_GLYPH_CLASS_GET )
goto Exit;
if ( !clazz || !clazz->glyph_prepare )
@ -546,7 +543,7 @@
dummy.format = clazz->glyph_format;
/* create result bitmap glyph */
error = ft_new_glyph( glyph->library, &ft_bitmap_glyph_class,
error = ft_new_glyph( glyph->library, FT_BITMAP_GLYPH_CLASS_GET,
(FT_Glyph*)(void*)&bitmap );
if ( error )
goto Exit;

113
src/libs/freetype2/base/ftinit.c
View File

@ -4,7 +4,7 @@
/* */
/* FreeType initialization layer (body). */
/* */
/* Copyright 1996-2001, 2002, 2005, 2007 by */
/* Copyright 1996-2001, 2002, 2005, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -42,6 +42,7 @@
#include FT_INTERNAL_OBJECTS_H
#include FT_INTERNAL_DEBUG_H
#include FT_MODULE_H
#include "basepic.h"
/*************************************************************************/
@ -53,6 +54,8 @@
#undef FT_COMPONENT
#define FT_COMPONENT trace_init
#ifndef FT_CONFIG_OPTION_PIC
#undef FT_USE_MODULE
#ifdef __cplusplus
#define FT_USE_MODULE( type, x ) extern "C" const type x;
@ -74,6 +77,99 @@
0
};
#else /* FT_CONFIG_OPTION_PIC */
#ifdef __cplusplus
#define FT_EXTERNC extern "C"
#else
#define FT_EXTERNC extern
#endif
/* declare the module's class creation/destruction functions */
#undef FT_USE_MODULE
#define FT_USE_MODULE( type, x ) \
FT_EXTERNC FT_Error FT_Create_Class_##x( FT_Library library, FT_Module_Class** output_class ); \
FT_EXTERNC void FT_Destroy_Class_##x( FT_Library library, FT_Module_Class* clazz );
#include FT_CONFIG_MODULES_H
/* count all module classes */
#undef FT_USE_MODULE
#define FT_USE_MODULE( type, x ) MODULE_CLASS_##x,
enum {
#include FT_CONFIG_MODULES_H
FT_NUM_MODULE_CLASSES
};
/* destroy all module classes */
#undef FT_USE_MODULE
#define FT_USE_MODULE( type, x ) \
if ( classes[i] ) { FT_Destroy_Class_##x(library, classes[i]); } \
i++; \
FT_BASE_DEF( void )
ft_destroy_default_module_classes( FT_Library library )
{
FT_Module_Class** classes;
FT_Memory memory;
FT_UInt i;
BasePIC* pic_container = library->pic_container.base;
if ( !pic_container->default_module_classes )
return;
memory = library->memory;
classes = pic_container->default_module_classes;
i = 0;
#include FT_CONFIG_MODULES_H
FT_FREE( classes );
pic_container->default_module_classes = 0;
}
/* initialize all module classes and the pointer table */
#undef FT_USE_MODULE
#define FT_USE_MODULE( type, x ) \
error = FT_Create_Class_##x(library, &clazz); \
if (error) goto Exit; \
classes[i++] = clazz;
FT_BASE_DEF( FT_Error )
ft_create_default_module_classes( FT_Library library )
{
FT_Error error;
FT_Memory memory;
FT_Module_Class** classes;
FT_Module_Class* clazz;
FT_UInt i;
BasePIC* pic_container = library->pic_container.base;
memory = library->memory;
pic_container->default_module_classes = 0;
if ( FT_ALLOC(classes, sizeof(FT_Module_Class*) * (FT_NUM_MODULE_CLASSES + 1) ) )
return error;
/* initialize all pointers to 0, especially the last one */
for (i = 0; i < FT_NUM_MODULE_CLASSES; i++)
classes[i] = 0;
classes[FT_NUM_MODULE_CLASSES] = 0;
i = 0;
#include FT_CONFIG_MODULES_H
Exit:
if (error) ft_destroy_default_module_classes( library );
else pic_container->default_module_classes = classes;
return error;
}
#endif /* FT_CONFIG_OPTION_PIC */
/* documentation is in ftmodapi.h */
@ -86,16 +182,15 @@
/* test for valid `library' delayed to FT_Add_Module() */
cur = ft_default_modules;
cur = FT_DEFAULT_MODULES_GET;
while ( *cur )
{
error = FT_Add_Module( library, *cur );
/* notify errors, but don't stop */
if ( error )
{
FT_ERROR(( "FT_Add_Default_Module: Cannot install `%s', error = 0x%x\n",
(*cur)->module_name, error ));
}
FT_TRACE0(( "FT_Add_Default_Module:"
" Cannot install `%s', error = 0x%x\n",
(*cur)->module_name, error ));
cur++;
}
}
@ -127,13 +222,7 @@
if ( error )
FT_Done_Memory( memory );
else
{
(*alibrary)->version_major = FREETYPE_MAJOR;
(*alibrary)->version_minor = FREETYPE_MINOR;
(*alibrary)->version_patch = FREETYPE_PATCH;
FT_Add_Default_Modules( *alibrary );
}
return error;
}

150
src/libs/freetype2/base/ftobjs.c
View File

@ -348,14 +348,18 @@
/* free bitmap buffer if needed */
ft_glyphslot_free_bitmap( slot );
/* free glyph loader */
if ( FT_DRIVER_USES_OUTLINES( driver ) )
/* slot->internal might be NULL in out-of-memory situations */
if ( slot->internal )
{
FT_GlyphLoader_Done( slot->internal->loader );
slot->internal->loader = 0;
}
/* free glyph loader */
if ( FT_DRIVER_USES_OUTLINES( driver ) )
{
FT_GlyphLoader_Done( slot->internal->loader );
slot->internal->loader = 0;
}
FT_FREE( slot->internal );
FT_FREE( slot->internal );
}
}
@ -588,27 +592,29 @@
* Determine whether we need to auto-hint or not.
* The general rules are:
*
* - Do only auto-hinting if we have a hinter module,
* a scalable font format dealing with outlines,
* and no transforms except simple slants.
* - Do only auto-hinting if we have a hinter module, a scalable font
* format dealing with outlines, and no transforms except simple
* slants and/or rotations by integer multiples of 90 degrees.
*
* - Then, autohint if FT_LOAD_FORCE_AUTOHINT is set
* or if we don't have a native font hinter.
* - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't
* have a native font hinter.
*
* - Otherwise, auto-hint for LIGHT hinting mode.
*
* - Exception: The font is `tricky' and requires
* the native hinter to load properly.
* - Exception: The font is `tricky' and requires the native hinter to
* load properly.
*/
if ( hinter &&
!( load_flags & FT_LOAD_NO_HINTING ) &&
!( load_flags & FT_LOAD_NO_AUTOHINT ) &&
FT_DRIVER_IS_SCALABLE( driver ) &&
FT_DRIVER_USES_OUTLINES( driver ) &&
!FT_IS_TRICKY( face ) &&
face->internal->transform_matrix.yy > 0 &&
face->internal->transform_matrix.yx == 0 )
if ( hinter &&
!( load_flags & FT_LOAD_NO_HINTING ) &&
!( load_flags & FT_LOAD_NO_AUTOHINT ) &&
FT_DRIVER_IS_SCALABLE( driver ) &&
FT_DRIVER_USES_OUTLINES( driver ) &&
!FT_IS_TRICKY( face ) &&
( ( face->internal->transform_matrix.yx == 0 &&
face->internal->transform_matrix.xx != 0 ) ||
( face->internal->transform_matrix.xx == 0 &&
face->internal->transform_matrix.yx != 0 ) ) )
{
if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) ||
!FT_DRIVER_HAS_HINTER( driver ) )
@ -2398,12 +2404,24 @@
ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics,
FT_Pos advance )
{
FT_Pos height = metrics->height;
/* compensate for glyph with bbox above/below the baseline */
if ( metrics->horiBearingY < 0 )
{
if ( height < metrics->horiBearingY )
height = metrics->horiBearingY;
}
else if ( metrics->horiBearingY > 0 )
height -= metrics->horiBearingY;
/* the factor 1.2 is a heuristical value */
if ( !advance )
advance = metrics->height * 12 / 10;
advance = height * 12 / 10;
metrics->vertBearingX = -( metrics->width / 2 );
metrics->vertBearingY = ( advance - metrics->height ) / 2;
metrics->vertBearingX = metrics->horiBearingX - metrics->horiAdvance / 2;
metrics->vertBearingY = ( advance - height ) / 2;
metrics->vertAdvance = advance;
}
@ -3048,7 +3066,12 @@
FT_CMap cmap = FT_CMAP( face->charmap );
result = cmap->clazz->char_index( cmap, charcode );
if ( charcode > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
FT_TRACE1(( " 0x%x is truncated\n", charcode ));
}
result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode );
}
return result;
}
@ -3128,8 +3151,20 @@
FT_CMap vcmap = FT_CMAP( charmap );
result = vcmap->clazz->char_var_index( vcmap, ucmap, charcode,
variantSelector );
if ( charcode > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
FT_TRACE1(( " 0x%x is truncated\n", charcode ));
}
if ( variantSelector > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
}
result = vcmap->clazz->char_var_index( vcmap, ucmap,
(FT_UInt32)charcode,
(FT_UInt32)variantSelector );
}
}
@ -3157,8 +3192,20 @@
FT_CMap vcmap = FT_CMAP( charmap );
result = vcmap->clazz->char_var_default( vcmap, charcode,
variantSelector );
if ( charcode > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
FT_TRACE1(( " 0x%x is truncated\n", charcode ));
}
if ( variantSelector > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
}
result = vcmap->clazz->char_var_default( vcmap,
(FT_UInt32)charcode,
(FT_UInt32)variantSelector );
}
}
@ -3213,7 +3260,14 @@
FT_Memory memory = FT_FACE_MEMORY( face );
result = vcmap->clazz->charvariant_list( vcmap, memory, charcode );
if ( charcode > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
FT_TRACE1(( " 0x%x is truncated\n", charcode ));
}
result = vcmap->clazz->charvariant_list( vcmap, memory,
(FT_UInt32)charcode );
}
}
return result;
@ -3240,8 +3294,14 @@
FT_Memory memory = FT_FACE_MEMORY( face );
if ( variantSelector > 0xFFFFFFFFUL )
{
FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
}
result = vcmap->clazz->variantchar_list( vcmap, memory,
variantSelector );
(FT_UInt32)variantSelector );
}
}
@ -3291,7 +3351,7 @@
((FT_Byte*)buffer)[0] = 0;
if ( face &&
glyph_index <= (FT_UInt)face->num_glyphs &&
(FT_Long)glyph_index <= face->num_glyphs &&
FT_HAS_GLYPH_NAMES( face ) )
{
FT_Service_GlyphDict service;
@ -3391,6 +3451,7 @@
FT_ULong *length )
{
FT_Service_SFNT_Table service;
FT_ULong offset;
if ( !face || !FT_IS_SFNT( face ) )
@ -3400,7 +3461,7 @@
if ( service == NULL )
return FT_Err_Unimplemented_Feature;
return service->table_info( face, table_index, tag, length );
return service->table_info( face, table_index, tag, &offset, length );
}
@ -3725,7 +3786,7 @@
while ( renderer )
{
error = renderer->render( renderer, slot, render_mode, NULL );
if ( !error ||
if ( !error ||
FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )
break;
@ -4123,6 +4184,13 @@
library->memory = memory;
#ifdef FT_CONFIG_OPTION_PIC
/* initialize position independent code containers */
error = ft_pic_container_init( library );
if ( error )
goto Fail;
#endif
/* allocate the render pool */
library->raster_pool_size = FT_RENDER_POOL_SIZE;
#if FT_RENDER_POOL_SIZE > 0
@ -4130,12 +4198,19 @@
goto Fail;
#endif
library->version_major = FREETYPE_MAJOR;
library->version_minor = FREETYPE_MINOR;
library->version_patch = FREETYPE_PATCH;
/* That's ok now */
*alibrary = library;
return FT_Err_Ok;
Fail:
#ifdef FT_CONFIG_OPTION_PIC
ft_pic_container_destroy( library );
#endif
FT_FREE( library );
return error;
}
@ -4216,7 +4291,7 @@
{
FT_Done_Face( FT_FACE( faces->head->data ) );
if ( faces->head )
FT_ERROR(( "FT_Done_Library: failed to free some faces\n" ));
FT_TRACE0(( "FT_Done_Library: failed to free some faces\n" ));
}
}
}
@ -4252,6 +4327,11 @@
FT_FREE( library->raster_pool );
library->raster_pool_size = 0;
#ifdef FT_CONFIG_OPTION_PIC
/* Destroy pic container contents */
ft_pic_container_destroy( library );
#endif
FT_FREE( library );
return FT_Err_Ok;
}

14
src/libs/freetype2/base/ftpatent.c
View File

@ -103,6 +103,7 @@
}
Exit:
FT_UNUSED( error );
FT_FRAME_EXIT();
return result;
}
@ -113,7 +114,7 @@
FT_ULong tag )
{
FT_Stream stream = face->stream;
FT_Error error;
FT_Error error = FT_Err_Ok;
FT_Service_SFNT_Table service;
FT_Bool result = FALSE;
@ -122,15 +123,18 @@
if ( service )
{
FT_ULong offset, size;
FT_UInt i = 0;
FT_ULong tag_i = 0, offset_i, length_i;
for ( i = 0; !error && tag_i != tag ; i++ )
error = service->table_info( face, i,
&tag_i, &offset_i, &length_i );
error = service->table_info( face, tag, &offset, &size );
if ( error ||
FT_STREAM_SEEK( offset ) )
FT_STREAM_SEEK( offset_i ) )
goto Exit;
result = _tt_check_patents_in_range( stream, size );
result = _tt_check_patents_in_range( stream, length_i );
}
Exit:

54
src/libs/freetype2/base/ftpic.c Normal file
View File

@ -0,0 +1,54 @@
/***************************************************************************/
/* */
/* ftpic.c */
/* */
/* The FreeType position independent code services (body). */
/* */
/* Copyright 2009 by */
/* Oran Agra and Mickey Gabel. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_INTERNAL_OBJECTS_H
#include "basepic.h"
#ifdef FT_CONFIG_OPTION_PIC
/* documentation is in ftpic.h */
FT_BASE_DEF( FT_Error )
ft_pic_container_init( FT_Library library )
{
FT_PIC_Container* pic_container = &library->pic_container;
FT_Error error = FT_Err_Ok;
FT_MEM_SET( pic_container, 0, sizeof(*pic_container) );
error = ft_base_pic_init( library );
if(error)
return error;
return FT_Err_Ok;
}
/* Destroy the contents of the container. */
FT_BASE_DEF( void )
ft_pic_container_destroy( FT_Library library )
{
ft_base_pic_free( library );
}
#endif /* FT_CONFIG_OPTION_PIC */
/* END */

4
src/libs/freetype2/base/ftrfork.c
View File

@ -752,9 +752,9 @@
const char *insertion )
{
char* new_name;
char* tmp;
const char* tmp;
const char* slash;
unsigned new_length;
size_t new_length;
FT_Error error = FT_Err_Ok;
FT_UNUSED( error );

94
src/libs/freetype2/base/ftsnames.c Normal file
View File

@ -0,0 +1,94 @@
/***************************************************************************/
/* */
/* ftsnames.c */
/* */
/* Simple interface to access SFNT name tables (which are used */
/* to hold font names, copyright info, notices, etc.) (body). */
/* */
/* This is _not_ used to retrieve glyph names! */
/* */
/* Copyright 1996-2001, 2002, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_SFNT_NAMES_H
#include FT_INTERNAL_TRUETYPE_TYPES_H
#include FT_INTERNAL_STREAM_H
#ifdef TT_CONFIG_OPTION_SFNT_NAMES
/* documentation is in ftsnames.h */
FT_EXPORT_DEF( FT_UInt )
FT_Get_Sfnt_Name_Count( FT_Face face )
{
return ( face && FT_IS_SFNT( face ) ) ? ((TT_Face)face)->num_names : 0;
}
/* documentation is in ftsnames.h */
FT_EXPORT_DEF( FT_Error )
FT_Get_Sfnt_Name( FT_Face face,
FT_UInt idx,
FT_SfntName *aname )
{
FT_Error error = FT_Err_Invalid_Argument;
if ( aname && face && FT_IS_SFNT( face ) )
{
TT_Face ttface = (TT_Face)face;
if ( idx < (FT_UInt)ttface->num_names )
{
TT_NameEntryRec* entry = ttface->name_table.names + idx;
/* load name on demand */
if ( entry->stringLength > 0 && entry->string == NULL )
{
FT_Memory memory = face->memory;
FT_Stream stream = face->stream;
if ( FT_NEW_ARRAY ( entry->string, entry->stringLength ) ||
FT_STREAM_SEEK( entry->stringOffset ) ||
FT_STREAM_READ( entry->string, entry->stringLength ) )
{
FT_FREE( entry->string );
entry->stringLength = 0;
}
}
aname->platform_id = entry->platformID;
aname->encoding_id = entry->encodingID;
aname->language_id = entry->languageID;
aname->name_id = entry->nameID;
aname->string = (FT_Byte*)entry->string;
aname->string_len = entry->stringLength;
error = FT_Err_Ok;
}
}
return error;
}
#endif /* TT_CONFIG_OPTION_SFNT_NAMES */
/* END */

56
src/libs/freetype2/base/ftstream.c
View File

@ -4,7 +4,7 @@
/* */
/* I/O stream support (body). */
/* */
/* Copyright 2000-2001, 2002, 2004, 2005, 2006, 2008 by */
/* Copyright 2000-2001, 2002, 2004, 2005, 2006, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -60,13 +60,12 @@
FT_Error error = FT_Err_Ok;
stream->pos = pos;
if ( stream->read )
{
if ( stream->read( stream, pos, 0, 0 ) )
{
FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_Seek:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
pos, stream->size ));
error = FT_Err_Invalid_Stream_Operation;
@ -75,12 +74,16 @@
/* note that seeking to the first position after the file is valid */
else if ( pos > stream->size )
{
FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_Seek:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
pos, stream->size ));
error = FT_Err_Invalid_Stream_Operation;
}
if ( !error )
stream->pos = pos;
return error;
}
@ -124,7 +127,8 @@
if ( pos >= stream->size )
{
FT_ERROR(( "FT_Stream_ReadAt: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_ReadAt:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
pos, stream->size ));
return FT_Err_Invalid_Stream_Operation;
@ -145,8 +149,8 @@
if ( read_bytes < count )
{
FT_ERROR(( "FT_Stream_ReadAt:" ));
FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
FT_ERROR(( "FT_Stream_ReadAt:"
" invalid read; expected %lu bytes, got %lu\n",
count, read_bytes ));
error = FT_Err_Invalid_Stream_Operation;
@ -211,7 +215,7 @@
FT_Stream_ReleaseFrame( FT_Stream stream,
FT_Byte** pbytes )
{
if ( stream->read )
if ( stream && stream->read )
{
FT_Memory memory = stream->memory;
@ -256,8 +260,8 @@
stream->base, count );
if ( read_bytes < count )
{
FT_ERROR(( "FT_Stream_EnterFrame:" ));
FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
FT_ERROR(( "FT_Stream_EnterFrame:"
" invalid read; expected %lu bytes, got %lu\n",
count, read_bytes ));
FT_FREE( stream->base );
@ -273,8 +277,8 @@
if ( stream->pos >= stream->size ||
stream->pos + count > stream->size )
{
FT_ERROR(( "FT_Stream_EnterFrame:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_EnterFrame:"
" invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
stream->pos, count, stream->size ));
error = FT_Err_Invalid_Stream_Operation;
@ -459,7 +463,8 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Stream_ReadChar: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_ReadChar:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
return 0;
@ -505,8 +510,8 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Stream_ReadShort:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_ReadShort:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
return 0;
@ -552,8 +557,8 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Stream_ReadShortLE:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_ReadShortLE:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
return 0;
@ -599,8 +604,8 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Stream_ReadOffset:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
FT_ERROR(( "FT_Stream_ReadOffset:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
return 0;
@ -645,9 +650,10 @@
return result;
Fail:
FT_ERROR(( "FT_Stream_ReadLong: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Stream_ReadLong:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
return 0;
}
@ -691,10 +697,10 @@
return result;
Fail:
FT_ERROR(( "FT_Stream_ReadLongLE:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Stream_ReadLongLE:"
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
return 0;
}

50
src/libs/freetype2/base/ftstroke.c
View File

@ -706,7 +706,7 @@
FT_Bool valid;
FT_StrokeBorderRec borders[2];
FT_Memory memory;
FT_Library library;
} FT_StrokerRec;
@ -729,7 +729,7 @@
if ( !FT_NEW( stroker ) )
{
stroker->memory = memory;
stroker->library = library;
ft_stroke_border_init( &stroker->borders[0], memory );
ft_stroke_border_init( &stroker->borders[1], memory );
@ -777,13 +777,13 @@
{
if ( stroker )
{
FT_Memory memory = stroker->memory;
FT_Memory memory = stroker->library->memory;
ft_stroke_border_done( &stroker->borders[0] );
ft_stroke_border_done( &stroker->borders[1] );
stroker->memory = NULL;
stroker->library = NULL;
FT_FREE( stroker );
}
}
@ -859,6 +859,31 @@
error = ft_stroke_border_lineto( border, &delta, FALSE );
}
else if ( stroker->line_cap == FT_STROKER_LINECAP_BUTT )
{
/* add a butt ending */
FT_Vector delta;
FT_Angle rotate = FT_SIDE_TO_ROTATE( side );
FT_Fixed radius = stroker->radius;
FT_StrokeBorder border = stroker->borders + side;
FT_Vector_From_Polar( &delta, radius, angle + rotate );
delta.x += stroker->center.x;
delta.y += stroker->center.y;
error = ft_stroke_border_lineto( border, &delta, FALSE );
if ( error )
goto Exit;
FT_Vector_From_Polar( &delta, radius, angle - rotate );
delta.x += stroker->center.x;
delta.y += stroker->center.y;
error = ft_stroke_border_lineto( border, &delta, FALSE );
}
Exit:
return error;
@ -1844,8 +1869,13 @@
return FT_Err_Invalid_Outline;
}
/* declare an extern to access ft_outline_glyph_class global allocated
in ftglyph.c, and use the FT_OUTLINE_GLYPH_CLASS_GET macro to access
it when FT_CONFIG_OPTION_PIC is defined */
#ifndef FT_CONFIG_OPTION_PIC
extern const FT_Glyph_Class ft_outline_glyph_class;
#endif
#include "basepic.h"
/* documentation is in ftstroke.h */
@ -1857,13 +1887,14 @@
{
FT_Error error = FT_Err_Invalid_Argument;
FT_Glyph glyph = NULL;
FT_Library library = stroker->library;
FT_UNUSED(library);
if ( pglyph == NULL )
goto Exit;
glyph = *pglyph;
if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
goto Exit;
{
@ -1930,13 +1961,14 @@
{
FT_Error error = FT_Err_Invalid_Argument;
FT_Glyph glyph = NULL;
FT_Library library = stroker->library;
FT_UNUSED(library);
if ( pglyph == NULL )
goto Exit;
glyph = *pglyph;
if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
goto Exit;
{

25
src/libs/freetype2/base/ftsynth.c
View File

@ -18,11 +18,21 @@
#include <ft2build.h>
#include FT_SYNTHESIS_H
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_OBJECTS_H
#include FT_OUTLINE_H
#include FT_BITMAP_H
/*************************************************************************/
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
/* messages during execution. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_synth
/*************************************************************************/
/*************************************************************************/
/**** ****/
@ -106,6 +116,18 @@
xstr = 1 << 6;
ystr &= ~63;
/*
* XXX: overflow check for 16-bit system, for compatibility
* with FT_GlyphSlot_Embolden() since freetype-2.1.10.
* unfortunately, this function return no informations
* about the cause of error.
*/
if ( ( ystr >> 6 ) > FT_INT_MAX || ( ystr >> 6 ) < FT_INT_MIN )
{
FT_TRACE1(( "FT_GlyphSlot_Embolden:" ));
FT_TRACE1(( "too strong embolding parameter ystr=%d\n", ystr ));
return;
}
error = FT_GlyphSlot_Own_Bitmap( slot );
if ( error )
return;
@ -129,8 +151,9 @@
slot->metrics.vertBearingY += ystr;
slot->metrics.vertAdvance += ystr;
/* XXX: 16-bit overflow case must be excluded before here */
if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
slot->bitmap_top += ystr >> 6;
slot->bitmap_top += (FT_Int)( ystr >> 6 );
}

9
src/libs/freetype2/base/ftsystem.c
View File

@ -4,7 +4,7 @@
/* */
/* ANSI-specific FreeType low-level system interface (body). */
/* */
/* Copyright 1996-2001, 2002, 2006, 2008 by */
/* Copyright 1996-2001, 2002, 2006, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -205,7 +205,8 @@
file = STREAM_FILE( stream );
ft_fseek( file, offset, SEEK_SET );
if ( stream->pos != offset )
ft_fseek( file, offset, SEEK_SET );
return (unsigned long)ft_fread( buffer, 1, count, file );
}
@ -226,8 +227,8 @@
file = ft_fopen( filepathname, "rb" );
if ( !file )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
FT_ERROR(( "FT_Stream_Open:"
" could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
}

10
src/libs/freetype2/base/fttrigon.c
View File

@ -72,10 +72,10 @@
val = ( val >= 0 ) ? val : -val;
v1 = (FT_UInt32)val >> 16;
v2 = (FT_UInt32)val & 0xFFFFL;
v2 = (FT_UInt32)(val & 0xFFFFL);
k1 = FT_TRIG_SCALE >> 16; /* constant */
k2 = FT_TRIG_SCALE & 0xFFFFL; /* constant */
k1 = (FT_UInt32)FT_TRIG_SCALE >> 16; /* constant */
k2 = (FT_UInt32)(FT_TRIG_SCALE & 0xFFFFL); /* constant */
hi = k1 * v1;
lo1 = k1 * v2 + k2 * v1; /* can't overflow */
@ -86,7 +86,7 @@
hi += lo1 >> 16;
if ( lo1 < lo3 )
hi += 0x10000UL;
hi += (FT_UInt32)0x10000UL;
val = (FT_Fixed)hi;
@ -433,7 +433,7 @@
if ( shift > 0 )
{
FT_Int32 half = 1L << ( shift - 1 );
FT_Int32 half = (FT_Int32)1L << ( shift - 1 );
vec->x = ( v.x + half + FT_SIGN_LONG( v.x ) ) >> shift;

2
src/libs/freetype2/base/rules.mk
View File

@ -37,10 +37,10 @@ BASE_SRC := $(BASE_DIR)/ftadvanc.c \
$(BASE_DIR)/ftcalc.c \
$(BASE_DIR)/ftdbgmem.c \
$(BASE_DIR)/ftgloadr.c \
$(BASE_DIR)/ftnames.c \
$(BASE_DIR)/ftobjs.c \
$(BASE_DIR)/ftoutln.c \
$(BASE_DIR)/ftrfork.c \
$(BASE_DIR)/ftsnames.c \
$(BASE_DIR)/ftstream.c \
$(BASE_DIR)/fttrigon.c \
$(BASE_DIR)/ftutil.c

6
src/libs/freetype2/bdf/bdf.h
View File

@ -114,8 +114,8 @@ FT_BEGIN_HEADER
union
{
char* atom;
long int32;
unsigned long card32;
long l;
unsigned long ul;
} value; /* Value of the property. */
@ -160,7 +160,7 @@ FT_BEGIN_HEADER
typedef struct _hashnode_
{
const char* key;
void* data;
size_t data;
} _hashnode, *hashnode;

68
src/libs/freetype2/bdf/bdfdrivr.c
View File

@ -53,7 +53,7 @@ THE SOFTWARE.
typedef struct BDF_CMapRec_
{
FT_CMapRec cmap;
FT_UInt num_encodings;
FT_ULong num_encodings; /* ftobjs.h: FT_CMap->clazz->size */
BDF_encoding_el* encodings;
} BDF_CMapRec, *BDF_CMap;
@ -92,8 +92,8 @@ THE SOFTWARE.
{
BDF_CMap cmap = (BDF_CMap)bdfcmap;
BDF_encoding_el* encodings = cmap->encodings;
FT_UInt min, max, mid;
FT_UInt result = 0;
FT_ULong min, max, mid; /* num_encodings */
FT_UShort result = 0; /* encodings->glyph */
min = 0;
@ -101,7 +101,7 @@ THE SOFTWARE.
while ( min < max )
{
FT_UInt32 code;
FT_ULong code;
mid = ( min + max ) >> 1;
@ -131,9 +131,9 @@ THE SOFTWARE.
{
BDF_CMap cmap = (BDF_CMap)bdfcmap;
BDF_encoding_el* encodings = cmap->encodings;
FT_UInt min, max, mid;
FT_UInt32 charcode = *acharcode + 1;
FT_UInt result = 0;
FT_ULong min, max, mid; /* num_encodings */
FT_UShort result = 0; /* encodings->glyph */
FT_ULong charcode = *acharcode + 1;
min = 0;
@ -141,7 +141,7 @@ THE SOFTWARE.
while ( min < max )
{
FT_UInt32 code;
FT_ULong code; /* same as BDF_encoding_el.enc */
mid = ( min + max ) >> 1;
@ -169,7 +169,14 @@ THE SOFTWARE.
}
Exit:
*acharcode = charcode;
if ( charcode > 0xFFFFFFFFUL )
{
FT_TRACE1(( "bdf_cmap_char_next: charcode 0x%x > 32bit API" ));
*acharcode = 0;
/* XXX: result should be changed to indicate an overflow error */
}
else
*acharcode = (FT_UInt32)charcode;
return result;
}
@ -196,9 +203,8 @@ THE SOFTWARE.
bdf_font_t* font = bdf->bdffont;
bdf_property_t* prop;
int nn, len;
char* strings[4] = { NULL, NULL, NULL, NULL };
int lengths[4];
char* strings[4] = { NULL, NULL, NULL, NULL };
size_t nn, len, lengths[4];
face->style_flags = 0;
@ -284,7 +290,7 @@ THE SOFTWARE.
/* add_style_name and setwidth_name */
if ( nn == 0 || nn == 3 )
{
int mm;
size_t mm;
for ( mm = 0; mm < len; mm++ )
@ -426,7 +432,7 @@ THE SOFTWARE.
prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
if ( prop )
bsize->width = (FT_Short)( ( prop->value.int32 + 5 ) / 10 );
bsize->width = (FT_Short)( ( prop->value.l + 5 ) / 10 );
else
bsize->width = (FT_Short)( bsize->height * 2/3 );
@ -434,21 +440,21 @@ THE SOFTWARE.
if ( prop )
/* convert from 722.7 decipoints to 72 points per inch */
bsize->size =
(FT_Pos)( ( prop->value.int32 * 64 * 7200 + 36135L ) / 72270L );
(FT_Pos)( ( prop->value.l * 64 * 7200 + 36135L ) / 72270L );
else
bsize->size = bsize->width << 6;
prop = bdf_get_font_property( font, "PIXEL_SIZE" );
if ( prop )
bsize->y_ppem = (FT_Short)prop->value.int32 << 6;
bsize->y_ppem = (FT_Short)prop->value.l << 6;
prop = bdf_get_font_property( font, "RESOLUTION_X" );
if ( prop )
resolution_x = (FT_Short)prop->value.int32;
resolution_x = (FT_Short)prop->value.l;
prop = bdf_get_font_property( font, "RESOLUTION_Y" );
if ( prop )
resolution_y = (FT_Short)prop->value.int32;
resolution_y = (FT_Short)prop->value.l;
if ( bsize->y_ppem == 0 )
{
@ -479,7 +485,12 @@ THE SOFTWARE.
(face->en_table[n]).glyph = (FT_Short)n;
if ( cur[n].encoding == font->default_char )
face->default_glyph = n;
{
if ( n < FT_UINT_MAX )
face->default_glyph = (FT_UInt)n;
else
FT_TRACE1(( "idx %d is too large for this system\n", n ));
}
}
}
@ -671,7 +682,10 @@ THE SOFTWARE.
bitmap->rows = glyph.bbx.height;
bitmap->width = glyph.bbx.width;
bitmap->pitch = glyph.bpr;
if ( glyph.bpr > INT_MAX )
FT_TRACE1(( "BDF_Glyph_Load: too large pitch %d is truncated\n",
glyph.bpr ));
bitmap->pitch = (int)glyph.bpr; /* same as FT_Bitmap.pitch */
/* note: we don't allocate a new array to hold the bitmap; */
/* we can simply point to it */
@ -743,13 +757,23 @@ THE SOFTWARE.
break;
case BDF_INTEGER:
if ( prop->value.l > 0x7FFFFFFFL || prop->value.l < ( -1 - 0x7FFFFFFFL ) )
{
FT_TRACE1(( "bdf_get_bdf_property: " ));
FT_TRACE1(( "too large integer 0x%x is truncated\n" ));
}
aproperty->type = BDF_PROPERTY_TYPE_INTEGER;
aproperty->u.integer = prop->value.int32;
aproperty->u.integer = (FT_Int32)prop->value.l;
break;
case BDF_CARDINAL:
if ( prop->value.ul > 0xFFFFFFFFUL )
{
FT_TRACE1(( "bdf_get_bdf_property: " ));
FT_TRACE1(( "too large cardinal 0x%x is truncated\n" ));
}
aproperty->type = BDF_PROPERTY_TYPE_CARDINAL;
aproperty->u.cardinal = prop->value.card32;
aproperty->u.cardinal = (FT_UInt32)prop->value.ul;
break;
default:

4
src/libs/freetype2/bdf/bdfdrivr.h
View File

@ -36,6 +36,10 @@ THE SOFTWARE.
FT_BEGIN_HEADER
#ifdef FT_CONFIG_OPTION_PIC
#error "this module does not support PIC yet"
#endif
typedef struct BDF_encoding_el_
{

78
src/libs/freetype2/bdf/bdflib.c
View File

@ -281,7 +281,7 @@
static FT_Error
hash_insert( char* key,
void* data,
size_t data,
hashtable* ht,
FT_Memory memory )
{
@ -415,18 +415,18 @@
static FT_Error
_bdf_list_ensure( _bdf_list_t* list,
int num_items )
_bdf_list_ensure( _bdf_list_t* list,
unsigned long num_items ) /* same as _bdf_list_t.used */
{
FT_Error error = BDF_Err_Ok;
if ( num_items > (int)list->size )
if ( num_items > list->size )
{
int oldsize = list->size;
int newsize = oldsize + ( oldsize >> 1 ) + 4;
int bigsize = FT_INT_MAX / sizeof ( char* );
FT_Memory memory = list->memory;
unsigned long oldsize = list->size; /* same as _bdf_list_t.size */
unsigned long newsize = oldsize + ( oldsize >> 1 ) + 4;
unsigned long bigsize = (unsigned long)( FT_INT_MAX / sizeof ( char* ) );
FT_Memory memory = list->memory;
if ( oldsize == bigsize )
@ -614,8 +614,8 @@
{
_bdf_line_func_t cb;
unsigned long lineno, buf_size;
int refill, bytes, hold, to_skip;
int start, end, cursor, avail;
int refill, hold, to_skip;
ptrdiff_t bytes, start, end, cursor, avail;
char* buf = 0;
FT_Memory memory = stream->memory;
FT_Error error = BDF_Err_Ok;
@ -648,8 +648,8 @@
{
if ( refill )
{
bytes = (int)FT_Stream_TryRead( stream, (FT_Byte*)buf + cursor,
(FT_ULong)(buf_size - cursor) );
bytes = (ptrdiff_t)FT_Stream_TryRead( stream, (FT_Byte*)buf + cursor,
(FT_ULong)(buf_size - cursor) );
avail = cursor + bytes;
cursor = 0;
refill = 0;
@ -971,7 +971,7 @@
int format,
bdf_font_t* font )
{
unsigned long n;
size_t n;
bdf_property_t* p;
FT_Memory memory = font->memory;
FT_Error error = BDF_Err_Ok;
@ -991,7 +991,9 @@
p = font->user_props + font->nuser_props;
FT_ZERO( p );
n = (unsigned long)( ft_strlen( name ) + 1 );
n = ft_strlen( name ) + 1;
if ( n > FT_ULONG_MAX )
return BDF_Err_Invalid_Argument;
if ( FT_NEW_ARRAY( p->name, n ) )
goto Exit;
@ -1003,7 +1005,7 @@
n = _num_bdf_properties + font->nuser_props;
error = hash_insert( p->name, (void *)n, &(font->proptbl), memory );
error = hash_insert( p->name, n, &(font->proptbl), memory );
if ( error )
goto Exit;
@ -1018,8 +1020,8 @@
bdf_get_property( char* name,
bdf_font_t* font )
{
hashnode hn;
unsigned long propid;
hashnode hn;
size_t propid;
if ( name == 0 || *name == 0 )
@ -1028,7 +1030,7 @@
if ( ( hn = hash_lookup( name, &(font->proptbl) ) ) == 0 )
return 0;
propid = (unsigned long)hn->data;
propid = hn->data;
if ( propid >= _num_bdf_properties )
return font->user_props + ( propid - _num_bdf_properties );
@ -1131,11 +1133,11 @@
_bdf_set_default_spacing( bdf_font_t* font,
bdf_options_t* opts )
{
unsigned long len;
char name[256];
_bdf_list_t list;
FT_Memory memory;
FT_Error error = BDF_Err_Ok;
size_t len;
char name[256];
_bdf_list_t list;
FT_Memory memory;
FT_Error error = BDF_Err_Ok;
if ( font == 0 || font->name == 0 || font->name[0] == 0 )
@ -1150,7 +1152,7 @@
font->spacing = opts->font_spacing;
len = (unsigned long)( ft_strlen( font->name ) + 1 );
len = ft_strlen( font->name ) + 1;
/* Limit ourselves to 256 characters in the font name. */
if ( len >= 256 )
{
@ -1261,7 +1263,7 @@
char* name,
char* value )
{
unsigned long propid;
size_t propid;
hashnode hn;
bdf_property_t *prop, *fp;
FT_Memory memory = font->memory;
@ -1273,7 +1275,7 @@
{
/* The property already exists in the font, so simply replace */
/* the value of the property with the current value. */
fp = font->props + (unsigned long)hn->data;
fp = font->props + hn->data;
switch ( fp->format )
{
@ -1289,11 +1291,11 @@
break;
case BDF_INTEGER:
fp->value.int32 = _bdf_atol( value, 0, 10 );
fp->value.l = _bdf_atol( value, 0, 10 );
break;
case BDF_CARDINAL:
fp->value.card32 = _bdf_atoul( value, 0, 10 );
fp->value.ul = _bdf_atoul( value, 0, 10 );
break;
default:
@ -1335,7 +1337,7 @@
font->props_size++;
}
propid = (unsigned long)hn->data;
propid = hn->data;
if ( propid >= _num_bdf_properties )
prop = font->user_props + ( propid - _num_bdf_properties );
else
@ -1359,11 +1361,11 @@
break;
case BDF_INTEGER:
fp->value.int32 = _bdf_atol( value, 0, 10 );
fp->value.l = _bdf_atol( value, 0, 10 );
break;
case BDF_CARDINAL:
fp->value.card32 = _bdf_atoul( value, 0, 10 );
fp->value.ul = _bdf_atoul( value, 0, 10 );
break;
}
@ -1372,7 +1374,7 @@
if ( ft_memcmp( name, "COMMENT", 7 ) != 0 ) {
/* Add the property to the font property table. */
error = hash_insert( fp->name,
(void *)font->props_used,
font->props_used,
(hashtable *)font->internal,
memory );
if ( error )
@ -1387,11 +1389,11 @@
/* present, and the SPACING property should override the default */
/* spacing. */
if ( ft_memcmp( name, "DEFAULT_CHAR", 12 ) == 0 )
font->default_char = fp->value.int32;
font->default_char = fp->value.l;
else if ( ft_memcmp( name, "FONT_ASCENT", 11 ) == 0 )
font->font_ascent = fp->value.int32;
font->font_ascent = fp->value.l;
else if ( ft_memcmp( name, "FONT_DESCENT", 12 ) == 0 )
font->font_descent = fp->value.int32;
font->font_descent = fp->value.l;
else if ( ft_memcmp( name, "SPACING", 7 ) == 0 )
{
if ( !fp->value.atom )
@ -2044,7 +2046,7 @@
p->memory = 0;
{ /* setup */
unsigned long i;
size_t i;
bdf_property_t* prop;
@ -2054,7 +2056,7 @@
for ( i = 0, prop = (bdf_property_t*)_bdf_properties;
i < _num_bdf_properties; i++, prop++ )
{
error = hash_insert( prop->name, (void *)i,
error = hash_insert( prop->name, i,
&(font->proptbl), memory );
if ( error )
goto Exit;
@ -2472,7 +2474,7 @@
hn = hash_lookup( name, (hashtable *)font->internal );
return hn ? ( font->props + (unsigned long)hn->data ) : 0;
return hn ? ( font->props + hn->data ) : 0;
}

94
src/libs/freetype2/cache/ftcbasic.c vendored
View File

@ -4,7 +4,7 @@
/* */
/* The FreeType basic cache interface (body). */
/* */
/* Copyright 2003, 2004, 2005, 2006, 2007 by */
/* Copyright 2003, 2004, 2005, 2006, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -17,15 +17,17 @@
#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_CACHE_H
#include "ftcglyph.h"
#include "ftcimage.h"
#include "ftcsbits.h"
#include FT_INTERNAL_MEMORY_H
#include "ftccback.h"
#include "ftcerror.h"
#define FT_COMPONENT trace_cache
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
@ -140,8 +142,18 @@
error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
&face );
if ( error || !face )
return result;
if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
{
FT_TRACE1(( "ftc_basic_family_get_count: too large number of glyphs " ));
FT_TRACE1(( "in this face, truncated\n", face->num_glyphs ));
}
if ( !error )
result = face->num_glyphs;
result = (FT_UInt)face->num_glyphs;
return result;
}
@ -304,7 +316,7 @@
FTC_Node *anode )
{
FTC_BasicQueryRec query;
FTC_INode node = 0; /* make compiler happy */
FTC_Node node = 0; /* make compiler happy */
FT_Error error;
FT_UInt32 hash;
@ -320,13 +332,13 @@
if ( anode )
*anode = NULL;
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
/*
* This one is a major hack used to detect whether we are passed a
* regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
*/
if ( type->width >= 0x10000 )
if ( (FT_ULong)type->width >= 0x10000L )
{
FTC_OldImageDesc desc = (FTC_OldImageDesc)type;
@ -341,10 +353,16 @@
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
{
if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
{
FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
}
query.attrs.scaler.face_id = type->face_id;
query.attrs.scaler.width = type->width;
query.attrs.scaler.height = type->height;
query.attrs.load_flags = type->flags;
query.attrs.load_flags = (FT_UInt)type->flags;
}
query.attrs.scaler.pixel = 1;
@ -365,7 +383,7 @@
error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
hash, gindex,
FTC_GQUERY( &query ),
(FTC_Node*) &node );
&node );
#endif
if ( !error )
{
@ -373,8 +391,8 @@
if ( anode )
{
*anode = FTC_NODE( node );
FTC_NODE( node )->ref_count++;
*anode = node;
node->ref_count++;
}
}
@ -394,7 +412,7 @@
FTC_Node *anode )
{
FTC_BasicQueryRec query;
FTC_INode node = 0; /* make compiler happy */
FTC_Node node = 0; /* make compiler happy */
FT_Error error;
FT_UInt32 hash;
@ -410,8 +428,15 @@
if ( anode )
*anode = NULL;
/* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
if ( load_flags > FT_UINT_MAX )
{
FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
}
query.attrs.scaler = scaler[0];
query.attrs.load_flags = load_flags;
query.attrs.load_flags = (FT_UInt)load_flags;
hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
@ -428,8 +453,8 @@
if ( anode )
{
*anode = FTC_NODE( node );
FTC_NODE( node )->ref_count++;
*anode = node;
node->ref_count++;
}
}
@ -630,7 +655,7 @@
{
FT_Error error;
FTC_BasicQueryRec query;
FTC_SNode node = 0; /* make compiler happy */
FTC_Node node = 0; /* make compiler happy */
FT_UInt32 hash;
@ -643,12 +668,12 @@
*ansbit = NULL;
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
/* This one is a major hack used to detect whether we are passed a
* regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
*/
if ( type->width >= 0x10000 )
if ( (FT_ULong)type->width >= 0x10000L )
{
FTC_OldImageDesc desc = (FTC_OldImageDesc)type;
@ -663,10 +688,16 @@
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
{
if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
{
FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
}
query.attrs.scaler.face_id = type->face_id;
query.attrs.scaler.width = type->width;
query.attrs.scaler.height = type->height;
query.attrs.load_flags = type->flags;
query.attrs.load_flags = (FT_UInt)type->flags;
}
query.attrs.scaler.pixel = 1;
@ -690,17 +721,18 @@
hash,
gindex,
FTC_GQUERY( &query ),
(FTC_Node*)&node );
&node );
#endif
if ( error )
goto Exit;
*ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
*ansbit = FTC_SNODE( node )->sbits +
( gindex - FTC_GNODE( node )->gindex );
if ( anode )
{
*anode = FTC_NODE( node );
FTC_NODE( node )->ref_count++;
*anode = node;
node->ref_count++;
}
Exit:
@ -720,7 +752,7 @@
{
FT_Error error;
FTC_BasicQueryRec query;
FTC_SNode node = 0; /* make compiler happy */
FTC_Node node = 0; /* make compiler happy */
FT_UInt32 hash;
@ -733,8 +765,15 @@
*ansbit = NULL;
/* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
if ( load_flags > FT_UINT_MAX )
{
FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
}
query.attrs.scaler = scaler[0];
query.attrs.load_flags = load_flags;
query.attrs.load_flags = (FT_UInt)load_flags;
/* beware, the hash must be the same for all glyph ranges! */
hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
@ -750,12 +789,13 @@
if ( error )
goto Exit;
*ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
*ansbit = FTC_SNODE( node )->sbits +
( gindex - FTC_GNODE( node )->gindex );
if ( anode )
{
*anode = FTC_NODE( node );
FTC_NODE( node )->ref_count++;
*anode = node;
node->ref_count++;
}
Exit:

23
src/libs/freetype2/cache/ftccache.c vendored
View File

@ -4,7 +4,7 @@
/* */
/* The FreeType internal cache interface (body). */
/* */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007 by */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -24,6 +24,9 @@
#include "ftccback.h"
#include "ftcerror.h"
#undef FT_COMPONENT
#define FT_COMPONENT trace_cache
#define FTC_HASH_MAX_LOAD 2
#define FTC_HASH_MIN_LOAD 1
@ -93,9 +96,9 @@
for (;;)
{
FTC_Node node, *pnode;
FT_UInt p = cache->p;
FT_UInt mask = cache->mask;
FT_UInt count = mask + p + 1; /* number of buckets */
FT_UFast p = cache->p;
FT_UFast mask = cache->mask;
FT_UFast count = mask + p + 1; /* number of buckets */
/* do we need to shrink the buckets array? */
@ -153,7 +156,7 @@
/* do we need to expand the buckets array? */
else if ( cache->slack > (FT_Long)count * FTC_HASH_SUB_LOAD )
{
FT_UInt old_index = p + mask;
FT_UFast old_index = p + mask;
FTC_Node* pold;
@ -216,7 +219,7 @@
if ( node == NULL )
{
FT_ERROR(( "ftc_node_hash_unlink: unknown node!\n" ));
FT_TRACE0(( "ftc_node_hash_unlink: unknown node\n" ));
return;
}
@ -273,7 +276,7 @@
/* find node's cache */
if ( node->cache_index >= manager->num_caches )
{
FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
return;
}
#endif
@ -283,7 +286,7 @@
#ifdef FT_DEBUG_ERROR
if ( cache == NULL )
{
FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
return;
}
#endif
@ -302,7 +305,7 @@
#if 0
/* check, just in case of general corruption :-) */
if ( manager->num_nodes == 0 )
FT_ERROR(( "ftc_node_destroy: invalid cache node count! = %d\n",
FT_TRACE0(( "ftc_node_destroy: invalid cache node count (%d)\n",
manager->num_nodes ));
#endif
}
@ -347,7 +350,7 @@
{
FTC_Manager manager = cache->manager;
FT_UFast i;
FT_UInt count;
FT_UFast count;
count = cache->p + cache->mask + 1;

11
src/libs/freetype2/cache/ftccache.h vendored
View File

@ -4,7 +4,7 @@
/* */
/* FreeType internal cache interface (specification). */
/* */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007 by */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -91,7 +91,7 @@ FT_BEGIN_HEADER
FT_Pointer query,
FTC_Cache cache );
typedef FT_ULong
typedef FT_Offset
(*FTC_Node_WeightFunc)( FTC_Node node,
FTC_Cache cache );
@ -121,7 +121,7 @@ FT_BEGIN_HEADER
FTC_Node_CompareFunc node_remove_faceid;
FTC_Node_FreeFunc node_free;
FT_UInt cache_size;
FT_Offset cache_size;
FTC_Cache_InitFunc cache_init;
FTC_Cache_DoneFunc cache_done;
@ -202,7 +202,7 @@ FT_BEGIN_HEADER
FTC_Cache _cache = FTC_CACHE(cache); \
FT_UInt32 _hash = (FT_UInt32)(hash); \
FTC_Node_CompareFunc _nodcomp = (FTC_Node_CompareFunc)(nodecmp); \
FT_UInt _idx; \
FT_UFast _idx; \
\
\
error = 0; \
@ -246,8 +246,7 @@ FT_BEGIN_HEADER
error = FTC_Cache_NewNode( _cache, _hash, query, &_node ); \
\
_Ok: \
_pnode = (FTC_Node*)(void*)&(node); \
*_pnode = _node; \
node = _node; \
FT_END_STMNT
#else /* !FTC_INLINE */

4
src/libs/freetype2/cache/ftccback.h vendored
View File

@ -36,7 +36,7 @@
FT_Pointer gquery,
FTC_Cache cache );
FT_LOCAL( FT_ULong )
FT_LOCAL( FT_Offset )
ftc_inode_weight( FTC_Node inode,
FTC_Cache cache );
@ -50,7 +50,7 @@
FT_Pointer gquery,
FTC_Cache cache );
FT_LOCAL( FT_ULong )
FT_LOCAL( FT_Offset )
ftc_snode_weight( FTC_Node snode,
FTC_Cache cache );

34
src/libs/freetype2/cache/ftccmap.c vendored
View File

@ -4,7 +4,7 @@
/* */
/* FreeType CharMap cache (body) */
/* */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -22,7 +22,6 @@
#include "ftcmanag.h"
#include FT_INTERNAL_MEMORY_H
#include FT_INTERNAL_DEBUG_H
#include FT_TRUETYPE_IDS_H
#include "ftccback.h"
#include "ftcerror.h"
@ -86,9 +85,9 @@
#define FTC_CMAP_INDICES_MAX 128
/* compute a query/node hash */
#define FTC_CMAP_HASH( faceid, index, charcode ) \
( FTC_FACE_ID_HASH( faceid ) + 211 * ( index ) + \
( (char_code) / FTC_CMAP_INDICES_MAX ) )
#define FTC_CMAP_HASH( faceid, index, charcode ) \
( FTC_FACE_ID_HASH( faceid ) + 211 * (index) + \
( (charcode) / FTC_CMAP_INDICES_MAX ) )
/* the charmap query */
typedef struct FTC_CMapQueryRec_
@ -175,7 +174,7 @@
/* compute the weight of a given cmap node */
FT_CALLBACK_DEF( FT_ULong )
FT_CALLBACK_DEF( FT_Offset )
ftc_cmap_node_weight( FTC_Node cnode,
FTC_Cache cache )
{
@ -284,7 +283,7 @@
{
FTC_Cache cache = FTC_CACHE( cmap_cache );
FTC_CMapQueryRec query;
FTC_CMapNode node;
FTC_Node node;
FT_Error error;
FT_UInt gindex = 0;
FT_UInt32 hash;
@ -304,7 +303,7 @@
if ( !cache )
{
FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0!\n" ));
FT_TRACE0(( "FTC_CMapCache_Lookup: bad arguments, returning 0\n" ));
return 0;
}
@ -374,18 +373,21 @@
FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
node, error );
#else
error = FTC_Cache_Lookup( cache, hash, &query, (FTC_Node*) &node );
error = FTC_Cache_Lookup( cache, hash, &query, &node );
#endif
if ( error )
goto Exit;
FT_ASSERT( (FT_UInt)( char_code - node->first ) < FTC_CMAP_INDICES_MAX );
FT_ASSERT( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first ) <
FTC_CMAP_INDICES_MAX );
/* something rotten can happen with rogue clients */
if ( (FT_UInt)( char_code - node->first >= FTC_CMAP_INDICES_MAX ) )
if ( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first >=
FTC_CMAP_INDICES_MAX ) )
return 0;
gindex = node->indices[char_code - node->first];
gindex = FTC_CMAP_NODE( node )->indices[char_code -
FTC_CMAP_NODE( node )->first];
if ( gindex == FTC_CMAP_UNKNOWN )
{
FT_Face face;
@ -393,7 +395,9 @@
gindex = 0;
error = FTC_Manager_LookupFace( cache->manager, node->face_id, &face );
error = FTC_Manager_LookupFace( cache->manager,
FTC_CMAP_NODE( node )->face_id,
&face );
if ( error )
goto Exit;
@ -414,7 +418,9 @@
FT_Set_Charmap( face, old );
}
node->indices[char_code - node->first] = (FT_UShort)gindex;
FTC_CMAP_NODE( node )->indices[char_code -
FTC_CMAP_NODE( node )->first]
= (FT_UShort)gindex;
}
Exit:

4
src/libs/freetype2/cache/ftcglyph.c vendored
View File

@ -4,7 +4,7 @@
/* */
/* FreeType Glyph Image (FT_Glyph) cache (body). */
/* */
/* Copyright 2000-2001, 2003, 2004, 2006 by */
/* Copyright 2000-2001, 2003, 2004, 2006, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -20,8 +20,6 @@
#include FT_CACHE_H
#include "ftcglyph.h"
#include FT_ERRORS_H
#include FT_INTERNAL_OBJECTS_H
#include FT_INTERNAL_DEBUG_H
#include "ftccback.h"
#include "ftcerror.h"

9
src/libs/freetype2/cache/ftcglyph.h vendored
View File

@ -277,12 +277,14 @@ FT_BEGIN_HEADER
FTC_GCache _gcache = FTC_GCACHE( cache ); \
FTC_GQuery _gquery = (FTC_GQuery)( query ); \
FTC_MruNode_CompareFunc _fcompare = (FTC_MruNode_CompareFunc)(famcmp); \
FTC_MruNode _mrunode; \
\
\
_gquery->gindex = (gindex); \
\
FTC_MRULIST_LOOKUP_CMP( &_gcache->families, _gquery, _fcompare, \
_gquery->family, error ); \
_mrunode, error ); \
_gquery->family = FTC_FAMILY( _mrunode ); \
if ( !error ) \
{ \
FTC_Family _gqfamily = _gquery->family; \
@ -303,11 +305,10 @@ FT_BEGIN_HEADER
#define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \
gindex, query, node, error ) \
FT_BEGIN_STMNT \
void* _n = &(node); \
\
\
error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, \
FTC_GQUERY( query ), (FTC_Node*)_n ); \
FTC_GQUERY( query ), node ); \
\
FT_END_STMNT
#endif /* !FTC_INLINE */

6
src/libs/freetype2/cache/ftcimage.c vendored
View File

@ -103,12 +103,12 @@
}
FT_LOCAL_DEF( FT_ULong )
FT_LOCAL_DEF( FT_Offset )
ftc_inode_weight( FTC_Node ftcinode,
FTC_Cache ftccache )
{
FTC_INode inode = (FTC_INode)ftcinode;
FT_ULong size = 0;
FT_Offset size = 0;
FT_Glyph glyph = inode->glyph;
FT_UNUSED( ftccache );
@ -151,7 +151,7 @@
#if 0
FT_LOCAL_DEF( FT_ULong )
FT_LOCAL_DEF( FT_Offset )
FTC_INode_Weight( FTC_INode inode )
{
return ftc_inode_weight( FTC_NODE( inode ), NULL );

56
src/libs/freetype2/cache/ftcmanag.c vendored
View File

@ -26,6 +26,10 @@
#include "ftccback.h"
#include "ftcerror.h"
#ifdef FT_CONFIG_OPTION_PIC
#error "cache system does not support PIC yet"
#endif
#undef FT_COMPONENT
#define FT_COMPONENT trace_cache
@ -78,6 +82,8 @@
} FTC_SizeNodeRec, *FTC_SizeNode;
#define FTC_SIZE_NODE( x ) ( (FTC_SizeNode)( x ) )
FT_CALLBACK_DEF( void )
ftc_size_node_done( FTC_MruNode ftcnode,
@ -176,8 +182,8 @@
FTC_Scaler scaler,
FT_Size *asize )
{
FT_Error error;
FTC_SizeNode node;
FT_Error error;
FTC_MruNode mrunode;
if ( asize == NULL )
@ -191,14 +197,14 @@
#ifdef FTC_INLINE
FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
node, error );
mrunode, error );
#else
error = FTC_MruList_Lookup( &manager->sizes, scaler, (FTC_MruNode*)&node );
error = FTC_MruList_Lookup( &manager->sizes, scaler, &mrunode );
#endif
if ( !error )
*asize = node->size;
*asize = FTC_SIZE_NODE( mrunode )->size;
return error;
}
@ -220,6 +226,8 @@
} FTC_FaceNodeRec, *FTC_FaceNode;
#define FTC_FACE_NODE( x ) ( ( FTC_FaceNode )( x ) )
FT_CALLBACK_DEF( FT_Error )
ftc_face_node_init( FTC_MruNode ftcnode,
@ -301,8 +309,8 @@
FTC_FaceID face_id,
FT_Face *aface )
{
FT_Error error;
FTC_FaceNode node;
FT_Error error;
FTC_MruNode mrunode;
if ( aface == NULL )
@ -317,14 +325,14 @@
#ifdef FTC_INLINE
FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
node, error );
mrunode, error );
#else
error = FTC_MruList_Lookup( &manager->faces, face_id, (FTC_MruNode*)&node );
error = FTC_MruList_Lookup( &manager->faces, face_id, &mrunode );
#endif
if ( !error )
*aface = node->face;
*aface = FTC_FACE_NODE( mrunode )->face;
return error;
}
@ -476,8 +484,8 @@
if ( (FT_UInt)node->cache_index >= manager->num_caches )
FT_ERROR(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
node->cache_index ));
FT_TRACE0(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
node->cache_index ));
else
weight += cache->clazz.node_weight( node, cache );
@ -486,8 +494,8 @@
} while ( node != first );
if ( weight != manager->cur_weight )
FT_ERROR(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
manager->cur_weight, weight ));
FT_TRACE0(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
manager->cur_weight, weight ));
}
/* check circular list */
@ -505,9 +513,9 @@
} while ( node != first );
if ( count != manager->num_nodes )
FT_ERROR((
"FTC_Manager_Check: invalid cache node count %d instead of %d\n",
manager->num_nodes, count ));
FT_TRACE0(( "FTC_Manager_Check:"
" invalid cache node count %d instead of %d\n",
manager->num_nodes, count ));
}
}
@ -534,9 +542,9 @@
#ifdef FT_DEBUG_ERROR
FTC_Manager_Check( manager );
FT_ERROR(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
manager->cur_weight, manager->max_weight,
manager->num_nodes ));
FT_TRACE0(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
manager->cur_weight, manager->max_weight,
manager->num_nodes ));
#endif
if ( manager->cur_weight < manager->max_weight || first == NULL )
@ -579,8 +587,8 @@
if ( manager->num_caches >= FTC_MAX_CACHES )
{
error = FTC_Err_Too_Many_Caches;
FT_ERROR(( "%s: too many registered caches\n",
"FTC_Manager_Register_Cache" ));
FT_ERROR(( "FTC_Manager_RegisterCache:"
" too many registered caches\n" ));
goto Exit;
}
@ -661,7 +669,9 @@
/* this will remove all FTC_SizeNode that correspond to
* the face_id as well
*/
FTC_MruList_RemoveSelection( &manager->faces, NULL, face_id );
FTC_MruList_RemoveSelection( &manager->faces,
(FTC_MruNode_CompareFunc)NULL,
face_id );
for ( nn = 0; nn < manager->num_caches; nn++ )
FTC_Cache_RemoveFaceID( manager->caches[nn], face_id );

8
src/libs/freetype2/cache/ftcmru.c vendored
View File

@ -4,7 +4,7 @@
/* */
/* FreeType MRU support (body). */
/* */
/* Copyright 2003, 2004, 2006 by */
/* Copyright 2003, 2004, 2006, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -46,7 +46,7 @@
{
if ( cnode == node )
{
fprintf( stderr, "FTC_MruNode_Prepend: invalid action!\n" );
fprintf( stderr, "FTC_MruNode_Prepend: invalid action\n" );
exit( 2 );
}
cnode = cnode->next;
@ -94,7 +94,7 @@
} while ( cnode != first );
fprintf( stderr, "FTC_MruNode_Up: invalid action!\n" );
fprintf( stderr, "FTC_MruNode_Up: invalid action\n" );
exit( 2 );
Ok:
}
@ -141,7 +141,7 @@
} while ( cnode != first );
fprintf( stderr, "FTC_MruNode_Remove: invalid action!\n" );
fprintf( stderr, "FTC_MruNode_Remove: invalid action\n" );
exit( 2 );
Ok:
}

7
src/libs/freetype2/cache/ftcmru.h vendored
View File

@ -107,7 +107,7 @@ FT_BEGIN_HEADER
typedef struct FTC_MruListClassRec_
{
FT_UInt node_size;
FT_Offset node_size;
FTC_MruNode_CompareFunc node_compare;
FTC_MruNode_InitFunc node_init;
FTC_MruNode_ResetFunc node_reset;
@ -163,7 +163,7 @@ FT_BEGIN_HEADER
FT_BEGIN_STMNT \
FTC_MruNode* _pfirst = &(list)->nodes; \
FTC_MruNode_CompareFunc _compare = (FTC_MruNode_CompareFunc)(compare); \
FTC_MruNode _first, _node, *_pnode; \
FTC_MruNode _first, _node; \
\
\
error = 0; \
@ -180,8 +180,7 @@ FT_BEGIN_HEADER
if ( _node != _first ) \
FTC_MruNode_Up( _pfirst, _node ); \
\
_pnode = (FTC_MruNode*)(void*)&(node); \
*_pnode = _node; \
node = _node; \
goto _MruOk; \
} \
_node = _node->next; \

17
src/libs/freetype2/cache/ftcsbits.c vendored
View File

@ -4,7 +4,7 @@
/* */
/* FreeType sbits manager (body). */
/* */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006 by */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -26,6 +26,9 @@
#include "ftccback.h"
#include "ftcerror.h"
#undef FT_COMPONENT
#define FT_COMPONENT trace_cache
/*************************************************************************/
/*************************************************************************/
@ -129,13 +132,13 @@
FT_Int temp;
FT_GlyphSlot slot = face->glyph;
FT_Bitmap* bitmap = &slot->bitmap;
FT_Int xadvance, yadvance;
FT_Pos xadvance, yadvance; /* FT_GlyphSlot->advance.{x|y} */
if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
{
FT_ERROR(( "%s: glyph loaded didn't return a bitmap!\n",
"ftc_snode_load" ));
FT_TRACE0(( "ftc_snode_load:"
" glyph loaded didn't return a bitmap\n" ));
goto BadGlyph;
}
@ -263,7 +266,7 @@
}
FT_LOCAL_DEF( FT_ULong )
FT_LOCAL_DEF( FT_Offset )
ftc_snode_weight( FTC_Node ftcsnode,
FTC_Cache cache )
{
@ -271,7 +274,7 @@
FT_UInt count = snode->count;
FTC_SBit sbit = snode->sbits;
FT_Int pitch;
FT_ULong size;
FT_Offset size;
FT_UNUSED( cache );
@ -300,7 +303,7 @@
#if 0
FT_LOCAL_DEF( FT_ULong )
FT_LOCAL_DEF( FT_Offset )
FTC_SNode_Weight( FTC_SNode snode )
{
return ftc_snode_weight( FTC_NODE( snode ), NULL );

1
src/libs/freetype2/cff/cff.c
View File

@ -19,6 +19,7 @@
#define FT_MAKE_OPTION_SINGLE_OBJECT
#include <ft2build.h>
#include "cffpic.c"
#include "cffdrivr.c"
#include "cffparse.c"
#include "cffload.c"

17
src/libs/freetype2/cff/cffcmap.c
View File

@ -65,7 +65,7 @@
}
FT_CALLBACK_DEF( FT_UInt )
FT_CALLBACK_DEF( FT_UInt32 )
cff_cmap_encoding_char_next( CFF_CMapStd cmap,
FT_UInt32 *pchar_code )
{
@ -99,9 +99,7 @@
}
FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
cff_cmap_encoding_class_rec =
{
FT_DEFINE_CMAP_CLASS(cff_cmap_encoding_class_rec,
sizeof ( CFF_CMapStdRec ),
(FT_CMap_InitFunc) cff_cmap_encoding_init,
@ -110,7 +108,7 @@
(FT_CMap_CharNextFunc) cff_cmap_encoding_char_next,
NULL, NULL, NULL, NULL, NULL
};
)
/*************************************************************************/
@ -194,7 +192,7 @@
}
FT_CALLBACK_DEF( FT_UInt )
FT_CALLBACK_DEF( FT_UInt32 )
cff_cmap_unicode_char_next( PS_Unicodes unicodes,
FT_UInt32 *pchar_code )
{
@ -207,9 +205,7 @@
}
FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
cff_cmap_unicode_class_rec =
{
FT_DEFINE_CMAP_CLASS(cff_cmap_unicode_class_rec,
sizeof ( PS_UnicodesRec ),
(FT_CMap_InitFunc) cff_cmap_unicode_init,
@ -218,7 +214,6 @@
(FT_CMap_CharNextFunc) cff_cmap_unicode_char_next,
NULL, NULL, NULL, NULL, NULL
};
)
/* END */

6
src/libs/freetype2/cff/cffcmap.h
View File

@ -43,8 +43,7 @@ FT_BEGIN_HEADER
} CFF_CMapStdRec;
FT_CALLBACK_TABLE const FT_CMap_ClassRec
cff_cmap_encoding_class_rec;
FT_DECLARE_CMAP_CLASS(cff_cmap_encoding_class_rec)
/*************************************************************************/
@ -57,8 +56,7 @@ FT_BEGIN_HEADER
/* unicode (synthetic) cmaps */
FT_CALLBACK_TABLE const FT_CMap_ClassRec
cff_cmap_unicode_class_rec;
FT_DECLARE_CMAP_CLASS(cff_cmap_unicode_class_rec)
FT_END_HEADER

120
src/libs/freetype2/cff/cffdrivr.c
View File

@ -21,7 +21,6 @@
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_INTERNAL_SFNT_H
#include FT_TRUETYPE_IDS_H
#include FT_SERVICE_CID_H
#include FT_SERVICE_POSTSCRIPT_CMAPS_H
#include FT_SERVICE_POSTSCRIPT_INFO_H
@ -32,8 +31,10 @@
#include "cffgload.h"
#include "cffload.h"
#include "cffcmap.h"
#include "cffparse.h"
#include "cfferrs.h"
#include "cffpic.h"
#include FT_SERVICE_XFREE86_NAME_H
#include FT_SERVICE_GLYPH_DICT_H
@ -199,7 +200,7 @@
FT_GlyphSlot slot = face->glyph;
flags |= FT_LOAD_ADVANCE_ONLY;
flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
for ( nn = 0; nn < count; nn++ )
{
@ -238,10 +239,10 @@
FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
if ( !psnames )
{
FT_ERROR(( "cff_get_glyph_name:" ));
FT_ERROR(( " cannot get glyph name from CFF & CEF fonts\n" ));
FT_ERROR(( " " ));
FT_ERROR(( " without the `PSNames' module\n" ));
FT_ERROR(( "cff_get_glyph_name:"
" cannot get glyph name from CFF & CEF fonts\n"
" "
" without the `PSNames' module\n" ));
error = CFF_Err_Unknown_File_Format;
goto Exit;
}
@ -309,11 +310,10 @@
}
static const FT_Service_GlyphDictRec cff_service_glyph_dict =
{
FT_DEFINE_SERVICE_GLYPHDICTREC(cff_service_glyph_dict,
(FT_GlyphDict_GetNameFunc) cff_get_glyph_name,
(FT_GlyphDict_NameIndexFunc)cff_get_name_index,
};
(FT_GlyphDict_NameIndexFunc)cff_get_name_index
)
/*
@ -378,13 +378,12 @@
}
static const FT_Service_PsInfoRec cff_service_ps_info =
{
FT_DEFINE_SERVICE_PSINFOREC(cff_service_ps_info,
(PS_GetFontInfoFunc) cff_ps_get_font_info,
(PS_GetFontExtraFunc) NULL,
(PS_HasGlyphNamesFunc) cff_ps_has_glyph_names,
(PS_GetFontPrivateFunc)NULL /* unsupported with CFF fonts */
};
)
/*
@ -402,10 +401,9 @@
}
static const FT_Service_PsFontNameRec cff_service_ps_name =
{
FT_DEFINE_SERVICE_PSFONTNAMEREC(cff_service_ps_name,
(FT_PsName_GetFunc)cff_get_ps_name
};
)
/*
@ -424,16 +422,16 @@
{
FT_CMap cmap = FT_CMAP( charmap );
FT_Error error = CFF_Err_Ok;
FT_Face face = FT_CMAP_FACE( cmap );
FT_Library library = FT_FACE_LIBRARY( face );
cmap_info->language = 0;
cmap_info->format = 0;
if ( cmap->clazz != &cff_cmap_encoding_class_rec &&
cmap->clazz != &cff_cmap_unicode_class_rec )
if ( cmap->clazz != &FT_CFF_CMAP_ENCODING_CLASS_REC_GET &&
cmap->clazz != &FT_CFF_CMAP_UNICODE_CLASS_REC_GET )
{
FT_Face face = FT_CMAP_FACE( cmap );
FT_Library library = FT_FACE_LIBRARY( face );
FT_Module sfnt = FT_Get_Module( library, "sfnt" );
FT_Service_TTCMaps service =
(FT_Service_TTCMaps)ft_module_get_service( sfnt,
@ -448,10 +446,9 @@
}
static const FT_Service_TTCMapsRec cff_service_get_cmap_info =
{
FT_DEFINE_SERVICE_TTCMAPSREC(cff_service_get_cmap_info,
(TT_CMap_Info_GetFunc)cff_get_cmap_info
};
)
/*
@ -498,8 +495,19 @@
*ordering = cff->ordering;
}
/*
* XXX: According to Adobe TechNote #5176, the supplement in CFF
* can be a real number. We truncate it to fit public API
* since freetype-2.3.6.
*/
if ( supplement )
*supplement = dict->cid_supplement;
{
if ( dict->cid_supplement < FT_INT_MIN ||
dict->cid_supplement > FT_INT_MAX )
FT_TRACE1(( "cff_get_ros: too large supplement %d is truncated\n",
dict->cid_supplement ));
*supplement = (FT_Int)dict->cid_supplement;
}
}
Fail:
@ -570,12 +578,11 @@
}
static const FT_Service_CIDRec cff_service_cid_info =
{
FT_DEFINE_SERVICE_CIDREC(cff_service_cid_info,
(FT_CID_GetRegistryOrderingSupplementFunc)cff_get_ros,
(FT_CID_GetIsInternallyCIDKeyedFunc) cff_get_is_cid,
(FT_CID_GetCIDFromGlyphIndexFunc) cff_get_cid_from_glyph_index
};
)
/*************************************************************************/
@ -589,20 +596,24 @@
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
static const FT_ServiceDescRec cff_services[] =
{
{ FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_CFF },
{ FT_SERVICE_ID_POSTSCRIPT_INFO, &cff_service_ps_info },
{ FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &cff_service_ps_name },
#ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
{ FT_SERVICE_ID_GLYPH_DICT, &cff_service_glyph_dict },
FT_DEFINE_SERVICEDESCREC6(cff_services,
FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_CFF,
FT_SERVICE_ID_POSTSCRIPT_INFO, &FT_CFF_SERVICE_PS_INFO_GET,
FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &FT_CFF_SERVICE_PS_NAME_GET,
FT_SERVICE_ID_GLYPH_DICT, &FT_CFF_SERVICE_GLYPH_DICT_GET,
FT_SERVICE_ID_TT_CMAP, &FT_CFF_SERVICE_GET_CMAP_INFO_GET,
FT_SERVICE_ID_CID, &FT_CFF_SERVICE_CID_INFO_GET
)
#else
FT_DEFINE_SERVICEDESCREC5(cff_services,
FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_CFF,
FT_SERVICE_ID_POSTSCRIPT_INFO, &FT_CFF_SERVICE_PS_INFO_GET,
FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &FT_CFF_SERVICE_PS_NAME_GET,
FT_SERVICE_ID_TT_CMAP, &FT_CFF_SERVICE_GET_CMAP_INFO_GET,
FT_SERVICE_ID_CID, &FT_CFF_SERVICE_CID_INFO_GET
)
#endif
{ FT_SERVICE_ID_TT_CMAP, &cff_service_get_cmap_info },
{ FT_SERVICE_ID_CID, &cff_service_cid_info },
{ NULL, NULL }
};
FT_CALLBACK_DEF( FT_Module_Interface )
cff_get_interface( FT_Module driver, /* CFF_Driver */
@ -610,9 +621,11 @@
{
FT_Module sfnt;
FT_Module_Interface result;
FT_Library library = driver->library;
FT_UNUSED(library);
result = ft_service_list_lookup( cff_services, module_interface );
result = ft_service_list_lookup( FT_CFF_SERVICES_GET, module_interface );
if ( result != NULL )
return result;
@ -625,11 +638,13 @@
/* The FT_DriverInterface structure is defined in ftdriver.h. */
FT_CALLBACK_TABLE_DEF
const FT_Driver_ClassRec cff_driver_class =
{
/* begin with the FT_Module_Class fields */
{
#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
#define CFF_SIZE_SELECT cff_size_select
#else
#define CFF_SIZE_SELECT 0
#endif
FT_DEFINE_DRIVER(cff_driver_class,
FT_MODULE_FONT_DRIVER |
FT_MODULE_DRIVER_SCALABLE |
FT_MODULE_DRIVER_HAS_HINTER,
@ -644,7 +659,6 @@
cff_driver_init,
cff_driver_done,
cff_get_interface,
},
/* now the specific driver fields */
sizeof( TT_FaceRec ),
@ -658,10 +672,8 @@
cff_slot_init,
cff_slot_done,
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
ft_stub_set_char_sizes,
ft_stub_set_pixel_sizes,
#endif
ft_stub_set_char_sizes, /* FT_CONFIG_OPTION_OLD_INTERNALS */
ft_stub_set_pixel_sizes, /* FT_CONFIG_OPTION_OLD_INTERNALS */
Load_Glyph,
@ -671,12 +683,8 @@
cff_size_request,
#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
cff_size_select
#else
0 /* FT_Size_SelectFunc */
#endif
};
CFF_SIZE_SELECT
)
/* END */

3
src/libs/freetype2/cff/cffdrivr.h
View File

@ -27,8 +27,7 @@
FT_BEGIN_HEADER
FT_CALLBACK_TABLE
const FT_Driver_ClassRec cff_driver_class;
FT_DECLARE_DRIVER( cff_driver_class )
FT_END_HEADER

96
src/libs/freetype2/cff/cffgload.c
View File

@ -18,11 +18,9 @@
#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_CALC_H
#include FT_INTERNAL_STREAM_H
#include FT_INTERNAL_SFNT_H
#include FT_OUTLINE_H
#include FT_TRUETYPE_TAGS_H
#include FT_INTERNAL_POSTSCRIPT_HINTS_H
#include "cffobjs.h"
@ -474,8 +472,6 @@
point->x = x >> 16;
point->y = y >> 16;
*control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
builder->last = *point;
}
outline->n_points++;
@ -554,27 +550,24 @@
cff_builder_close_contour( CFF_Builder* builder )
{
FT_Outline* outline = builder->current;
FT_Int first;
if ( !outline )
return;
/* XXXX: We must not include the last point in the path if it */
/* is located on the first point. */
first = outline->n_contours <= 1
? 0 : outline->contours[outline->n_contours - 2] + 1;
/* We must not include the last point in the path if it */
/* is located on the first point. */
if ( outline->n_points > 1 )
{
FT_Int first = 0;
FT_Vector* p1 = outline->points + first;
FT_Vector* p2 = outline->points + outline->n_points - 1;
FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
if ( outline->n_contours > 1 )
{
first = outline->contours[outline->n_contours - 2] + 1;
p1 = outline->points + first;
}
/* `delete' last point only if it coincides with the first */
/* point and if it is not a control point (which can happen). */
if ( p1->x == p2->x && p1->y == p2->y )
@ -583,8 +576,18 @@
}
if ( outline->n_contours > 0 )
outline->contours[outline->n_contours - 1] =
(short)( outline->n_points - 1 );
{
/* Don't add contours only consisting of one point, i.e., */
/* check whether begin point and last point are the same. */
if ( first == outline->n_points - 1 )
{
outline->n_contours--;
outline->n_points--;
}
else
outline->contours[outline->n_contours - 1] =
(short)( outline->n_points - 1 );
}
}
@ -704,6 +707,12 @@
FT_ULong charstring_len;
if ( decoder->seac )
{
FT_ERROR(( "cff_operator_seac: invalid nested seac\n" ));
return CFF_Err_Syntax_Error;
}
#ifdef FT_CONFIG_OPTION_INCREMENTAL
/* Incremental fonts don't necessarily have valid charsets. */
/* They use the character code, not the glyph index, in this case. */
@ -724,8 +733,8 @@
if ( bchar_index < 0 || achar_index < 0 )
{
FT_ERROR(( "cff_operator_seac:" ));
FT_ERROR(( " invalid seac character code arguments\n" ));
FT_ERROR(( "cff_operator_seac:"
" invalid seac character code arguments\n" ));
return CFF_Err_Syntax_Error;
}
@ -774,8 +783,11 @@
&charstring, &charstring_len );
if ( !error )
{
/* the seac operator must not be nested */
decoder->seac = TRUE;
error = cff_decoder_parse_charstrings( decoder, charstring,
charstring_len );
decoder->seac = FALSE;
if ( error )
goto Exit;
@ -800,8 +812,11 @@
&charstring, &charstring_len );
if ( !error )
{
/* the seac operator must not be nested */
decoder->seac = TRUE;
error = cff_decoder_parse_charstrings( decoder, charstring,
charstring_len );
decoder->seac = FALSE;
if ( error )
goto Exit;
@ -863,9 +878,10 @@
decoder->read_width = 1;
/* compute random seed from stack address of parameter */
seed = (FT_Fixed)(char*)&seed ^
(FT_Fixed)(char*)&decoder ^
(FT_Fixed)(char*)&charstring_base;
seed = (FT_Fixed)( ( (FT_PtrDist)(char*)&seed ^
(FT_PtrDist)(char*)&decoder ^
(FT_PtrDist)(char*)&charstring_base ) &
FT_ULONG_MAX ) ;
seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
if ( seed == 0 )
seed = 0x7384;
@ -920,18 +936,18 @@
ip += 2;
}
else if ( v < 247 )
val = (FT_Long)v - 139;
val = (FT_Int32)v - 139;
else if ( v < 251 )
{
if ( ip >= limit )
goto Syntax_Error;
val = ( (FT_Long)v - 247 ) * 256 + *ip++ + 108;
val = ( (FT_Int32)v - 247 ) * 256 + *ip++ + 108;
}
else if ( v < 255 )
{
if ( ip >= limit )
goto Syntax_Error;
val = -( (FT_Long)v - 251 ) * 256 - *ip++ - 108;
val = -( (FT_Int32)v - 251 ) * 256 - *ip++ - 108;
}
else
{
@ -2241,8 +2257,8 @@
if ( idx >= decoder->num_locals )
{
FT_ERROR(( "cff_decoder_parse_charstrings:" ));
FT_ERROR(( " invalid local subr index\n" ));
FT_ERROR(( "cff_decoder_parse_charstrings:"
" invalid local subr index\n" ));
goto Syntax_Error;
}
@ -2263,7 +2279,7 @@
if ( !zone->base || zone->limit == zone->base )
{
FT_ERROR(( "cff_decoder_parse_charstrings:"
" invoking empty subrs!\n" ));
" invoking empty subrs\n" ));
goto Syntax_Error;
}
@ -2283,8 +2299,8 @@
if ( idx >= decoder->num_globals )
{
FT_ERROR(( "cff_decoder_parse_charstrings:" ));
FT_ERROR(( " invalid global subr index\n" ));
FT_ERROR(( "cff_decoder_parse_charstrings:"
" invalid global subr index\n" ));
goto Syntax_Error;
}
@ -2305,7 +2321,7 @@
if ( !zone->base || zone->limit == zone->base )
{
FT_ERROR(( "cff_decoder_parse_charstrings:"
" invoking empty subrs!\n" ));
" invoking empty subrs\n" ));
goto Syntax_Error;
}
@ -2354,15 +2370,15 @@
return error;
Syntax_Error:
FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error!\n" ));
FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error\n" ));
return CFF_Err_Invalid_File_Format;
Stack_Underflow:
FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow!\n" ));
FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow\n" ));
return CFF_Err_Too_Few_Arguments;
Stack_Overflow:
FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow!\n" ));
FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow\n" ));
return CFF_Err_Stack_Overflow;
}
@ -2565,8 +2581,8 @@
FT_Byte fd_index = cff_fd_select_get( &cff->fd_select,
glyph_index );
FT_Int top_upm = cff->top_font.font_dict.units_per_em;
FT_Int sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
FT_ULong top_upm = cff->top_font.font_dict.units_per_em;
FT_ULong sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
@ -2711,9 +2727,14 @@
glyph->root.linearHoriAdvance = decoder.glyph_width;
glyph->root.internal->glyph_transformed = 0;
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
has_vertical_info = FT_BOOL( face->vertical_info &&
face->vertical.number_Of_VMetrics > 0 &&
face->vertical.long_metrics );
#else
has_vertical_info = FT_BOOL( face->vertical_info &&
face->vertical.number_Of_VMetrics > 0 );
#endif
/* get the vertical metrics from the vtmx table if we have one */
if ( has_vertical_info )
@ -2750,8 +2771,8 @@
glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
/* apply the font matrix -- `xx' has already been normalized */
if ( !( font_matrix.yy == 0x10000L &&
if ( !( font_matrix.xx == 0x10000L &&
font_matrix.yy == 0x10000L &&
font_matrix.xy == 0 &&
font_matrix.yx == 0 ) )
FT_Outline_Transform( &glyph->root.outline, &font_matrix );
@ -2804,7 +2825,8 @@
metrics->horiBearingY = cbox.yMax;
if ( has_vertical_info )
metrics->vertBearingX = -metrics->width / 2;
metrics->vertBearingX = metrics->horiBearingX -
metrics->horiAdvance / 2;
else
ft_synthesize_vertical_metrics( metrics,
metrics->vertAdvance );

8
src/libs/freetype2/cff/cffgload.h
View File

@ -4,7 +4,7 @@
/* */
/* OpenType Glyph Loader (specification). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by */
/* Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -53,8 +53,6 @@ FT_BEGIN_HEADER
/* */
/* current :: The current glyph outline. */
/* */
/* last :: The last point position. */
/* */
/* pos_x :: The horizontal translation (if composite glyph). */
/* */
/* pos_y :: The vertical translation (if composite glyph). */
@ -88,8 +86,6 @@ FT_BEGIN_HEADER
FT_Outline* base;
FT_Outline* current;
FT_Vector last;
FT_Pos pos_x;
FT_Pos pos_y;
@ -158,6 +154,8 @@ FT_BEGIN_HEADER
FT_Render_Mode hint_mode;
FT_Bool seac;
} CFF_Decoder;

70
src/libs/freetype2/cff/cffload.c
View File

@ -736,6 +736,7 @@
{
FT_Error error = FT_Err_Ok;
FT_UInt i;
FT_Long j;
FT_UShort max_cid = 0;
@ -750,8 +751,11 @@
if ( FT_NEW_ARRAY( charset->cids, max_cid ) )
goto Exit;
for ( i = 0; i < num_glyphs; i++ )
charset->cids[charset->sids[i]] = (FT_UShort)i;
/* When multiple GIDs map to the same CID, we choose the lowest */
/* GID. This is not described in any spec, but it matches the */
/* behaviour of recent Acroread versions. */
for ( j = num_glyphs - 1; j >= 0 ; j-- )
charset->cids[charset->sids[j]] = (FT_UShort)j;
charset->max_cid = max_cid;
charset->num_glyphs = num_glyphs;
@ -842,7 +846,20 @@
goto Exit;
for ( j = 1; j < num_glyphs; j++ )
charset->sids[j] = FT_GET_USHORT();
{
FT_UShort sid = FT_GET_USHORT();
/* this constant is given in the CFF specification */
if ( sid < 65000L )
charset->sids[j] = sid;
else
{
FT_TRACE0(( "cff_charset_load:"
" invalid SID value %d set to zero\n", sid ));
charset->sids[j] = 0;
}
}
FT_FRAME_EXIT();
}
@ -875,6 +892,20 @@
goto Exit;
}
/* check whether the range contains at least one valid glyph; */
/* the constant is given in the CFF specification */
if ( glyph_sid >= 65000L ) {
FT_ERROR(( "cff_charset_load: invalid SID range\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
/* try to rescue some of the SIDs if `nleft' is too large */
if ( nleft > 65000L - 1L || glyph_sid >= 65000L - nleft ) {
FT_ERROR(( "cff_charset_load: invalid SID range trimmed\n" ));
nleft = ( FT_UInt )( 65000L - 1L - glyph_sid );
}
/* Fill in the range of sids -- `nleft + 1' glyphs. */
for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
charset->sids[j] = glyph_sid;
@ -883,7 +914,7 @@
break;
default:
FT_ERROR(( "cff_charset_load: invalid table format!\n" ));
FT_ERROR(( "cff_charset_load: invalid table format\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
@ -906,7 +937,7 @@
if ( num_glyphs > 229 )
{
FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
"predefined charset (Adobe ISO-Latin)!\n" ));
"predefined charset (Adobe ISO-Latin)\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
@ -924,7 +955,7 @@
if ( num_glyphs > 166 )
{
FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
"predefined charset (Adobe Expert)!\n" ));
"predefined charset (Adobe Expert)\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
@ -942,7 +973,7 @@
if ( num_glyphs > 87 )
{
FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
"predefined charset (Adobe Expert Subset)!\n" ));
"predefined charset (Adobe Expert Subset)\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
@ -1127,7 +1158,7 @@
break;
default:
FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
@ -1222,7 +1253,7 @@
break;
default:
FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
error = CFF_Err_Invalid_File_Format;
goto Exit;
}
@ -1240,7 +1271,8 @@
CFF_Index idx,
FT_UInt font_index,
FT_Stream stream,
FT_ULong base_offset )
FT_ULong base_offset,
FT_Library library )
{
FT_Error error;
CFF_ParserRec parser;
@ -1250,7 +1282,7 @@
CFF_Private priv = &font->private_dict;
cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict );
cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library );
/* set defaults */
FT_MEM_ZERO( top, sizeof ( *top ) );
@ -1301,7 +1333,7 @@
priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
priv->blue_scale = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
cff_parser_init( &parser, CFF_CODE_PRIVATE, priv );
cff_parser_init( &parser, CFF_CODE_PRIVATE, priv, library );
if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
FT_FRAME_ENTER( font->font_dict.private_size ) )
@ -1354,7 +1386,8 @@
FT_LOCAL_DEF( FT_Error )
cff_font_load( FT_Stream stream,
cff_font_load( FT_Library library,
FT_Stream stream,
FT_Int face_index,
CFF_Font font,
FT_Bool pure_cff )
@ -1394,7 +1427,7 @@
font->header_size < 4 ||
font->absolute_offsize > 4 )
{
FT_TRACE2(( "[not a CFF font header!]\n" ));
FT_TRACE2(( "[not a CFF font header]\n" ));
error = CFF_Err_Unknown_File_Format;
goto Exit;
}
@ -1432,7 +1465,8 @@
&font->font_dict_index,
face_index,
stream,
base_offset );
base_offset,
library );
if ( error )
goto Exit;
@ -1462,7 +1496,7 @@
if ( fd_index.count > CFF_MAX_CID_FONTS )
{
FT_ERROR(( "cff_font_load: FD array too large in CID font\n" ));
FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
goto Fail_CID;
}
@ -1480,7 +1514,7 @@
{
sub = font->subfonts[idx];
error = cff_subfont_load( sub, &fd_index, idx,
stream, base_offset );
stream, base_offset, library );
if ( error )
goto Fail_CID;
}
@ -1503,7 +1537,7 @@
/* read the charstrings index now */
if ( dict->charstrings_offset == 0 )
{
FT_ERROR(( "cff_font_load: no charstrings offset!\n" ));
FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
error = CFF_Err_Unknown_File_Format;
goto Exit;
}

3
src/libs/freetype2/cff/cffload.h
View File

@ -58,7 +58,8 @@ FT_BEGIN_HEADER
FT_LOCAL( FT_Error )
cff_font_load( FT_Stream stream,
cff_font_load( FT_Library library,
FT_Stream stream,
FT_Int face_index,
CFF_Font font,
FT_Bool pure_cff );

Some files were not shown because too many files have changed in this diff Show More