2005-07-22 Owen Taylor <otaylor@redhat.com>
Patch from David Turner. Review and testing by Behdad Esfahbod
* pango/opentype/ftglue.[ch] Makefile.am: Glue layer that provides
implementation of the internal functions that the opentype code
expects in terms of publically exported FreeType API.
* pango/opentype/ftxgdef.c pango/opentype/ftxgpos.c
pango/opentype/ftxgsub.c pango/opentype/ftxopen.c
pango/opentype/otlbuffer.c pango/opentype/pango-ot-info.c
pango/opentype/pango-ot-ruleset.c: Remove includes of
internal headers. Small changes to work with ftglue.[ch]
* pango/opentype/fterrcompat.h: Remove: no longer needed.
* pango/opentype/ftxgpos.c: Use FT_IS_SFNT(face) rather
than poking at FT_MODULE_CLASS (face->driver)->module_name.
* pango/opentype/ftxopen.c (Free_FeatureList): Free
fl->ApplyOrder. (Found by Behdad)
pull/1/head
Owen Taylor
20 years ago
committed by
Owen Taylor
parent
43dbec6f3a
commit
ff7034787d
11 changed files with 520 additions and 132 deletions
@ -1,95 +0,0 @@ |
||||
/* Pango
|
||||
* fterrcompat.h: Compat defines for compiling with newer versions |
||||
* of FreeType |
||||
* |
||||
* Copyright © 2003 Red Hat, Inc |
||||
* |
||||
* The code is dual-licensed under the GNU Public License and the |
||||
* FreeType license. See see FT-license.txt for full details. |
||||
*/ |
||||
#ifndef FTERRCOMPAT_H |
||||
#define FTERRCOMPAT_H |
||||
|
||||
#include <config.h> |
||||
|
||||
#define TT_Err_Ok FT_Err_Ok |
||||
#define TT_Err_Invalid_Argument FT_Err_Invalid_Argument |
||||
#define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle |
||||
#define TT_Err_Table_Missing FT_Err_Table_Missing |
||||
|
||||
/* Compat macros for name changes in FreeType 2.1.0
|
||||
*/ |
||||
#if (FREETYPE_MAJOR == 2) && (FREETYPE_MINOR >= 1) |
||||
|
||||
#define FILE_Pos() FT_STREAM_POS() |
||||
#define FILE_Seek( position ) FT_STREAM_SEEK( position) |
||||
|
||||
#define ACCESS_Frame( size ) FT_FRAME_ENTER( size ) |
||||
#define FORGET_Frame() FT_FRAME_EXIT() |
||||
|
||||
#define GET_Char() FT_GET_CHAR() |
||||
#define GET_Byte() FT_GET_BYTE() |
||||
#define GET_Short() FT_GET_SHORT() |
||||
#define GET_UShort() FT_GET_USHORT() |
||||
#define GET_Offset() FT_GET_OFF3() |
||||
#define GET_UOffset() FT_GET_UOFF3() |
||||
#define GET_Long() FT_GET_LONG() |
||||
#define GET_ULong() FT_GET_ULONG() |
||||
#define GET_Tag4() FT_GET_TAG4() |
||||
|
||||
/* Macro definitions to avoid bogus warnings about strict
|
||||
* aliasing. These make code generation worse, so we only |
||||
* use them when necessary |
||||
*/ |
||||
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) |
||||
#define ALLOC_ARRAY( _pointer_, _count_, _type_ ) ({ \ |
||||
int result; \
|
||||
void *_tmp_; \
|
||||
result = FT_SET_ERROR ( FT_MEM_ALLOC_ARRAY ( _tmp_, \
|
||||
_count_, \
|
||||
_type_ ) ); \
|
||||
_pointer_ = _tmp_; \
|
||||
result; \
|
||||
}) |
||||
|
||||
/* FT_MEM_REALLOC macro broken in 2.1.0 */ |
||||
#define REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ ) ({ \ |
||||
int result; \
|
||||
void *_tmp_ = _pointer_; \
|
||||
result = FT_SET_ERROR ( FT_MEM_REALLOC( _tmp_, \
|
||||
(_old_) * sizeof ( _type_ ), \
|
||||
(_new_) * sizeof ( _type_ ) ) ); \
|
||||
_pointer_ = _tmp_; \
|
||||
result; \
|
||||
}) |
||||
|
||||
#define FREE( _pointer_ ) ({ \ |
||||
void *_tmp_ = _pointer_; \
|
||||
FT_FREE ( _tmp_ ); \
|
||||
_pointer_ = _tmp_; \
|
||||
}) |
||||
#define ALLOC( _pointer_, _size_ ) ({ \ |
||||
int result; \
|
||||
void *_tmp_; \
|
||||
result = FT_ALLOC( _tmp_, _size_ ); \
|
||||
_pointer_ = _tmp_; \
|
||||
result; \
|
||||
}) |
||||
#else |
||||
#define ALLOC_ARRAY( _pointer_, _count_, _type_ ) \ |
||||
FT_SET_ERROR (FT_MEM_ALLOC_ARRAY( _pointer_, _count_, _type_)) |
||||
|
||||
/* FT_MEM_REALLOC macro broken in 2.1.0 */ |
||||
#define REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ ) \ |
||||
FT_SET_ERROR ( FT_MEM_REALLOC( _pointer_, (_old_) * sizeof ( _type_ ), \
|
||||
(_new_) * sizeof ( _type_ ) ) ) |
||||
|
||||
#define FREE( _pointer_ ) FT_FREE( _pointer_ ) |
||||
#define ALLOC( _pointer_, _size_ ) FT_ALLOC( _pointer_, _size_ ) |
||||
#endif /* gcc >= 3.3 */ |
||||
|
||||
#define MEM_Copy( dest, source, count ) FT_MEM_COPY( dest, source, count ) |
||||
|
||||
#endif /* freetype >= 2.1.0 */ |
||||
|
||||
#endif /* FTERRCOMPAT_H */ |
||||
@ -0,0 +1,350 @@ |
||||
/* ftglue.c: Glue code for compiling the OpenType code from
|
||||
* FreeType 1 using only the public API of FreeType 2 |
||||
* |
||||
* By David Turner, The FreeType Project (www.freetype.org) |
||||
* |
||||
* This code is explicitely put in the public domain |
||||
* |
||||
* See ftglue.h for more information. |
||||
*/ |
||||
|
||||
#include "ftglue.h" |
||||
|
||||
#if 0 |
||||
#include <stdio.h> |
||||
#define LOG(x) ftglue_log x |
||||
|
||||
static void |
||||
ftglue_log( const char* format, ... ) |
||||
{ |
||||
va_list ap; |
||||
|
||||
va_start( ap, format ); |
||||
vfprintf( stderr, format, ap ); |
||||
va_end( ap ); |
||||
} |
||||
|
||||
#else |
||||
#define LOG(x) do {} while (0) |
||||
#endif |
||||
|
||||
/* only used internally */ |
||||
static FT_Pointer |
||||
ftglue_qalloc( FT_Memory memory, |
||||
FT_ULong size, |
||||
FT_Error *perror ) |
||||
{ |
||||
FT_Error error = 0; |
||||
FT_Pointer block = NULL; |
||||
|
||||
if ( size > 0 ) |
||||
{ |
||||
block = memory->alloc( memory, size ); |
||||
if ( !block ) |
||||
error = FT_Err_Out_Of_Memory; |
||||
} |
||||
|
||||
*perror = error; |
||||
return block; |
||||
} |
||||
|
||||
#undef QALLOC /* just in case */ |
||||
#define QALLOC(ptr,size) ( (ptr) = ftglue_qalloc( memory, (size), &error ), error != 0 ) |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Pointer ) |
||||
ftglue_alloc( FT_Memory memory, |
||||
FT_ULong size, |
||||
FT_Error *perror ) |
||||
{ |
||||
FT_Error error = 0; |
||||
FT_Pointer block = NULL; |
||||
|
||||
if ( size > 0 ) |
||||
{ |
||||
block = memory->alloc( memory, size ); |
||||
if ( !block ) |
||||
error = FT_Err_Out_Of_Memory; |
||||
else |
||||
memset( (char*)block, 0, (size_t)size ); |
||||
} |
||||
|
||||
*perror = error; |
||||
return block; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Pointer ) |
||||
ftglue_realloc( FT_Memory memory, |
||||
FT_Pointer block, |
||||
FT_ULong old_size, |
||||
FT_ULong new_size, |
||||
FT_Error *perror ) |
||||
{ |
||||
FT_Pointer block2 = NULL; |
||||
FT_Error error = 0; |
||||
|
||||
if ( old_size == 0 || block == NULL ) |
||||
{ |
||||
block2 = ftglue_alloc( memory, new_size, &error ); |
||||
} |
||||
else if ( new_size == 0 ) |
||||
{ |
||||
ftglue_free( memory, block ); |
||||
block2 = NULL; |
||||
} |
||||
else |
||||
{ |
||||
block2 = memory->realloc( memory, old_size, new_size, block ); |
||||
if ( block2 == NULL ) |
||||
error = FT_Err_Out_Of_Memory; |
||||
else if ( new_size > old_size ) |
||||
memset( (char*)block2 + old_size, 0, (size_t)(new_size - old_size) ); |
||||
} |
||||
|
||||
if ( !error ) |
||||
block = block2; |
||||
|
||||
*perror = error; |
||||
return block; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( void ) |
||||
ftglue_free( FT_Memory memory, |
||||
FT_Pointer block ) |
||||
{ |
||||
if ( block ) |
||||
memory->free( memory, block ); |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Long ) |
||||
ftglue_stream_pos( FT_Stream stream ) |
||||
{ |
||||
LOG(( "ftglue:stream:pos() -> %ld\n", stream->pos )); |
||||
return stream->pos; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Error ) |
||||
ftglue_stream_seek( FT_Stream stream, |
||||
FT_Long pos ) |
||||
{ |
||||
FT_Error error = 0; |
||||
|
||||
stream->pos = pos; |
||||
if ( stream->read ) |
||||
{ |
||||
if ( stream->read( stream, pos, 0, 0 ) ) |
||||
error = FT_Err_Invalid_Stream_Operation; |
||||
} |
||||
else if ( pos > stream->size ) |
||||
error = FT_Err_Invalid_Stream_Operation; |
||||
|
||||
LOG(( "ftglue:stream:seek(%ld) -> %d\n", pos, error )); |
||||
return error; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Error ) |
||||
ftglue_stream_frame_enter( FT_Stream stream, |
||||
FT_ULong count ) |
||||
{ |
||||
FT_Error error = FT_Err_Ok; |
||||
FT_ULong read_bytes; |
||||
|
||||
if ( stream->read ) |
||||
{ |
||||
/* allocate the frame in memory */ |
||||
FT_Memory memory = stream->memory; |
||||
|
||||
|
||||
if ( QALLOC( stream->base, count ) ) |
||||
goto Exit; |
||||
|
||||
/* read it */ |
||||
read_bytes = stream->read( stream, stream->pos, |
||||
stream->base, count ); |
||||
if ( read_bytes < count ) |
||||
{ |
||||
FREE( stream->base ); |
||||
error = FT_Err_Invalid_Stream_Operation; |
||||
} |
||||
stream->cursor = stream->base; |
||||
stream->limit = stream->cursor + count; |
||||
stream->pos += read_bytes; |
||||
} |
||||
else |
||||
{ |
||||
/* check current and new position */ |
||||
if ( stream->pos >= stream->size || |
||||
stream->pos + count > stream->size ) |
||||
{ |
||||
error = FT_Err_Invalid_Stream_Operation; |
||||
goto Exit; |
||||
} |
||||
|
||||
/* set cursor */ |
||||
stream->cursor = stream->base + stream->pos; |
||||
stream->limit = stream->cursor + count; |
||||
stream->pos += count; |
||||
} |
||||
|
||||
Exit: |
||||
LOG(( "ftglue:stream:frame_enter(%ld) -> %d\n", count, error )); |
||||
return error; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( void ) |
||||
ftglue_stream_frame_exit( FT_Stream stream ) |
||||
{ |
||||
if ( stream->read ) |
||||
{ |
||||
FT_Memory memory = stream->memory; |
||||
|
||||
FREE( stream->base ); |
||||
} |
||||
stream->cursor = 0; |
||||
stream->limit = 0; |
||||
|
||||
LOG(( "ftglue:stream:frame_exit()\n" )); |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Byte ) |
||||
ftglue_stream_get_byte( FT_Stream stream ) |
||||
{ |
||||
FT_Byte result = 0; |
||||
|
||||
if ( stream->cursor < stream->limit ) |
||||
result = *stream->cursor++; |
||||
|
||||
return result; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Short ) |
||||
ftglue_stream_get_short( FT_Stream stream ) |
||||
{ |
||||
FT_Byte* p; |
||||
FT_Short result = 0; |
||||
|
||||
p = stream->cursor; |
||||
if ( p + 2 <= stream->limit ) |
||||
{ |
||||
result = (FT_Short)((p[0] << 8) | p[1]); |
||||
stream->cursor = p+2; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Long ) |
||||
ftglue_stream_get_long( FT_Stream stream ) |
||||
{ |
||||
FT_Byte* p; |
||||
FT_Long result = 0; |
||||
|
||||
p = stream->cursor; |
||||
if ( p + 4 <= stream->limit ) |
||||
{ |
||||
result = (FT_Long)(((FT_Long)p[0] << 24) | |
||||
((FT_Long)p[1] << 16) | |
||||
((FT_Long)p[2] << 8) | |
||||
p[3] ); |
||||
stream->cursor = p+4; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
|
||||
FTGLUE_APIDEF( FT_Error ) |
||||
ftglue_face_goto_table( FT_Face face, |
||||
FT_ULong the_tag, |
||||
FT_Stream stream ) |
||||
{ |
||||
FT_Error error; |
||||
|
||||
LOG(( "ftglue_face_goto_table( %p, %c%c%c%c, %p )\n", |
||||
face,
|
||||
(int)((the_tag >> 24) & 0xFF),
|
||||
(int)((the_tag >> 16) & 0xFF),
|
||||
(int)((the_tag >> 8) & 0xFF),
|
||||
(int)(the_tag & 0xFF), |
||||
stream )); |
||||
|
||||
if ( !FT_IS_SFNT(face) ) |
||||
{ |
||||
LOG(( "not a SFNT face !!\n" )); |
||||
error = FT_Err_Invalid_Face_Handle; |
||||
} |
||||
else |
||||
{ |
||||
/* parse the directory table directly, without using
|
||||
* FreeType's built-in data structures |
||||
*/ |
||||
FT_ULong offset = 0; |
||||
FT_UInt count, nn; |
||||
|
||||
if ( face->num_faces > 1 ) |
||||
{ |
||||
/* deal with TrueType collections */ |
||||
FT_ULong offset; |
||||
|
||||
LOG(( ">> This is a TrueType Collection\n" )); |
||||
|
||||
if ( FILE_Seek( 12 + face->face_index*4 ) || |
||||
ACCESS_Frame( 4 ) ) |
||||
goto Exit; |
||||
|
||||
offset = GET_ULong(); |
||||
|
||||
FORGET_Frame(); |
||||
} |
||||
|
||||
LOG(( "TrueType offset = %ld\n", offset )); |
||||
|
||||
if ( FILE_Seek( offset+4 ) || |
||||
ACCESS_Frame( 2 ) ) |
||||
goto Exit; |
||||
|
||||
count = GET_UShort(); |
||||
|
||||
FORGET_Frame(); |
||||
|
||||
if ( FILE_Seek( offset+12 ) || |
||||
ACCESS_Frame( count*16 ) ) |
||||
goto Exit; |
||||
|
||||
for ( nn = 0; nn < count; nn++ ) |
||||
{ |
||||
FT_ULong tag = GET_ULong(); |
||||
FT_ULong checksum = GET_ULong(); |
||||
FT_ULong start = GET_ULong(); |
||||
FT_ULong size = GET_ULong(); |
||||
|
||||
FT_UNUSED(checksum); |
||||
FT_UNUSED(size); |
||||
|
||||
if ( tag == the_tag ) |
||||
{ |
||||
LOG(( "TrueType table (start: %ld) (size: %ld)\n", start, size )); |
||||
error = ftglue_stream_seek( stream, offset+start ); |
||||
goto FoundIt; |
||||
} |
||||
} |
||||
error = TT_Err_Table_Missing; |
||||
|
||||
FoundIt: |
||||
FORGET_Frame(); |
||||
} |
||||
|
||||
Exit: |
||||
LOG(( "TrueType error=%d\n", error )); |
||||
|
||||
return error; |
||||
}
|
||||
|
||||
#undef QALLOC |
||||
@ -0,0 +1,156 @@ |
||||
/* ftglue.c: Glue code for compiling the OpenType code from
|
||||
* FreeType 1 using only the public API of FreeType 2 |
||||
* |
||||
* By David Turner, The FreeType Project (www.freetype.org) |
||||
* |
||||
* This code is explicitely put in the public domain |
||||
* |
||||
* ========================================================================== |
||||
* |
||||
* the OpenType parser codes was originally written as an extension to |
||||
* FreeType 1.x. As such, its source code was embedded within the library, |
||||
* and used many internal FreeType functions to deal with memory and |
||||
* stream i/o. |
||||
* |
||||
* When it was 'salvaged' for Pango and Qt, the code was "ported" to FreeType 2, |
||||
* which basically means that some macro tricks were performed in order to |
||||
* directly access FT2 _internal_ functions. |
||||
* |
||||
* these functions were never part of FT2 public API, and _did_ change between |
||||
* various releases. This created chaos for many users: when they upgraded the |
||||
* FreeType library on their system, they couldn't run Gnome anymore since |
||||
* Pango refused to link. |
||||
* |
||||
* Very fortunately, it's possible to completely avoid this problem because |
||||
* the FT_StreamRec and FT_MemoryRec structure types, which describe how |
||||
* memory and stream implementations interface with the rest of the font |
||||
* library, have always been part of the public API, and never changed. |
||||
* |
||||
* What we do thus is re-implement, within the OpenType parser, the few |
||||
* functions that depend on them. This only adds one or two kilobytes of |
||||
* code, and ensures that the parser can work with _any_ version |
||||
* of FreeType installed on your system. How sweet... ! |
||||
* |
||||
* Note that we assume that Pango doesn't use any other internal functions |
||||
* from FreeType. It used to in old versions, but this should no longer |
||||
* be the case. (crossing my fingers). |
||||
* |
||||
* - David Turner |
||||
* - The FreeType Project (www.freetype.org) |
||||
* |
||||
* PS: This "glue" code is explicitely put in the public domain |
||||
*/ |
||||
#ifndef __OPENTYPE_FTGLUE_H__ |
||||
#define __OPENTYPE_FTGLUE_H__ |
||||
|
||||
#include <ft2build.h> |
||||
#include FT_FREETYPE_H |
||||
|
||||
FT_BEGIN_HEADER |
||||
|
||||
|
||||
/* utility macros */ |
||||
#define TT_Err_Ok FT_Err_Ok |
||||
#define TT_Err_Invalid_Argument FT_Err_Invalid_Argument |
||||
#define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle |
||||
#define TT_Err_Table_Missing FT_Err_Table_Missing |
||||
|
||||
#define SET_ERR(c) ( (error = (c)) != 0 ) |
||||
|
||||
#ifndef FTGLUE_API |
||||
#define FTGLUE_API(x) extern x |
||||
#endif |
||||
|
||||
#ifndef FTGLUE_APIDEF |
||||
#define FTGLUE_APIDEF(x) x |
||||
#endif |
||||
|
||||
/* stream macros used by the OpenType parser */ |
||||
#define FILE_Pos() ftglue_stream_pos( stream ) |
||||
#define FILE_Seek(pos) SET_ERR( ftglue_stream_seek( stream, pos ) ) |
||||
#define ACCESS_Frame(size) SET_ERR( ftglue_stream_frame_enter( stream, size ) ) |
||||
#define FORGET_Frame() ftglue_stream_frame_exit( stream ) |
||||
|
||||
#define GET_Byte() ftglue_stream_get_byte( stream ) |
||||
#define GET_Short() ftglue_stream_get_short( stream ) |
||||
#define GET_Long() ftglue_stream_get_long( stream ) |
||||
|
||||
#define GET_Char() ((FT_Char)GET_Byte()) |
||||
#define GET_UShort() ((FT_UShort)GET_Short()) |
||||
#define GET_ULong() ((FT_ULong)GET_Long()) |
||||
#define GET_Tag4() GET_ULong() |
||||
|
||||
FTGLUE_API( FT_Long ) |
||||
ftglue_stream_pos( FT_Stream stream ); |
||||
|
||||
FTGLUE_API( FT_Error ) |
||||
ftglue_stream_seek( FT_Stream stream, |
||||
FT_Long pos ); |
||||
|
||||
FTGLUE_API( FT_Error ) |
||||
ftglue_stream_frame_enter( FT_Stream stream, |
||||
FT_ULong size ); |
||||
|
||||
FTGLUE_API( void ) |
||||
ftglue_stream_frame_exit( FT_Stream stream ); |
||||
|
||||
FTGLUE_API( FT_Byte ) |
||||
ftglue_stream_get_byte( FT_Stream stream ); |
||||
|
||||
FTGLUE_API( FT_Short ) |
||||
ftglue_stream_get_short( FT_Stream stream ); |
||||
|
||||
FTGLUE_API( FT_Long ) |
||||
ftglue_stream_get_long( FT_Stream stream ); |
||||
|
||||
FTGLUE_API( FT_Error ) |
||||
ftglue_face_goto_table( FT_Face face, |
||||
FT_ULong tag, |
||||
FT_Stream stream ); |
||||
|
||||
/* memory macros used by the OpenType parser */ |
||||
#define ALLOC(_ptr,_size) \ |
||||
( (_ptr) = ftglue_alloc( memory, _size, &error ), error != 0 ) |
||||
|
||||
#define REALLOC(_ptr,_oldsz,_newsz) \ |
||||
( (_ptr) = ftglue_realloc( memory, (_ptr), (_oldsz), (_newsz), &error ), error != 0 ) |
||||
|
||||
#define FREE(_ptr) \ |
||||
FT_BEGIN_STMNT \
|
||||
if ( (_ptr) ) \
|
||||
{ \
|
||||
ftglue_free( memory, _ptr ); \
|
||||
_ptr = NULL; \
|
||||
} \
|
||||
FT_END_STMNT |
||||
|
||||
#define ALLOC_ARRAY(_ptr,_count,_type) \ |
||||
ALLOC(_ptr,(_count)*sizeof(_type)) |
||||
|
||||
#define REALLOC_ARRAY(_ptr,_oldcnt,_newcnt,_type) \ |
||||
REALLOC(_ptr,(_oldcnt)*sizeof(_type),(_newcnt)*sizeof(_type)) |
||||
|
||||
#define MEM_Copy(dest,source,count) memcpy( (char*)(dest), (const char*)(source), (size_t)(count) ) |
||||
|
||||
|
||||
FTGLUE_API( FT_Pointer ) |
||||
ftglue_alloc( FT_Memory memory, |
||||
FT_ULong size, |
||||
FT_Error *perror ); |
||||
|
||||
FTGLUE_API( FT_Pointer ) |
||||
ftglue_realloc( FT_Memory memory, |
||||
FT_Pointer block, |
||||
FT_ULong old_size, |
||||
FT_ULong new_size, |
||||
FT_Error *perror ); |
||||
|
||||
FTGLUE_API( void ) |
||||
ftglue_free( FT_Memory memory, |
||||
FT_Pointer block ); |
||||
|
||||
/* */ |
||||
|
||||
FT_END_HEADER |
||||
|
||||
#endif /* __OPENTYPE_FTGLUE_H__ */ |
||||
Loading…
Reference in new issue