diff --git a/ChangeLog b/ChangeLog index f67ddcb6d..9d58f9796 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,23 +1,31 @@ +2002-04-19 Werner Lemberg + + * src/pfr/pfrload.c (pfr_extra_items_farse): Fix debug message. + (pfr_phy_font_load): s/size/Size/ for local variable to avoid + compiler warning. + * src/pfr/pfrobjs.c (pfr_face_init): Fix debug message. + (pfr_slot_load): Remove redundant local variable. + 2002-04-19 David Turner - * src/type1/t1gload.h, src/type1/t1gload.c: fixed incorrect - parameter sign-ness in callback function + Adding a PFR font driver to the FreeType sources. Note that it + doesn't support embedded bitmaps or kerning tables yet. - * include/freetype/config/ftmodule.h, - include/freetype/internal/fttrace.h, - src/Jamfile, src/pfr/*: - - adding a PFR font driver to the FreeType sources. Not that it - doesn't support embedded bitmaps or kerning tables for now.. + src/pfr/*: New files. + * include/freetype/config/ftmodule.h, + include/freetype/internal/fttrace.h, src/Jamefile: Updated. - * include/freetype/internal/ftmemory.h: adding the FT_MEM_ZERO - and FT_ZERO macros + * src/type1/t1gload.h (T1_Load_Glyph), src/type1/t1gload.c + (T1_Load_Glyph): Fixed incorrect parameter sign-ness in callback + function. - * include/freetype/internal/ftstream.h: adding the FT_NEXT_OFF3, - FT_NEXT_UOFF3, FT_NEXT_OFF3_LE and FT_NEXT_UOFF3_LE to parse - in-memory 24-bit integers. + * include/freetype/internal/ftmemory.h (FT_MEM_ZERO, FT_ZERO): New + macros. + * include/freetype/internal/ftstream.h (FT_NEXT_OFF3, FT_NEXT_UOFF3, + FT_NEXT_OFF3_LE, FT_NEXT_UOFF3_LE): New macros to parse in-memory + 24-bit integers. 2002-04-18 David Turner diff --git a/include/freetype/internal/ftmemory.h b/include/freetype/internal/ftmemory.h index dcd591d9f..cbe66d7f8 100644 --- a/include/freetype/internal/ftmemory.h +++ b/include/freetype/internal/ftmemory.h @@ -178,9 +178,11 @@ FT_BEGIN_HEADER #define FT_MEM_MOVE( dest, source, count ) ft_memmove( dest, source, count ) -#define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count ) -#define FT_ZERO(p) FT_MEM_ZERO( p, sizeof(*(p)) ) +#define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count ) + +#define FT_ZERO( p ) FT_MEM_ZERO( p, sizeof ( *(p) ) ) + /*************************************************************************/ /* */ diff --git a/src/pfr/descrip.mms b/src/pfr/descrip.mms index f5b11d63a..75178d0ef 100644 --- a/src/pfr/descrip.mms +++ b/src/pfr/descrip.mms @@ -3,7 +3,7 @@ # -# Copyright 1996-2002 by +# Copyright 2002 by # David Turner, Robert Wilhelm, and Werner Lemberg. # # This file is part of the FreeType project, and may only be used, modified, diff --git a/src/pfr/module.mk b/src/pfr/module.mk index 24ca8b2d2..3da0d5a3c 100644 --- a/src/pfr/module.mk +++ b/src/pfr/module.mk @@ -3,7 +3,7 @@ # -# Copyright 1996-2002 by +# Copyright 2002 by # David Turner, Robert Wilhelm, and Werner Lemberg. # # This file is part of the FreeType project, and may only be used, modified, diff --git a/src/pfr/pfr.c b/src/pfr/pfr.c index fa384d5f3..632820842 100644 --- a/src/pfr/pfr.c +++ b/src/pfr/pfr.c @@ -2,9 +2,9 @@ /* */ /* pfr.c */ /* */ -/* FreeType PFR driver component */ +/* FreeType PFR driver component. */ /* */ -/* Copyright 1996-2002 by */ +/* Copyright 2002 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* */ /* This file is part of the FreeType project, and may only be used, */ diff --git a/src/pfr/pfrcmap.c b/src/pfr/pfrcmap.c index 900a8a37d..9a8b98b4f 100644 --- a/src/pfr/pfrcmap.c +++ b/src/pfr/pfrcmap.c @@ -1,25 +1,45 @@ +/***************************************************************************/ +/* */ +/* pfrcmap.c */ +/* */ +/* FreeType PFR cmap handling (body). */ +/* */ +/* Copyright 2002 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 "pfrcmap.h" #include "pfrobjs.h" #include FT_INTERNAL_DEBUG_H + FT_CALLBACK_DEF( FT_Error ) pfr_cmap_init( PFR_CMap cmap ) { - PFR_Face face = (PFR_Face)FT_CMAP_FACE(cmap); + PFR_Face face = (PFR_Face)FT_CMAP_FACE( cmap ); cmap->num_chars = face->phy_font.num_chars; cmap->chars = face->phy_font.chars; /* just for safety, check that the character entries are correctly */ - /* sorted in increasing character code order.. */ + /* sorted in increasing character code order */ { FT_UInt n; + for ( n = 1; n < cmap->num_chars; n++ ) { - if ( cmap->chars[n-1].char_code >= cmap->chars[n].char_code ) - FT_ASSERT(0); + if ( cmap->chars[n - 1].char_code >= cmap->chars[n].char_code ) + FT_ASSERT( 0 ); } } @@ -63,8 +83,8 @@ FT_CALLBACK_DEF( FT_UInt ) - pfr_cmap_char_next( PFR_CMap cmap, - FT_UInt32 *pchar_code ) + pfr_cmap_char_next( PFR_CMap cmap, + FT_UInt32 *pchar_code ) { FT_UInt result = 0; FT_UInt32 char_code = *pchar_code + 1; @@ -122,8 +142,11 @@ { sizeof ( PFR_CMapRec ), - (FT_CMap_InitFunc) pfr_cmap_init, - (FT_CMap_DoneFunc) pfr_cmap_done, - (FT_CMap_CharIndexFunc) pfr_cmap_char_index, - (FT_CMap_CharNextFunc) pfr_cmap_char_next + (FT_CMap_InitFunc) pfr_cmap_init, + (FT_CMap_DoneFunc) pfr_cmap_done, + (FT_CMap_CharIndexFunc)pfr_cmap_char_index, + (FT_CMap_CharNextFunc) pfr_cmap_char_next }; + + +/* END */ diff --git a/src/pfr/pfrcmap.h b/src/pfr/pfrcmap.h index 922d7b996..d77813e3c 100644 --- a/src/pfr/pfrcmap.h +++ b/src/pfr/pfrcmap.h @@ -1,13 +1,32 @@ -#ifndef __PFR_CMAP_H__ -#define __PFR_CMAP_H__ +/***************************************************************************/ +/* */ +/* pfrcmap.h */ +/* */ +/* FreeType PFR cmap handling (specification). */ +/* */ +/* Copyright 2002 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. */ +/* */ +/***************************************************************************/ + + +#ifndef __PFRCMAP_H__ +#define __PFRCMAP_H__ #include #include FT_INTERNAL_OBJECTS_H #include "pfrtypes.h" + FT_BEGIN_HEADER - typedef struct PFR_CMapRec_ + typedef struct PFR_CMapRec_ { FT_CMapRec cmap; FT_UInt num_chars; @@ -16,8 +35,12 @@ FT_BEGIN_HEADER } PFR_CMapRec, *PFR_CMap; - FT_CALLBACK_TABLE const FT_CMap_ClassRec pfr_cmap_class_rec; + FT_CALLBACK_TABLE const FT_CMap_ClassRec pfr_cmap_class_rec; FT_END_HEADER -#endif /* __PFR_CMAP_H__ */ + +#endif /* __PFRCMAP_H__ */ + + +/* END */ diff --git a/src/pfr/pfrdrivr.c b/src/pfr/pfrdrivr.c index a10bc936f..9d9f3e313 100644 --- a/src/pfr/pfrdrivr.c +++ b/src/pfr/pfrdrivr.c @@ -1,3 +1,21 @@ +/***************************************************************************/ +/* */ +/* pfrdrivr.c */ +/* */ +/* FreeType PFR driver interface (body). */ +/* */ +/* Copyright 2002 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 #include FT_INTERNAL_DEBUG_H #include FT_INTERNAL_STREAM_H @@ -20,33 +38,33 @@ 0, /* format interface */ - (FT_Module_Constructor) NULL, - (FT_Module_Destructor) NULL, - (FT_Module_Requester) NULL + (FT_Module_Constructor)NULL, + (FT_Module_Destructor) NULL, + (FT_Module_Requester) NULL }, sizeof( PFR_FaceRec ), sizeof( PFR_SizeRec ), sizeof( PFR_SlotRec ), - (FT_Face_InitFunc) pfr_face_init, - (FT_Face_DoneFunc) pfr_face_done, - (FT_Size_InitFunc) NULL, - (FT_Size_DoneFunc) NULL, - (FT_Slot_InitFunc) pfr_slot_init, - (FT_Slot_DoneFunc) pfr_slot_done, + (FT_Face_InitFunc) pfr_face_init, + (FT_Face_DoneFunc) pfr_face_done, + (FT_Size_InitFunc) NULL, + (FT_Size_DoneFunc) NULL, + (FT_Slot_InitFunc) pfr_slot_init, + (FT_Slot_DoneFunc) pfr_slot_done, - (FT_Size_ResetPointsFunc) NULL, - (FT_Size_ResetPixelsFunc) NULL, - (FT_Slot_LoadFunc) pfr_slot_load, - (FT_CharMap_CharIndexFunc) NULL, + (FT_Size_ResetPointsFunc) NULL, + (FT_Size_ResetPixelsFunc) NULL, + (FT_Slot_LoadFunc) pfr_slot_load, + (FT_CharMap_CharIndexFunc)NULL, - (FT_Face_GetKerningFunc) 0, - (FT_Face_AttachFunc) 0, - (FT_Face_GetAdvancesFunc) 0, + (FT_Face_GetKerningFunc) 0, + (FT_Face_AttachFunc) 0, + (FT_Face_GetAdvancesFunc) 0, - (FT_CharMap_CharNextFunc) NULL + (FT_CharMap_CharNextFunc) NULL }; - +/* END */ diff --git a/src/pfr/pfrdrivr.h b/src/pfr/pfrdrivr.h index 1575ebec2..36f1205b7 100644 --- a/src/pfr/pfrdrivr.h +++ b/src/pfr/pfrdrivr.h @@ -2,9 +2,9 @@ /* */ /* pfrdrivr.h */ /* */ -/* High-level Type PFR driver interface */ +/* High-level Type PFR driver interface (specification). */ /* */ -/* Copyright 1996-2002 by */ +/* Copyright 2002 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* */ /* This file is part of the FreeType project, and may only be used, */ @@ -16,8 +16,8 @@ /***************************************************************************/ -#ifndef __PFR_DRIVER_H__ -#define __PFR_DRIVER_H__ +#ifndef __PFRDRIVR_H__ +#define __PFRDRIVR_H__ #include @@ -32,7 +32,8 @@ FT_BEGIN_HEADER FT_END_HEADER -#endif /* __PFR_DRIVER_H__ */ + +#endif /* __PFRDRIVR_H__ */ /* END */ diff --git a/src/pfr/pfrgload.c b/src/pfr/pfrgload.c index 33de64d44..70ea7a736 100644 --- a/src/pfr/pfrgload.c +++ b/src/pfr/pfrgload.c @@ -1,17 +1,36 @@ +/***************************************************************************/ +/* */ +/* pfrgload.c */ +/* */ +/* FreeType PFR glyph loader (body). */ +/* */ +/* Copyright 2002 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 "pfrgload.h" -#include "pfrload.h" /* for macro definitions */ +#include "pfrload.h" /* for macro definitions */ #include FT_INTERNAL_DEBUG_H #undef FT_COMPONENT #define FT_COMPONENT trace_pfr - /**************************************************************************/ - /**************************************************************************/ - /***** *****/ - /***** PFR GLYPH BUILDER *****/ - /***** *****/ - /**************************************************************************/ - /**************************************************************************/ + + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** PFR GLYPH BUILDER *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ FT_LOCAL_DEF( void ) @@ -32,6 +51,7 @@ { FT_Memory memory = glyph->loader->memory; + FT_FREE( glyph->x_control ); glyph->y_control = NULL; @@ -49,7 +69,7 @@ } - /* close current contour, if any */ + /* close current contour, if any */ static void pfr_glyph_close_contour( PFR_Glyph glyph ) { @@ -57,6 +77,7 @@ FT_Outline* outline = &loader->current.outline; FT_Int last, first; + if ( !glyph->path_begun ) return; @@ -64,7 +85,7 @@ last = outline->n_points - 1; first = 0; if ( outline->n_contours > 0 ) - first = outline->contours[ outline->n_contours-1 ]; + first = outline->contours[outline->n_contours - 1]; /* if the last point falls on the same location than the first one */ /* we need to delete it */ @@ -73,6 +94,7 @@ FT_Vector* p1 = outline->points + first; FT_Vector* p2 = outline->points + last; + if ( p1->x == p2->x && p1->y == p2->y ) { outline->n_points--; @@ -82,14 +104,13 @@ /* don't add empty contours */ if ( last >= first ) - outline->contours[ outline->n_contours++ ] = (short) last; + outline->contours[outline->n_contours++] = (short)last; glyph->path_begun = 0; } - - /* reset glyph to start the loading of a new glyph */ + /* reset glyph to start the loading of a new glyph */ static void pfr_glyph_start( PFR_Glyph glyph ) { @@ -105,7 +126,8 @@ FT_Outline* outline = &loader->current.outline; FT_Error error; - /* check that we've begun a new path */ + + /* check that we have begun a new path */ FT_ASSERT( glyph->path_begun != 0 ); error = FT_GlyphLoader_CheckPoints( loader, 1, 0 ); @@ -113,6 +135,7 @@ { FT_UInt n = outline->n_points; + outline->points[n] = *to; outline->tags [n] = FT_Curve_Tag_On; @@ -133,14 +156,16 @@ FT_Outline* outline = &loader->current.outline; FT_Error error; - /* check that we've begun a new path */ + + /* check that we have begun a new path */ FT_ASSERT( glyph->path_begun != 0 ); error = FT_GlyphLoader_CheckPoints( loader, 3, 0 ); if ( !error ) { - FT_Vector* vec = outline->points + outline->n_points; - FT_Byte* tag = (FT_Byte*)outline->tags + outline->n_points; + FT_Vector* vec = outline->points + outline->n_points; + FT_Byte* tag = (FT_Byte*)outline->tags + outline->n_points; + vec[0] = *control1; vec[1] = *control2; @@ -163,6 +188,7 @@ FT_GlyphLoader loader = glyph->loader; FT_Error error; + /* close current contour if any */ pfr_glyph_close_contour( glyph ); @@ -179,7 +205,6 @@ } - static void pfr_glyph_end( PFR_Glyph glyph ) { @@ -191,54 +216,55 @@ } - /**************************************************************************/ - /**************************************************************************/ - /***** *****/ - /***** PFR GLYPH LOADER *****/ - /***** *****/ - /**************************************************************************/ - /**************************************************************************/ + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** PFR GLYPH LOADER *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ - /* Load a simple glyph */ + /* load a simple glyph */ static FT_Error pfr_glyph_load_simple( PFR_Glyph glyph, FT_Byte* p, FT_Byte* limit ) { - FT_Error error = 0; + FT_Error error = 0; FT_Memory memory = glyph->loader->memory; FT_UInt flags, x_count, y_count, i, count, mask; FT_Int x; - PFR_CHECK(1); - flags = PFR_NEXT_BYTE(p); + + PFR_CHECK( 1 ); + flags = PFR_NEXT_BYTE( p ); /* test for composite glyphs */ - FT_ASSERT( (flags & PFR_GLYPH_IS_COMPOUND) == 0 ); + FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) == 0 ); x_count = 0; y_count = 0; if ( flags & PFR_GLYPH_1BYTE_XYCOUNT ) { - PFR_CHECK(1); - count = PFR_NEXT_BYTE(p); - x_count = (count & 15); - y_count = (count >> 4); + PFR_CHECK( 1 ); + count = PFR_NEXT_BYTE( p ); + x_count = ( count & 15 ); + y_count = ( count >> 4 ); } else { if ( flags & PFR_GLYPH_XCOUNT ) { - PFR_CHECK(1); - x_count = PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + x_count = PFR_NEXT_BYTE( p ); } if ( flags & PFR_GLYPH_YCOUNT ) { - PFR_CHECK(1); - y_count = PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + y_count = PFR_NEXT_BYTE( p ); } } @@ -247,9 +273,12 @@ /* re-allocate array when necessary */ if ( count > glyph->max_xy_control ) { - FT_UInt new_max = (count+7) & -8; + FT_UInt new_max = ( count + 7 ) & -8; - if ( FT_RENEW_ARRAY( glyph->x_control, glyph->max_xy_control, new_max ) ) + + if ( FT_RENEW_ARRAY( glyph->x_control, + glyph->max_xy_control, + new_max ) ) goto Exit; glyph->max_xy_control = new_max; @@ -259,23 +288,24 @@ mask = 0; x = 0; + for ( i = 0; i < count; i++ ) { - if ( (i & 7) == 0 ) + if ( ( i & 7 ) == 0 ) { - PFR_CHECK(1); - mask = PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + mask = PFR_NEXT_BYTE( p ); } if ( mask & 1 ) { - PFR_CHECK(2); - x = PFR_NEXT_SHORT(p); + PFR_CHECK( 2 ); + x = PFR_NEXT_SHORT( p ); } else { - PFR_CHECK(1); - x += PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + x += PFR_NEXT_BYTE( p ); } glyph->x_control[i] = x; @@ -283,16 +313,16 @@ mask >>= 1; } - /* XXXX: for now we ignore the secondary stroke and edge definitions */ - /* since we don't want to support native PFR hinting.. */ - /* */ + /* XXX: for now we ignore the secondary stroke and edge definitions */ + /* since we don't want to support native PFR hinting */ + /* */ if ( flags & PFR_GLYPH_EXTRA_ITEMS ) { error = pfr_extra_items_skip( &p, limit ); - if (error) goto Exit; + if ( error ) + goto Exit; } - pfr_glyph_start( glyph ); /* now load a simple glyph */ @@ -300,6 +330,7 @@ FT_Vector pos[4]; FT_Vector* cur; + pos[0].x = pos[0].y = 0; pos[3] = pos[0]; @@ -307,65 +338,67 @@ { FT_Int format, args_format = 0, args_count, n; + /***************************************************************/ /* read instruction */ /* */ - PFR_CHECK(1); - format = PFR_NEXT_BYTE(p); - switch (format >> 4) + PFR_CHECK( 1 ); + format = PFR_NEXT_BYTE( p ); + + switch ( format >> 4 ) { - case 0: /* end glyph */ - FT_TRACE6(( "- end glyph" )); - args_count = 0; - break; + case 0: /* end glyph */ + FT_TRACE6(( "- end glyph" )); + args_count = 0; + break; - case 1: /* general line operation */ - FT_TRACE6(( "- general line" )); - goto Line1; + case 1: /* general line operation */ + FT_TRACE6(( "- general line" )); + goto Line1; - case 4: /* move to inside contour */ - FT_TRACE6(( "- move to inside" )); - goto Line1; + case 4: /* move to inside contour */ + FT_TRACE6(( "- move to inside" )); + goto Line1; - case 5: /* move to outside contour */ - FT_TRACE6(( "- move to outside" )); - Line1: - args_format = format & 15; - args_count = 1; - break; + case 5: /* move to outside contour */ + FT_TRACE6(( "- move to outside" )); + Line1: + args_format = format & 15; + args_count = 1; + break; - case 2: /* horizontal line to */ - FT_TRACE6(( "- horizontal line to cx.%d", format & 15 )); - pos[0].y = pos[3].y; - pos[0].x = glyph->x_control[ format & 15 ]; - pos[3] = pos[0]; - args_count = 0; - break; + case 2: /* horizontal line to */ + FT_TRACE6(( "- horizontal line to cx.%d", format & 15 )); + pos[0].y = pos[3].y; + pos[0].x = glyph->x_control[format & 15]; + pos[3] = pos[0]; + args_count = 0; + break; - case 3: /* vertical line to */ - FT_TRACE6(( "- vertical line to cy.%d", format & 15 )); - pos[0].x = pos[3].x; - pos[0].y = glyph->y_control[ format & 15 ]; - pos[3] = pos[0]; - args_count = 0; - break; + case 3: /* vertical line to */ + FT_TRACE6(( "- vertical line to cy.%d", format & 15 )); + pos[0].x = pos[3].x; + pos[0].y = glyph->y_control[format & 15]; + pos[3] = pos[0]; + args_count = 0; + break; - case 6: /* horizontal to vertical curve */ - FT_TRACE6(( "- hv curve " )); - args_format = 0xB8E; - args_count = 3; - break; + case 6: /* horizontal to vertical curve */ + FT_TRACE6(( "- hv curve " )); + args_format = 0xB8E; + args_count = 3; + break; - case 7: /* vertical to horizontal curve */ - FT_TRACE6(( "- vh curve" )); - args_format = 0xE2B; - args_count = 3; - break; + case 7: /* vertical to horizontal curve */ + FT_TRACE6(( "- vh curve" )); + args_format = 0xE2B; + args_count = 3; + break; - default: /* general curve to */ - FT_TRACE6(( "- general curve" )); - args_count = 4; - args_format = (format & 15); + default: /* general curve to */ + FT_TRACE6(( "- general curve" )); + args_count = 4; + args_format = format & 15; } /***********************************************************/ @@ -376,67 +409,68 @@ { FT_Int index, delta; + /* read the X argument */ switch ( args_format & 3 ) { - case 0: /* 8-bit index */ - PFR_CHECK(1); - index = PFR_NEXT_BYTE(p); - cur->x = glyph->x_control[index]; - FT_TRACE7(( " cx#%d", index )); - break; + case 0: /* 8-bit index */ + PFR_CHECK( 1 ); + index = PFR_NEXT_BYTE( p ); + cur->x = glyph->x_control[index]; + FT_TRACE7(( " cx#%d", index )); + break; - case 1: /* 16-bit value */ - PFR_CHECK(2); - cur->x = PFR_NEXT_SHORT(p); - FT_TRACE7(( " x.%d", cur->x )); - break; + case 1: /* 16-bit value */ + PFR_CHECK( 2 ); + cur->x = PFR_NEXT_SHORT( p ); + FT_TRACE7(( " x.%d", cur->x )); + break; - case 2: /* 8-bit delta */ - PFR_CHECK(1); - delta = PFR_NEXT_INT8(p); - cur->x = pos[3].x + delta; - FT_TRACE7(( " dx.%d", delta )); - break; + case 2: /* 8-bit delta */ + PFR_CHECK( 1 ); + delta = PFR_NEXT_INT8( p ); + cur->x = pos[3].x + delta; + FT_TRACE7(( " dx.%d", delta )); + break; - default: - FT_TRACE7(( " |" )); - cur->x = pos[3].x; + default: + FT_TRACE7(( " |" )); + cur->x = pos[3].x; } /* read the Y argument */ - switch ( (args_format >> 2) & 3 ) + switch ( ( args_format >> 2 ) & 3 ) { - case 0: /* 8-bit index */ - PFR_CHECK(1); - index = PFR_NEXT_BYTE(p); - cur->y = glyph->y_control[index]; - FT_TRACE7(( " cy#%d", index )); - break; + case 0: /* 8-bit index */ + PFR_CHECK( 1 ); + index = PFR_NEXT_BYTE( p ); + cur->y = glyph->y_control[index]; + FT_TRACE7(( " cy#%d", index )); + break; - case 1: /* 16-bit absolute value */ - PFR_CHECK(2); - cur->y = PFR_NEXT_SHORT(p); - FT_TRACE7(( " y.%d", cur->y )); - break; + case 1: /* 16-bit absolute value */ + PFR_CHECK( 2 ); + cur->y = PFR_NEXT_SHORT( p ); + FT_TRACE7(( " y.%d", cur->y )); + break; - case 2: /* 8-bit delta */ - PFR_CHECK(1); - delta = PFR_NEXT_INT8(p); - cur->y = pos[3].y + delta; - FT_TRACE7(( " dy.%d", delta )); - break; + case 2: /* 8-bit delta */ + PFR_CHECK( 1 ); + delta = PFR_NEXT_INT8( p ); + cur->y = pos[3].y + delta; + FT_TRACE7(( " dy.%d", delta )); + break; - default: - FT_TRACE7(( " -" )); - cur->y = pos[3].y; + default: + FT_TRACE7(( " -" )); + cur->y = pos[3].y; } /* read the additional format flag for the general curve */ if ( n == 0 && args_count == 4 ) { - PFR_CHECK(1); - args_format = PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + args_format = PFR_NEXT_BYTE( p ); args_count--; } else @@ -452,29 +486,29 @@ /***********************************************************/ /* finally, execute instruction */ /* */ - switch (format >> 4) + switch ( format >> 4 ) { - case 0: /* end glyph => EXIT */ - pfr_glyph_end( glyph ); + case 0: /* end glyph => EXIT */ + pfr_glyph_end( glyph ); + goto Exit; + + case 1: /* line operations */ + case 2: + case 3: + error = pfr_glyph_line_to( glyph, pos ); + goto Test_Error; + + case 4: /* move to inside contour */ + case 5: /* move to outside contour */ + error = pfr_glyph_move_to( glyph, pos ); + goto Test_Error; + + default: /* curve operations */ + error = pfr_glyph_curve_to( glyph, pos, pos + 1, pos + 2 ); + + Test_Error: /* test error condition */ + if ( error ) goto Exit; - - case 1: /* line operations */ - case 2: - case 3: - error = pfr_glyph_line_to( glyph, pos ); - goto Test_Error; - - case 4: /* move to inside contour */ - case 5: /* move to outside contour */ - error = pfr_glyph_move_to( glyph, pos ); - goto Test_Error; - - default: /* curve operations */ - error = pfr_glyph_curve_to( glyph, pos, pos+1, pos+2 ); - - Test_Error: /* test error condition */ - if (error) - goto Exit; } } /* for (;;) */ } @@ -489,9 +523,7 @@ } - - /* load a composite/compound glyph */ - + /* load a composite/compound glyph */ static FT_Error pfr_glyph_load_compound( PFR_Glyph glyph, FT_Byte* p, @@ -504,11 +536,12 @@ FT_UInt flags, i, count, org_count; FT_Int x_pos, y_pos; - PFR_CHECK(1); - flags = PFR_NEXT_BYTE(p); + + PFR_CHECK( 1 ); + flags = PFR_NEXT_BYTE( p ); /* test for composite glyphs */ - FT_ASSERT( (flags & PFR_GLYPH_IS_COMPOUND) != 0 ); + FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) != 0 ); count = flags & 0x3F; @@ -521,12 +554,12 @@ } /* we can't rely on the FT_GlyphLoader to load sub-glyphs, because */ - /* the PFR format is so damn stupid that it uses direct file offsets */ - /* to point to the sub-glyphs (instead of glyph indices).. */ + /* the PFR format is dumb, using direct file offsets to point to the */ + /* sub-glyphs (instead of glyph indices). Sigh. */ /* */ - /* for now, we'll load the list of sub-glyphs in a different array */ + /* For now, we load the list of sub-glyphs into a different array */ /* but this will prevent us from using the auto-hinter at its best */ - /* quality.. */ + /* quality. */ /* */ org_count = glyph->num_subs; @@ -534,6 +567,7 @@ { FT_UInt new_max = ( org_count + count + 3 ) & -4; + if ( FT_RENEW_ARRAY( glyph->subs, glyph->max_subs, new_max ) ) goto Exit; @@ -548,55 +582,56 @@ { FT_UInt format; - PFR_CHECK(1); - format = PFR_NEXT_BYTE(p); + + PFR_CHECK( 1 ); + format = PFR_NEXT_BYTE( p ); /* read scale when available */ subglyph->x_scale = 0x10000L; if ( format & PFR_SUBGLYPH_XSCALE ) { - PFR_CHECK(2); - subglyph->x_scale = PFR_NEXT_SHORT(p) << 4; + PFR_CHECK( 2 ); + subglyph->x_scale = PFR_NEXT_SHORT( p ) << 4; } subglyph->y_scale = 0x10000L; if ( format & PFR_SUBGLYPH_YSCALE ) { - PFR_CHECK(2); - subglyph->y_scale = PFR_NEXT_SHORT(p) << 4; + PFR_CHECK( 2 ); + subglyph->y_scale = PFR_NEXT_SHORT( p ) << 4; } /* read offset */ switch ( format & 3 ) { - case 1: - PFR_CHECK(2); - x_pos = PFR_NEXT_SHORT(p); - break; + case 1: + PFR_CHECK( 2 ); + x_pos = PFR_NEXT_SHORT( p ); + break; - case 2: - PFR_CHECK(1); - x_pos += PFR_NEXT_INT8(p); - break; + case 2: + PFR_CHECK( 1 ); + x_pos += PFR_NEXT_INT8( p ); + break; - default: - ; + default: + ; } - switch ( (format >> 2) & 3 ) + switch ( ( format >> 2 ) & 3 ) { - case 1: - PFR_CHECK(2); - y_pos = PFR_NEXT_SHORT(p); - break; + case 1: + PFR_CHECK( 2 ); + y_pos = PFR_NEXT_SHORT( p ); + break; - case 2: - PFR_CHECK(1); - y_pos += PFR_NEXT_INT8(p); - break; + case 2: + PFR_CHECK( 1 ); + y_pos += PFR_NEXT_INT8( p ); + break; - default: - ; + default: + ; } subglyph->x_delta = x_pos; @@ -605,30 +640,29 @@ /* read glyph position and size now */ if ( format & PFR_SUBGLYPH_2BYTE_SIZE ) { - PFR_CHECK(2); - subglyph->gps_size = PFR_NEXT_USHORT(p); + PFR_CHECK( 2 ); + subglyph->gps_size = PFR_NEXT_USHORT( p ); } else { - PFR_CHECK(1); - subglyph->gps_size = PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + subglyph->gps_size = PFR_NEXT_BYTE( p ); } if ( format & PFR_SUBGLYPH_3BYTE_OFFSET ) { - PFR_CHECK(3); - subglyph->gps_offset = PFR_NEXT_LONG(p); + PFR_CHECK( 3 ); + subglyph->gps_offset = PFR_NEXT_LONG( p ); } else { - PFR_CHECK(2); - subglyph->gps_offset = PFR_NEXT_USHORT(p); + PFR_CHECK( 2 ); + subglyph->gps_offset = PFR_NEXT_USHORT( p ); } glyph->num_subs++; } - Exit: return error; @@ -639,23 +673,23 @@ } - static FT_Error - pfr_glyph_load_rec( PFR_Glyph glyph, - FT_Stream stream, - FT_ULong gps_offset, - FT_ULong offset, - FT_ULong size ) + pfr_glyph_load_rec( PFR_Glyph glyph, + FT_Stream stream, + FT_ULong gps_offset, + FT_ULong offset, + FT_ULong size ) { FT_Error error; FT_Byte* p; FT_Byte* limit; + if ( FT_STREAM_SEEK( gps_offset + offset ) || FT_FRAME_ENTER( size ) ) - goto Exit; + goto Exit; - p = (FT_Byte*) stream->cursor; + p = (FT_Byte*)stream->cursor; limit = p + size; if ( size > 0 && *p & PFR_GLYPH_IS_COMPOUND ) @@ -672,7 +706,8 @@ FT_FRAME_EXIT(); - if ( error ) goto Exit; + if ( error ) + goto Exit; count = glyph->num_subs - old_count; @@ -687,11 +722,12 @@ old_points = base->n_points; error = pfr_glyph_load_rec( glyph, stream, gps_offset, - subglyph->gps_offset, subglyph->gps_size ); + subglyph->gps_offset, + subglyph->gps_size ); if ( error ) goto Exit; - /* note that the 'glyph->subs' might have been re-allocated */ + /* note that `glyph->subs' might have been re-allocated */ subglyph = glyph->subs + old_count + n; num_points = base->n_points - old_points; @@ -703,8 +739,10 @@ for ( i = 0; i < num_points; i++, vec++ ) { - vec->x = FT_MulFix( vec->x, subglyph->x_scale ) + subglyph->x_delta; - vec->y = FT_MulFix( vec->y, subglyph->y_scale ) + subglyph->y_delta; + vec->x = FT_MulFix( vec->x, subglyph->x_scale ) + + subglyph->x_delta; + vec->y = FT_MulFix( vec->y, subglyph->y_scale ) + + subglyph->y_delta; } } else @@ -736,11 +774,11 @@ FT_LOCAL_DEF( FT_Error ) - pfr_glyph_load( PFR_Glyph glyph, - FT_Stream stream, - FT_ULong gps_offset, - FT_ULong offset, - FT_ULong size ) + pfr_glyph_load( PFR_Glyph glyph, + FT_Stream stream, + FT_ULong gps_offset, + FT_ULong offset, + FT_ULong size ) { /* initialize glyph loader */ FT_GlyphLoader_Rewind( glyph->loader ); @@ -749,3 +787,5 @@ return pfr_glyph_load_rec( glyph, stream, gps_offset, offset, size ); } + +/* END */ diff --git a/src/pfr/pfrgload.h b/src/pfr/pfrgload.h index a706ad916..76916e559 100644 --- a/src/pfr/pfrgload.h +++ b/src/pfr/pfrgload.h @@ -1,10 +1,29 @@ -#ifndef __PFR_GLYPH_LOAD_H__ -#define __PFR_GLYPH_LOAD_H__ +/***************************************************************************/ +/* */ +/* pfrgload.h */ +/* */ +/* FreeType PFR glyph loader (specification). */ +/* */ +/* Copyright 2002 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. */ +/* */ +/***************************************************************************/ + + +#ifndef __PFRGLOAD_H__ +#define __PFRGLOAD_H__ #include "pfrtypes.h" FT_BEGIN_HEADER + FT_LOCAL( void ) pfr_glyph_init( PFR_Glyph glyph, FT_GlyphLoader loader ); @@ -24,4 +43,4 @@ FT_BEGIN_HEADER FT_END_HEADER -#endif /* __PFR_GLYPH_LOAD_H__ */ +#endif /* __PFRGLOAD_H__ */ diff --git a/src/pfr/pfrload.c b/src/pfr/pfrload.c index a6d59172e..410bbfaeb 100644 --- a/src/pfr/pfrload.c +++ b/src/pfr/pfrload.c @@ -1,3 +1,21 @@ +/***************************************************************************/ +/* */ +/* pfrload.c */ +/* */ +/* FreeType PFR loader (body). */ +/* */ +/* Copyright 2002 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 "pfrload.h" #include FT_INTERNAL_DEBUG_H #include FT_INTERNAL_STREAM_H @@ -5,17 +23,19 @@ #undef FT_COMPONENT #define FT_COMPONENT trace_pfr - /***********************************************************************/ - /***********************************************************************/ - /***** *****/ - /***** EXTRA ITEMS *****/ - /***** *****/ - /***********************************************************************/ - /***********************************************************************/ + + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** EXTRA ITEMS *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ FT_LOCAL_DEF( FT_Error ) - pfr_extra_items_skip( FT_Byte* *pp, FT_Byte* limit ) + pfr_extra_items_skip( FT_Byte* *pp, + FT_Byte* limit ) { return pfr_extra_items_parse( pp, limit, NULL, NULL ); } @@ -31,20 +51,23 @@ FT_Byte* p = *pp; FT_UInt num_items, item_type, item_size; - PFR_CHECK(1); - num_items = PFR_NEXT_BYTE(p); + + PFR_CHECK( 1 ); + num_items = PFR_NEXT_BYTE( p ); + for ( ; num_items > 0; num_items-- ) { - PFR_CHECK(2); - item_size = PFR_NEXT_BYTE(p); - item_type = PFR_NEXT_BYTE(p); + PFR_CHECK( 2 ); + item_size = PFR_NEXT_BYTE( p ); + item_type = PFR_NEXT_BYTE( p ); - PFR_CHECK(item_size); + PFR_CHECK( item_size ); if ( item_list ) { PFR_ExtraItem extra = item_list; + for ( extra = item_list; extra->parser != NULL; extra++ ) { if ( extra->type == item_type ) @@ -65,62 +88,61 @@ return error; Too_Short: - FT_ERROR(( "pfr.extra_items.skip: invalid extra items table\n" )); + FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" )); error = FT_Err_Invalid_Table; goto Exit; } + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** PFR HEADER *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ - /***********************************************************************/ - /***********************************************************************/ - /***** *****/ - /***** PFR HEADER *****/ - /***** *****/ - /***********************************************************************/ - /***********************************************************************/ - - static const FT_Frame_Field pfr_header_fields[] = + static const FT_Frame_Field pfr_header_fields[] = { #undef FT_STRUCTURE #define FT_STRUCTURE PFR_HeaderRec - FT_FRAME_START(58), - FT_FRAME_ULONG (signature), - FT_FRAME_USHORT(version), - FT_FRAME_USHORT(signature2), - FT_FRAME_USHORT(header_size), + FT_FRAME_START( 58 ), + FT_FRAME_ULONG ( signature ), + FT_FRAME_USHORT( version ), + FT_FRAME_USHORT( signature2 ), + FT_FRAME_USHORT( header_size ), - FT_FRAME_USHORT(log_dir_size), - FT_FRAME_USHORT(log_dir_offset), + FT_FRAME_USHORT( log_dir_size ), + FT_FRAME_USHORT( log_dir_offset ), - FT_FRAME_USHORT(log_font_max_size), - FT_FRAME_UOFF3 (log_font_section_size), - FT_FRAME_UOFF3 (log_font_section_offset), + FT_FRAME_USHORT( log_font_max_size ), + FT_FRAME_UOFF3 ( log_font_section_size ), + FT_FRAME_UOFF3 ( log_font_section_offset ), - FT_FRAME_USHORT(phy_font_max_size), - FT_FRAME_UOFF3 (phy_font_section_size), - FT_FRAME_UOFF3 (phy_font_section_offset), + FT_FRAME_USHORT( phy_font_max_size ), + FT_FRAME_UOFF3 ( phy_font_section_size ), + FT_FRAME_UOFF3 ( phy_font_section_offset ), - FT_FRAME_USHORT(gps_max_size), - FT_FRAME_UOFF3 (gps_section_size), - FT_FRAME_UOFF3 (gps_section_offset), + FT_FRAME_USHORT( gps_max_size ), + FT_FRAME_UOFF3 ( gps_section_size ), + FT_FRAME_UOFF3 ( gps_section_offset ), - FT_FRAME_BYTE (max_blue_values), - FT_FRAME_BYTE (max_x_orus), - FT_FRAME_BYTE (max_y_orus), + FT_FRAME_BYTE ( max_blue_values ), + FT_FRAME_BYTE ( max_x_orus ), + FT_FRAME_BYTE ( max_y_orus ), - FT_FRAME_BYTE (phy_font_max_size_high), - FT_FRAME_BYTE (color_flags), + FT_FRAME_BYTE ( phy_font_max_size_high ), + FT_FRAME_BYTE ( color_flags ), - FT_FRAME_UOFF3 (bct_max_size), - FT_FRAME_UOFF3 (bct_set_max_size), - FT_FRAME_UOFF3 (phy_bct_set_max_size), + FT_FRAME_UOFF3 ( bct_max_size ), + FT_FRAME_UOFF3 ( bct_set_max_size ), + FT_FRAME_UOFF3 ( phy_bct_set_max_size ), - FT_FRAME_USHORT(num_phy_fonts), - FT_FRAME_BYTE (max_vert_stem_snap), - FT_FRAME_BYTE (max_horz_stem_snap), - FT_FRAME_USHORT(max_chars), + FT_FRAME_USHORT( num_phy_fonts ), + FT_FRAME_BYTE ( max_vert_stem_snap ), + FT_FRAME_BYTE ( max_horz_stem_snap ), + FT_FRAME_USHORT( max_chars ), FT_FRAME_END }; @@ -131,6 +153,7 @@ { FT_Error error; + /* read header directly */ if ( !FT_STREAM_SEEK( 0 ) && !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) ) @@ -149,11 +172,12 @@ { FT_Bool result = 1; + /* check signature and header size */ - if ( header->signature != 0x50465230 || /* "PFR0" */ - header->version > 4 || - header->header_size < 58 || - header->signature2 != 0x0d0a ) /* CR/LF */ + if ( header->signature != 0x50465230L || /* "PFR0" */ + header->version > 4 || + header->header_size < 58 || + header->signature2 != 0x0d0a ) /* CR/LF */ { result = 0; } @@ -179,7 +203,8 @@ FT_UInt count; FT_UInt result = 0; - if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT(count) ) + + if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT( count ) ) goto Exit; result = count; @@ -191,11 +216,11 @@ FT_LOCAL_DEF( FT_Error ) - pfr_log_font_load( PFR_LogFont log_font, - FT_Stream stream, - FT_UInt index, - FT_UInt32 section_offset, - FT_Bool size_increment ) + pfr_log_font_load( PFR_LogFont log_font, + FT_Stream stream, + FT_UInt index, + FT_UInt32 section_offset, + FT_Bool size_increment ) { FT_UInt num_log_fonts; FT_UInt flags; @@ -203,15 +228,17 @@ FT_UInt32 size; FT_Error error; - if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT(num_log_fonts) ) + + if ( FT_STREAM_SEEK( section_offset ) || + FT_READ_USHORT( num_log_fonts ) ) goto Exit; if ( index >= num_log_fonts ) return FT_Err_Invalid_Argument; - if ( FT_STREAM_SKIP( index*5 ) || - FT_READ_USHORT(size) || - FT_READ_UOFF3 (offset) ) + if ( FT_STREAM_SKIP( index * 5 ) || + FT_READ_USHORT( size ) || + FT_READ_UOFF3 ( offset ) ) goto Exit; /* save logical font size and offset */ @@ -224,6 +251,7 @@ FT_Byte* limit; FT_UInt local; + if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) ) goto Exit; @@ -232,12 +260,12 @@ PFR_CHECK(13); - log_font->matrix[0] = PFR_NEXT_LONG(p); - log_font->matrix[1] = PFR_NEXT_LONG(p); - log_font->matrix[2] = PFR_NEXT_LONG(p); - log_font->matrix[3] = PFR_NEXT_LONG(p); + log_font->matrix[0] = PFR_NEXT_LONG( p ); + log_font->matrix[1] = PFR_NEXT_LONG( p ); + log_font->matrix[2] = PFR_NEXT_LONG( p ); + log_font->matrix[3] = PFR_NEXT_LONG( p ); - flags = PFR_NEXT_BYTE(p); + flags = PFR_NEXT_BYTE( p ); local = 0; if ( flags & PFR_LOG_STROKE ) @@ -256,23 +284,23 @@ local++; } - PFR_CHECK(local); + PFR_CHECK( local ); if ( flags & PFR_LOG_STROKE ) { log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE ) - ? PFR_NEXT_SHORT(p) - : PFR_NEXT_BYTE(p); + ? PFR_NEXT_SHORT( p ) + : PFR_NEXT_BYTE( p ); - if ( (flags & PFR_LINE_JOIN_MASK) == PFR_LINE_JOIN_MITER ) - log_font->miter_limit = PFR_NEXT_LONG(p); + if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER ) + log_font->miter_limit = PFR_NEXT_LONG( p ); } if ( flags & PFR_LOG_BOLD ) { log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD ) - ? PFR_NEXT_SHORT(p) - : PFR_NEXT_BYTE(p); + ? PFR_NEXT_SHORT( p ) + : PFR_NEXT_BYTE( p ); } if ( flags & PFR_LOG_EXTRA_ITEMS ) @@ -282,12 +310,12 @@ } PFR_CHECK(5); - log_font->phys_size = PFR_NEXT_USHORT(p); - log_font->phys_offset = PFR_NEXT_ULONG(p); + log_font->phys_size = PFR_NEXT_USHORT( p ); + log_font->phys_offset = PFR_NEXT_ULONG( p ); if ( size_increment ) { - PFR_CHECK(1); - log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE(p) << 16; + PFR_CHECK( 1 ); + log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16; } } @@ -313,7 +341,7 @@ /***********************************************************************/ - /* load bitmap strikes lists */ + /* load bitmap strikes lists */ FT_CALLBACK_DEF( FT_Error ) pfr_extra_item_load_bitmap_info( FT_Byte* p, FT_Byte* limit, @@ -325,18 +353,21 @@ FT_UInt n, count, size1; FT_Error error = 0; - PFR_CHECK(5); + + PFR_CHECK( 5 ); p += 3; /* skip bctSize */ - flags0 = PFR_NEXT_BYTE(p); - count = PFR_NEXT_BYTE(p); + flags0 = PFR_NEXT_BYTE( p ); + count = PFR_NEXT_BYTE( p ); /* re-allocate when needed */ if ( phy_font->num_strikes + count > phy_font->max_strikes ) { FT_UInt new_max = (phy_font->num_strikes + count + 3) & -4; - if ( FT_RENEW_ARRAY( phy_font->strikes, phy_font->num_strikes, new_max ) ) + if ( FT_RENEW_ARRAY( phy_font->strikes, + phy_font->num_strikes, + new_max ) ) goto Exit; phy_font->max_strikes = new_max; @@ -360,31 +391,31 @@ strike = phy_font->strikes + phy_font->num_strikes; - PFR_CHECK( count*size1 ); + PFR_CHECK( count * size1 ); for ( n = 0; n < count; n++, strike++ ) { strike->x_ppm = ( flags0 & PFR_STRIKE_2BYTE_XPPM ) - ? PFR_NEXT_USHORT(p) - : PFR_NEXT_BYTE(p); + ? PFR_NEXT_USHORT( p ) + : PFR_NEXT_BYTE( p ); strike->y_ppm = ( flags0 & PFR_STRIKE_2BYTE_YPPM ) - ? PFR_NEXT_USHORT(p) - : PFR_NEXT_BYTE(p); + ? PFR_NEXT_USHORT( p ) + : PFR_NEXT_BYTE( p ); - strike->flags = PFR_NEXT_BYTE(p); + strike->flags = PFR_NEXT_BYTE( p ); strike->bct_size = ( flags0 & PFR_STRIKE_3BYTE_SIZE ) - ? PFR_NEXT_ULONG(p) - : PFR_NEXT_USHORT(p); + ? PFR_NEXT_ULONG( p ) + : PFR_NEXT_USHORT( p ); strike->bct_offset = ( flags0 & PFR_STRIKE_3BYTE_OFFSET ) - ? PFR_NEXT_ULONG(p) - : PFR_NEXT_USHORT(p); + ? PFR_NEXT_ULONG( p ) + : PFR_NEXT_USHORT( p ); strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT ) - ? PFR_NEXT_USHORT(p) - : PFR_NEXT_BYTE(p); + ? PFR_NEXT_USHORT( p ) + : PFR_NEXT_BYTE( p ); } phy_font->num_strikes += count; @@ -399,7 +430,7 @@ } - /* load font ID, i.e. name */ + /* load font ID, i.e. name */ FT_CALLBACK_DEF( FT_Error ) pfr_extra_item_load_font_id( FT_Byte* p, FT_Byte* limit, @@ -409,6 +440,7 @@ FT_Memory memory = phy_font->memory; FT_UInt len = (FT_UInt)( limit - p ); + if ( phy_font->font_id != NULL ) goto Exit; @@ -424,28 +456,29 @@ } - /* load stem snap tables */ + /* load stem snap tables */ FT_CALLBACK_DEF( FT_Error ) pfr_extra_item_load_stem_snaps( FT_Byte* p, FT_Byte* limit, PFR_PhyFont phy_font ) { - FT_UInt count, num_vert, num_horz; - FT_Int* snaps; - FT_Error error = 0; - FT_Memory memory = phy_font->memory; + FT_UInt count, num_vert, num_horz; + FT_Int* snaps; + FT_Error error = 0; + FT_Memory memory = phy_font->memory; + if ( phy_font->vertical.stem_snaps != NULL ) goto Exit; - PFR_CHECK(1); - count = PFR_NEXT_BYTE(p); + PFR_CHECK( 1 ); + count = PFR_NEXT_BYTE( p ); num_vert = count & 15; num_horz = count >> 4; count = num_vert + num_horz; - PFR_CHECK( count*2 ); + PFR_CHECK( count * 2 ); if ( FT_NEW_ARRAY( snaps, count ) ) goto Exit; @@ -454,7 +487,7 @@ phy_font->horizontal.stem_snaps = snaps + num_vert; for ( ; count > 0; count--, snaps++ ) - *snaps = FT_NEXT_SHORT(p); + *snaps = FT_NEXT_SHORT( p ); Exit: return error; @@ -466,7 +499,7 @@ } - static const PFR_ExtraItemRec pfr_phy_font_extra_items[] = + static const PFR_ExtraItemRec pfr_phy_font_extra_items[] = { { 1, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_bitmap_info }, { 2, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_font_id }, @@ -475,9 +508,6 @@ }; - - - FT_LOCAL_DEF( void ) pfr_phy_font_done( PFR_PhyFont phy_font, FT_Memory memory ) @@ -500,16 +530,12 @@ phy_font->chars_offset = 0; } - - - - FT_LOCAL_DEF( FT_Error ) - pfr_phy_font_load( PFR_PhyFont phy_font, - FT_Stream stream, - FT_UInt32 offset, - FT_UInt32 size ) + pfr_phy_font_load( PFR_PhyFont phy_font, + FT_Stream stream, + FT_UInt32 offset, + FT_UInt32 size ) { FT_Error error; FT_Memory memory = stream->memory; @@ -517,6 +543,7 @@ FT_Byte* p; FT_Byte* limit; + phy_font->memory = memory; phy_font->offset = offset; @@ -527,37 +554,37 @@ limit = p + size; PFR_CHECK( 15 ); - phy_font->font_ref_number = PFR_NEXT_USHORT(p); - phy_font->outline_resolution = PFR_NEXT_USHORT(p); - phy_font->metrics_resolution = PFR_NEXT_USHORT(p); - phy_font->bbox.xMin = PFR_NEXT_SHORT(p); - phy_font->bbox.yMin = PFR_NEXT_SHORT(p); - phy_font->bbox.xMax = PFR_NEXT_SHORT(p); - phy_font->bbox.yMax = PFR_NEXT_SHORT(p); - phy_font->flags = flags = PFR_NEXT_BYTE(p); + phy_font->font_ref_number = PFR_NEXT_USHORT( p ); + phy_font->outline_resolution = PFR_NEXT_USHORT( p ); + phy_font->metrics_resolution = PFR_NEXT_USHORT( p ); + phy_font->bbox.xMin = PFR_NEXT_SHORT( p ); + phy_font->bbox.yMin = PFR_NEXT_SHORT( p ); + phy_font->bbox.xMax = PFR_NEXT_SHORT( p ); + phy_font->bbox.yMax = PFR_NEXT_SHORT( p ); + phy_font->flags = flags = PFR_NEXT_BYTE( p ); /* get the standard advance for non-proprotional fonts */ if ( !(flags & PFR_PHY_PROPORTIONAL) ) { - PFR_CHECK(2); - phy_font->standard_advance = PFR_NEXT_SHORT(p); + PFR_CHECK( 2 ); + phy_font->standard_advance = PFR_NEXT_SHORT( p ); } /* load the extra items when present */ if ( flags & PFR_PHY_EXTRA_ITEMS ) { - error = - pfr_extra_items_parse( &p, limit, pfr_phy_font_extra_items, phy_font ); + error = pfr_extra_items_parse( &p, limit, + pfr_phy_font_extra_items, phy_font ); if ( error ) goto Fail; } /* skip the aux bytes */ - PFR_CHECK(3); - num_aux = PFR_NEXT_ULONG(p); + PFR_CHECK( 3 ); + num_aux = PFR_NEXT_ULONG( p ); - PFR_CHECK(num_aux); + PFR_CHECK( num_aux ); p += num_aux; /* read the blue values */ @@ -565,79 +592,81 @@ FT_UInt n, count; PFR_CHECK( 1 ); - phy_font->num_blue_values = count = PFR_NEXT_BYTE(p); + phy_font->num_blue_values = count = PFR_NEXT_BYTE( p ); - PFR_CHECK( count*2 ); + PFR_CHECK( count * 2 ); if ( FT_NEW_ARRAY( phy_font->blue_values, count ) ) goto Fail; for ( n = 0; n < count; n++ ) - phy_font->blue_values[n] = PFR_NEXT_SHORT(p); + phy_font->blue_values[n] = PFR_NEXT_SHORT( p ); } - PFR_CHECK(8); - phy_font->blue_fuzz = PFR_NEXT_BYTE(p); - phy_font->blue_scale = PFR_NEXT_BYTE(p); + PFR_CHECK( 8 ); + phy_font->blue_fuzz = PFR_NEXT_BYTE( p ); + phy_font->blue_scale = PFR_NEXT_BYTE( p ); - phy_font->vertical.standard = PFR_NEXT_USHORT(p); - phy_font->horizontal.standard = PFR_NEXT_USHORT(p); + phy_font->vertical.standard = PFR_NEXT_USHORT( p ); + phy_font->horizontal.standard = PFR_NEXT_USHORT( p ); /* read the character descriptors */ { - FT_UInt n, count, size; + FT_UInt n, count, Size; - phy_font->num_chars = count = PFR_NEXT_USHORT(p); - phy_font->chars_offset = offset + (p - stream->cursor); + + phy_font->num_chars = count = PFR_NEXT_USHORT( p ); + phy_font->chars_offset = offset + ( p - stream->cursor ); if ( FT_NEW_ARRAY( phy_font->chars, count ) ) goto Fail; - size = 1 + 1 + 2; + Size = 1 + 1 + 2; if ( flags & PFR_PHY_2BYTE_CHARCODE ) - size += 1; + Size += 1; if ( flags & PFR_PHY_PROPORTIONAL ) - size += 2; + Size += 2; if ( flags & PFR_PHY_ASCII_CODE ) - size += 1; + Size += 1; if ( flags & PFR_PHY_2BYTE_GPS_SIZE ) - size += 1; + Size += 1; if ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) - size += 1; + Size += 1; - PFR_CHECK( count*size ); + PFR_CHECK( count * Size ); for ( n = 0; n < count; n++ ) { - PFR_Char cur = &phy_font->chars[n]; + PFR_Char cur = &phy_font->chars[n]; - cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE ) - ? PFR_NEXT_USHORT(p) - : PFR_NEXT_BYTE(p); - cur->advance = ( flags & PFR_PHY_PROPORTIONAL ) - ? PFR_NEXT_SHORT(p) + cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE ) + ? PFR_NEXT_USHORT( p ) + : PFR_NEXT_BYTE( p ); + + cur->advance = ( flags & PFR_PHY_PROPORTIONAL ) + ? PFR_NEXT_SHORT( p ) : phy_font->standard_advance; #if 0 - cur->ascii = ( flags & PFR_PHY_ASCII_CODE ) - ? PFR_NEXT_BYTE(p) + cur->ascii = ( flags & PFR_PHY_ASCII_CODE ) + ? PFR_NEXT_BYTE( p ) : 0; #else - if ( flags & PFR_PHY_ASCII_CODE ) - p += 1; + if ( flags & PFR_PHY_ASCII_CODE ) + p += 1; #endif - cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE ) - ? PFR_NEXT_USHORT(p) - : PFR_NEXT_BYTE(p); + cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE ) + ? PFR_NEXT_USHORT( p ) + : PFR_NEXT_BYTE( p ); - cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) - ? PFR_NEXT_ULONG(p) - : PFR_NEXT_USHORT(p); + cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) + ? PFR_NEXT_ULONG( p ) + : PFR_NEXT_USHORT( p ); } } @@ -655,3 +684,4 @@ } +/* END */ diff --git a/src/pfr/pfrload.h b/src/pfr/pfrload.h index 58b8a6fb4..9e54b7d3f 100644 --- a/src/pfr/pfrload.h +++ b/src/pfr/pfrload.h @@ -1,30 +1,56 @@ -#ifndef __PFR_LOAD_H__ -#define __PFR_LOAD_H__ +/***************************************************************************/ +/* */ +/* pfrload.h */ +/* */ +/* FreeType PFR loader (specification). */ +/* */ +/* Copyright 2002 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. */ +/* */ +/***************************************************************************/ + + +#ifndef __PFRLOAD_H__ +#define __PFRLOAD_H__ #include "pfrobjs.h" #include FT_INTERNAL_STREAM_H + FT_BEGIN_HEADER #ifdef PFR_CONFIG_NO_CHECKS -# define PFR_CHECK(x) do { } while (0) +#define PFR_CHECK( x ) do { } while ( 0 ) #else -# define PFR_CHECK(x) do { if ( p + (x) > limit ) goto Too_Short; } while (0) +#define PFR_CHECK( x ) do \ + { \ + if ( p + (x) > limit ) \ + goto Too_Short; \ + } while ( 0 ) #endif -#define PFR_NEXT_BYTE(p) FT_NEXT_BYTE(p) -#define PFR_NEXT_INT8(p) FT_NEXT_CHAR(p) -#define PFR_NEXT_SHORT(p) FT_NEXT_SHORT(p) -#define PFR_NEXT_USHORT(p) FT_NEXT_USHORT(p) -#define PFR_NEXT_LONG(p) FT_NEXT_OFF3(p) -#define PFR_NEXT_ULONG(p) FT_NEXT_UOFF3(p) +#define PFR_NEXT_BYTE( p ) FT_NEXT_BYTE( p ) +#define PFR_NEXT_INT8( p ) FT_NEXT_CHAR( p ) +#define PFR_NEXT_SHORT( p ) FT_NEXT_SHORT( p ) +#define PFR_NEXT_USHORT( p ) FT_NEXT_USHORT( p ) +#define PFR_NEXT_LONG( p ) FT_NEXT_OFF3( p ) +#define PFR_NEXT_ULONG( p ) FT_NEXT_UOFF3( p ) + /* handling extra items */ - typedef FT_Error (*PFR_ExtraItem_ParseFunc)( FT_Byte* p, - FT_Byte* limit, - FT_Pointer data ); - typedef struct PFR_ExtraItemRec_ + typedef FT_Error + (*PFR_ExtraItem_ParseFunc)( FT_Byte* p, + FT_Byte* limit, + FT_Pointer data ); + + typedef struct PFR_ExtraItemRec_ { FT_UInt type; PFR_ExtraItem_ParseFunc parser; @@ -33,8 +59,10 @@ FT_BEGIN_HEADER typedef const struct PFR_ExtraItemRec_* PFR_ExtraItem; + FT_LOCAL( FT_Error ) - pfr_extra_items_skip( FT_Byte* *pp, FT_Byte* limit ); + pfr_extra_items_skip( FT_Byte* *pp, + FT_Byte* limit ); FT_LOCAL( FT_Error ) pfr_extra_items_parse( FT_Byte* *pp, @@ -43,47 +71,48 @@ FT_BEGIN_HEADER FT_Pointer item_data ); - /* load a PFR header */ + /* load a PFR header */ FT_LOCAL( FT_Error ) pfr_header_load( PFR_Header header, FT_Stream stream ); - /* check a PFR header */ + /* check a PFR header */ FT_LOCAL( FT_Bool ) pfr_header_check( PFR_Header header ); - - /* return number of logical fonts in this file */ + /* return number of logical fonts in this file */ FT_LOCAL( FT_Error ) - pfr_log_font_count( FT_Stream stream, - FT_UInt32 log_section_offset, - FT_UInt *acount ); + pfr_log_font_count( FT_Stream stream, + FT_UInt32 log_section_offset, + FT_UInt *acount ); - - /* load a pfr logical font entry */ + /* load a pfr logical font entry */ FT_LOCAL( FT_Error ) - pfr_log_font_load( PFR_LogFont log_font, - FT_Stream stream, - FT_UInt face_index, - FT_UInt32 section_offset, - FT_Bool size_increment ); + pfr_log_font_load( PFR_LogFont log_font, + FT_Stream stream, + FT_UInt face_index, + FT_UInt32 section_offset, + FT_Bool size_increment ); - /* load a physical font entry */ + /* load a physical font entry */ FT_LOCAL( FT_Error ) - pfr_phy_font_load( PFR_PhyFont phy_font, - FT_Stream stream, - FT_UInt32 offset, - FT_UInt32 size ); + pfr_phy_font_load( PFR_PhyFont phy_font, + FT_Stream stream, + FT_UInt32 offset, + FT_UInt32 size ); - /* finalize a physical font */ + /* finalize a physical font */ FT_LOCAL( void ) pfr_phy_font_done( PFR_PhyFont phy_font, FT_Memory memory ); - /* */ + /* */ FT_END_HEADER -#endif /* __PFR_LOAD_H__ */ +#endif /* __PFRLOAD_H__ */ + + +/* END */ diff --git a/src/pfr/pfrobjs.c b/src/pfr/pfrobjs.c index fb9a54e57..c5eb8d4bf 100644 --- a/src/pfr/pfrobjs.c +++ b/src/pfr/pfrobjs.c @@ -1,3 +1,21 @@ +/***************************************************************************/ +/* */ +/* pfrobjs.c */ +/* */ +/* FreeType PFR object methods (body). */ +/* */ +/* Copyright 2002 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 "pfrobjs.h" #include "pfrload.h" #include "pfrgload.h" @@ -8,19 +26,20 @@ #undef FT_COMPONENT #define FT_COMPONENT trace_pfr - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** FACE OBJECT METHODS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ + + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** FACE OBJECT METHODS *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ FT_LOCAL_DEF( void ) - pfr_face_done( PFR_Face face ) + pfr_face_done( PFR_Face face ) { /* finalize the physical font record */ - pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY(face) ); + pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) ); /* no need to finalize the logical font or the header */ } @@ -33,13 +52,15 @@ { FT_Error error; + /* load the header and check it */ error = pfr_header_load( &face->header, stream ); - if ( error ) goto Exit; + if ( error ) + goto Exit; if ( !pfr_header_check( &face->header ) ) { - FT_TRACE4(( "PFR.Face.Init: not a valid PFR font\n" )); + FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" )); error = FT_Err_Invalid_Argument; goto Exit; } @@ -48,10 +69,12 @@ { FT_UInt num_faces; + error = pfr_log_font_count( stream, face->header.log_dir_offset, &num_faces ); - if ( error ) goto Exit; + if ( error ) + goto Exit; face->root.num_faces = num_faces; } @@ -61,7 +84,7 @@ if ( face_index >= face->root.num_faces ) { - FT_ERROR(( "PFR.Face.Init: invalid face index\n" )); + FT_ERROR(( "pfr_face_init: invalid face index\n" )); error = FT_Err_Invalid_Argument; goto Exit; } @@ -83,9 +106,10 @@ /* now, set-up all root face fields */ { - FT_Face root = FT_FACE(face); + FT_Face root = FT_FACE( face ); PFR_PhyFont phy_font = &face->phy_font; + root->face_index = face_index; root->num_glyphs = phy_font->num_chars; root->face_flags = FT_FACE_FLAG_SCALABLE; @@ -98,7 +122,7 @@ else root->face_flags |= FT_FACE_FLAG_VERTICAL; - /* XXXX: kerning and embedded bitmap support isn't there yet */ + /* XXX: kerning and embedded bitmap support isn't there yet */ root->family_name = phy_font->font_id; root->style_name = NULL; /* no style name in font file */ @@ -107,38 +131,42 @@ root->available_sizes = 0; root->bbox = phy_font->bbox; - root->units_per_EM = (FT_UShort) phy_font->outline_resolution; - root->ascender = (FT_Short) phy_font->bbox.yMax; - root->descender = (FT_Short) phy_font->bbox.yMin; - root->height = (FT_Short)( ((root->ascender - root->descender)*12) / 10 ); + root->units_per_EM = (FT_UShort)phy_font->outline_resolution; + root->ascender = (FT_Short) phy_font->bbox.yMax; + root->descender = (FT_Short) phy_font->bbox.yMin; + root->height = (FT_Short) + ( ( ( root->ascender - root->descender ) * 12 ) + / 10 ); /* now compute maximum advance width */ - if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 ) - root->max_advance_width = (FT_Short) phy_font->standard_advance; + if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 ) + root->max_advance_width = (FT_Short)phy_font->standard_advance; else { FT_Int max = 0; FT_UInt count = phy_font->num_chars; PFR_Char gchar = phy_font->chars; + for ( ; count > 0; count--, gchar++ ) { if ( max < gchar->advance ) max = gchar->advance; } - root->max_advance_width = (FT_Short) max; + root->max_advance_width = (FT_Short)max; } root->max_advance_height = root->height; - root->underline_position = (FT_Short)( - root->units_per_EM/10 ); - root->underline_thickness = (FT_Short)( root->units_per_EM/30 ); + root->underline_position = (FT_Short)( - root->units_per_EM / 10 ); + root->underline_thickness = (FT_Short)( root->units_per_EM / 30 ); /* create charmap */ { - FT_CharMapRec charmap; + FT_CharMapRec charmap; + charmap.face = root; charmap.platform_id = 3; charmap.encoding_id = 1; @@ -153,18 +181,18 @@ } - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** SLOT OBJECT METHOD *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ + /*************************************************************************/ + /*************************************************************************/ + /***** *****/ + /***** SLOT OBJECT METHOD *****/ + /***** *****/ + /*************************************************************************/ + /*************************************************************************/ FT_LOCAL_DEF( FT_Error ) pfr_slot_init( PFR_Slot slot ) { - FT_GlyphLoader loader = slot->root.internal->loader; + FT_GlyphLoader loader = slot->root.internal->loader; pfr_glyph_init( &slot->glyph, loader ); @@ -186,12 +214,13 @@ FT_Int load_flags ) { FT_Error error; - PFR_Face face = (PFR_Face) slot->root.face; + PFR_Face face = (PFR_Face)slot->root.face; PFR_Char gchar = face->phy_font.chars + gindex; FT_Outline* outline = &slot->root.outline; FT_ULong gps_offset; - /* check that the glyph index is correct */ + + /* check that the glyph index is correct */ FT_ASSERT( gindex < face->phy_font.num_chars ); slot->root.format = ft_glyph_format_outline; @@ -199,21 +228,20 @@ outline->n_contours = 0; gps_offset = face->header.gps_section_offset; - - /* load the glyph outline ( FT_LOAD_NO_RECURSE isn't supported ) */ + /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */ error = pfr_glyph_load( &slot->glyph, face->root.stream, gps_offset, gchar->gps_offset, gchar->gps_size ); - if (!error) + if ( !error ) { FT_BBox cbox; - FT_Outline* outline = &slot->root.outline; FT_Glyph_Metrics* metrics = &slot->root.metrics; FT_Pos advance; FT_Int em_metrics, em_outline; FT_Bool scaling; - scaling = FT_BOOL( (load_flags & FT_LOAD_NO_SCALE) == 0 ); + + scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 ); /* copy outline data */ *outline = slot->glyph.loader->base.outline; @@ -243,7 +271,7 @@ slot->root.linearHoriAdvance = metrics->horiAdvance; slot->root.linearVertAdvance = metrics->vertAdvance; - /* make-up vertical metrics (?) */ + /* make-up vertical metrics(?) */ metrics->vertBearingX = 0; metrics->vertBearingY = 0; @@ -255,6 +283,7 @@ FT_Fixed y_scale = size->root.metrics.y_scale; FT_Vector* vec = outline->points; + /* scale outline points */ for ( n = 0; n < outline->n_points; n++, vec++ ) { @@ -278,3 +307,6 @@ return error; } + + +/* END */ diff --git a/src/pfr/pfrobjs.h b/src/pfr/pfrobjs.h index 644ff8c57..03633a4b9 100644 --- a/src/pfr/pfrobjs.h +++ b/src/pfr/pfrobjs.h @@ -1,19 +1,37 @@ -#ifndef __PFR_OBJS_H__ -#define __PFR_OBJS_H__ +/***************************************************************************/ +/* */ +/* pfrobjs.h */ +/* */ +/* FreeType PFR object methods (specification). */ +/* */ +/* Copyright 2002 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. */ +/* */ +/***************************************************************************/ + + +#ifndef __PFROBJS_H__ +#define __PFROBJS_H__ #include "pfrtypes.h" + FT_BEGIN_HEADER - typedef struct PFR_FaceRec_* PFR_Face; + typedef struct PFR_FaceRec_* PFR_Face; - typedef struct PFR_SizeRec_* PFR_Size; + typedef struct PFR_SizeRec_* PFR_Size; - typedef struct PFR_SlotRec_* PFR_Slot; + typedef struct PFR_SlotRec_* PFR_Slot; - - typedef struct PFR_FaceRec_ + typedef struct PFR_FaceRec_ { FT_FaceRec root; PFR_HeaderRec header; @@ -23,14 +41,14 @@ FT_BEGIN_HEADER } PFR_FaceRec; - typedef struct PFR_SizeRec_ + typedef struct PFR_SizeRec_ { - FT_SizeRec root; + FT_SizeRec root; } PFR_SizeRec; - typedef struct PFR_SlotRec_ + typedef struct PFR_SlotRec_ { FT_GlyphSlotRec root; PFR_GlyphRec glyph; @@ -43,7 +61,6 @@ FT_BEGIN_HEADER PFR_Face face, FT_Int face_index ); - FT_LOCAL( void ) pfr_face_done( PFR_Face face ); @@ -51,7 +68,6 @@ FT_BEGIN_HEADER FT_LOCAL( FT_Error ) pfr_slot_init( PFR_Slot slot ); - FT_LOCAL( void ) pfr_slot_done( PFR_Slot slot ); @@ -65,4 +81,4 @@ FT_BEGIN_HEADER FT_END_HEADER -#endif /* __PFR_OBJS_H__ */ +#endif /* __PFROBJS_H__ */ diff --git a/src/pfr/pfrtypes.h b/src/pfr/pfrtypes.h index e965b5b16..eb821d300 100644 --- a/src/pfr/pfrtypes.h +++ b/src/pfr/pfrtypes.h @@ -1,57 +1,75 @@ -#ifndef __PFR_TYPES_H__ -#define __PFR_TYPES_H__ +/***************************************************************************/ +/* */ +/* pfrtypes.h */ +/* */ +/* FreeType PFR data structures (specification only). */ +/* */ +/* Copyright 2002 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. */ +/* */ +/***************************************************************************/ + + +#ifndef __PFRTYPES_H__ +#define __PFRTYPES_H__ #include #include FT_INTERNAL_OBJECTS_H FT_BEGIN_HEADER - /************************************************************************/ + /************************************************************************/ - /* the PFR Header structure */ - typedef struct PFR_HeaderRec_ + /* the PFR Header structure */ + typedef struct PFR_HeaderRec_ { - FT_UInt32 signature; - FT_UInt version; - FT_UInt signature2; - FT_UInt header_size; + FT_UInt32 signature; + FT_UInt version; + FT_UInt signature2; + FT_UInt header_size; - FT_UInt log_dir_size; - FT_UInt log_dir_offset; + FT_UInt log_dir_size; + FT_UInt log_dir_offset; - FT_UInt log_font_max_size; - FT_UInt32 log_font_section_size; - FT_UInt32 log_font_section_offset; + FT_UInt log_font_max_size; + FT_UInt32 log_font_section_size; + FT_UInt32 log_font_section_offset; - FT_UInt32 phy_font_max_size; - FT_UInt32 phy_font_section_size; - FT_UInt32 phy_font_section_offset; + FT_UInt32 phy_font_max_size; + FT_UInt32 phy_font_section_size; + FT_UInt32 phy_font_section_offset; - FT_UInt gps_max_size; - FT_UInt32 gps_section_size; - FT_UInt32 gps_section_offset; + FT_UInt gps_max_size; + FT_UInt32 gps_section_size; + FT_UInt32 gps_section_offset; - FT_UInt max_blue_values; - FT_UInt max_x_orus; - FT_UInt max_y_orus; + FT_UInt max_blue_values; + FT_UInt max_x_orus; + FT_UInt max_y_orus; - FT_UInt phy_font_max_size_high; - FT_UInt color_flags; + FT_UInt phy_font_max_size_high; + FT_UInt color_flags; - FT_UInt32 bct_max_size; - FT_UInt32 bct_set_max_size; - FT_UInt32 phy_bct_set_max_size; + FT_UInt32 bct_max_size; + FT_UInt32 bct_set_max_size; + FT_UInt32 phy_bct_set_max_size; - FT_UInt num_phy_fonts; - FT_UInt max_vert_stem_snap; - FT_UInt max_horz_stem_snap; - FT_UInt max_chars; + FT_UInt num_phy_fonts; + FT_UInt max_vert_stem_snap; + FT_UInt max_horz_stem_snap; + FT_UInt max_chars; } PFR_HeaderRec, *PFR_Header; - /* used in 'color_flags' field of the PFR_Header */ - typedef enum PFR_HeaderFlags_ + /* used in `color_flags' field of the PFR_Header */ + typedef enum PFR_HeaderFlags_ { PFR_FLAG_BLACK_PIXEL = 1, PFR_FLAG_INVERT_BITMAP = 2 @@ -59,9 +77,9 @@ FT_BEGIN_HEADER } PFR_HeaderFlags; - /************************************************************************/ + /************************************************************************/ - typedef struct PFR_LogFontRec_ + typedef struct PFR_LogFontRec_ { FT_UInt32 size; FT_UInt32 offset; @@ -78,19 +96,19 @@ FT_BEGIN_HEADER } PFR_LogFontRec, *PFR_LogFont; - typedef enum PFR_LogFlags_ + typedef enum PFR_LogFlags_ { - PFR_LOG_EXTRA_ITEMS = 0x40, - PFR_LOG_2BYTE_BOLD = 0x20, - PFR_LOG_BOLD = 0x10, - PFR_LOG_2BYTE_STROKE = 8, - PFR_LOG_STROKE = 4, - PFR_LINE_JOIN_MASK = 3 + PFR_LOG_EXTRA_ITEMS = 0x40, + PFR_LOG_2BYTE_BOLD = 0x20, + PFR_LOG_BOLD = 0x10, + PFR_LOG_2BYTE_STROKE = 8, + PFR_LOG_STROKE = 4, + PFR_LINE_JOIN_MASK = 3 } PFR_LogFlags; - typedef enum PFR_LineJoinFlags_ + typedef enum PFR_LineJoinFlags_ { PFR_LINE_JOIN_MITER = 0, PFR_LINE_JOIN_ROUND = 1, @@ -99,18 +117,18 @@ FT_BEGIN_HEADER } PFR_LineJoinFlags; - /************************************************************************/ + /************************************************************************/ - typedef enum PFR_BitmapFlags_ + typedef enum PFR_BitmapFlags_ { - PFR_BITMAP_3BYTE_OFFSET = 4, - PFR_BITMAP_2BYTE_SIZE = 2, - PFR_BITMAP_2BYTE_CHARCODE = 1 + PFR_BITMAP_3BYTE_OFFSET = 4, + PFR_BITMAP_2BYTE_SIZE = 2, + PFR_BITMAP_2BYTE_CHARCODE = 1 } PFR_BitmapFlags; - typedef struct PFR_BitmapCharRec_ + typedef struct PFR_BitmapCharRec_ { FT_UInt char_code; FT_UInt gps_size; @@ -119,7 +137,7 @@ FT_BEGIN_HEADER } PFR_BitmapCharRec, *PFR_BitmapChar; - typedef enum PFR_StrikeFlags_ + typedef enum PFR_StrikeFlags_ { PFR_STRIKE_2BYTE_COUNT = 0x10, PFR_STRIKE_3BYTE_OFFSET = 0x08, @@ -130,7 +148,7 @@ FT_BEGIN_HEADER } PFR_StrikeFlags; - typedef struct PFR_StrikeRec_ + typedef struct PFR_StrikeRec_ { FT_UInt x_ppm; FT_UInt y_ppm; @@ -149,33 +167,32 @@ FT_BEGIN_HEADER } PFR_StrikeRec, *PFR_Strike; + /************************************************************************/ - /************************************************************************/ - - typedef struct PFR_CharRec_ + typedef struct PFR_CharRec_ { - FT_UInt char_code; - FT_Int advance; - FT_UInt gps_size; - FT_UInt32 gps_offset; + FT_UInt char_code; + FT_Int advance; + FT_UInt gps_size; + FT_UInt32 gps_offset; } PFR_CharRec, *PFR_Char; - /************************************************************************/ + /************************************************************************/ - typedef struct PFR_DimensionRec_ + typedef struct PFR_DimensionRec_ { - FT_UInt standard; - FT_UInt num_stem_snaps; - FT_Int* stem_snaps; + FT_UInt standard; + FT_UInt num_stem_snaps; + FT_Int* stem_snaps; } PFR_DimensionRec, *PFR_Dimension; - /************************************************************************/ + /************************************************************************/ - typedef struct PFR_PhyFontRec_ + typedef struct PFR_PhyFontRec_ { FT_Memory memory; FT_UInt32 offset; @@ -207,7 +224,8 @@ FT_BEGIN_HEADER } PFR_PhyFontRec, *PFR_PhyFont; - typedef enum PFR_PhyFlags_ + + typedef enum PFR_PhyFlags_ { PFR_PHY_EXTRA_ITEMS = 0x80, PFR_PHY_3BYTE_GPS_OFFSET = 0x20, @@ -219,9 +237,10 @@ FT_BEGIN_HEADER } PFR_PhyFlags; - /************************************************************************/ - typedef enum PFR_GlyphFlags_ + /************************************************************************/ + + typedef enum PFR_GlyphFlags_ { PFR_GLYPH_IS_COMPOUND = 0x80, PFR_GLYPH_EXTRA_ITEMS = 0x08, @@ -231,8 +250,9 @@ FT_BEGIN_HEADER } PFR_GlyphFlags; - /* controlled coordinate */ - typedef struct PFR_CoordRec_ + + /* controlled coordinate */ + typedef struct PFR_CoordRec_ { FT_UInt org; FT_UInt cur; @@ -240,7 +260,7 @@ FT_BEGIN_HEADER } PFR_CoordRec, *PFR_Coord; - typedef struct PFR_SubGlyphRec_ + typedef struct PFR_SubGlyphRec_ { FT_Fixed x_scale; FT_Fixed y_scale; @@ -252,7 +272,7 @@ FT_BEGIN_HEADER } PFR_SubGlyphRec, *PFR_SubGlyph; - typedef enum PFR_SubgGlyphFlags_ + typedef enum PFR_SubgGlyphFlags_ { PFR_SUBGLYPH_3BYTE_OFFSET = 0x80, PFR_SUBGLYPH_2BYTE_SIZE = 0x40, @@ -262,8 +282,7 @@ FT_BEGIN_HEADER } PFR_SubGlyphFlags; - - typedef struct PFR_GlyphRec_ + typedef struct PFR_GlyphRec_ { FT_Byte format; @@ -286,4 +305,7 @@ FT_BEGIN_HEADER FT_END_HEADER -#endif /* __PFR_TYPES_H__ */ +#endif /* __PFRTYPES_H__ */ + + +/* END */