ReceiveTempSMS
/
Al-Qurtas-Islamic-bank-The-Best-Bank-in-Iraq
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Simplifying the FIELD_* and FRAME_* macros. Before calling these macros, 

you should #define FT_STRUCTURE to the structure which will be filled.

Replaced FT_FIELD_REF with FT_FIELD_SIZE, FT_FIELD_SIZE_DELTA, and
FT_FIELD_OFFSET to make the code more readable; additionally, it should be
more portable because we no longer cast a pointer to an FT_UShort (which
e.g. fails with Sun's C++ compiler) but computes the difference between two
pointers which is guaranteed to work.

Fixing warnings (and C++ errors) while using Sun's latest cc and CC
incarnations.  Most of them are related to variable shadowing.
This commit is contained in:
Werner Lemberg 2000-07-31 18:59:02 +00:00
parent 35ca3426eb
commit e72c9fec17
24 changed files with 597 additions and 555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
builds/unix/ftsystem.c
View File

@ -235,12 +235,12 @@
stream->size = stat_buf.st_size; stream->size = stat_buf.st_size;
stream->pos = 0; stream->pos = 0;
stream->base = mmap( NULL, stream->base = (unsigned char*)mmap( NULL,
stream->size, stream->size,
PROT_READ, PROT_READ,
MAP_FILE | MAP_PRIVATE, MAP_FILE | MAP_PRIVATE,
file, file,
0 ); 0 );
if ( (long)stream->base == -1 ) if ( (long)stream->base == -1 )
{ {

63
include/freetype/internal/ftstream.h
View File

@ -81,48 +81,55 @@
typedef struct FT_Frame_Field_ typedef struct FT_Frame_Field_
{ {
FT_Frame_Op value; FT_Frame_Op value;
char size; FT_Byte size;
FT_UShort offset; FT_UShort offset;
} FT_Frame_Field; } FT_Frame_Field;
/* make-up a FT_Frame_Field out of a structure type and a field name */ /* Construct an FT_Frame_Field out of a structure type and a field name. */
#define FT_FIELD_REF( s, f ) (((s*)0)->f) /* The structure type must be set in the FT_STRUCTURE macro before */
/* calling the FT_FRAME_START() macro. */
#define FT_FIELD_SIZE( f ) \
(FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f )
#define FT_FIELD_SIZE_DELTA( f ) \
(FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f[0] )
#define FT_FIELD_OFFSET( f ) \
(FT_UShort)( (char*)&(((FT_STRUCTURE*)0)->f) - (char*)0 )
#define FT_FRAME_FIELD( frame_op, struct_type, field ) \ #define FT_FRAME_FIELD( frame_op, field ) \
{ \ { \
frame_op, \ frame_op, \
sizeof ( FT_FIELD_REF( struct_type,field ) ), \ FT_FIELD_SIZE( field ), \
(FT_UShort)(char*)&FT_FIELD_REF( struct_type, field ) \ FT_FIELD_OFFSET( field ) \
} }
#define FT_MAKE_EMPTY_FIELD( frame_op ) { frame_op, 0, 0 } #define FT_MAKE_EMPTY_FIELD( frame_op ) { frame_op, 0, 0 }
#define FT_FRAME_START( s ) { ft_frame_start, 0, s } #define FT_FRAME_START( size ) { ft_frame_start, 0, size }
#define FT_FRAME_END { ft_frame_end, 0, 0 } #define FT_FRAME_END { ft_frame_end, 0, 0 }
#define FT_FRAME_LONG( s, f ) FT_FRAME_FIELD( ft_frame_long_be, s, f ) #define FT_FRAME_LONG( f ) FT_FRAME_FIELD( ft_frame_long_be, f )
#define FT_FRAME_ULONG( s, f ) FT_FRAME_FIELD( ft_frame_ulong_be, s, f ) #define FT_FRAME_ULONG( f ) FT_FRAME_FIELD( ft_frame_ulong_be, f )
#define FT_FRAME_SHORT( s, f ) FT_FRAME_FIELD( ft_frame_short_be, s, f ) #define FT_FRAME_SHORT( f ) FT_FRAME_FIELD( ft_frame_short_be, f )
#define FT_FRAME_USHORT( s, f ) FT_FRAME_FIELD( ft_frame_ushort_be, s, f ) #define FT_FRAME_USHORT( f ) FT_FRAME_FIELD( ft_frame_ushort_be, f )
#define FT_FRAME_BYTE( s, f ) FT_FRAME_FIELD( ft_frame_byte, s, f ) #define FT_FRAME_BYTE( f ) FT_FRAME_FIELD( ft_frame_byte, f )
#define FT_FRAME_CHAR( s, f ) FT_FRAME_FIELD( ft_frame_schar, s, f ) #define FT_FRAME_CHAR( f ) FT_FRAME_FIELD( ft_frame_schar, f )
#define FT_FRAME_LONG_LE( s, f ) FT_FRAME_FIELD( ft_frame_long_le, s, f ) #define FT_FRAME_LONG_LE( f ) FT_FRAME_FIELD( ft_frame_long_le, f )
#define FT_FRAME_ULONG_LE( s, f ) FT_FRAME_FIELD( ft_frame_ulong_le, s, f ) #define FT_FRAME_ULONG_LE( f ) FT_FRAME_FIELD( ft_frame_ulong_le, f )
#define FT_FRAME_SHORT_LE( s, f ) FT_FRAME_FIELD( ft_frame_short_le, s, f ) #define FT_FRAME_SHORT_LE( f ) FT_FRAME_FIELD( ft_frame_short_le, f )
#define FT_FRAME_USHORT_LE( s, f ) FT_FRAME_FIELD( ft_frame_ushort_le, s, f ) #define FT_FRAME_USHORT_LE( f ) FT_FRAME_FIELD( ft_frame_ushort_le, f )
#define FT_FRAME_SKIP_LONG { ft_frame_long_be, 0, 0 } #define FT_FRAME_SKIP_LONG { ft_frame_long_be, 0, 0 }
#define FT_FRAME_SKIP_SHORT { ft_frame_short_be, 0, 0 } #define FT_FRAME_SKIP_SHORT { ft_frame_short_be, 0, 0 }
#define FT_FRAME_SKIP_BYTE { ft_frame_byte, 0, 0 } #define FT_FRAME_SKIP_BYTE { ft_frame_byte, 0, 0 }
#define FT_FRAME_BYTES( struct_type, field, count ) \ #define FT_FRAME_BYTES( field, count ) \
{ \ { \
ft_frame_bytes, \ ft_frame_bytes, \
count, \ count, \
(FT_UShort)(char*)&FT_FIELD_REF( struct_type, field ) \ FT_FIELD_OFFSET( field ) \
} }
#define FT_FRAME_SKIP_BYTES( count ) { ft_frame_skip, count, 0 } #define FT_FRAME_SKIP_BYTES( count ) { ft_frame_skip, count, 0 }

135
src/autohint/ahglyph.c
View File

@ -260,14 +260,14 @@
void ah_outline_save( AH_Outline* outline, void ah_outline_save( AH_Outline* outline,
AH_Loader* gloader ) AH_Loader* gloader )
{ {
AH_Point* point = outline->points; AH_Point* point = outline->points;
AH_Point* limit = point + outline->num_points; AH_Point* point_limit = point + outline->num_points;
FT_Vector* vec = gloader->current.outline.points; FT_Vector* vec = gloader->current.outline.points;
char* tag = gloader->current.outline.tags; char* tag = gloader->current.outline.tags;
/* we assume that the glyph loader has already been checked for storage */ /* we assume that the glyph loader has already been checked for storage */
for ( ; point < limit; point++, vec++, tag++ ) for ( ; point < point_limit; point++, vec++, tag++ )
{ {
vec->x = point->x; vec->x = point->x;
vec->y = point->y; vec->y = point->y;
@ -393,8 +393,8 @@
{ {
/* do one thing at a time -- it is easier to understand, and */ /* do one thing at a time -- it is easier to understand, and */
/* the code is clearer */ /* the code is clearer */
AH_Point* point = points; AH_Point* point;
AH_Point* limit = point + outline->num_points; AH_Point* point_limit = points + outline->num_points;
/* compute coordinates */ /* compute coordinates */
@ -404,7 +404,7 @@
FT_Fixed y_scale = outline->y_scale; FT_Fixed y_scale = outline->y_scale;
for (; point < limit; vec++, point++ ) for ( point = points; point < point_limit; vec++, point++ )
{ {
point->fx = vec->x; point->fx = vec->x;
point->fy = vec->y; point->fy = vec->y;
@ -420,7 +420,7 @@
char* tag = source->tags; char* tag = source->tags;
for ( point = points; point < limit; point++, tag++ ) for ( point = points; point < point_limit; point++, tag++ )
{ {
switch ( FT_CURVE_TAG( *tag ) ) switch ( FT_CURVE_TAG( *tag ) )
{ {
@ -448,7 +448,7 @@
end = points + source->contours[0]; end = points + source->contours[0];
prev = end; prev = end;
for ( point = points; point < limit; point++ ) for ( point = points; point < point_limit; point++ )
{ {
point->prev = prev; point->prev = prev;
if ( point < end ) if ( point < end )
@ -460,7 +460,7 @@
{ {
point->next = first; point->next = first;
contour_index++; contour_index++;
if ( point + 1 < limit ) if ( point + 1 < point_limit )
{ {
end = points + source->contours[contour_index]; end = points + source->contours[contour_index];
first = point + 1; first = point + 1;
@ -472,13 +472,13 @@
/* set-up the contours array */ /* set-up the contours array */
{ {
AH_Point** contour = outline->contours; AH_Point** contour = outline->contours;
AH_Point** limit = contour + outline->num_contours; AH_Point** contour_limit = contour + outline->num_contours;
short* end = source->contours; short* end = source->contours;
short index = 0; short index = 0;
for ( ; contour < limit; contour++, end++ ) for ( ; contour < contour_limit; contour++, end++ )
{ {
contour[0] = points + index; contour[0] = points + index;
index = end[0] + 1; index = end[0] + 1;
@ -487,7 +487,7 @@
/* compute directions of in & out vectors */ /* compute directions of in & out vectors */
{ {
for ( point = points; point < limit; point++ ) for ( point = points; point < point_limit; point++ )
{ {
AH_Point* prev; AH_Point* prev;
AH_Point* next; AH_Point* next;
@ -546,11 +546,11 @@
void ah_setup_uv( AH_Outline* outline, void ah_setup_uv( AH_Outline* outline,
AH_UV source ) AH_UV source )
{ {
AH_Point* point = outline->points; AH_Point* point = outline->points;
AH_Point* limit = point + outline->num_points; AH_Point* point_limit = point + outline->num_points;
for ( ; point < limit; point++ ) for ( ; point < point_limit; point++ )
{ {
FT_Pos u, v; FT_Pos u, v;
@ -616,16 +616,16 @@
for ( dimension = 1; dimension >= 0; dimension-- ) for ( dimension = 1; dimension >= 0; dimension-- )
{ {
AH_Point** contour = outline->contours; AH_Point** contour = outline->contours;
AH_Point** contour_limit = contour + outline->num_contours; AH_Point** contour_limit = contour + outline->num_contours;
AH_Segment* segment = segments; AH_Segment* segment = segments;
FT_Int num_segments = 0; FT_Int num_segments = 0;
#ifdef AH_HINT_METRICS #ifdef AH_HINT_METRICS
AH_Point* min_point = 0; AH_Point* min_point = 0;
AH_Point* max_point = 0; AH_Point* max_point = 0;
FT_Pos min_coord = 32000; FT_Pos min_coord = 32000;
FT_Pos max_coord = -32000; FT_Pos max_coord = -32000;
#endif #endif
@ -747,11 +747,13 @@
segment->contour = contour; segment->contour = contour;
on_edge = 1; on_edge = 1;
#ifdef AH_HINT_METRICS
if ( point == max_point ) if ( point == max_point )
max_point = 0; max_point = 0;
if ( point == min_point ) if ( point == min_point )
min_point = 0; min_point = 0;
#endif
} }
point = point->next; point = point->next;
@ -765,17 +767,18 @@
/* we do this by inserting fake segments when needed */ /* we do this by inserting fake segments when needed */
if ( dimension == 0 ) if ( dimension == 0 )
{ {
AH_Point* point = outline->points; AH_Point* point = outline->points;
AH_Point* limit = point + outline->num_points; AH_Point* point_limit = point + outline->num_points;
AH_Point* min_point = 0; FT_Pos min_pos = 32000;
AH_Point* max_point = 0; FT_Pos max_pos = -32000;
FT_Pos min_pos = 32000;
FT_Pos max_pos = -32000;
min_point = 0;
max_point = 0;
/* compute minimum and maximum points */ /* compute minimum and maximum points */
for ( ; point < limit; point++ ) for ( ; point < point_limit; point++ )
{ {
FT_Pos x = point->fx; FT_Pos x = point->fx;
@ -840,14 +843,14 @@
void ah_outline_link_segments( AH_Outline* outline ) void ah_outline_link_segments( AH_Outline* outline )
{ {
AH_Segment* segments; AH_Segment* segments;
AH_Segment* limit; AH_Segment* segment_limit;
int dimension; int dimension;
ah_setup_uv( outline, ah_uv_fyx ); ah_setup_uv( outline, ah_uv_fyx );
segments = outline->horz_segments; segments = outline->horz_segments;
limit = segments + outline->num_hsegments; segment_limit = segments + outline->num_hsegments;
for ( dimension = 1; dimension >= 0; dimension-- ) for ( dimension = 1; dimension >= 0; dimension-- )
{ {
@ -856,7 +859,7 @@
/* now compare each segment to the others */ /* now compare each segment to the others */
for ( seg1 = segments; seg1 < limit; seg1++ ) for ( seg1 = segments; seg1 < segment_limit; seg1++ )
{ {
FT_Pos best_score = 32000; FT_Pos best_score = 32000;
AH_Segment* best_segment = 0; AH_Segment* best_segment = 0;
@ -867,7 +870,7 @@
if ( seg1->first == seg1->last ) if ( seg1->first == seg1->last )
continue; continue;
for ( seg2 = segments; seg2 < limit; seg2++ ) for ( seg2 = segments; seg2 < segment_limit; seg2++ )
if ( seg1 != seg2 && seg1->dir + seg2->dir == 0 ) if ( seg1 != seg2 && seg1->dir + seg2->dir == 0 )
{ {
FT_Pos pos1 = seg1->pos; FT_Pos pos1 = seg1->pos;
@ -937,7 +940,7 @@
} /* edges 1 */ } /* edges 1 */
/* now, compute the `serif' segments */ /* now, compute the `serif' segments */
for ( seg1 = segments; seg1 < limit; seg1++ ) for ( seg1 = segments; seg1 < segment_limit; seg1++ )
{ {
seg2 = seg1->link; seg2 = seg1->link;
@ -950,8 +953,8 @@
ah_setup_uv( outline, ah_uv_fxy ); ah_setup_uv( outline, ah_uv_fxy );
segments = outline->vert_segments; segments = outline->vert_segments;
limit = segments + outline->num_vsegments; segment_limit = segments + outline->num_vsegments;
} }
} }
@ -962,14 +965,14 @@
void ah_dump_segments( AH_Outline* outline ) void ah_dump_segments( AH_Outline* outline )
{ {
AH_Segment* segments; AH_Segment* segments;
AH_Segment* limit; AH_Segment* segment_limit;
AH_Point* points; AH_Point* points;
FT_Int dimension; FT_Int dimension;
points = outline->points; points = outline->points;
segments = outline->horz_segments; segments = outline->horz_segments;
limit = segments + outline->num_hsegments; segment_limit = segments + outline->num_hsegments;
for ( dimension = 1; dimension >= 0; dimension-- ) for ( dimension = 1; dimension >= 0; dimension-- )
{ {
@ -981,7 +984,7 @@
printf ( " [ index | pos | dir | link | serif |" printf ( " [ index | pos | dir | link | serif |"
" numl | first | start ]\n" ); " numl | first | start ]\n" );
for ( seg = segments; seg < limit; seg++ ) for ( seg = segments; seg < segment_limit; seg++ )
{ {
printf ( " [ %5d | %4d | %5s | %4d | %5d | %4d | %5d | %5d ]\n", printf ( " [ %5d | %4d | %5s | %4d | %5d | %4d | %5d | %5d ]\n",
seg - segments, seg - segments,
@ -1002,8 +1005,8 @@
seg->last - points ); seg->last - points );
} }
segments = outline->vert_segments; segments = outline->vert_segments;
limit = segments + outline->num_vsegments; segment_limit = segments + outline->num_vsegments;
} }
} }
@ -1285,14 +1288,14 @@
void ah_outline_compute_blue_edges( AH_Outline* outline, void ah_outline_compute_blue_edges( AH_Outline* outline,
AH_Face_Globals* face_globals ) AH_Face_Globals* face_globals )
{ {
AH_Edge* edge = outline->horz_edges; AH_Edge* edge = outline->horz_edges;
AH_Edge* limit = edge + outline->num_hedges; AH_Edge* edge_limit = edge + outline->num_hedges;
AH_Globals* globals = &face_globals->design; AH_Globals* globals = &face_globals->design;
FT_Fixed y_scale = outline->y_scale; FT_Fixed y_scale = outline->y_scale;
/* compute for each horizontal edge, which blue zone is closer */ /* compute for each horizontal edge, which blue zone is closer */
for ( ; edge < limit; edge++ ) for ( ; edge < edge_limit; edge++ )
{ {
AH_Blue blue; AH_Blue blue;
FT_Pos* best_blue = 0; FT_Pos* best_blue = 0;
@ -1381,14 +1384,14 @@
void ah_outline_scale_blue_edges( AH_Outline* outline, void ah_outline_scale_blue_edges( AH_Outline* outline,
AH_Face_Globals* globals ) AH_Face_Globals* globals )
{ {
AH_Edge* edge = outline->horz_edges; AH_Edge* edge = outline->horz_edges;
AH_Edge* limit = edge + outline->num_hedges; AH_Edge* edge_limit = edge + outline->num_hedges;
FT_Int delta; FT_Int delta;
delta = globals->scaled.blue_refs - globals->design.blue_refs; delta = globals->scaled.blue_refs - globals->design.blue_refs;
for ( ; edge < limit; edge++ ) for ( ; edge < edge_limit; edge++ )
{ {
if ( edge->blue_edge ) if ( edge->blue_edge )
edge->blue_edge += delta; edge->blue_edge += delta;
@ -1401,14 +1404,14 @@
void ah_dump_edges( AH_Outline* outline ) void ah_dump_edges( AH_Outline* outline )
{ {
AH_Edge* edges; AH_Edge* edges;
AH_Edge* limit; AH_Edge* edge_limit;
AH_Segment* segments; AH_Segment* segments;
FT_Int dimension; FT_Int dimension;
edges = outline->horz_edges; edges = outline->horz_edges;
limit = edges + outline->num_hedges; edge_limit = edges + outline->num_hedges;
segments = outline->horz_segments; segments = outline->horz_segments;
for ( dimension = 1; dimension >= 0; dimension-- ) for ( dimension = 1; dimension >= 0; dimension-- )
{ {
@ -1420,7 +1423,7 @@
printf ( " [ index | pos | dir | link |" printf ( " [ index | pos | dir | link |"
" serif | blue | opos | pos ]\n" ); " serif | blue | opos | pos ]\n" );
for ( edge = edges; edge < limit; edge++ ) for ( edge = edges; edge < edge_limit; edge++ )
{ {
printf ( " [ %5d | %4d | %5s | %4d | %5d | %c | %5.2f | %5.2f ]\n", printf ( " [ %5d | %4d | %5s | %4d | %5d | %c | %5.2f | %5.2f ]\n",
edge - edges, edge - edges,
@ -1441,9 +1444,9 @@
edge->pos / 64.0 ); edge->pos / 64.0 );
} }
edges = outline->vert_edges; edges = outline->vert_edges;
limit = edges + outline->num_vedges; edge_limit = edges + outline->num_vedges;
segments = outline->vert_segments; segments = outline->vert_segments;
} }
} }

8
src/autohint/ahhint.c
View File

@ -521,13 +521,8 @@
{ {
AH_Point* point; AH_Point* point;
AH_Edge* edge; AH_Edge* edge;
AH_Edge* before;
AH_Edge* after;
before = 0;
after = 0;
if ( edges < edge_limit ) if ( edges < edge_limit )
for ( point = points; point < point_limit; point++ ) for ( point = points; point < point_limit; point++ )
{ {
@ -670,8 +665,7 @@
{ {
for ( p = p1; p <= p2; p++ ) for ( p = p1; p <= p2; p++ )
{ {
FT_Pos u = p->v; u = p->v;
if ( u <= v1 ) if ( u <= v1 )
u += d1; u += d1;

75
src/base/ftstream.c
View File

@ -669,7 +669,7 @@
case ft_frame_bytes: /* read a byte sequence */ case ft_frame_bytes: /* read a byte sequence */
case ft_frame_skip: /* skip some bytes */ case ft_frame_skip: /* skip some bytes */
{ {
FT_Int len = fields->size; FT_UInt len = fields->size;
if ( stream->cursor + len > stream->limit ) if ( stream->cursor + len > stream->limit )
@ -702,21 +702,16 @@
case ft_frame_short_le: case ft_frame_short_le:
case ft_frame_ushort_le: /* read a 2-byte little-endian short */ case ft_frame_ushort_le: /* read a 2-byte little-endian short */
value = 0;
p = stream->cursor;
if ( p + 1 < stream->limit )
{ {
FT_Byte* p; value = ( FT_UShort)p[0] | ((FT_UShort)p[1] << 8 );
stream->cursor += 2;
value = 0;
p = stream->cursor;
if ( p + 1 < stream->limit )
{
value = ( FT_UShort)p[0] | ((FT_UShort)p[1] << 8 );
stream->cursor += 2;
}
sign_shift = 16;
break;
} }
sign_shift = 16;
break;
case ft_frame_long_be: case ft_frame_long_be:
case ft_frame_ulong_be: /* read a 4-byte big-endian long */ case ft_frame_ulong_be: /* read a 4-byte big-endian long */
@ -726,24 +721,19 @@
case ft_frame_long_le: case ft_frame_long_le:
case ft_frame_ulong_le: /* read a 4-byte little-endian long */ case ft_frame_ulong_le: /* read a 4-byte little-endian long */
value = 0;
p = stream->cursor;
if ( p + 3 < stream->limit )
{ {
FT_Byte* p; value = (FT_ULong)p[0] |
( (FT_ULong)p[1] << 8 ) |
( (FT_ULong)p[2] << 16 ) |
value = 0; ( (FT_ULong)p[3] << 24 );
p = stream->cursor; stream->cursor += 4;
if ( p + 3 < stream->limit )
{
value = (FT_ULong)p[0] |
( (FT_ULong)p[1] << 8 ) |
( (FT_ULong)p[2] << 16 ) |
( (FT_ULong)p[3] << 24 );
stream->cursor += 4;
}
sign_shift = 0;
break;
} }
sign_shift = 0;
break;
case ft_frame_off3_be: case ft_frame_off3_be:
case ft_frame_uoff3_be: /* read a 3-byte big-endian long */ case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
@ -753,23 +743,18 @@
case ft_frame_off3_le: case ft_frame_off3_le:
case ft_frame_uoff3_le: /* read a 3-byte little-endian long */ case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
value = 0;
p = stream->cursor;
if ( p + 2 < stream->limit )
{ {
FT_Byte* p; value = (FT_ULong)p[0] |
( (FT_ULong)p[1] << 8 ) |
( (FT_ULong)p[2] << 16 );
value = 0; stream->cursor += 3;
p = stream->cursor;
if ( p + 2 < stream->limit )
{
value = (FT_ULong)p[0] |
( (FT_ULong)p[1] << 8 ) |
( (FT_ULong)p[2] << 16 );
stream->cursor += 3;
}
sign_shift = 8;
break;
} }
sign_shift = 8;
break;
default: default:
/* otherwise, exit the loop */ /* otherwise, exit the loop */

11
src/cff/t2load.c
View File

@ -571,11 +571,14 @@
{ {
static const FT_Frame_Field cff_header_fields[] = static const FT_Frame_Field cff_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE CFF_Font
FT_FRAME_START( 4 ), FT_FRAME_START( 4 ),
FT_FRAME_BYTE( CFF_Font, version_major ), FT_FRAME_BYTE( version_major ),
FT_FRAME_BYTE( CFF_Font, version_minor ), FT_FRAME_BYTE( version_minor ),
FT_FRAME_BYTE( CFF_Font, header_size ), FT_FRAME_BYTE( header_size ),
FT_FRAME_BYTE( CFF_Font, absolute_offsize ), FT_FRAME_BYTE( absolute_offsize ),
FT_FRAME_END FT_FRAME_END
}; };

3
src/cff/t2objs.c
View File

@ -343,7 +343,8 @@
else else
{ {
/* rewind to start of file; we are going to load a pure-CFF font */ /* rewind to start of file; we are going to load a pure-CFF font */
(void)FILE_Seek( 0 ); if ( FILE_Seek( 0 ) )
goto Exit;
error = FT_Err_Ok; error = FT_Err_Ok;
} }

41
src/cff/t2parse.c
View File

@ -28,6 +28,7 @@
#include <freetype/internal/t2errors.h> #include <freetype/internal/t2errors.h>
#include <freetype/internal/ftstream.h>
/*************************************************************************/ /*************************************************************************/
@ -359,8 +360,8 @@
static static
FT_Error parse_cid_ros( T2_Parser* parser ) FT_Error parse_cid_ros( T2_Parser* parser )
{ {
CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object; CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
FT_Byte** data = parser->stack; FT_Byte** data = parser->stack;
FT_Error error; FT_Error error;
@ -386,11 +387,9 @@
T2_FIELD( code, name, t2_kind_string ) T2_FIELD( code, name, t2_kind_string )
#define T2_FIELD_BOOL( code, name ) \ #define T2_FIELD_BOOL( code, name ) \
T2_FIELD( code, name, t2_kind_bool ) T2_FIELD( code, name, t2_kind_bool )
#define T2_FIELD_DELTA( code, name,max ) \ #define T2_FIELD_DELTA( code, name, max ) \
T2_FIELD( code, name, t2_kind_delta ) T2_FIELD( code, name, t2_kind_delta )
#define T2_REF( s, f ) ( ((s*)0)->f )
#define T2_FIELD_CALLBACK( code, name ) \ #define T2_FIELD_CALLBACK( code, name ) \
{ \ { \
t2_kind_callback, \ t2_kind_callback, \
@ -401,25 +400,25 @@
}, },
#undef T2_FIELD #undef T2_FIELD
#define T2_FIELD( code, name, kind ) \ #define T2_FIELD( code, name, kind ) \
{ \ { \
kind, \ kind, \
code | T2CODE, \ code | T2CODE, \
(FT_UInt)(char*)&T2_REF( T2TYPE, name ), \ FT_FIELD_OFFSET( name ), \
sizeof( T2_REF( T2TYPE, name ) ), \ FT_FIELD_SIZE( name ), \
0, 0, 0 \ 0, 0, 0 \
}, },
#undef T2_FIELD_DELTA #undef T2_FIELD_DELTA
#define T2_FIELD_DELTA( code, name, max ) \ #define T2_FIELD_DELTA( code, name, max ) \
{ \ { \
t2_kind_delta, \ t2_kind_delta, \
code | T2CODE, \ code | T2CODE, \
(FT_UInt)(char*)&T2_REF( T2TYPE, name ), \ FT_FIELD_OFFSET( name ), \
sizeof( T2_REF( T2TYPE, name )[0] ), \ FT_FIELD_SIZE_DELTA( name ), \
0, \ 0, \
max, \ max, \
(FT_UInt)(char*)&T2_REF( T2TYPE, num_ ## name ) \ FT_FIELD_OFFSET( num_ ## name ) \
}, },
#define T2CODE_TOPDICT 0x1000 #define T2CODE_TOPDICT 0x1000

12
src/cff/t2tokens.h
View File

@ -16,10 +16,10 @@
/***************************************************************************/ /***************************************************************************/
#undef T2TYPE #undef FT_STRUCTURE
#define FT_STRUCTURE CFF_Font_Dict
#undef T2CODE #undef T2CODE
#define T2TYPE CFF_Font_Dict #define T2CODE T2CODE_TOPDICT
#define T2CODE T2CODE_TOPDICT
T2_FIELD_STRING ( 0, version ) T2_FIELD_STRING ( 0, version )
T2_FIELD_STRING ( 1, notice ) T2_FIELD_STRING ( 1, notice )
@ -66,10 +66,10 @@
#endif #endif
#undef T2TYPE #undef FT_STRUCTURE
#define FT_STRUCTURE CFF_Private
#undef T2CODE #undef T2CODE
#define T2TYPE CFF_Private #define T2CODE T2CODE_PRIVATE
#define T2CODE T2CODE_PRIVATE
T2_FIELD_DELTA( 6, blue_values, 14 ) T2_FIELD_DELTA( 6, blue_values, 14 )
T2_FIELD_DELTA( 7, other_blues, 10 ) T2_FIELD_DELTA( 7, other_blues, 10 )

2
src/cid/cidobjs.c
View File

@ -214,7 +214,7 @@
if ( face->cid.cid_font_name ) if ( face->cid.cid_font_name )
{ {
root->family_name = face->cid.cid_font_name; root->family_name = face->cid.cid_font_name;
root->style_name = "Regular"; root->style_name = (char *)"Regular";
} }
} }

49
src/cid/cidparse.h
View File

@ -20,6 +20,7 @@
#define CIDPARSE_H #define CIDPARSE_H
#include <freetype/internal/t1types.h> #include <freetype/internal/t1types.h>
#include <freetype/internal/ftstream.h>
#ifdef __cplusplus #ifdef __cplusplus
@ -252,7 +253,7 @@
CID_Field_Type type; /* type of field */ CID_Field_Type type; /* type of field */
CID_Field_Parser reader; CID_Field_Parser reader;
FT_UInt offset; /* offset of field in object */ FT_UInt offset; /* offset of field in object */
FT_UInt size; /* size of field in bytes */ FT_Byte size; /* size of field in bytes */
FT_UInt array_max; /* maximal number of elements for */ FT_UInt array_max; /* maximal number of elements for */
/* array */ /* array */
FT_UInt count_offset; /* offset of element count for */ FT_UInt count_offset; /* offset of element count for */
@ -260,15 +261,13 @@
} CID_Field_Rec; } CID_Field_Rec;
#define CID_FIELD_REF( s, f ) ( ((s*)0)->f ) #define CID_NEW_SIMPLE_FIELD( _ident, _type, _fname ) \
{ \
#define CID_NEW_SIMPLE_FIELD( _ident, _type, _fname ) \ _ident, T1CODE, _type, \
{ \ 0, \
_ident, T1CODE, _type, \ FT_FIELD_OFFSET( _fname ), \
0, \ FT_FIELD_SIZE( _fname ), \
(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \ 0, 0 \
sizeof ( CID_FIELD_REF( T1TYPE, _fname ) ), \
0, 0 \
}, },
#define CID_NEW_CALLBACK_FIELD( _ident, _reader ) \ #define CID_NEW_CALLBACK_FIELD( _ident, _reader ) \
@ -279,23 +278,23 @@
0, 0 \ 0, 0 \
}, },
#define CID_NEW_TABLE_FIELD( _ident, _type, _fname, _max ) \ #define CID_NEW_TABLE_FIELD( _ident, _type, _fname, _max ) \
{ \ { \
_ident, T1CODE, _type, \ _ident, T1CODE, _type, \
0, \ 0, \
(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( CID_FIELD_REF( T1TYPE, _fname )[0] ), \ FT_FIELD_SIZE_DELTA( _fname ), \
_max, \ _max, \
(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, num_ ## _fname ) \ FT_FIELD_OFFSET( num_ ## _fname ) \
}, },
#define CID_NEW_TABLE_FIELD2( _ident, _type, _fname, _max ) \ #define CID_NEW_TABLE_FIELD2( _ident, _type, _fname, _max ) \
{ \ { \
_ident, T1CODE, _type, \ _ident, T1CODE, _type, \
0, \ 0, \
(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( CID_FIELD_REF( T1TYPE, _fname )[0] ), \ FT_FIELD_SIZE_DELTA( _fname ), \
_max, 0 \ _max, 0 \
}, },

24
src/cid/cidtokens.h
View File

@ -16,10 +16,10 @@
/***************************************************************************/ /***************************************************************************/
#undef T1TYPE #undef FT_STRUCTURE
#define FT_STRUCTURE CID_Info
#undef T1CODE #undef T1CODE
#define T1TYPE CID_Info #define T1CODE t1_field_cid_info
#define T1CODE t1_field_cid_info
CID_FIELD_STRING ( "CIDFontName", cid_font_name ) CID_FIELD_STRING ( "CIDFontName", cid_font_name )
CID_FIELD_NUM ( "CIDFontVersion", cid_version ) CID_FIELD_NUM ( "CIDFontVersion", cid_version )
@ -36,10 +36,10 @@
CID_FIELD_NUM ( "CIDCount", cid_count ) CID_FIELD_NUM ( "CIDCount", cid_count )
#undef T1TYPE #undef FT_STRUCTURE
#define FT_STRUCTURE T1_FontInfo
#undef T1CODE #undef T1CODE
#define T1TYPE T1_FontInfo #define T1CODE t1_field_font_info
#define T1CODE t1_field_font_info
CID_FIELD_STRING( "version", version ) CID_FIELD_STRING( "version", version )
CID_FIELD_STRING( "Notice", notice ) CID_FIELD_STRING( "Notice", notice )
@ -52,10 +52,10 @@
CID_FIELD_NUM ( "UnderlineThickness", underline_thickness ) CID_FIELD_NUM ( "UnderlineThickness", underline_thickness )
#undef T1TYPE #undef FT_STRUCTURE
#define FT_STRUCTURE CID_FontDict
#undef T1CODE #undef T1CODE
#define T1TYPE CID_FontDict #define T1CODE t1_field_font_dict
#define T1CODE t1_field_font_dict
CID_FIELD_CALLBACK( "FontMatrix", font_matrix ) CID_FIELD_CALLBACK( "FontMatrix", font_matrix )
CID_FIELD_NUM ( "PaintType", paint_type ) CID_FIELD_NUM ( "PaintType", paint_type )
@ -69,10 +69,10 @@
CID_FIELD_NUM ( "StrokeWidth", stroke_width ) CID_FIELD_NUM ( "StrokeWidth", stroke_width )
#undef T1TYPE #undef FT_STRUCTURE
#define FT_STRUCTURE T1_Private
#undef T1CODE #undef T1CODE
#define T1TYPE T1_Private #define T1CODE t1_field_private
#define T1CODE t1_field_private
CID_FIELD_NUM ( "UniqueID", unique_id ) CID_FIELD_NUM ( "UniqueID", unique_id )
CID_FIELD_NUM ( "lenIV", lenIV ) CID_FIELD_NUM ( "lenIV", lenIV )

33
src/raster1/ftraster.c
View File

@ -2825,31 +2825,22 @@
/* Now finalize the profiles that needs it */ /* Now finalize the profiles that needs it */
P = draw_left;
while ( P )
{ {
PProfile Q, P; Q = P->link;
if ( P->height == 0 )
DelOld( &draw_left, P );
P = draw_left; P = Q;
while ( P )
{
Q = P->link;
if ( P->height == 0 )
DelOld( &draw_left, P );
P = Q;
}
} }
P = draw_right;
while ( P )
{ {
PProfile Q, P = draw_right; Q = P->link;
if ( P->height == 0 )
DelOld( &draw_right, P );
while ( P ) P = Q;
{
Q = P->link;
if ( P->height == 0 )
DelOld( &draw_right, P );
P = Q;
}
} }
} }

327
src/sfnt/ttload.c
View File

@ -19,6 +19,7 @@
#include <freetype/internal/ftdebug.h> #include <freetype/internal/ftdebug.h>
#include <freetype/internal/tterrors.h> #include <freetype/internal/tterrors.h>
#include <freetype/internal/ftstream.h>
#include <freetype/tttags.h> #include <freetype/tttags.h>
@ -124,11 +125,13 @@
if ( length ) if ( length )
*length = table->Length; *length = table->Length;
(void)FILE_Seek( table->Offset ); if ( FILE_Seek( table->Offset ) )
goto Exit;
} }
else else
error = TT_Err_Table_Missing; error = TT_Err_Table_Missing;
Exit:
return error; return error;
} }
@ -173,19 +176,25 @@
const FT_Frame_Field sfnt_header_fields[] = const FT_Frame_Field sfnt_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE SFNT_Header
FT_FRAME_START( 8 ), FT_FRAME_START( 8 ),
FT_FRAME_USHORT( SFNT_Header, num_tables ), FT_FRAME_USHORT( num_tables ),
FT_FRAME_USHORT( SFNT_Header, search_range ), FT_FRAME_USHORT( search_range ),
FT_FRAME_USHORT( SFNT_Header, entry_selector ), FT_FRAME_USHORT( entry_selector ),
FT_FRAME_USHORT( SFNT_Header, range_shift ), FT_FRAME_USHORT( range_shift ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field ttc_header_fields[] = const FT_Frame_Field ttc_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TTC_Header
FT_FRAME_START( 8 ), FT_FRAME_START( 8 ),
FT_FRAME_LONG( TTC_Header, version ), FT_FRAME_LONG( version ),
FT_FRAME_LONG( TTC_Header, count ), FT_FRAME_LONG( count ),
FT_FRAME_END }; FT_FRAME_END };
@ -456,26 +465,29 @@
static const FT_Frame_Field header_fields[] = static const FT_Frame_Field header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_Header
FT_FRAME_START( 54 ), FT_FRAME_START( 54 ),
FT_FRAME_ULONG( TT_Header, Table_Version ), FT_FRAME_ULONG ( Table_Version ),
FT_FRAME_ULONG( TT_Header, Font_Revision ), FT_FRAME_ULONG ( Font_Revision ),
FT_FRAME_LONG( TT_Header, CheckSum_Adjust ), FT_FRAME_LONG ( CheckSum_Adjust ),
FT_FRAME_LONG( TT_Header, Magic_Number ), FT_FRAME_LONG ( Magic_Number ),
FT_FRAME_USHORT( TT_Header, Flags ), FT_FRAME_USHORT( Flags ),
FT_FRAME_USHORT( TT_Header, Units_Per_EM ), FT_FRAME_USHORT( Units_Per_EM ),
FT_FRAME_LONG( TT_Header, Created[0] ), FT_FRAME_LONG ( Created[0] ),
FT_FRAME_LONG( TT_Header, Created[1] ), FT_FRAME_LONG ( Created[1] ),
FT_FRAME_LONG( TT_Header, Modified[0] ), FT_FRAME_LONG ( Modified[0] ),
FT_FRAME_LONG( TT_Header, Modified[1] ), FT_FRAME_LONG ( Modified[1] ),
FT_FRAME_SHORT( TT_Header, xMin ), FT_FRAME_SHORT ( xMin ),
FT_FRAME_SHORT( TT_Header, yMin ), FT_FRAME_SHORT ( yMin ),
FT_FRAME_SHORT( TT_Header, xMax ), FT_FRAME_SHORT ( xMax ),
FT_FRAME_SHORT( TT_Header, yMax ), FT_FRAME_SHORT ( yMax ),
FT_FRAME_USHORT( TT_Header, Mac_Style ), FT_FRAME_USHORT( Mac_Style ),
FT_FRAME_USHORT( TT_Header, Lowest_Rec_PPEM ), FT_FRAME_USHORT( Lowest_Rec_PPEM ),
FT_FRAME_SHORT( TT_Header, Font_Direction ), FT_FRAME_SHORT ( Font_Direction ),
FT_FRAME_SHORT( TT_Header, Index_To_Loc_Format ), FT_FRAME_SHORT ( Index_To_Loc_Format ),
FT_FRAME_SHORT( TT_Header, Glyph_Data_Format ), FT_FRAME_SHORT ( Glyph_Data_Format ),
FT_FRAME_END FT_FRAME_END
}; };
@ -527,22 +539,25 @@
const FT_Frame_Field maxp_fields[] = const FT_Frame_Field maxp_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_MaxProfile
FT_FRAME_START( 32 ), FT_FRAME_START( 32 ),
FT_FRAME_ULONG( TT_MaxProfile, version ), FT_FRAME_ULONG ( version ),
FT_FRAME_USHORT( TT_MaxProfile, numGlyphs ), FT_FRAME_USHORT( numGlyphs ),
FT_FRAME_USHORT( TT_MaxProfile, maxPoints ), FT_FRAME_USHORT( maxPoints ),
FT_FRAME_USHORT( TT_MaxProfile, maxContours ), FT_FRAME_USHORT( maxContours ),
FT_FRAME_USHORT( TT_MaxProfile, maxCompositePoints ), FT_FRAME_USHORT( maxCompositePoints ),
FT_FRAME_USHORT( TT_MaxProfile, maxCompositeContours ), FT_FRAME_USHORT( maxCompositeContours ),
FT_FRAME_USHORT( TT_MaxProfile, maxZones ), FT_FRAME_USHORT( maxZones ),
FT_FRAME_USHORT( TT_MaxProfile, maxTwilightPoints ), FT_FRAME_USHORT( maxTwilightPoints ),
FT_FRAME_USHORT( TT_MaxProfile, maxStorage ), FT_FRAME_USHORT( maxStorage ),
FT_FRAME_USHORT( TT_MaxProfile, maxFunctionDefs ), FT_FRAME_USHORT( maxFunctionDefs ),
FT_FRAME_USHORT( TT_MaxProfile, maxInstructionDefs ), FT_FRAME_USHORT( maxInstructionDefs ),
FT_FRAME_USHORT( TT_MaxProfile, maxStackElements ), FT_FRAME_USHORT( maxStackElements ),
FT_FRAME_USHORT( TT_MaxProfile, maxSizeOfInstructions ), FT_FRAME_USHORT( maxSizeOfInstructions ),
FT_FRAME_USHORT( TT_MaxProfile, maxComponentElements ), FT_FRAME_USHORT( maxComponentElements ),
FT_FRAME_USHORT( TT_MaxProfile, maxComponentDepth ), FT_FRAME_USHORT( maxComponentDepth ),
FT_FRAME_END }; FT_FRAME_END };
@ -758,24 +773,27 @@
const FT_Frame_Field metrics_header_fields[] = const FT_Frame_Field metrics_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_HoriHeader
FT_FRAME_START( 36 ), FT_FRAME_START( 36 ),
FT_FRAME_ULONG( TT_HoriHeader, Version ), FT_FRAME_ULONG ( Version ),
FT_FRAME_SHORT( TT_HoriHeader, Ascender ), FT_FRAME_SHORT ( Ascender ),
FT_FRAME_SHORT( TT_HoriHeader, Descender ), FT_FRAME_SHORT ( Descender ),
FT_FRAME_SHORT( TT_HoriHeader, Line_Gap ), FT_FRAME_SHORT ( Line_Gap ),
FT_FRAME_USHORT( TT_HoriHeader, advance_Width_Max ), FT_FRAME_USHORT( advance_Width_Max ),
FT_FRAME_SHORT( TT_HoriHeader, min_Left_Side_Bearing ), FT_FRAME_SHORT ( min_Left_Side_Bearing ),
FT_FRAME_SHORT( TT_HoriHeader, min_Right_Side_Bearing ), FT_FRAME_SHORT ( min_Right_Side_Bearing ),
FT_FRAME_SHORT( TT_HoriHeader, xMax_Extent ), FT_FRAME_SHORT ( xMax_Extent ),
FT_FRAME_SHORT( TT_HoriHeader, caret_Slope_Rise ), FT_FRAME_SHORT ( caret_Slope_Rise ),
FT_FRAME_SHORT( TT_HoriHeader, caret_Slope_Run ), FT_FRAME_SHORT ( caret_Slope_Run ),
FT_FRAME_SHORT( TT_HoriHeader, Reserved[0] ), FT_FRAME_SHORT ( Reserved[0] ),
FT_FRAME_SHORT( TT_HoriHeader, Reserved[1] ), FT_FRAME_SHORT ( Reserved[1] ),
FT_FRAME_SHORT( TT_HoriHeader, Reserved[2] ), FT_FRAME_SHORT ( Reserved[2] ),
FT_FRAME_SHORT( TT_HoriHeader, Reserved[3] ), FT_FRAME_SHORT ( Reserved[3] ),
FT_FRAME_SHORT( TT_HoriHeader, Reserved[4] ), FT_FRAME_SHORT ( Reserved[4] ),
FT_FRAME_SHORT( TT_HoriHeader, metric_Data_Format ), FT_FRAME_SHORT ( metric_Data_Format ),
FT_FRAME_USHORT( TT_HoriHeader, number_Of_HMetrics ), FT_FRAME_USHORT( number_Of_HMetrics ),
FT_FRAME_END FT_FRAME_END
}; };
@ -858,22 +876,28 @@
const FT_Frame_Field name_table_fields[] = const FT_Frame_Field name_table_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_NameTable
FT_FRAME_START( 6 ), FT_FRAME_START( 6 ),
FT_FRAME_USHORT( TT_NameTable, format ), FT_FRAME_USHORT( format ),
FT_FRAME_USHORT( TT_NameTable, numNameRecords ), FT_FRAME_USHORT( numNameRecords ),
FT_FRAME_USHORT( TT_NameTable, storageOffset ), FT_FRAME_USHORT( storageOffset ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field name_record_fields[] = const FT_Frame_Field name_record_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_NameRec
/* no FT_FRAME_START */ /* no FT_FRAME_START */
FT_FRAME_USHORT( TT_NameRec, platformID ), FT_FRAME_USHORT( platformID ),
FT_FRAME_USHORT( TT_NameRec, encodingID ), FT_FRAME_USHORT( encodingID ),
FT_FRAME_USHORT( TT_NameRec, languageID ), FT_FRAME_USHORT( languageID ),
FT_FRAME_USHORT( TT_NameRec, nameID ), FT_FRAME_USHORT( nameID ),
FT_FRAME_USHORT( TT_NameRec, stringLength ), FT_FRAME_USHORT( stringLength ),
FT_FRAME_USHORT( TT_NameRec, stringOffset ), FT_FRAME_USHORT( stringOffset ),
FT_FRAME_END FT_FRAME_END
}; };
@ -1049,18 +1073,24 @@
const FT_Frame_Field cmap_fields[] = const FT_Frame_Field cmap_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_CMapDir
FT_FRAME_START( 4 ), FT_FRAME_START( 4 ),
FT_FRAME_USHORT( TT_CMapDir, tableVersionNumber ), FT_FRAME_USHORT( tableVersionNumber ),
FT_FRAME_USHORT( TT_CMapDir, numCMaps ), FT_FRAME_USHORT( numCMaps ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field cmap_rec_fields[] = const FT_Frame_Field cmap_rec_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_CMapTable
FT_FRAME_START( 6 ), FT_FRAME_START( 6 ),
FT_FRAME_USHORT( TT_CMapTable, format ), FT_FRAME_USHORT( format ),
FT_FRAME_USHORT( TT_CMapTable, length ), FT_FRAME_USHORT( length ),
FT_FRAME_USHORT( TT_CMapTable, version ), FT_FRAME_USHORT( version ),
FT_FRAME_END FT_FRAME_END
}; };
@ -1154,71 +1184,74 @@
FT_Error error; FT_Error error;
TT_OS2* os2; TT_OS2* os2;
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_OS2
const FT_Frame_Field os2_fields[] = const FT_Frame_Field os2_fields[] =
{ {
FT_FRAME_START( 78 ), FT_FRAME_START( 78 ),
FT_FRAME_USHORT( TT_OS2, version ), FT_FRAME_USHORT( version ),
FT_FRAME_SHORT( TT_OS2, xAvgCharWidth ), FT_FRAME_SHORT ( xAvgCharWidth ),
FT_FRAME_USHORT( TT_OS2, usWeightClass ), FT_FRAME_USHORT( usWeightClass ),
FT_FRAME_USHORT( TT_OS2, usWidthClass ), FT_FRAME_USHORT( usWidthClass ),
FT_FRAME_SHORT( TT_OS2, fsType ), FT_FRAME_SHORT ( fsType ),
FT_FRAME_SHORT( TT_OS2, ySubscriptXSize ), FT_FRAME_SHORT ( ySubscriptXSize ),
FT_FRAME_SHORT( TT_OS2, ySubscriptYSize ), FT_FRAME_SHORT ( ySubscriptYSize ),
FT_FRAME_SHORT( TT_OS2, ySubscriptXOffset ), FT_FRAME_SHORT ( ySubscriptXOffset ),
FT_FRAME_SHORT( TT_OS2, ySubscriptYOffset ), FT_FRAME_SHORT ( ySubscriptYOffset ),
FT_FRAME_SHORT( TT_OS2, ySuperscriptXSize ), FT_FRAME_SHORT ( ySuperscriptXSize ),
FT_FRAME_SHORT( TT_OS2, ySuperscriptYSize ), FT_FRAME_SHORT ( ySuperscriptYSize ),
FT_FRAME_SHORT( TT_OS2, ySuperscriptXOffset ), FT_FRAME_SHORT ( ySuperscriptXOffset ),
FT_FRAME_SHORT( TT_OS2, ySuperscriptYOffset ), FT_FRAME_SHORT ( ySuperscriptYOffset ),
FT_FRAME_SHORT( TT_OS2, yStrikeoutSize ), FT_FRAME_SHORT ( yStrikeoutSize ),
FT_FRAME_SHORT( TT_OS2, yStrikeoutPosition ), FT_FRAME_SHORT ( yStrikeoutPosition ),
FT_FRAME_SHORT( TT_OS2, sFamilyClass ), FT_FRAME_SHORT ( sFamilyClass ),
FT_FRAME_BYTE( TT_OS2, panose[0] ), FT_FRAME_BYTE ( panose[0] ),
FT_FRAME_BYTE( TT_OS2, panose[1] ), FT_FRAME_BYTE ( panose[1] ),
FT_FRAME_BYTE( TT_OS2, panose[2] ), FT_FRAME_BYTE ( panose[2] ),
FT_FRAME_BYTE( TT_OS2, panose[3] ), FT_FRAME_BYTE ( panose[3] ),
FT_FRAME_BYTE( TT_OS2, panose[4] ), FT_FRAME_BYTE ( panose[4] ),
FT_FRAME_BYTE( TT_OS2, panose[5] ), FT_FRAME_BYTE ( panose[5] ),
FT_FRAME_BYTE( TT_OS2, panose[6] ), FT_FRAME_BYTE ( panose[6] ),
FT_FRAME_BYTE( TT_OS2, panose[7] ), FT_FRAME_BYTE ( panose[7] ),
FT_FRAME_BYTE( TT_OS2, panose[8] ), FT_FRAME_BYTE ( panose[8] ),
FT_FRAME_BYTE( TT_OS2, panose[9] ), FT_FRAME_BYTE ( panose[9] ),
FT_FRAME_ULONG( TT_OS2, ulUnicodeRange1 ), FT_FRAME_ULONG ( ulUnicodeRange1 ),
FT_FRAME_ULONG( TT_OS2, ulUnicodeRange2 ), FT_FRAME_ULONG ( ulUnicodeRange2 ),
FT_FRAME_ULONG( TT_OS2, ulUnicodeRange3 ), FT_FRAME_ULONG ( ulUnicodeRange3 ),
FT_FRAME_ULONG( TT_OS2, ulUnicodeRange4 ), FT_FRAME_ULONG ( ulUnicodeRange4 ),
FT_FRAME_BYTE( TT_OS2, achVendID[0] ), FT_FRAME_BYTE ( achVendID[0] ),
FT_FRAME_BYTE( TT_OS2, achVendID[1] ), FT_FRAME_BYTE ( achVendID[1] ),
FT_FRAME_BYTE( TT_OS2, achVendID[2] ), FT_FRAME_BYTE ( achVendID[2] ),
FT_FRAME_BYTE( TT_OS2, achVendID[3] ), FT_FRAME_BYTE ( achVendID[3] ),
FT_FRAME_USHORT( TT_OS2, fsSelection ), FT_FRAME_USHORT( fsSelection ),
FT_FRAME_USHORT( TT_OS2, usFirstCharIndex ), FT_FRAME_USHORT( usFirstCharIndex ),
FT_FRAME_USHORT( TT_OS2, usLastCharIndex ), FT_FRAME_USHORT( usLastCharIndex ),
FT_FRAME_SHORT( TT_OS2, sTypoAscender ), FT_FRAME_SHORT ( sTypoAscender ),
FT_FRAME_SHORT( TT_OS2, sTypoDescender ), FT_FRAME_SHORT ( sTypoDescender ),
FT_FRAME_SHORT( TT_OS2, sTypoLineGap ), FT_FRAME_SHORT ( sTypoLineGap ),
FT_FRAME_USHORT( TT_OS2, usWinAscent ), FT_FRAME_USHORT( usWinAscent ),
FT_FRAME_USHORT( TT_OS2, usWinDescent ), FT_FRAME_USHORT( usWinDescent ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field os2_fields_extra[] = const FT_Frame_Field os2_fields_extra[] =
{ {
FT_FRAME_START( 8 ), FT_FRAME_START( 8 ),
FT_FRAME_ULONG( TT_OS2, ulCodePageRange1 ), FT_FRAME_ULONG( ulCodePageRange1 ),
FT_FRAME_ULONG( TT_OS2, ulCodePageRange2 ), FT_FRAME_ULONG( ulCodePageRange2 ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field os2_fields_extra2[] = const FT_Frame_Field os2_fields_extra2[] =
{ {
FT_FRAME_START( 10 ), FT_FRAME_START( 10 ),
FT_FRAME_SHORT( TT_OS2, sxHeight ), FT_FRAME_SHORT ( sxHeight ),
FT_FRAME_SHORT( TT_OS2, sCapHeight ), FT_FRAME_SHORT ( sCapHeight ),
FT_FRAME_USHORT( TT_OS2, usDefaultChar ), FT_FRAME_USHORT( usDefaultChar ),
FT_FRAME_USHORT( TT_OS2, usBreakChar ), FT_FRAME_USHORT( usBreakChar ),
FT_FRAME_USHORT( TT_OS2, usMaxContext ), FT_FRAME_USHORT( usMaxContext ),
FT_FRAME_END FT_FRAME_END
}; };
@ -1290,16 +1323,19 @@
static const FT_Frame_Field post_fields[] = static const FT_Frame_Field post_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_Postscript
FT_FRAME_START( 32 ), FT_FRAME_START( 32 ),
FT_FRAME_ULONG( TT_Postscript, FormatType ), FT_FRAME_ULONG( FormatType ),
FT_FRAME_ULONG( TT_Postscript, italicAngle ), FT_FRAME_ULONG( italicAngle ),
FT_FRAME_SHORT( TT_Postscript, underlinePosition ), FT_FRAME_SHORT( underlinePosition ),
FT_FRAME_SHORT( TT_Postscript, underlineThickness ), FT_FRAME_SHORT( underlineThickness ),
FT_FRAME_ULONG( TT_Postscript, isFixedPitch ), FT_FRAME_ULONG( isFixedPitch ),
FT_FRAME_ULONG( TT_Postscript, minMemType42 ), FT_FRAME_ULONG( minMemType42 ),
FT_FRAME_ULONG( TT_Postscript, maxMemType42 ), FT_FRAME_ULONG( maxMemType42 ),
FT_FRAME_ULONG( TT_Postscript, minMemType1 ), FT_FRAME_ULONG( minMemType1 ),
FT_FRAME_ULONG( TT_Postscript, maxMemType1 ), FT_FRAME_ULONG( maxMemType1 ),
FT_FRAME_END FT_FRAME_END
}; };
@ -1342,21 +1378,24 @@
{ {
static const FT_Frame_Field pclt_fields[] = static const FT_Frame_Field pclt_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_PCLT
FT_FRAME_START( 54 ), FT_FRAME_START( 54 ),
FT_FRAME_ULONG ( TT_PCLT, Version ), FT_FRAME_ULONG ( Version ),
FT_FRAME_ULONG ( TT_PCLT, FontNumber ), FT_FRAME_ULONG ( FontNumber ),
FT_FRAME_USHORT( TT_PCLT, Pitch ), FT_FRAME_USHORT( Pitch ),
FT_FRAME_USHORT( TT_PCLT, xHeight ), FT_FRAME_USHORT( xHeight ),
FT_FRAME_USHORT( TT_PCLT, Style ), FT_FRAME_USHORT( Style ),
FT_FRAME_USHORT( TT_PCLT, TypeFamily ), FT_FRAME_USHORT( TypeFamily ),
FT_FRAME_USHORT( TT_PCLT, CapHeight ), FT_FRAME_USHORT( CapHeight ),
FT_FRAME_BYTES ( TT_PCLT, TypeFace, 16 ), FT_FRAME_BYTES ( TypeFace, 16 ),
FT_FRAME_BYTES ( TT_PCLT, CharacterComplement, 8 ), FT_FRAME_BYTES ( CharacterComplement, 8 ),
FT_FRAME_BYTES ( TT_PCLT, FileName, 6 ), FT_FRAME_BYTES ( FileName, 6 ),
FT_FRAME_CHAR ( TT_PCLT, StrokeWeight ), FT_FRAME_CHAR ( StrokeWeight ),
FT_FRAME_CHAR ( TT_PCLT, WidthType ), FT_FRAME_CHAR ( WidthType ),
FT_FRAME_BYTE ( TT_PCLT, SerifStyle ), FT_FRAME_BYTE ( SerifStyle ),
FT_FRAME_BYTE ( TT_PCLT, Reserved ), FT_FRAME_BYTE ( Reserved ),
FT_FRAME_END FT_FRAME_END
}; };

81
src/sfnt/ttsbit.c
View File

@ -18,6 +18,7 @@
#include <freetype/internal/ftdebug.h> #include <freetype/internal/ftdebug.h>
#include <freetype/internal/tterrors.h> #include <freetype/internal/tterrors.h>
#include <freetype/internal/ftstream.h>
#include <freetype/tttags.h> #include <freetype/tttags.h>
@ -191,17 +192,20 @@
const FT_Frame_Field sbit_metrics_fields[] = const FT_Frame_Field sbit_metrics_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_SBit_Metrics
FT_FRAME_START( 8 ), FT_FRAME_START( 8 ),
FT_FRAME_BYTE( TT_SBit_Metrics, height ), FT_FRAME_BYTE( height ),
FT_FRAME_BYTE( TT_SBit_Metrics, width ), FT_FRAME_BYTE( width ),
FT_FRAME_CHAR( TT_SBit_Metrics, horiBearingX ), FT_FRAME_CHAR( horiBearingX ),
FT_FRAME_CHAR( TT_SBit_Metrics, horiBearingY ), FT_FRAME_CHAR( horiBearingY ),
FT_FRAME_BYTE( TT_SBit_Metrics, horiAdvance ), FT_FRAME_BYTE( horiAdvance ),
FT_FRAME_CHAR( TT_SBit_Metrics, vertBearingX ), FT_FRAME_CHAR( vertBearingX ),
FT_FRAME_CHAR( TT_SBit_Metrics, vertBearingY ), FT_FRAME_CHAR( vertBearingY ),
FT_FRAME_BYTE( TT_SBit_Metrics, vertAdvance ), FT_FRAME_BYTE( vertAdvance ),
FT_FRAME_END FT_FRAME_END
}; };
@ -404,43 +408,49 @@
const FT_Frame_Field sbit_line_metrics_fields[] = const FT_Frame_Field sbit_line_metrics_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_SBit_Line_Metrics
/* no FT_FRAME_START */ /* no FT_FRAME_START */
FT_FRAME_CHAR( TT_SBit_Line_Metrics, ascender ), FT_FRAME_CHAR( ascender ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, descender ), FT_FRAME_CHAR( descender ),
FT_FRAME_BYTE( TT_SBit_Line_Metrics, max_width ), FT_FRAME_BYTE( max_width ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, caret_slope_numerator ), FT_FRAME_CHAR( caret_slope_numerator ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, caret_slope_denominator ), FT_FRAME_CHAR( caret_slope_denominator ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, caret_offset ), FT_FRAME_CHAR( caret_offset ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, min_origin_SB ), FT_FRAME_CHAR( min_origin_SB ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, min_advance_SB ), FT_FRAME_CHAR( min_advance_SB ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, max_before_BL ), FT_FRAME_CHAR( max_before_BL ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, min_after_BL ), FT_FRAME_CHAR( min_after_BL ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, pads[0] ), FT_FRAME_CHAR( pads[0] ),
FT_FRAME_CHAR( TT_SBit_Line_Metrics, pads[1] ), FT_FRAME_CHAR( pads[1] ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field strike_start_fields[] = const FT_Frame_Field strike_start_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_SBit_Strike
/* no FT_FRAME_START */ /* no FT_FRAME_START */
FT_FRAME_ULONG( TT_SBit_Strike, ranges_offset ), FT_FRAME_ULONG( ranges_offset ),
FT_FRAME_SKIP_LONG, FT_FRAME_SKIP_LONG,
FT_FRAME_ULONG( TT_SBit_Strike, num_ranges ), FT_FRAME_ULONG( num_ranges ),
FT_FRAME_ULONG( TT_SBit_Strike, color_ref ), FT_FRAME_ULONG( color_ref ),
FT_FRAME_END FT_FRAME_END
}; };
const FT_Frame_Field strike_end_fields[] = const FT_Frame_Field strike_end_fields[] =
{ {
/* no FT_FRAME_START */ /* no FT_FRAME_START */
FT_FRAME_USHORT( TT_SBit_Strike, start_glyph ), FT_FRAME_USHORT( start_glyph ),
FT_FRAME_USHORT( TT_SBit_Strike, end_glyph ), FT_FRAME_USHORT( end_glyph ),
FT_FRAME_BYTE ( TT_SBit_Strike, x_ppem ), FT_FRAME_BYTE ( x_ppem ),
FT_FRAME_BYTE ( TT_SBit_Strike, y_ppem ), FT_FRAME_BYTE ( y_ppem ),
FT_FRAME_BYTE ( TT_SBit_Strike, bit_depth ), FT_FRAME_BYTE ( bit_depth ),
FT_FRAME_CHAR ( TT_SBit_Strike, flags ), FT_FRAME_CHAR ( flags ),
FT_FRAME_END FT_FRAME_END
}; };
@ -838,12 +848,15 @@
const FT_Frame_Field sbit_small_metrics_fields[] = const FT_Frame_Field sbit_small_metrics_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_SBit_Small_Metrics
FT_FRAME_START( 5 ), FT_FRAME_START( 5 ),
FT_FRAME_BYTE( TT_SBit_Small_Metrics, height ), FT_FRAME_BYTE( height ),
FT_FRAME_BYTE( TT_SBit_Small_Metrics, width ), FT_FRAME_BYTE( width ),
FT_FRAME_CHAR( TT_SBit_Small_Metrics, bearingX ), FT_FRAME_CHAR( bearingX ),
FT_FRAME_CHAR( TT_SBit_Small_Metrics, bearingY ), FT_FRAME_CHAR( bearingY ),
FT_FRAME_BYTE( TT_SBit_Small_Metrics, advance ), FT_FRAME_BYTE( advance ),
FT_FRAME_END FT_FRAME_END
}; };

14
src/truetype/ttgload.c
View File

@ -213,15 +213,17 @@
FT_ULong offset, FT_ULong offset,
FT_UInt byte_count ) FT_UInt byte_count )
{ {
FT_Error error; FT_Error error;
FT_Stream stream = loader->stream; FT_Stream stream = loader->stream;
/* the following line sets the `error' variable through macros! */
(void)( FILE_Seek( offset ) || ACCESS_Frame( byte_count ) );
FT_TRACE5(( "Glyph %ld\n", glyph_index )); FT_TRACE5(( "Glyph %ld\n", glyph_index ));
return error;
/* the following line sets the `error' variable through macros! */
if ( FILE_Seek( offset ) || ACCESS_Frame( byte_count ) )
return error;
return TT_Err_Ok;
} }

5
src/truetype/ttobjs.c
View File

@ -460,10 +460,11 @@
Fail_Memory: Fail_Memory:
#endif
TT_Done_Size( size ); TT_Done_Size( size );
return error; return error;
#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
} }

6
src/type1z/z1gload.c
View File

@ -939,13 +939,13 @@
values = top; values = top;
for ( nn = 0; nn < num_points; nn++ ) for ( nn = 0; nn < num_points; nn++ )
{ {
FT_Int x = values[0]; FT_Int tmp = values[0];
for ( mm = 1; mm < blend->num_designs; mm++ ) for ( mm = 1; mm < blend->num_designs; mm++ )
x += FT_MulFix( *delta++, blend->weight_vector[mm] ); tmp += FT_MulFix( *delta++, blend->weight_vector[mm] );
*values++ = x; *values++ = tmp;
} }
/* note that `top' will be incremented later by calls to `pop' */ /* note that `top' will be incremented later by calls to `pop' */
break; break;

16
src/type1z/z1load.c
View File

@ -700,42 +700,42 @@
#define Z1_NEW_STRING( _name, _field ) \ #define Z1_NEW_STRING( _name, _field ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_STRING( T1TYPE, _field ); Z1_FIELD_STRING( _field );
#define Z1_NEW_BOOL( _name, _field ) \ #define Z1_NEW_BOOL( _name, _field ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_BOOL( T1TYPE, _field ); Z1_FIELD_BOOL( _field );
#define Z1_NEW_NUM( _name, _field ) \ #define Z1_NEW_NUM( _name, _field ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_NUM( T1TYPE, _field ); Z1_FIELD_NUM( _field );
#define Z1_NEW_FIXED( _name, _field ) \ #define Z1_NEW_FIXED( _name, _field ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_FIXED( T1TYPE, _field, _power ); Z1_FIELD_FIXED( _field, _power );
#define Z1_NEW_NUM_TABLE( _name, _field, _max, _count ) \ #define Z1_NEW_NUM_TABLE( _name, _field, _max, _count ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_NUM_ARRAY( T1TYPE, _field, _count, _max ); Z1_FIELD_NUM_ARRAY( _field, _count, _max );
#define Z1_NEW_FIXED_TABLE( _name, _field, _max, _count ) \ #define Z1_NEW_FIXED_TABLE( _name, _field, _max, _count ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_FIXED_ARRAY( T1TYPE, _field, _count, _max ); Z1_FIELD_FIXED_ARRAY( _field, _count, _max );
#define Z1_NEW_NUM_TABLE2( _name, _field, _max ) \ #define Z1_NEW_NUM_TABLE2( _name, _field, _max ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_NUM_ARRAY2( T1TYPE, _field, _max ); Z1_FIELD_NUM_ARRAY2( _field, _max );
#define Z1_NEW_FIXED_TABLE2( _name, _field, _max ) \ #define Z1_NEW_FIXED_TABLE2( _name, _field, _max ) \
static \ static \
const Z1_Field_Rec t1_field_ ## _field = \ const Z1_Field_Rec t1_field_ ## _field = \
Z1_FIELD_FIXED_ARRAY2( T1TYPE, _field, _max ); Z1_FIELD_FIXED_ARRAY2( _field, _max );
#define Z1_FONTINFO_STRING( n, f ) Z1_NEW_STRING( n, f ) #define Z1_FONTINFO_STRING( n, f ) Z1_NEW_STRING( n, f )

7
src/type1z/z1objs.c
View File

@ -243,7 +243,7 @@
if ( face->type1.font_name ) if ( face->type1.font_name )
{ {
root->family_name = face->type1.font_name; root->family_name = face->type1.font_name;
root->style_name = "Regular"; root->style_name = (char *)"Regular";
} }
} }
@ -293,11 +293,8 @@
/* synthesize a Unicode charmap if there is support in the `PSNames' */ /* synthesize a Unicode charmap if there is support in the `PSNames' */
/* module */ /* module */
if ( face->psnames ) if ( psnames )
{ {
PSNames_Interface* psnames = (PSNames_Interface*)face->psnames;
if ( psnames->unicode_value ) if ( psnames->unicode_value )
{ {
error = psnames->build_unicodes( error = psnames->build_unicodes(

12
src/type1z/z1parse.c
View File

@ -1029,10 +1029,10 @@
goto Exit; goto Exit;
/* swap between big and little endianness */ /* swap between big and little endianness */
*size = ( ( asize & 0xFF000000L ) >> 24 ) | *size = ( ( asize & 0xFF000000UL ) >> 24 ) |
( ( asize & 0x00FF0000L ) >> 8 ) | ( ( asize & 0x00FF0000UL ) >> 8 ) |
( ( asize & 0x0000FF00L ) << 8 ) | ( ( asize & 0x0000FF00UL ) << 8 ) |
( ( asize & 0x000000FFL ) << 24 ); ( ( asize & 0x000000FFUL ) << 24 );
} }
Exit: Exit:
@ -1092,7 +1092,8 @@
{ {
/* assume that this is a PFA file for now; an error will */ /* assume that this is a PFA file for now; an error will */
/* be produced later when more things are checked */ /* be produced later when more things are checked */
(void)FILE_Seek( 0L ); if ( FILE_Seek( 0L ) )
goto Exit;
size = stream->size; size = stream->size;
} }
else else
@ -1221,7 +1222,6 @@
/* then re-read them into memory. */ /* then re-read them into memory. */
FT_Long start_pos = FILE_Pos(); FT_Long start_pos = FILE_Pos();
FT_UShort tag; FT_UShort tag;
FT_Long size;
parser->private_len = 0; parser->private_len = 0;

113
src/type1z/z1parse.h
View File

@ -20,6 +20,7 @@
#define Z1PARSE_H #define Z1PARSE_H
#include <freetype/internal/t1types.h> #include <freetype/internal/t1types.h>
#include <freetype/internal/ftstream.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -72,7 +73,7 @@
{ {
Z1_Field_Type type; /* type of field */ Z1_Field_Type type; /* type of field */
FT_UInt offset; /* offset of field in object */ FT_UInt offset; /* offset of field in object */
FT_UInt size; /* size of field in bytes */ FT_Byte size; /* size of field in bytes */
FT_UInt array_max; /* maximum number of elements for array */ FT_UInt array_max; /* maximum number of elements for array */
FT_UInt count_offset; /* offset of element count for arrays */ FT_UInt count_offset; /* offset of element count for arrays */
FT_Int flag_bit; /* bit number for field flag */ FT_Int flag_bit; /* bit number for field flag */
@ -80,76 +81,74 @@
} Z1_Field_Rec; } Z1_Field_Rec;
#define Z1_FIELD_REF( s, f ) ( ((s*)0)->f ) #define Z1_FIELD_BOOL( _fname ) \
{ \
#define Z1_FIELD_BOOL( _ftype, _fname ) \ t1_field_bool, \
{ \ FT_FIELD_OFFSET( _fname ), \
t1_field_bool, \ FT_FIELD_SIZE( _fname ), \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ 0, 0, 0 \
sizeof ( Z1_FIELD_REF( _ftype, _fname ) ), \
0, 0, 0 \
} }
#define Z1_FIELD_NUM( _ftype, _fname ) \ #define Z1_FIELD_NUM( _fname ) \
{ \ { \
t1_field_integer, \ t1_field_integer, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname ) ), \ FT_FIELD_SIZE( _fname ), \
0, 0, 0 \ 0, 0, 0 \
} }
#define Z1_FIELD_FIXED( _ftype, _fname, _power ) \ #define Z1_FIELD_FIXED( _fname, _power ) \
{ \ { \
t1_field_fixed, \ t1_field_fixed, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname ) ), \ FT_FIELD_SIZE( _fname ), \
0, 0, 0 \ 0, 0, 0 \
} }
#define Z1_FIELD_STRING( _ftype, _fname ) \ #define Z1_FIELD_STRING( _fname ) \
{ \ { \
t1_field_string, \ t1_field_string, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname ) ), \ FT_FIELD_SIZE( _fname ), \
0, 0, 0 \ 0, 0, 0 \
} }
#define Z1_FIELD_NUM_ARRAY( _ftype, _fname, _fcount, _fmax ) \ #define Z1_FIELD_NUM_ARRAY( _fname, _fcount, _fmax ) \
{ \ { \
t1_field_integer, \ t1_field_integer, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname )[0] ), \ FT_FIELD_SIZE_DELTA( _fname ), \
_fmax, \ _fmax, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fcount ), \ FT_FIELD_OFFSET( _fcount ), \
0 \ 0 \
} }
#define Z1_FIELD_FIXED_ARRAY( _ftype, _fname, _fcount, _fmax ) \ #define Z1_FIELD_FIXED_ARRAY( _fname, _fcount, _fmax ) \
{ \ { \
t1_field_fixed, \ t1_field_fixed, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname )[0] ), \ FT_FIELD_SIZE_DELTA( _fname ), \
_fmax, \ _fmax, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fcount ), \ FT_FIELD_OFFSET( _fcount ), \
0 \ 0 \
} }
#define Z1_FIELD_NUM_ARRAY2( _ftype, _fname, _fmax ) \ #define Z1_FIELD_NUM_ARRAY2( _fname, _fmax ) \
{ \ { \
t1_field_integer, \ t1_field_integer, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSET( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname )[0] ), \ FT_FIELD_SIZE_DELTA( _fname ), \
_fmax, \ _fmax, \
0, 0 \ 0, 0 \
} }
#define Z1_FIELD_FIXED_ARRAY2( _ftype, _fname, _fmax ) \ #define Z1_FIELD_FIXED_ARRAY2( _fname, _fmax ) \
{ \ { \
t1_field_fixed, \ t1_field_fixed, \
(FT_UInt)(char*)&Z1_FIELD_REF( _ftype, _fname ), \ FT_FIELD_OFFSTE( _fname ), \
sizeof ( Z1_FIELD_REF( _ftype, _fname )[0] ), \ FT_FIELD_SIZE_DELTA( _fname ), \
_fmax, \ _fmax, \
0, 0 \ 0, 0 \
} }

12
src/type1z/z1tokens.h
View File

@ -16,8 +16,8 @@
/***************************************************************************/ /***************************************************************************/
#undef T1TYPE #undef FT_STRUCTURE
#define T1TYPE T1_FontInfo #define FT_STRUCTURE T1_FontInfo
Z1_FONTINFO_STRING( "version", version ) Z1_FONTINFO_STRING( "version", version )
Z1_FONTINFO_STRING( "Notice", notice ) Z1_FONTINFO_STRING( "Notice", notice )
@ -31,8 +31,8 @@
Z1_FONTINFO_NUM ( "UnderlineThickness", underline_thickness ) Z1_FONTINFO_NUM ( "UnderlineThickness", underline_thickness )
#undef T1TYPE #undef FT_STRUCTURE
#define T1TYPE T1_Private #define FT_STRUCTURE T1_Private
Z1_PRIVATE_NUM ( "UniqueID", unique_id ) Z1_PRIVATE_NUM ( "UniqueID", unique_id )
Z1_PRIVATE_NUM ( "lenIV", lenIV ) Z1_PRIVATE_NUM ( "lenIV", lenIV )
@ -57,8 +57,8 @@
Z1_PRIVATE_NUM_TABLE ( "StemSnapV", snap_heights, 12, num_snap_heights ) Z1_PRIVATE_NUM_TABLE ( "StemSnapV", snap_heights, 12, num_snap_heights )
#undef T1TYPE #undef FT_STRUCTURE
#define T1TYPE T1_Font #define FT_STRUCTURE T1_Font
Z1_TOPDICT_NUM( "PaintType", paint_type ) Z1_TOPDICT_NUM( "PaintType", paint_type )
Z1_TOPDICT_NUM( "FontType", font_type ) Z1_TOPDICT_NUM( "FontType", font_type )

91
src/winfonts/winfnt.c
View File

@ -46,64 +46,73 @@
static static
const FT_Frame_Field winmz_header_fields[] = const FT_Frame_Field winmz_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE WinMZ_Header
FT_FRAME_START( 64 ), FT_FRAME_START( 64 ),
FT_FRAME_USHORT_LE ( WinMZ_Header, magic ), FT_FRAME_USHORT_LE ( magic ),
FT_FRAME_SKIP_BYTES( 29 * 2 ), FT_FRAME_SKIP_BYTES( 29 * 2 ),
FT_FRAME_ULONG_LE ( WinMZ_Header, lfanew ), FT_FRAME_ULONG_LE ( lfanew ),
FT_FRAME_END FT_FRAME_END
}; };
static static
const FT_Frame_Field winne_header_fields[] = const FT_Frame_Field winne_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE WinNE_Header
FT_FRAME_START( 40 ), FT_FRAME_START( 40 ),
FT_FRAME_USHORT_LE ( WinNE_Header, magic ), FT_FRAME_USHORT_LE ( magic ),
FT_FRAME_SKIP_BYTES( 34 ), FT_FRAME_SKIP_BYTES( 34 ),
FT_FRAME_USHORT_LE ( WinNE_Header, resource_tab_offset ), FT_FRAME_USHORT_LE ( resource_tab_offset ),
FT_FRAME_USHORT_LE ( WinNE_Header, rname_tab_offset ), FT_FRAME_USHORT_LE ( rname_tab_offset ),
FT_FRAME_END FT_FRAME_END
}; };
static static
const FT_Frame_Field winfnt_header_fields[] = const FT_Frame_Field winfnt_header_fields[] =
{ {
#undef FT_STRUCTURE
#define FT_STRUCTURE WinFNT_Header
FT_FRAME_START( 134 ), FT_FRAME_START( 134 ),
FT_FRAME_USHORT_LE( WinFNT_Header, version ), FT_FRAME_USHORT_LE( version ),
FT_FRAME_ULONG_LE ( WinFNT_Header, file_size ), FT_FRAME_ULONG_LE ( file_size ),
FT_FRAME_BYTES ( WinFNT_Header, copyright, 60 ), FT_FRAME_BYTES ( copyright, 60 ),
FT_FRAME_USHORT_LE( WinFNT_Header, file_type ), FT_FRAME_USHORT_LE( file_type ),
FT_FRAME_USHORT_LE( WinFNT_Header, nominal_point_size ), FT_FRAME_USHORT_LE( nominal_point_size ),
FT_FRAME_USHORT_LE( WinFNT_Header, vertical_resolution ), FT_FRAME_USHORT_LE( vertical_resolution ),
FT_FRAME_USHORT_LE( WinFNT_Header, horizontal_resolution ), FT_FRAME_USHORT_LE( horizontal_resolution ),
FT_FRAME_USHORT_LE( WinFNT_Header, ascent ), FT_FRAME_USHORT_LE( ascent ),
FT_FRAME_USHORT_LE( WinFNT_Header, internal_leading ), FT_FRAME_USHORT_LE( internal_leading ),
FT_FRAME_USHORT_LE( WinFNT_Header, external_leading ), FT_FRAME_USHORT_LE( external_leading ),
FT_FRAME_BYTE ( WinFNT_Header, italic ), FT_FRAME_BYTE ( italic ),
FT_FRAME_BYTE ( WinFNT_Header, underline ), FT_FRAME_BYTE ( underline ),
FT_FRAME_BYTE ( WinFNT_Header, strike_out ), FT_FRAME_BYTE ( strike_out ),
FT_FRAME_USHORT_LE( WinFNT_Header, weight ), FT_FRAME_USHORT_LE( weight ),
FT_FRAME_BYTE ( WinFNT_Header, charset ), FT_FRAME_BYTE ( charset ),
FT_FRAME_USHORT_LE( WinFNT_Header, pixel_width ), FT_FRAME_USHORT_LE( pixel_width ),
FT_FRAME_USHORT_LE( WinFNT_Header, pixel_height ), FT_FRAME_USHORT_LE( pixel_height ),
FT_FRAME_BYTE ( WinFNT_Header, pitch_and_family ), FT_FRAME_BYTE ( pitch_and_family ),
FT_FRAME_USHORT_LE( WinFNT_Header, avg_width ), FT_FRAME_USHORT_LE( avg_width ),
FT_FRAME_USHORT_LE( WinFNT_Header, max_width ), FT_FRAME_USHORT_LE( max_width ),
FT_FRAME_BYTE ( WinFNT_Header, first_char ), FT_FRAME_BYTE ( first_char ),
FT_FRAME_BYTE ( WinFNT_Header, last_char ), FT_FRAME_BYTE ( last_char ),
FT_FRAME_BYTE ( WinFNT_Header, default_char ), FT_FRAME_BYTE ( default_char ),
FT_FRAME_BYTE ( WinFNT_Header, break_char ), FT_FRAME_BYTE ( break_char ),
FT_FRAME_USHORT_LE( WinFNT_Header, bytes_per_row ), FT_FRAME_USHORT_LE( bytes_per_row ),
FT_FRAME_ULONG_LE ( WinFNT_Header, device_offset ), FT_FRAME_ULONG_LE ( device_offset ),
FT_FRAME_ULONG_LE ( WinFNT_Header, face_name_offset ), FT_FRAME_ULONG_LE ( face_name_offset ),
FT_FRAME_ULONG_LE ( WinFNT_Header, bits_pointer ), FT_FRAME_ULONG_LE ( bits_pointer ),
FT_FRAME_ULONG_LE ( WinFNT_Header, bits_offset ), FT_FRAME_ULONG_LE ( bits_offset ),
FT_FRAME_BYTE ( WinFNT_Header, reserved ), FT_FRAME_BYTE ( reserved ),
FT_FRAME_ULONG_LE ( WinFNT_Header, flags ), FT_FRAME_ULONG_LE ( flags ),
FT_FRAME_USHORT_LE( WinFNT_Header, A_space ), FT_FRAME_USHORT_LE( A_space ),
FT_FRAME_USHORT_LE( WinFNT_Header, B_space ), FT_FRAME_USHORT_LE( B_space ),
FT_FRAME_USHORT_LE( WinFNT_Header, C_space ), FT_FRAME_USHORT_LE( C_space ),
FT_FRAME_USHORT_LE( WinFNT_Header, color_table_offset ), FT_FRAME_USHORT_LE( color_table_offset ),
FT_FRAME_BYTES ( WinFNT_Header, reserved, 4 ), FT_FRAME_BYTES ( reserved, 4 ),
FT_FRAME_END FT_FRAME_END
}; };