From 4c1867bfab4e4c0c8f05cd1579ec7d709defa484 Mon Sep 17 00:00:00 2001 From: Werner Lemberg Date: Fri, 4 Feb 2005 00:02:31 +0000 Subject: [PATCH] * src/otlayout/*: Removed. Obsolete. --- ChangeLog | 4 + src/otlayout/otlayout.h | 236 --------- src/otlayout/otlbase.c | 231 -------- src/otlayout/otlbase.h | 37 -- src/otlayout/otlcommn.c | 967 ---------------------------------- src/otlayout/otlcommn.h | 326 ------------ src/otlayout/otlconf.h | 78 --- src/otlayout/otlgdef.c | 203 -------- src/otlayout/otlgdef.h | 41 -- src/otlayout/otlgpos.c | 1102 --------------------------------------- src/otlayout/otlgpos.h | 44 -- src/otlayout/otlgsub.c | 1069 ------------------------------------- src/otlayout/otlgsub.h | 52 -- src/otlayout/otljstf.c | 262 ---------- src/otlayout/otljstf.h | 44 -- src/otlayout/otlparse.c | 144 ----- src/otlayout/otlparse.h | 100 ---- src/otlayout/otltable.h | 62 --- src/otlayout/otltags.h | 87 ---- src/otlayout/otlutils.h | 33 -- 20 files changed, 4 insertions(+), 5118 deletions(-) delete mode 100644 src/otlayout/otlayout.h delete mode 100644 src/otlayout/otlbase.c delete mode 100644 src/otlayout/otlbase.h delete mode 100644 src/otlayout/otlcommn.c delete mode 100644 src/otlayout/otlcommn.h delete mode 100644 src/otlayout/otlconf.h delete mode 100644 src/otlayout/otlgdef.c delete mode 100644 src/otlayout/otlgdef.h delete mode 100644 src/otlayout/otlgpos.c delete mode 100644 src/otlayout/otlgpos.h delete mode 100644 src/otlayout/otlgsub.c delete mode 100644 src/otlayout/otlgsub.h delete mode 100644 src/otlayout/otljstf.c delete mode 100644 src/otlayout/otljstf.h delete mode 100644 src/otlayout/otlparse.c delete mode 100644 src/otlayout/otlparse.h delete mode 100644 src/otlayout/otltable.h delete mode 100644 src/otlayout/otltags.h delete mode 100644 src/otlayout/otlutils.h diff --git a/ChangeLog b/ChangeLog index bbb5c9894..462bfa80f 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2005-02-04 Werner Lemberg + + * src/otlayout/*: Removed. Obsolete. + 2004-12-28 Werner Lemberg * builds/unix/ltmain.sh: Regenerated with `libtoolize --force diff --git a/src/otlayout/otlayout.h b/src/otlayout/otlayout.h deleted file mode 100644 index c177cc2aa..000000000 --- a/src/otlayout/otlayout.h +++ /dev/null @@ -1,236 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlayout.h */ -/* */ -/* OpenType layout support (specification only). */ -/* */ -/* Copyright 2002, 2004 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 __OT_LAYOUT_H__ -#define __OT_LAYOUT_H__ - - -#include "otlconf.h" - -OTL_BEGIN_HEADER - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** BASE DATA TYPES *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - - typedef unsigned char OTL_Byte; - typedef const OTL_Byte* OTL_Bytes; - - typedef int OTL_Error; - - typedef void* OTL_Pointer; - - typedef unsigned char OTL_Bool; - - typedef signed int OTL_Int; - typedef unsigned int OTL_UInt; - - typedef signed long OTL_Long; - typedef unsigned long OTL_ULong; - - typedef signed short OTL_Int16; - typedef unsigned short OTL_UInt16; - - -#if OTL_SIZEOF_INT == 4 - - typedef signed int OTL_Int32; - typedef unsigned int OTL_UInt32; - -#elif OTL_SIZEOF_LONG == 4 - - typedef signed long OTL_Int32; - typedef unsigned long OTL_UInt32; - -#else -# error "no 32-bits type found" -#endif - - typedef OTL_UInt32 OTL_Tag; - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** ERROR CODES *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - - enum - { - OTL_Err_Ok = 0, - OTL_Err_InvalidFormat, - OTL_Err_InvalidSize, - OTL_Err_InvalidData, - OTL_Err_InvalidOffset, - - OTL_Err_Max - - }; - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** MEMORY MANAGEMENT *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - - typedef OTL_Pointer (*OTL_AllocFunc)( OTL_ULong size, - OTL_Pointer data ); - - typedef OTL_Pointer (*OTL_ReallocFunc)( OTL_Pointer block, - OTL_ULong size, - OTL_Pointer data ); - - typedef void (*OTL_FreeFunc)( OTL_Pointer block, - OTL_Pointer data ); - - typedef struct OTL_MemoryRec_ - { - OTL_Pointer mem_data; - OTL_AllocFunc mem_alloc; - OTL_ReallocFunc mem_realloc; - OTL_FreeFunc mem_free; - - } OTL_MemoryRec, *OTL_Memory; - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** ENUMERATIONS *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - -/* re-define OTL_MAKE_TAG to something different if you're not */ -/* using an ASCII-based character set (Vaxes anyone ?) */ -#ifndef OTL_MAKE_TAG -#define OTL_MAKE_TAG(c1,c2,c3,c4) \ - ( ( (OTL_UInt32)(c1) << 24 ) | \ - ( (OTL_UInt32)(c2) << 16 ) | \ - ( (OTL_UInt32)(c3) << 8 ) | \ - ( (OTL_UInt32)(c4) ) ) -#endif - - typedef enum OTL_ScriptTag_ - { - OTL_SCRIPT_NONE = 0, - -#define OTL_SCRIPT_TAG(c1,c2,c3,c4,s,n) OTL_SCRIPT_TAG_ ## n = OTL_MAKE_TAG(c1,c2,c3,c4), -#include "otltags.h" - - OTL_SCRIPT_MAX - - } OTL_ScriptTag; - - - typedef enum OTL_LangTag_ - { - OTL_LANG_DEFAULT = 0, - -#define OTL_LANG_TAG(c1,c2,c3,c4,s,n) OTL_LANG_TAG_ ## n = OTL_MAKE_TAG(c1,c2,c3,c4), -#include "otltags.h" - - OTL_LANG_MAX - - } OTL_LangTag; - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** MEMORY READS *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - -#define OTL_PEEK_USHORT(p) ( ((OTL_UInt)((p)[0]) << 8) | \ - ((OTL_UInt)((p)[1]) ) ) - -#define OTL_PEEK_ULONG(p) ( ((OTL_UInt32)((p)[0]) << 24) | \ - ((OTL_UInt32)((p)[1]) << 16) | \ - ((OTL_UInt32)((p)[2]) << 8) | \ - ((OTL_UInt32)((p)[3]) ) ) - -#define OTL_PEEK_SHORT(p) ((OTL_Int16)OTL_PEEK_USHORT(p)) - -#define OTL_PEEK_LONG(p) ((OTL_Int32)OTL_PEEK_ULONG(p)) - -#define OTL_NEXT_USHORT(p) ( (p) += 2, OTL_PEEK_USHORT((p)-2) ) -#define OTL_NEXT_ULONG(p) ( (p) += 4, OTL_PEEK_ULONG((p)-4) ) - -#define OTL_NEXT_SHORT(p) ((OTL_Int16)OTL_NEXT_USHORT(p)) -#define OTL_NEXT_LONG(p) ((OTL_Int32)OTL_NEXT_ULONG(p)) - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** VALIDATION *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - - typedef struct OTL_ValidatorRec_* OTL_Validator; - - typedef struct OTL_ValidatorRec_ - { - OTL_Bytes limit; - OTL_Bytes base; - OTL_Error error; - OTL_jmp_buf jump_buffer; - - } OTL_ValidatorRec; - - typedef void (*OTL_ValidateFunc)( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ); - - OTL_API( void ) - otl_validator_error( OTL_Validator validator, - OTL_Error error ); - -#define OTL_INVALID(e) otl_validator_error( valid, e ) - -#define OTL_INVALID_TOO_SHORT OTL_INVALID( OTL_Err_InvalidSize ) -#define OTL_INVALID_DATA OTL_INVALID( OTL_Err_InvalidData ) -#define OTL_INVALID_FORMAT OTL_INVALID( OTL_Err_InvalidFormat ) - -#define OTL_CHECK(_count) OTL_BEGIN_STMNT \ - if ( p + (_count) > valid->limit ) \ - OTL_INVALID_TOO_SHORT; \ - OTL_END_STMNT - - /* */ - -OTL_END_HEADER - -#endif /* __OT_LAYOUT_H__ */ - - -/* END */ diff --git a/src/otlayout/otlbase.c b/src/otlayout/otlbase.c deleted file mode 100644 index 2fe242667..000000000 --- a/src/otlayout/otlbase.c +++ /dev/null @@ -1,231 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlbase.c */ -/* */ -/* OpenType layout support, BASE table (body). */ -/* */ -/* Copyright 2002, 2004 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 "otlbase.h" -#include "otlcommn.h" - - - static void - otl_base_coord_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - - OTL_CHECK( 4 ); - - format = OTL_NEXT_USHORT( p ); - - p += 2; /* skip coordinate */ - - switch ( format ) - { - case 1: - break; - - case 2: - OTL_CHECK( 4 ); - break; - - case 3: - OTL_CHECK( 2 ); - - otl_device_table_validate( table + OTL_PEEK_USHORT( p ), valid ); - break; - - default: - OTL_INVALID_DATA; - } - } - - - static void - otl_base_tag_list_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt count; - - - OTL_CHECK( 2 ); - - count = OTL_NEXT_USHORT( p ); - OTL_CHECK( count * 4 ); - } - - - static void - otl_base_values_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_coord; - - - OTL_CHECK( 4 ); - - p += 2; /* skip default index */ - num_coord = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_coord * 2 ); - - /* scan base coordinate records */ - for ( ; num_coord > 0; num_coord-- ) - otl_base_coord_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - - - static void - otl_base_minmax_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt min_coord, max_coord, num_minmax; - - - OTL_CHECK( 6 ); - - min_coord = OTL_NEXT_USHORT( p ); - max_coord = OTL_NEXT_USHORT( p ); - num_minmax = OTL_NEXT_USHORT( p ); - - if ( min_coord ) - otl_base_coord_validate( table + min_coord, valid ); - - if ( max_coord ) - otl_base_coord_validate( table + max_coord, valid ); - - OTL_CHECK( num_minmax * 8 ); - - /* scan feature minmax records */ - for ( ; num_minmax > 0; num_minmax-- ) - { - p += 4; /* skip tag */ - - min_coord = OTL_NEXT_USHORT( p ); - max_coord = OTL_NEXT_USHORT( p ); - - if ( min_coord ) - otl_base_coord_validate( table + min_coord, valid ); - - if ( max_coord ) - otl_base_coord_validate( table + max_coord, valid ); - } - } - - - static void - otl_base_script_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt values, default_minmax, num_langsys; - - - OTL_CHECK( 6 ); - - values = OTL_NEXT_USHORT( p ); - default_minmax = OTL_NEXT_USHORT( p ); - num_langsys = OTL_NEXT_USHORT( p ); - - if ( values ) - otl_base_values_validate( table + values, valid ); - - if ( default_minmax ) - otl_base_minmax_validate( table + default_minmax, valid ); - - OTL_CHECK( num_langsys * 6 ); - - /* scan base langsys records */ - for ( ; num_langsys > 0; num_langsys-- ) - { - p += 4; /* skip tag */ - - otl_base_minmax_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - } - - - static void - otl_base_script_list_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_scripts; - - - OTL_CHECK( 2 ); - - num_scripts = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_scripts * 6 ); - - /* scan base script records */ - for ( ; num_scripts > 0; num_scripts-- ) - { - p += 4; /* skip tag */ - - otl_base_script_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - } - - - static void - otl_axis_table_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt tags; - - - OTL_CHECK( 4 ); - - tags = OTL_NEXT_USHORT( p ); - if ( tags ) - otl_base_tag_list_validate( table + tags, valid ); - - otl_base_script_list_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - - - OTL_LOCALDEF( void ) - otl_base_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt val; - - - OTL_CHECK( 6 ); - - if ( OTL_NEXT_ULONG( p ) != 0x10000UL ) - OTL_INVALID_DATA; - - /* validate horizontal axis table */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_axis_table_validate( table + val, valid ); - - /* validate vertical axis table */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_axis_table_validate( table + val, valid ); - } - - -/* END */ diff --git a/src/otlayout/otlbase.h b/src/otlayout/otlbase.h deleted file mode 100644 index f11273545..000000000 --- a/src/otlayout/otlbase.h +++ /dev/null @@ -1,37 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlbase.h */ -/* */ -/* OpenType layout support, BASE table (specification). */ -/* */ -/* Copyright 2002, 2004 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 __OTLBASE_H__ -#define __OTLBASE_H__ - -#include "otlayout.h" - -OTL_BEGIN_HEADER - - - OTL_LOCAL( void ) - otl_base_validate( OTL_Bytes table, - OTL_Validator valid ); - - -OTL_END_HEADER - -#endif /* __OTLBASE_H__ */ - - -/* END */ diff --git a/src/otlayout/otlcommn.c b/src/otlayout/otlcommn.c deleted file mode 100644 index d84116770..000000000 --- a/src/otlayout/otlcommn.c +++ /dev/null @@ -1,967 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlcommn.c */ -/* */ -/* OpenType layout support, common tables (body). */ -/* */ -/* Copyright 2002, 2004 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 "otlayout.h" - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** COVERAGE TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_coverage_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - - OTL_CHECK( 4 ); - - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt num_glyphs = OTL_NEXT_USHORT( p ); - - - OTL_CHECK( num_glyphs * 2 ); - - } - break; - - case 2: - { - OTL_UInt n, num_ranges = OTL_NEXT_USHORT( p ); - OTL_UInt start, end, start_coverage, total = 0, last = 0; - - - OTL_CHECK( num_ranges * 6 ); - - /* scan range records */ - for ( n = 0; n < num_ranges; n++ ) - { - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - start_coverage = OTL_NEXT_USHORT( p ); - - if ( start > end || start_coverage != total ) - OTL_INVALID_DATA; - - if ( n > 0 && start <= last ) - OTL_INVALID_DATA; - - total += end - start + 1; - last = end; - } - } - break; - - default: - OTL_INVALID_FORMAT; - } - - /* no need to check glyph indices used as input to coverage tables */ - /* since even invalid glyph indices return a meaningful result */ - } - - - OTL_LOCALDEF( OTL_UInt ) - otl_coverage_get_first( OTL_Bytes table ) - { - OTL_Bytes p = table; - - - p += 4; /* skip format and count */ - - return OTL_NEXT_USHORT( p ); - } - - - OTL_LOCALDEF( OTL_UInt ) - otl_coverage_get_last( OTL_Bytes table ) - { - OTL_Bytes p = table; - OTL_UInt format = OTL_NEXT_USHORT( p ); - OTL_UInt count = OTL_NEXT_USHORT( p ); - OTL_UInt result; - - - switch ( format ) - { - case 1: - p += ( count - 1 ) * 2; - result = OTL_NEXT_USHORT( p ); - break; - - case 2: - p += ( count - 1 ) * 6 + 2; - result = OTL_NEXT_USHORT( p ); - break; - - default: - ; - } - - return result; - } - - - OTL_LOCALDEF( OTL_UInt ) - otl_coverage_get_count( OTL_Bytes table ) - { - OTL_Bytes p = table; - OTL_UInt format = OTL_NEXT_USHORT( p ); - OTL_UInt count = OTL_NEXT_USHORT( p ); - OTL_UInt result = 0; - - - switch ( format ) - { - case 1: - return count; - - case 2: - { - OTL_UInt start, end; - - - for ( ; count > 0; count-- ) - { - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - p += 2; /* skip start_index */ - - result += end - start + 1; - } - } - break; - - default: - ; - } - - return result; - } - - -#if 0 - OTL_LOCALDEF( OTL_Long ) - otl_coverage_get_index( OTL_Bytes table, - OTL_UInt glyph_index ) - { - OTL_Bytes p = table; - OTL_UInt format = OTL_NEXT_USHORT( p ); - OTL_UInt count = OTL_NEXT_USHORT( p ); - - - switch ( format ) - { - case 1: - { - OTL_UInt min = 0, max = count, mid, gindex; - - - table += 4; - while ( min < max ) - { - mid = ( min + max ) >> 1; - p = table + 2 * mid; - gindex = OTL_PEEK_USHORT( p ); - - if ( glyph_index == gindex ) - return (OTL_Long)mid; - - if ( glyph_index < gindex ) - max = mid; - else - min = mid + 1; - } - } - break; - - case 2: - { - OTL_UInt min = 0, max = count, mid; - OTL_UInt start, end; - - - table += 4; - while ( min < max ) - { - mid = ( min + max ) >> 1; - p = table + 6 * mid; - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - - if ( glyph_index < start ) - max = mid; - else if ( glyph_index > end ) - min = mid + 1; - else - return (OTL_Long)( glyph_index + OTL_NEXT_USHORT( p ) - start ); - } - } - break; - - default: - ; - } - - return -1; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** CLASS DEFINITION TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_class_definition_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - - OTL_CHECK( 4 ); - - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt num_glyphs; - - - p += 2; /* skip start_glyph */ - - OTL_CHECK( 2 ); - num_glyphs = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_glyphs * 2 ); - } - break; - - case 2: - { - OTL_UInt n, num_ranges = OTL_NEXT_USHORT( p ); - OTL_UInt start, end, last = 0; - - - OTL_CHECK( num_ranges * 6 ); - - /* scan class range records */ - for ( n = 0; n < num_ranges; n++ ) - { - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - p += 2; /* ignored */ - - if ( start > end || ( n > 0 && start <= last ) ) - OTL_INVALID_DATA; - - last = end; - } - } - break; - - default: - OTL_INVALID_FORMAT; - } - - /* no need to check glyph indices used as input to class definition */ - /* tables since even invalid glyph indices return a meaningful result */ - } - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_class_definition_get_value( OTL_Bytes table, - OTL_UInt glyph_index ) - { - OTL_Bytes p = table; - OTL_UInt format = OTL_NEXT_USHORT( p ); - - - switch ( format ) - { - case 1: - { - OTL_UInt start = OTL_NEXT_USHORT( p ); - OTL_UInt count = OTL_NEXT_USHORT( p ); - OTL_UInt idx = (OTL_UInt)( glyph_index - start ); - - - if ( idx < count ) - { - p += 2 * idx; - return OTL_PEEK_USHORT( p ); - } - } - break; - - case 2: - { - OTL_UInt count = OTL_NEXT_USHORT( p ); - OTL_UInt min = 0, max = count, mid, gindex, start, end; - - - table += 4; - while ( min < max ) - { - mid = ( min + max ) >> 1; - p = table + 6 * mid; - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - - if ( glyph_index < start ) - max = mid; - else if ( glyph_index > end ) - min = mid + 1; - else - return OTL_PEEK_USHORT( p ); - } - } - break; - - default: - ; - } - - return 0; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** DEVICE TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_device_table_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt start, end, count, format; - - - OTL_CHECK( 8 ); - - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - format = OTL_NEXT_USHORT( p ); - - if ( format < 1 || format > 3 || end < start ) - OTL_INVALID_DATA; - - count = end - start + 1; - - OTL_CHECK( ( 1 << format ) * count / 8 ); - } - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_device_table_get_start( OTL_Bytes table ) - { - OTL_Bytes p = table; - - - return OTL_PEEK_USHORT( p ); - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_device_table_get_end( OTL_Bytes table ) - { - OTL_Bytes p = table + 2; - - - return OTL_PEEK_USHORT( p ); - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_Int ) - otl_device_table_get_delta( OTL_Bytes table, - OTL_UInt size ) - { - OTL_Bytes p = table; - OTL_Int result = 0; - OTL_UInt start, end, format, idx, value, shift; - - - start = OTL_NEXT_USHORT( p ); - end = OTL_NEXT_USHORT( p ); - format = OTL_NEXT_USHORT( p ); - - if ( size >= start && size <= end ) - { - /* we could do that with clever bit operations, but a switch is */ - /* much simpler to understand and maintain */ - /* */ - switch ( format ) - { - case 1: - idx = (OTL_UInt)( ( size - start ) * 2 ); - p += idx / 16; - value = OTL_PEEK_USHORT( p ); - shift = idx & 15; - result = (OTL_Int16)( value << shift ) >> ( 14 - shift ); - - break; - - case 2: - idx = (OTL_UInt)( ( size - start ) * 4 ); - p += idx / 16; - value = OTL_PEEK_USHORT( p ); - shift = idx & 15; - result = (OTL_Int16)( value << shift ) >> ( 12 - shift ); - - break; - - case 3: - idx = (OTL_UInt)( ( size - start ) * 8 ); - p += idx / 16; - value = OTL_PEEK_USHORT( p ); - shift = idx & 15; - result = (OTL_Int16)( value << shift ) >> ( 8 - shift ); - - break; - - default: - ; - } - } - - return result; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LOOKUPS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_lookup_validate( OTL_Bytes table, - OTL_UInt type_count, - OTL_ValidateFunc* type_funcs, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt lookup_type, lookup_flag, num_subtables; - OTL_ValidateFunc validate; - - - OTL_CHECK( 6 ); - lookup_type = OTL_NEXT_USHORT( p ); - lookup_flag = OTL_NEXT_USHORT( p ); - num_subtables = OTL_NEXT_USHORT( p ); - - if ( lookup_type == 0 || lookup_type >= type_count ) - OTL_INVALID_DATA; - - validate = type_funcs[lookup_type - 1]; - - OTL_CHECK( 2 * num_subtables ); - - /* scan subtables */ - for ( ; num_subtables > 0; num_subtables-- ) - validate( table + OTL_NEXT_USHORT( p ), lookup_count, glyph_count, - valid ); - } - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_lookup_get_count( OTL_Bytes table ) - { - OTL_Bytes p = table + 4; - - - return OTL_PEEK_USHORT( p ); - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_Bytes ) - otl_lookup_get_table( OTL_Bytes table, - OTL_UInt idx ) - { - OTL_Bytes p, result = 0; - OTL_UInt count; - - - p = table + 4; - count = OTL_NEXT_USHORT( p ); - if ( idx < count ) - { - p += idx * 2; - result = table + OTL_PEEK_USHORT( p ); - } - - return result; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LOOKUP LISTS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_lookup_list_validate( OTL_Bytes table, - OTL_UInt type_count, - OTL_ValidateFunc* type_funcs, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_lookups, count; - - - OTL_CHECK( 2 ); - num_lookups = OTL_NEXT_USHORT( p ); - OTL_CHECK( 2 * num_lookups ); - - /* scan lookup records */ - for ( count = num_lookups; count > 0; count-- ) - otl_lookup_validate( table + OTL_NEXT_USHORT( p ), - type_count, type_funcs, - num_lookups, glyph_count, valid ); - } - - - OTL_LOCALDEF( OTL_UInt ) - otl_lookup_list_get_count( OTL_Bytes table ) - { - OTL_Bytes p = table; - - - return OTL_PEEK_USHORT( p ); - } - - -#if 0 - OTL_LOCALDEF( OTL_Bytes ) - otl_lookup_list_get_lookup( OTL_Bytes table, - OTL_UInt idx ) - { - OTL_Bytes p, result = 0; - OTL_UInt count; - - - p = table; - count = OTL_NEXT_USHORT( p ); - if ( idx < count ) - { - p += idx * 2; - result = table + OTL_PEEK_USHORT( p ); - } - - return result; - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_Bytes ) - otl_lookup_list_get_table( OTL_Bytes table, - OTL_UInt lookup_index, - OTL_UInt table_index ) - { - OTL_Bytes result = 0; - - - result = otl_lookup_list_get_lookup( table, lookup_index ); - if ( result ) - result = otl_lookup_get_table( result, table_index ); - - return result; - } -#endif - - -#if 0 - OTL_LOCALDEF( void ) - otl_lookup_list_foreach( OTL_Bytes table, - OTL_ForeachFunc func, - OTL_Pointer func_data ) - { - OTL_Bytes p = table; - OTL_UInt count = OTL_NEXT_USHORT( p ); - - - for ( ; count > 0; count-- ) - func( table + OTL_NEXT_USHORT( p ), func_data ); - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** FEATURES *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_feature_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_lookups; - - - OTL_CHECK( 4 ); - p += 2; /* unused */ - num_lookups = OTL_NEXT_USHORT( p ); - OTL_CHECK( 2 * num_lookups ); - - for ( ; num_lookups > 0; num_lookups-- ) - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_feature_get_count( OTL_Bytes table ) - { - OTL_Bytes p = table + 4; - - - return OTL_PEEK_USHORT( p ); - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_feature_get_lookups( OTL_Bytes table, - OTL_UInt start, - OTL_UInt count, - OTL_UInt *lookups ) - { - OTL_Bytes p; - OTL_UInt num_features, result = 0; - - - p = table + 4; - num_features = OTL_NEXT_USHORT( p ); - - p += start * 2; - - for ( ; count > 0 && start < num_features; count--, start++ ) - { - lookups[0] = OTL_NEXT_USHORT(p); - lookups++; - result++; - } - - return result; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** FEATURE LIST *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_feature_list_validate( OTL_Bytes table, - OTL_Bytes lookups, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_features, lookup_count; - - - OTL_CHECK( 2 ); - num_features = OTL_NEXT_USHORT( p ); - OTL_CHECK( 2 * num_features ); - - lookup_count = otl_lookup_list_get_count( lookups ); - - /* scan feature records */ - for ( ; num_features > 0; num_features-- ) - { - p += 4; /* skip tag */ - - otl_feature_validate( table + OTL_NEXT_USHORT( p ), lookup_count, - valid ); - } - } - - - OTL_LOCALDEF( OTL_UInt ) - otl_feature_list_get_count( OTL_Bytes table ) - { - OTL_Bytes p = table; - - - return OTL_PEEK_USHORT( p ); - } - - -#if 0 - OTL_LOCALDEF( OTL_Bytes ) - otl_feature_list_get_feature( OTL_Bytes table, - OTL_UInt idx ) - { - OTL_Bytes p, result = 0; - OTL_UInt count; - - - p = table; - count = OTL_NEXT_USHORT( p ); - - if ( idx < count ) - { - p += idx * 2; - result = table + OTL_PEEK_USHORT( p ); - } - - return result; - } -#endif - - -#if 0 - OTL_LOCALDEF( void ) - otl_feature_list_foreach( OTL_Bytes table, - OTL_ForeachFunc func, - OTL_Pointer func_data ) - { - OTL_Bytes p; - OTL_UInt count; - - - p = table; - count = OTL_NEXT_USHORT( p ); - - for ( ; count > 0; count-- ) - func( table + OTL_NEXT_USHORT( p ), func_data ); - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LANGUAGE SYSTEM *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - - OTL_LOCALDEF( void ) - otl_lang_validate( OTL_Bytes table, - OTL_UInt feature_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt req_feature; - OTL_UInt num_features; - - - OTL_CHECK( 6 ); - - p += 2; /* unused */ - req_feature = OTL_NEXT_USHORT( p ); - num_features = OTL_NEXT_USHORT( p ); - - if ( req_feature != 0xFFFFU && req_feature >= feature_count ) - OTL_INVALID_DATA; - - OTL_CHECK( 2 * num_features ); - - for ( ; num_features > 0; num_features-- ) - if ( OTL_NEXT_USHORT( p ) >= feature_count ) - OTL_INVALID_DATA; - } - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_lang_get_count( OTL_Bytes table ) - { - OTL_Bytes p = table + 4; - - - return OTL_PEEK_USHORT( p ); - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_lang_get_req_feature( OTL_Bytes table ) - { - OTL_Bytes p = table + 2; - - - return OTL_PEEK_USHORT( p ); - } -#endif - - -#if 0 - OTL_LOCALDEF( OTL_UInt ) - otl_lang_get_features( OTL_Bytes table, - OTL_UInt start, - OTL_UInt count, - OTL_UInt *features ) - { - OTL_Bytes p = table + 4; - OTL_UInt num_features = OTL_NEXT_USHORT( p ); - OTL_UInt result = 0; - - - p += start * 2; - - for ( ; count > 0 && start < num_features; start++, count-- ) - { - features[0] = OTL_NEXT_USHORT( p ); - features++; - result++; - } - - return result; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** SCRIPTS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_script_validate( OTL_Bytes table, - OTL_UInt feature_count, - OTL_Validator valid ) - { - OTL_UInt default_lang, num_langs; - OTL_Bytes p = table; - - - OTL_CHECK( 4 ); - - default_lang = OTL_NEXT_USHORT( p ); - num_langs = OTL_NEXT_USHORT( p ); - - if ( default_lang != 0 ) - otl_lang_validate( table + default_lang, feature_count, valid ); - - OTL_CHECK( num_langs * 6 ); - - /* scan langsys records */ - for ( ; num_langs > 0; num_langs-- ) - { - p += 4; /* skip tag */ - - otl_lang_validate( table + OTL_NEXT_USHORT( p ), feature_count, valid ); - } - } - - - OTL_LOCALDEF( void ) - otl_script_list_validate( OTL_Bytes table, - OTL_Bytes features, - OTL_Validator valid ) - { - OTL_UInt num_scripts, feature_count; - OTL_Bytes p = table; - - - OTL_CHECK( 2 ); - num_scripts = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_scripts * 6 ); - - feature_count = otl_feature_list_get_count( features ); - - /* scan script records */ - for ( ; num_scripts > 0; num_scripts-- ) - { - p += 4; /* skip tag */ - - otl_script_validate( table + OTL_NEXT_USHORT( p ), feature_count, - valid ); - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** UTILITY FUNCTIONS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( OTL_UInt ) - otl_gsubgpos_get_lookup_count( OTL_Bytes table ) - { - OTL_Bytes p = table + 8; - - - return otl_lookup_list_get_count( table + OTL_PEEK_USHORT( p ) ); - } - - -/* END */ diff --git a/src/otlayout/otlcommn.h b/src/otlayout/otlcommn.h deleted file mode 100644 index 000d5abfe..000000000 --- a/src/otlayout/otlcommn.h +++ /dev/null @@ -1,326 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlcommn.h */ -/* */ -/* OpenType layout support, common tables (specification). */ -/* */ -/* Copyright 2002, 2004 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 __OTLCOMMN_H__ -#define __OTLCOMMN_H__ - -#include "otlayout.h" - -OTL_BEGIN_HEADER - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** COVERAGE TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* validate coverage table */ - OTL_LOCAL( void ) - otl_coverage_validate( OTL_Bytes table, - OTL_Validator valid ); - - /* return first covered glyph */ - OTL_LOCAL( OTL_UInt ) - otl_coverage_get_first( OTL_Bytes table ); - - /* return last covered glyph */ - OTL_LOCAL( OTL_UInt ) - otl_coverage_get_last( OTL_Bytes table ); - - /* return number of covered glyphs */ - OTL_LOCAL( OTL_UInt ) - otl_coverage_get_count( OTL_Bytes table ); - -#if 0 - /* Return the coverage index corresponding to a glyph glyph index. */ - /* Return -1 if the glyph isn't covered. */ - OTL_LOCAL( OTL_Long ) - otl_coverage_get_index( OTL_Bytes table, - OTL_UInt glyph_index ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** CLASS DEFINITION TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* validate class definition table */ - OTL_LOCAL( void ) - otl_class_definition_validate( OTL_Bytes table, - OTL_Validator valid ); - -#if 0 - /* return class value for a given glyph index */ - OTL_LOCAL( OTL_UInt ) - otl_class_definition_get_value( OTL_Bytes table, - OTL_UInt glyph_index ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** DEVICE TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* validate a device table */ - OTL_LOCAL( void ) - otl_device_table_validate( OTL_Bytes table, - OTL_Validator valid ); - -#if 0 - /* return a device table's first size */ - OTL_LOCAL( OTL_UInt ) - otl_device_table_get_start( OTL_Bytes table ); -#endif - -#if 0 - /* return a device table's last size */ - OTL_LOCAL( OTL_UInt ) - otl_device_table_get_end( OTL_Bytes table ); -#endif - -#if 0 - /* return pixel adjustment for a given size */ - OTL_LOCAL( OTL_Int ) - otl_device_table_get_delta( OTL_Bytes table, - OTL_UInt size ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LOOKUPS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCAL( void ) - otl_lookup_validate( OTL_Bytes table, - OTL_UInt type_count, - OTL_ValidateFunc* type_funcs, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ); - -#if 0 - /* return number of sub-tables in a lookup */ - OTL_LOCAL( OTL_UInt ) - otl_lookup_get_count( OTL_Bytes table ); -#endif - -#if 0 - /* return lookup sub-table */ - OTL_LOCAL( OTL_Bytes ) - otl_lookup_get_table( OTL_Bytes table, - OTL_UInt idx ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LOOKUP LISTS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* validate lookup list */ - OTL_LOCAL( void ) - otl_lookup_list_validate( OTL_Bytes table, - OTL_UInt type_count, - OTL_ValidateFunc* type_funcs, - OTL_UInt glyph_count, - OTL_Validator valid ); - - /* return number of lookups in list */ - OTL_LOCAL( OTL_UInt ) - otl_lookup_list_get_count( OTL_Bytes table ); - -#if 0 - /* return a given lookup from a list */ - OTL_LOCAL( OTL_Bytes ) - otl_lookup_list_get_lookup( OTL_Bytes table, - OTL_UInt idx ); -#endif - -#if 0 - /* return lookup sub-table from a list */ - OTL_LOCAL( OTL_Bytes ) - otl_lookup_list_get_table( OTL_Bytes table, - OTL_UInt lookup_index, - OTL_UInt table_index ); -#endif - -#if 0 - /* iterate over lookup list */ - OTL_LOCAL( void ) - otl_lookup_list_foreach( OTL_Bytes table, - OTL_ForeachFunc func, - OTL_Pointer func_data ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** FEATURES *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* validate feature table */ - OTL_LOCAL( void ) - otl_feature_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ); - -#if 0 - /* return feature's lookup count */ - OTL_LOCAL( OTL_UInt ) - otl_feature_get_count( OTL_Bytes table ); -#endif - -#if 0 - /* get several lookups indices from a feature. returns the number of */ - /* lookups grabbed */ - OTL_LOCAL( OTL_UInt ) - otl_feature_get_lookups( OTL_Bytes table, - OTL_UInt start, - OTL_UInt count, - OTL_UInt *lookups ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** FEATURE LIST *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* validate a feature list */ - /* lookups must already be validated */ - OTL_LOCAL( void ) - otl_feature_list_validate( OTL_Bytes table, - OTL_Bytes lookups, - OTL_Validator valid ); - - /* return number of features in list */ - OTL_LOCAL( OTL_UInt ) - otl_feature_list_get_count( OTL_Bytes table ); - -#if 0 - /* return a given feature from a list */ - OTL_LOCAL( OTL_Bytes ) - otl_feature_list_get_feature( OTL_Bytes table, - OTL_UInt idx ); -#endif - -#if 0 - /* iterate over all features in a list */ - OTL_LOCAL( void ) - otl_feature_list_foreach( OTL_Bytes table, - OTL_ForeachFunc func, - OTL_Pointer func_data ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LANGUAGE SYSTEM *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCAL( void ) - otl_lang_validate( OTL_Bytes table, - OTL_UInt feature_count, - OTL_Validator valid ); - -#if 0 - OTL_LOCAL( OTL_UInt ) - otl_lang_get_req_feature( OTL_Bytes table ); -#endif - -#if 0 - OTL_LOCAL( OTL_UInt ) - otl_lang_get_count( OTL_Bytes table ); -#endif - -#if 0 - OTL_LOCAL( OTL_UInt ) - otl_lang_get_features( OTL_Bytes table, - OTL_UInt start, - OTL_UInt count, - OTL_UInt *features ); -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** SCRIPTS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCAL( void ) - otl_script_validate( OTL_Bytes table, - OTL_UInt feature_count, - OTL_Validator valid ); - - /* validate a script list */ - /* features must already be validated */ - OTL_LOCAL( void ) - otl_script_list_validate( OTL_Bytes table, - OTL_Bytes features, - OTL_Validator valid ); - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** UTILITY FUNCTIONS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCAL( OTL_UInt ) - otl_gsubgpos_get_lookup_count( OTL_Bytes table ); - - /* */ - -OTL_END_HEADER - -#endif /* __OTLCOMMN_H__ */ - - -/* END */ diff --git a/src/otlayout/otlconf.h b/src/otlayout/otlconf.h deleted file mode 100644 index 3ef17a079..000000000 --- a/src/otlayout/otlconf.h +++ /dev/null @@ -1,78 +0,0 @@ -#ifndef __OT_LAYOUT_CONFIG_H__ -#define __OT_LAYOUT_CONFIG_H__ - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** CONFIGURATION MACROS *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - -#ifdef __cplusplus -# define OTL_BEGIN_HEADER extern "C" { -#else -# define OTL_BEGIN_HEADER /* nothing */ -#endif - -#ifdef __cplusplus -# define OTL_END_HEADER } -#else -# define OTL_END_HEADER /* nothing */ -#endif - -#ifndef OTL_API -# ifdef __cplusplus -# define OTL_API( x ) extern "C" -# else -# define OTL_API( x ) extern x -# endif -#endif - -#ifndef OTL_APIDEF -# define OTL_APIDEF( x ) x -#endif - -#ifndef OTL_LOCAL -# define OTL_LOCAL( x ) extern x -#endif - -#ifndef OTL_LOCALDEF -# define OTL_LOCALDEF( x ) x -#endif - -#define OTL_BEGIN_STMNT do { -#define OTL_END_STMNT } while (0) -#define OTL_DUMMY_STMNT OTL_BEGIN_STMNT OTL_END_STMNT - -#define OTL_UNUSED( x ) (x)=(x) -#define OTL_UNUSED_CONST(x) (void)(x) - - -#include -#if UINT_MAX == 0xFFFFU -# define OTL_SIZEOF_INT 2 -#elif UINT_MAX == 0xFFFFFFFFU -# define OTL_SIZEOF_INT 4 -#elif UINT_MAX > 0xFFFFFFFFU && UINT_MAX == 0xFFFFFFFFFFFFFFFFU -# define OTL_SIZEOF_INT 8 -#else -# error "unsupported number of bytes in 'int' type!" -#endif - -#if ULONG_MAX == 0xFFFFFFFFU -# define OTL_SIZEOF_LONG 4 -#elif ULONG_MAX > 0xFFFFFFFFU && ULONG_MAX == 0xFFFFFFFFFFFFFFFFU -# define OTL_SIZEOF_LONG 8 -#else -# error "unsupported number of bytes in 'long' type!" -#endif - -#include -#define OTL_jmp_buf jmp_buf -#define otl_setjmp setjmp -#define otl_longjmp longjmp - -/* */ - -#endif /* __OT_LAYOUT_CONFIG_H__ */ diff --git a/src/otlayout/otlgdef.c b/src/otlayout/otlgdef.c deleted file mode 100644 index b83ac2050..000000000 --- a/src/otlayout/otlgdef.c +++ /dev/null @@ -1,203 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlgdef.c */ -/* */ -/* OpenType layout support, GDEF table (body). */ -/* */ -/* Copyright 2002, 2004 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 "otlgdef.h" -#include "otlcommn.h" - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** ATTACHMENTS LIST *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_attach_point_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt count; - - - OTL_CHECK( 2 ); - - count = OTL_NEXT_USHORT( p ); - OTL_CHECK( count * 2 ); - } - - - static void - otl_attach_list_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_Bytes coverage; - OTL_UInt num_glyphs; - - - OTL_CHECK( 4 ); - - coverage = table + OTL_NEXT_USHORT( p ); - num_glyphs = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( coverage, valid ); - if ( num_glyphs != otl_coverage_get_count( coverage ) ) - OTL_INVALID_DATA; - - OTL_CHECK( num_glyphs * 2 ); - - /* scan attach point records */ - for ( ; num_glyphs > 0; num_glyphs-- ) - otl_attach_point_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** LIGATURE CARETS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_caret_value_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_Int format; - - - OTL_CHECK( 4 ); - - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - /* skip coordinate, no test */ - break; - - case 2: - /* skip contour point index, no test */ - break; - - case 3: - p += 2; /* skip coordinate */ - - OTL_CHECK( 2 ); - - otl_device_table_validate( table + OTL_PEEK_USHORT( p ), valid ); - break; - - default: - OTL_INVALID_DATA; - } - } - - - static void - otl_ligature_glyph_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_carets; - - - OTL_CHECK( 2 ); - num_carets = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_carets * 2 ); - - /* scan caret value records */ - for ( ; num_carets > 0; num_carets-- ) - otl_caret_value_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - - - static void - otl_ligature_caret_list_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_Bytes coverage; - OTL_UInt num_ligglyphs; - - - OTL_CHECK( 4 ); - - coverage = table + OTL_NEXT_USHORT( p ); - num_ligglyphs = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( coverage, valid ); - if ( num_ligglyphs != otl_coverage_get_count( coverage ) ) - OTL_INVALID_DATA; - - OTL_CHECK( num_ligglyphs * 2 ); - - /* scan ligature glyph records */ - for ( ; num_ligglyphs > 0; num_ligglyphs-- ) - otl_ligature_glyph_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GDEF TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_APIDEF( void ) - otl_gdef_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt val; - - - OTL_CHECK( 12 ); - - /* check format */ - if ( OTL_NEXT_ULONG( p ) != 0x00010000UL ) - OTL_INVALID_FORMAT; - - /* validate glyph class definition table */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_class_definition_validate( table + val, valid ); - - /* validate attachment point list */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_attach_list_validate( table + val, valid ); - - /* validate ligature caret list */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_ligature_caret_list_validate( table + val, valid ); - - /* validate mark attachment class definition table */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_class_definition_validate( table + val, valid ); - } - - -/* END */ diff --git a/src/otlayout/otlgdef.h b/src/otlayout/otlgdef.h deleted file mode 100644 index dc7d41bb2..000000000 --- a/src/otlayout/otlgdef.h +++ /dev/null @@ -1,41 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlgdef.h */ -/* */ -/* OpenType layout support, GDEF table (specification). */ -/* */ -/* Copyright 2002, 2004 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 __OTLGDEF_H__ -#define __OTLGDEF_H__ - -#include "otlayout.h" - -#if 0 -#include "otltable.h" -#endif - -OTL_BEGIN_HEADER - - - OTL_API( void ) - otl_gdef_validate( OTL_Bytes table, - OTL_Validator valid ); - - -OTL_END_HEADER - -#endif /* __OTLGDEF_H__ */ - - -/* END */ diff --git a/src/otlayout/otlgpos.c b/src/otlayout/otlgpos.c deleted file mode 100644 index 29d8a245e..000000000 --- a/src/otlayout/otlgpos.c +++ /dev/null @@ -1,1102 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlgpos.c */ -/* */ -/* OpenType layout support, GPOS table (body). */ -/* */ -/* Copyright 2002, 2004 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 "otlgpos.h" -#include "otlcommn.h" - - - /* forward declaration */ - static OTL_ValidateFunc otl_gpos_validate_funcs[]; - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** VALUE RECORDS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static OTL_UInt - otl_value_length( OTL_UInt format ) - { - OTL_UInt count; - - - count = ( ( format & 0xAA ) >> 1 ) + ( format & 0x55 ); - count = ( ( count & 0xCC ) >> 2 ) + ( count & 0x33 ); - count = ( ( count & 0xF0 ) >> 4 ) + ( count & 0x0F ); - - return count * 2; - } - - - static void - otl_value_validate( OTL_Bytes table, - OTL_Bytes pos_table, - OTL_UInt format, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt count, device; - - - if ( format >= 0x100 ) - OTL_INVALID_DATA; - - for ( count = 4; count > 0; count-- ) - { - if ( format & 1 ) - { - OTL_CHECK( 2 ); - p += 2; - } - - format >>= 1; - } - - for ( count = 4; count > 0; count-- ) - { - if ( format & 1 ) - { - OTL_CHECK( 2 ); - device = OTL_NEXT_USHORT( p ); - if ( device ) - otl_device_table_validate( pos_table + device, valid ); - } - format >>= 1; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** ANCHORS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_anchor_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - - OTL_CHECK( 6 ); - format = OTL_NEXT_USHORT( p ); - p += 4; /* skip coordinates */ - - switch ( format ) - { - case 1: - break; - - case 2: - OTL_CHECK( 2 ); /* anchor point */ - break; - - case 3: - { - OTL_UInt x_device, y_device; - - - OTL_CHECK( 4 ); - x_device = OTL_NEXT_USHORT( p ); - y_device = OTL_NEXT_USHORT( p ); - - if ( x_device ) - otl_device_table_validate( table + x_device, valid ); - - if ( y_device ) - otl_device_table_validate( table + y_device, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** MARK ARRAY *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_mark_array_validate( OTL_Bytes table, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt count; - - OTL_CHECK( 2 ); - - count = OTL_NEXT_USHORT( p ); - OTL_CHECK( count * 4 ); - for ( ; count > 0; count-- ) - { - p += 2; /* ignore class index */ - otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 1 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gpos_lookup1_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, value_format; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - value_format = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - otl_value_validate( p, table, value_format, valid ); - } - break; - - case 2: - { - OTL_UInt coverage, value_format, num_values, len_value; - - - OTL_CHECK( 6 ); - coverage = OTL_NEXT_USHORT( p ); - value_format = OTL_NEXT_USHORT( p ); - num_values = OTL_NEXT_USHORT( p ); - - len_value = otl_value_length( value_format ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_values * len_value ); - - /* scan value records */ - for ( ; num_values > 0; num_values-- ) - { - otl_value_validate( p, table, value_format, valid ); - p += len_value; - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 2 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gpos_pairset_validate( OTL_Bytes table, - OTL_Bytes pos_table, - OTL_UInt format1, - OTL_UInt format2, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt value_len1, value_len2, num_pairvalues; - - - OTL_CHECK( 2 ); - num_pairvalues = OTL_NEXT_USHORT( p ); - value_len1 = otl_value_length( format1 ); - value_len2 = otl_value_length( format2 ); - - OTL_CHECK( num_pairvalues * ( value_len1 + value_len2 + 2 ) ); - - /* scan pair value records */ - for ( ; num_pairvalues > 0; num_pairvalues-- ) - { - p += 2; /* ignore glyph id */ - - otl_value_validate( p, pos_table, format1, valid ); - p += value_len1; - - otl_value_validate( p, pos_table, format2, valid ); - p += value_len2; - } - } - - - static void - otl_gpos_lookup2_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, value1, value2, num_pairsets; - - - OTL_CHECK( 8 ); - coverage = OTL_NEXT_USHORT( p ); - value1 = OTL_NEXT_USHORT( p ); - value2 = OTL_NEXT_USHORT( p ); - num_pairsets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_pairsets * 2 ); - - for ( ; num_pairsets > 0; num_pairsets-- ) - otl_gpos_pairset_validate( table + OTL_NEXT_USHORT( p ), - table, value1, value2, valid ); - } - break; - - case 2: - { - OTL_UInt coverage, value1, value2, class1, class2; - OTL_UInt num_classes1, num_classes2, len_value1, len_value2, count; - - - OTL_CHECK( 14 ); - coverage = OTL_NEXT_USHORT( p ); - value1 = OTL_NEXT_USHORT( p ); - value2 = OTL_NEXT_USHORT( p ); - class1 = OTL_NEXT_USHORT( p ); - class2 = OTL_NEXT_USHORT( p ); - num_classes1 = OTL_NEXT_USHORT( p ); - num_classes2 = OTL_NEXT_USHORT( p ); - - len_value1 = otl_value_length( value1 ); - len_value2 = otl_value_length( value2 ); - - otl_coverage_validate( table + coverage, valid ); - otl_class_definition_validate( table + class1, valid ); - otl_class_definition_validate( table + class2, valid ); - - OTL_CHECK( num_classes1 * num_classes2 * - ( len_value1 + len_value2 ) ); - - for ( ; num_classes1 > 0; num_classes1-- ) - { - for ( count = num_classes2; count > 0; count-- ) - { - otl_value_validate( p, table, value1, valid ); - p += len_value1; - - otl_value_validate( p, table, value2, valid ); - p += len_value2; - } - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 3 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gpos_lookup3_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_entryexit, anchor1, anchor2; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_entryexit = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_entryexit * 4 ); - - /* scan entry-exit records */ - for ( ; num_entryexit > 0; num_entryexit-- ) - { - anchor1 = OTL_NEXT_USHORT( p ); - anchor2 = OTL_NEXT_USHORT( p ); - - if ( anchor1 ) - otl_anchor_validate( table + anchor1, valid ); - - if ( anchor2 ) - otl_anchor_validate( table + anchor2, valid ); - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 4 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_base_array_validate( OTL_Bytes table, - OTL_UInt class_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_bases, count; - - - OTL_CHECK( 2 ); - num_bases = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_bases * class_count * 2 ); - - /* scan base array records */ - for ( ; num_bases > 0; num_bases-- ) - /* scan base records */ - for ( count = class_count; count > 0; count-- ) - otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid ); - } - - - static void - otl_gpos_lookup4_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt mark_coverage, base_coverage, num_classes; - OTL_UInt mark_array, base_array; - - - OTL_CHECK( 10 ); - mark_coverage = OTL_NEXT_USHORT( p ); - base_coverage = OTL_NEXT_USHORT( p ); - num_classes = OTL_NEXT_USHORT( p ); - mark_array = OTL_NEXT_USHORT( p ); - base_array = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + mark_coverage, valid ); - otl_coverage_validate( table + base_coverage, valid ); - - otl_mark_array_validate( table + mark_array, valid ); - otl_base_array_validate( table + base_array, num_classes, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 5 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* used by lookup type 5 and 6 */ - static void - otl_liga_mark2_validate( OTL_Bytes table, - OTL_UInt class_count, - OTL_Bool maybe_zero, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_components, count; - - - OTL_CHECK( 2 ); - num_components = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_components * class_count * 2 ); - - /* scan component records */ - for ( ; num_components > 0; num_components-- ) - /* scan ligature anchor records */ - for ( count = class_count; count > 0; count-- ) - { - OTL_UInt offset = OTL_NEXT_USHORT( p ); - - - if ( !offset && maybe_zero ) - continue; - - otl_anchor_validate( table + offset, valid ); - } - } - - - static void - otl_liga_array_validate( OTL_Bytes table, - OTL_UInt class_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt ligature_count; - - - OTL_CHECK( 2 ); - ligature_count = OTL_NEXT_USHORT( p ); - - OTL_CHECK( ligature_count * 2 ); - - /* scan ligature attach records */ - for ( ; ligature_count > 0; ligature_count-- ) - otl_liga_mark2_validate( table + OTL_NEXT_USHORT( p ), class_count, 1, - valid ); - } - - - static void - otl_gpos_lookup5_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt mark_coverage, liga_coverage, num_classes; - OTL_UInt mark_array, liga_array; - - - OTL_CHECK( 10 ); - mark_coverage = OTL_NEXT_USHORT( p ); - liga_coverage = OTL_NEXT_USHORT( p ); - num_classes = OTL_NEXT_USHORT( p ); - mark_array = OTL_NEXT_USHORT( p ); - liga_array = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + mark_coverage, valid ); - otl_coverage_validate( table + liga_coverage, valid ); - - otl_mark_array_validate( table + mark_array, valid ); - otl_liga_array_validate( table + liga_array, num_classes, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 6 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gpos_lookup6_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage1, coverage2, num_classes, array1, array2; - - - OTL_CHECK( 10 ); - coverage1 = OTL_NEXT_USHORT( p ); - coverage2 = OTL_NEXT_USHORT( p ); - num_classes = OTL_NEXT_USHORT( p ); - array1 = OTL_NEXT_USHORT( p ); - array2 = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage1, valid ); - otl_coverage_validate( table + coverage2, valid ); - - otl_mark_array_validate( table + array1, valid ); - otl_liga_mark2_validate( table + array2, num_classes, 0, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 7 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* used for both format 1 and 2 */ - static void - otl_pos_rule_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_glyphs, num_pos; - - - OTL_CHECK( 4 ); - num_glyphs = OTL_NEXT_USHORT( p ); - num_pos = OTL_NEXT_USHORT( p ); - - if ( num_glyphs == 0 ) - OTL_INVALID_DATA; - - OTL_CHECK( ( num_glyphs - 1 ) * 2 + num_pos * 4 ); - - for ( ; num_pos > 0; num_pos-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - - /* no need to check glyph indices/classes used as input for this */ - /* context rule since even invalid glyph indices/classes return a */ - /* meaningful result */ - } - - - /* used for both format 1 and 2 */ - static void - otl_pos_rule_set_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_posrules; - - - OTL_CHECK( 2 ); - num_posrules = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_posrules * 2 ); - - /* scan posrule records */ - for ( ; num_posrules > 0; num_posrules-- ) - otl_pos_rule_validate( table + OTL_NEXT_USHORT( p ), lookup_count, - valid ); - } - - - static void - otl_gpos_lookup7_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_posrule_sets; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_posrule_sets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_posrule_sets * 2 ); - - /* scan posrule set records */ - for ( ; num_posrule_sets > 0; num_posrule_sets-- ) - otl_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, valid ); - } - break; - - case 2: - { - OTL_UInt coverage, class_def, num_posclass_sets; - - - OTL_CHECK( 6 ); - coverage = OTL_NEXT_USHORT( p ); - class_def = OTL_NEXT_USHORT( p ); - num_posclass_sets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - otl_class_definition_validate( table + class_def, valid ); - - OTL_CHECK( num_posclass_sets * 2 ); - - /* scan pos class set rules */ - for ( ; num_posclass_sets > 0; num_posclass_sets-- ) - { - OTL_UInt offset = OTL_NEXT_USHORT( p ); - - - if ( offset ) - otl_pos_rule_set_validate( table + offset, lookup_count, valid ); - } - } - break; - - case 3: - { - OTL_UInt num_glyphs, num_pos, count; - - - OTL_CHECK( 4 ); - num_glyphs = OTL_NEXT_USHORT( p ); - num_pos = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_glyphs * 2 + num_pos * 4 ); - - for ( count = num_glyphs; count > 0; count-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - for ( ; num_pos > 0; num_pos-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 8 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* used for both format 1 and 2 */ - static void - otl_chain_pos_rule_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_backtrack_glyphs, num_input_glyphs, num_lookahead_glyphs; - OTL_UInt num_pos; - - - OTL_CHECK( 2 ); - num_backtrack_glyphs = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_backtrack_glyphs * 2 + 2 ); - p += num_backtrack_glyphs * 2; - - num_input_glyphs = OTL_NEXT_USHORT( p ); - if ( num_input_glyphs == 0 ) - OTL_INVALID_DATA; - - OTL_CHECK( num_input_glyphs * 2 ); - p += ( num_input_glyphs - 1 ) * 2; - - num_lookahead_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookahead_glyphs * 2 + 2 ); - p += num_lookahead_glyphs * 2; - - num_pos = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_pos * 4 ); - - for ( ; num_pos > 0; num_pos-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_input_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - - /* no need to check glyph indices/classes used as input for this */ - /* context rule since even invalid glyph indices/classes return a */ - /* meaningful result */ - } - - - /* used for both format 1 and 2 */ - static void - otl_chain_pos_rule_set_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_chain_subrules; - - - OTL_CHECK( 2 ); - num_chain_subrules = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_chain_subrules * 2 ); - - /* scan chain pos rule records */ - for ( ; num_chain_subrules > 0; num_chain_subrules-- ) - otl_chain_pos_rule_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, valid ); - } - - - static void - otl_gpos_lookup8_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_chain_pos_rulesets; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_chain_pos_rulesets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_chain_pos_rulesets * 2 ); - - /* scan chain pos ruleset records */ - for ( ; num_chain_pos_rulesets > 0; num_chain_pos_rulesets-- ) - otl_chain_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, valid ); - } - break; - - case 2: - { - OTL_UInt coverage, back_class, input_class, ahead_class; - OTL_UInt num_chainpos_class_sets; - - - OTL_CHECK( 10 ); - coverage = OTL_NEXT_USHORT( p ); - back_class = OTL_NEXT_USHORT( p ); - input_class = OTL_NEXT_USHORT( p ); - ahead_class = OTL_NEXT_USHORT( p ); - num_chainpos_class_sets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - otl_class_definition_validate( table + back_class, valid ); - otl_class_definition_validate( table + input_class, valid ); - otl_class_definition_validate( table + ahead_class, valid ); - - OTL_CHECK( num_chainpos_class_sets * 2 ); - - /* scan chainpos class set records */ - for ( ; num_chainpos_class_sets > 0; num_chainpos_class_sets-- ) - { - OTL_UInt offset = OTL_NEXT_USHORT( p ); - - - if ( offset ) - otl_chain_pos_rule_set_validate( table + offset, lookup_count, - valid ); - } - } - break; - - case 3: - { - OTL_UInt num_backtrack_glyphs, num_input_glyphs; - OTL_UInt num_lookahead_glyphs, num_pos, count; - - - OTL_CHECK( 2 ); - - num_backtrack_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_backtrack_glyphs * 2 + 2 ); - - for ( ; num_backtrack_glyphs > 0; num_backtrack_glyphs-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_input_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_input_glyphs * 2 + 2 ); - - for ( count = num_input_glyphs; count > 0; count-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_lookahead_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookahead_glyphs * 2 + 2 ); - - for ( ; num_lookahead_glyphs > 0; num_lookahead_glyphs-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_pos = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_pos * 4 ); - - for ( ; num_pos > 0; num_pos-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_input_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS LOOKUP TYPE 9 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gpos_lookup9_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt lookup_type, lookup_offset; - OTL_ValidateFunc validate; - - - OTL_CHECK( 6 ); - lookup_type = OTL_NEXT_USHORT( p ); - lookup_offset = OTL_NEXT_ULONG( p ); - - if ( lookup_type == 0 || lookup_type >= 9 ) - OTL_INVALID_DATA; - - validate = otl_gpos_validate_funcs[lookup_type - 1]; - validate( table + lookup_offset, lookup_count, glyph_count, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - static OTL_ValidateFunc otl_gpos_validate_funcs[9] = - { - otl_gpos_lookup1_validate, - otl_gpos_lookup2_validate, - otl_gpos_lookup3_validate, - otl_gpos_lookup4_validate, - otl_gpos_lookup5_validate, - otl_gpos_lookup6_validate, - otl_gpos_lookup7_validate, - otl_gpos_lookup8_validate, - otl_gpos_lookup9_validate - }; - - - OTL_LOCALDEF( void ) - otl_gpos_subtable_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - otl_lookup_validate( table, 9, otl_gpos_validate_funcs, - lookup_count, glyph_count, valid ); - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GPOS TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_gpos_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt scripts, features, lookups; - - - OTL_CHECK( 10 ); - - if ( OTL_NEXT_USHORT( p ) != 0x10000UL ) - OTL_INVALID_DATA; - - scripts = OTL_NEXT_USHORT( p ); - features = OTL_NEXT_USHORT( p ); - lookups = OTL_NEXT_USHORT( p ); - - otl_lookup_list_validate( table + lookups, 9, otl_gpos_validate_funcs, - glyph_count, valid ); - otl_feature_list_validate( table + features, table + lookups, valid ); - otl_script_list_validate( table + scripts, table + features, valid ); - } - - -/* END */ diff --git a/src/otlayout/otlgpos.h b/src/otlayout/otlgpos.h deleted file mode 100644 index 3b6fc05e1..000000000 --- a/src/otlayout/otlgpos.h +++ /dev/null @@ -1,44 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlgpos.h */ -/* */ -/* OpenType layout support, GPOS table (specification). */ -/* */ -/* Copyright 2002, 2004 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 __OTLGPOS_H__ -#define __OTLGPOS_H__ - -#include "otlayout.h" - -OTL_BEGIN_HEADER - - - OTL_LOCAL( void ) - otl_gpos_subtable_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ); - - OTL_LOCAL( void ) - otl_gpos_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ); - - -OTL_END_HEADER - -#endif /* __OTLGPOS_H__ */ - - -/* END */ diff --git a/src/otlayout/otlgsub.c b/src/otlayout/otlgsub.c deleted file mode 100644 index ca41d6d57..000000000 --- a/src/otlayout/otlgsub.c +++ /dev/null @@ -1,1069 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlgsub.c */ -/* */ -/* OpenType layout support, GSUB table (body). */ -/* */ -/* Copyright 2002, 2004 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 "otlgsub.h" -#include "otlcommn.h" -#include "otlparse.h" - - - /* forward declaration */ - static OTL_ValidateFunc otl_gsub_validate_funcs[]; - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 1 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* - * 1: Single Substitution - Table format(s) - * - * This table is used to substitute individual glyph indices - * with another one. There are only two sub-formats: - * - * Name Offset Size Description - * -------------------------------------------------------------- - * format 0 2 sub-table format (1) - * offset 2 2 offset to coverage table - * delta 4 2 16-bit delta to apply on all - * covered glyph indices - * - * Name Offset Size Description - * -------------------------------------------------------------- - * format 0 2 sub-table format (2) - * offset 2 2 offset to coverage table - * count 4 2 coverage table count - * substs[] 6 2*count substituted glyph indices, - * - */ - - static void - otl_gsub_lookup1_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - - switch ( format ) - { - case 1: - { - OTL_Bytes coverage; - OTL_Int delta; - OTL_Long idx; - - - OTL_CHECK( 4 ); - coverage = table + OTL_NEXT_USHORT( p ); - delta = OTL_NEXT_SHORT( p ); - - otl_coverage_validate( coverage, valid ); - - idx = otl_coverage_get_first( coverage ) + delta; - if ( idx < 0 ) - OTL_INVALID_DATA; - - idx = otl_coverage_get_last( coverage ) + delta; - if ( (OTL_UInt)idx >= glyph_count ) - OTL_INVALID_DATA; - } - break; - - case 2: - { - OTL_UInt coverage, num_glyphs; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_glyphs = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_glyphs * 2 ); - - for ( ; num_glyphs > 0; num_glyphs-- ) - if ( OTL_NEXT_USHORT( p ) >= glyph_count ) - OTL_INVALID_DATA; - } - break; - - default: - OTL_INVALID_DATA; - } - } - - -#if 0 - static OTL_Bool - otl_gsub_lookup1_apply( OTL_Bytes table, - OTL_Parser parser ) - { - OTL_Bytes p = table; - OTL_Bytes coverage; - OTL_UInt format, gindex, property; - OTL_Long index; - OTL_Bool subst = 0; - - - if ( parser->context_len != 0xFFFFU && parser->context_len < 1 ) - goto Exit; - - gindex = otl_parser_get_gindex( parser ); - - otl_parser_check_property( parser, gindex, &property ); - if ( parser->error ) - goto Exit; - - format = OTL_NEXT_USHORT(p); - coverage = table + OTL_NEXT_USHORT(p); - index = otl_coverage_get_index( coverage, gindex ); - - if ( index >= 0 ) - { - switch ( format ) - { - case 1: - { - OTL_Int delta = OTL_NEXT_SHORT( p ); - - - gindex = ( gindex + delta ) & 0xFFFFU; - otl_parser_replace_1( parser, gindex ); - subst = 1; - } - break; - - case 2: - { - OTL_UInt count = OTL_NEXT_USHORT( p ); - - - if ( (OTL_UInt)index < count ) - { - p += index * 2; - otl_parser_replace_1( parser, OTL_PEEK_USHORT( p ) ); - subst = 1; - } - } - break; - - default: - ; - } - } - - Exit: - return subst; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 2 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* - * 2: Multiple Substitution - Table format(s) - * - * Replaces a single glyph with one or more glyphs. - * - * Name Offset Size Description - * -------------------------------------------------------------- - * format 0 2 sub-table format (1) - * offset 2 2 offset to coverage table - * count 4 2 coverage table count - * sequencess[] 6 2*count offsets to sequence items - * - * each sequence item has the following format: - * - * Name Offset Size Description - * -------------------------------------------------------------- - * count 0 2 number of replacement glyphs - * gindices[] 2 2*count string of glyph indices - * - */ - - static void - otl_sequence_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_glyphs; - - - OTL_CHECK( 2 ); - num_glyphs = OTL_NEXT_USHORT( p ); - - /* according to the specification, `num_glyphs' should be > 0; */ - /* we can deal with these cases pretty well, however */ - - OTL_CHECK( num_glyphs * 2 ); - - for ( ; num_glyphs > 0; num_glyphs-- ) - if ( OTL_NEXT_USHORT( p ) >= glyph_count ) - OTL_INVALID_DATA; - } - - - static void - otl_gsub_lookup2_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_sequences; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_sequences = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_sequences * 2 ); - - /* scan sequence records */ - for ( ; num_sequences > 0; num_sequences-- ) - otl_sequence_validate( table + OTL_NEXT_USHORT( p ), glyph_count, - valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - -#if 0 - static OTL_Bool - otl_gsub_lookup2_apply( OTL_Bytes table, - OTL_Parser parser ) - { - OTL_Bytes p = table; - OTL_Bytes coverage, sequence; - OTL_UInt format, gindex, property, context_len, seq_count, count; - OTL_Long index; - OTL_Bool subst = 0; - - - if ( parser->context_len != 0xFFFFU && parser->context_len < 1 ) - goto Exit; - - gindex = otl_parser_get_gindex( parser ); - - otl_parser_check_property( parser, gindex, &property ); - if ( parser->error ) - goto Exit; - - p += 2; /* skip format */ - coverage = table + OTL_NEXT_USHORT( p ); - seq_count = OTL_NEXT_USHORT( p ); - index = otl_coverage_get_index( coverage, gindex ); - - if ( (OTL_UInt)index >= seq_count || index < 0 ) - goto Exit; - - p += index * 2; - sequence = table + OTL_PEEK_USHORT( p ); - p = sequence; - count = OTL_NEXT_USHORT( p ); - - otl_parser_replace_n( parser, count, p ); - subst = 1; - - Exit: - return subst; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 3 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* - * 3: Alternate Substitution - Table format(s) - * - * Replaces a single glyph by another one taken liberally - * in a list of alternatives. - * - * Name Offset Size Description - * --------------------------------------------------------------- - * format 0 2 sub-table format (1) - * offset 2 2 offset to coverage table - * count 4 2 coverage table count - * alternates[] 6 2*count offsets to alternate items - * - * each alternate item has the following format: - * - * Name Offset Size Description - * --------------------------------------------------------------- - * count 0 2 number of replacement glyphs - * gindices[] 2 2*count string of glyph indices, each - * one is a valid alternative - * - */ - - static void - otl_alternate_set_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_glyphs; - - - OTL_CHECK( 2 ); - num_glyphs = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_glyphs * 2 ); - - for ( ; num_glyphs > 0; num_glyphs-- ) - if ( OTL_NEXT_USHORT( p ) >= glyph_count ) - OTL_INVALID_DATA; - } - - - static void - otl_gsub_lookup3_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_alternate_sets; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_alternate_sets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_alternate_sets * 2 ); - - /* scan alternate set records */ - for ( ; num_alternate_sets > 0; num_alternate_sets-- ) - otl_alternate_set_validate( table + OTL_NEXT_USHORT( p ), - glyph_count, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - -#if 0 - static OTL_Bool - otl_gsub_lookup3_apply( OTL_Bytes table, - OTL_Parser parser ) - { - OTL_Bytes p = table; - OTL_Bytes coverage, alternates; - OTL_UInt format, gindex, property, seq_count, count; - OTL_Long index; - OTL_Bool subst = 0; - - OTL_GSUB_Alternate alternate = parser->alternate; - - - if ( parser->context_len != 0xFFFFU && parser->context_len < 1 ) - goto Exit; - - if ( alternate == 0 ) - goto Exit; - - gindex = otl_parser_get_gindex( parser ); - - otl_parser_check_property( parser, gindex, &property ); - if ( parser->error ) - goto Exit; - - p += 2; /* skip format */ - coverage = table + OTL_NEXT_USHORT( p ); - seq_count = OTL_NEXT_USHORT( p ); - index = otl_coverage_get_index( coverage, gindex ); - - if ( (OTL_UInt)index >= seq_count || index < 0 ) - goto Exit; - - p += index * 2; - alternates = table + OTL_PEEK_USHORT( p ); - p = alternates; - count = OTL_NEXT_USHORT( p ); - - gindex = alternate->handler_func( - gindex, count, p, alternate->handler_data ); - - otl_parser_replace_1( parser, gindex ); - subst = 1; - - Exit: - return subst; - } -#endif - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 4 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_ligature_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt glyph_id, num_components; - - - OTL_CHECK( 4 ); - glyph_id = OTL_NEXT_USHORT( p ); - if ( glyph_id >= glyph_count ) - OTL_INVALID_DATA; - - num_components = OTL_NEXT_USHORT( p ); - - if ( num_components == 0 ) - OTL_INVALID_DATA; - - num_components--; - - OTL_CHECK( num_components * 2 ); - } - - - static void - otl_ligature_set_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_ligatures; - - - OTL_CHECK( 2 ); - num_ligatures = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_ligatures * 2 ); - - /* scan ligature records */ - for ( ; num_ligatures > 0; num_ligatures-- ) - otl_ligature_validate( table + OTL_NEXT_USHORT( p ), glyph_count, - valid ); - } - - - static void - otl_gsub_lookup4_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( lookup_count); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_ligsets; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_ligsets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_ligsets * 2 ); - - /* scan ligature set records */ - for ( ; num_ligsets > 0; num_ligsets-- ) - otl_ligature_set_validate( table + OTL_NEXT_USHORT( p ), - glyph_count, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 5 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* used for both format 1 and 2 */ - static void - otl_sub_rule_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_glyphs, num_subst; - - - OTL_CHECK( 4 ); - num_glyphs = OTL_NEXT_USHORT( p ); - num_subst = OTL_NEXT_USHORT( p ); - - if ( num_glyphs == 0 ) - OTL_INVALID_DATA; - - OTL_CHECK( ( num_glyphs - 1 ) * 2 + num_subst * 4 ); - - for ( ; num_subst > 0; num_subst-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - - /* no need to check glyph indices/classes used as input for this */ - /* context rule since even invalid glyph indices/classes return a */ - /* meaningful result */ - } - - - /* used for both format 1 and 2 */ - static void - otl_sub_rule_set_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_subrules; - - - OTL_CHECK( 2 ); - num_subrules = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_subrules * 2 ); - - /* scan subrule records */ - for ( ; num_subrules > 0; num_subrules-- ) - otl_sub_rule_validate( table + OTL_NEXT_USHORT( p ), lookup_count, - valid ); - } - - - static void - otl_gsub_lookup5_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_subrulesets; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_subrulesets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_subrulesets * 2 ); - - /* scan subrule set records */ - for ( ; num_subrulesets > 0; num_subrulesets-- ) - otl_sub_rule_set_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, valid ); - } - break; - - case 2: - { - OTL_UInt coverage, class_def, num_subclass_sets; - - - OTL_CHECK( 6 ); - coverage = OTL_NEXT_USHORT( p ); - class_def = OTL_NEXT_USHORT( p ); - num_subclass_sets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - otl_class_definition_validate( table + class_def, valid ); - - OTL_CHECK( num_subclass_sets * 2 ); - - /* scan subclass set records */ - for ( ; num_subclass_sets > 0; num_subclass_sets-- ) - { - OTL_UInt offset = OTL_NEXT_USHORT( p ); - - - if ( offset ) - otl_sub_rule_set_validate( table + offset, lookup_count, valid ); - } - } - break; - - case 3: - { - OTL_UInt num_glyphs, num_subst, count; - - - OTL_CHECK( 4 ); - num_glyphs = OTL_NEXT_USHORT( p ); - num_subst = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_glyphs * 2 + num_subst * 4 ); - - for ( count = num_glyphs; count > 0; count-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - for ( ; num_subst > 0; num_subst-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 6 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* used for both format 1 and 2 */ - static void - otl_chain_sub_rule_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_backtrack_glyphs, num_input_glyphs, num_lookahead_glyphs; - OTL_UInt num_subst; - - - OTL_CHECK( 2 ); - num_backtrack_glyphs = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_backtrack_glyphs * 2 + 2 ); - p += num_backtrack_glyphs * 2; - - num_input_glyphs = OTL_NEXT_USHORT( p ); - if ( num_input_glyphs == 0 ) - OTL_INVALID_DATA; - - OTL_CHECK( num_input_glyphs * 2 ); - p += ( num_input_glyphs - 1 ) * 2; - - num_lookahead_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookahead_glyphs * 2 + 2 ); - p += num_lookahead_glyphs * 2; - - num_subst = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_subst * 4 ); - - for ( ; num_subst > 0; num_subst-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_input_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - - /* no need to check glyph indices/classes used as input for this */ - /* context rule since even invalid glyph indices/classes return a */ - /* meaningful result */ - } - - - /* used for both format 1 and 2 */ - static void - otl_chain_sub_rule_set_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_chain_subrules; - - - OTL_CHECK( 2 ); - num_chain_subrules = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_chain_subrules * 2 ); - - /* scan chain subst rule records */ - for ( ; num_chain_subrules > 0; num_chain_subrules-- ) - otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, valid ); - } - - - static void - otl_gsub_lookup6_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - OTL_UNUSED( glyph_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt coverage, num_chain_subrulesets; - - - OTL_CHECK( 4 ); - coverage = OTL_NEXT_USHORT( p ); - num_chain_subrulesets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - OTL_CHECK( num_chain_subrulesets * 2 ); - - /* scan chain subrule set records */ - for ( ; num_chain_subrulesets > 0; num_chain_subrulesets-- ) - otl_chain_sub_rule_set_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, valid ); - } - break; - - case 2: - { - OTL_UInt coverage, back_class, input_class, ahead_class; - OTL_UInt num_chain_subclass_sets; - - - OTL_CHECK( 10 ); - coverage = OTL_NEXT_USHORT( p ); - back_class = OTL_NEXT_USHORT( p ); - input_class = OTL_NEXT_USHORT( p ); - ahead_class = OTL_NEXT_USHORT( p ); - num_chain_subclass_sets = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( table + coverage, valid ); - - otl_class_definition_validate( table + back_class, valid ); - otl_class_definition_validate( table + input_class, valid ); - otl_class_definition_validate( table + ahead_class, valid ); - - OTL_CHECK( num_chain_subclass_sets * 2 ); - - /* scan chain subclass set records */ - for ( ; num_chain_subclass_sets > 0; num_chain_subclass_sets-- ) - { - OTL_UInt offset = OTL_NEXT_USHORT( p ); - - - if ( offset ) - otl_chain_sub_rule_set_validate( table + offset, lookup_count, - valid ); - } - } - break; - - case 3: - { - OTL_UInt num_backtrack_glyphs, num_input_glyphs; - OTL_UInt num_lookahead_glyphs, num_subst, count; - - - OTL_CHECK( 2 ); - - num_backtrack_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_backtrack_glyphs * 2 + 2 ); - - for ( ; num_backtrack_glyphs > 0; num_backtrack_glyphs-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_input_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_input_glyphs * 2 + 2 ); - - for ( count = num_input_glyphs; count > 0; count-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_lookahead_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookahead_glyphs * 2 + 2 ); - - for ( ; num_lookahead_glyphs > 0; num_lookahead_glyphs-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_subst = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_subst * 4 ); - - for ( ; num_subst > 0; num_subst-- ) - { - if ( OTL_NEXT_USHORT( p ) >= num_input_glyphs ) - OTL_INVALID_DATA; - - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 7 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gsub_lookup7_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt format; - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - { - OTL_UInt lookup_type, lookup_offset; - OTL_ValidateFunc validate; - - - OTL_CHECK( 6 ); - lookup_type = OTL_NEXT_USHORT( p ); - lookup_offset = OTL_NEXT_ULONG( p ); - - if ( lookup_type == 0 || lookup_type == 7 || lookup_type > 8 ) - OTL_INVALID_DATA; - - validate = otl_gsub_validate_funcs[lookup_type - 1]; - validate( table + lookup_offset, lookup_count, glyph_count, valid ); - } - break; - - default: - OTL_INVALID_DATA; - } - } - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB LOOKUP TYPE 8 *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - static void - otl_gsub_lookup8_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table, coverage; - OTL_UInt format; - OTL_UInt num_backtrack_glyphs, num_lookahead_glyphs, num_glyphs; - - OTL_UNUSED( lookup_count ); - - - OTL_CHECK( 2 ); - format = OTL_NEXT_USHORT( p ); - switch ( format ) - { - case 1: - OTL_CHECK( 4 ); - - coverage = table + OTL_NEXT_USHORT( p ); - num_backtrack_glyphs = OTL_NEXT_USHORT( p ); - - otl_coverage_validate( coverage, valid ); - - OTL_CHECK( num_backtrack_glyphs * 2 + 2 ); - - for ( ; num_backtrack_glyphs > 0; num_backtrack_glyphs-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_lookahead_glyphs = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookahead_glyphs * 2 + 2 ); - - for ( ; num_lookahead_glyphs > 0; num_lookahead_glyphs-- ) - otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid ); - - num_glyphs = OTL_NEXT_USHORT( p ); - if ( num_glyphs != otl_coverage_get_count( coverage ) ) - OTL_INVALID_DATA; - - OTL_CHECK( num_glyphs * 2 ); - - for ( ; num_glyphs > 0; num_glyphs-- ) - if ( OTL_NEXT_USHORT( p ) >= glyph_count ) - OTL_INVALID_DATA; - - break; - - default: - OTL_INVALID_DATA; - } - } - - - static OTL_ValidateFunc otl_gsub_validate_funcs[8] = - { - otl_gsub_lookup1_validate, - otl_gsub_lookup2_validate, - otl_gsub_lookup3_validate, - otl_gsub_lookup4_validate, - otl_gsub_lookup5_validate, - otl_gsub_lookup6_validate, - otl_gsub_lookup7_validate, - otl_gsub_lookup8_validate - }; - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** GSUB TABLE *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - OTL_LOCALDEF( void ) - otl_gsub_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt scripts, features, lookups; - - - OTL_CHECK( 10 ); - - if ( OTL_NEXT_USHORT( p ) != 0x10000UL ) - OTL_INVALID_DATA; - - scripts = OTL_NEXT_USHORT( p ); - features = OTL_NEXT_USHORT( p ); - lookups = OTL_NEXT_USHORT( p ); - - otl_lookup_list_validate( table + lookups, 8, otl_gsub_validate_funcs, - glyph_count, valid ); - otl_feature_list_validate( table + features, table + lookups, valid ); - otl_script_list_validate( table + scripts, table + features, valid ); - } - - -/* END */ diff --git a/src/otlayout/otlgsub.h b/src/otlayout/otlgsub.h deleted file mode 100644 index 027d343eb..000000000 --- a/src/otlayout/otlgsub.h +++ /dev/null @@ -1,52 +0,0 @@ -/***************************************************************************/ -/* */ -/* otlgsub.h */ -/* */ -/* OpenType layout support, GSUB table (specification). */ -/* */ -/* Copyright 2002, 2004 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 __OTLGSUB_H__ -#define __OTLGSUB_H__ - -#include "otlayout.h" - -OTL_BEGIN_HEADER - - - typedef OTL_UInt - (*OTL_GSUB_AlternateFunc)( OTL_UInt gindex, - OTL_UInt count, - OTL_Bytes alternates, - OTL_Pointer data ); - - typedef struct OTL_GSUB_AlternateRec_ - { - OTL_GSUB_AlternateFunc handler_func; - OTL_Pointer handler_data; - - } OTL_GSUB_AlternateRec, *OTL_GSUB_Alternate; - - - OTL_LOCAL( void ) - otl_gsub_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ); - - -OTL_END_HEADER - -#endif /* __OTLGSUB_H__ */ - - -/* END */ diff --git a/src/otlayout/otljstf.c b/src/otlayout/otljstf.c deleted file mode 100644 index 1583980bb..000000000 --- a/src/otlayout/otljstf.c +++ /dev/null @@ -1,262 +0,0 @@ -/***************************************************************************/ -/* */ -/* otljstf.c */ -/* */ -/* OpenType layout support, JSTF table (body). */ -/* */ -/* Copyright 2002, 2004 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 "otljstf.h" -#include "otlcommn.h" -#include "otlgpos.h" - - - static void - otl_jstf_extender_validate( OTL_Bytes table, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_glyphs; - - - OTL_CHECK( 2 ); - - num_glyphs = OTL_NEXT_USHORT( p ); - - OTL_CHECK( num_glyphs * 2 ); - - for ( ; num_glyphs > 0; num_glyphs-- ) - if ( OTL_NEXT_USHORT( p ) >= glyph_count ) - OTL_INVALID_DATA; - } - - - static void - otl_jstf_gsubgpos_mods_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_lookups; - - - OTL_CHECK( 2 ); - num_lookups = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookups * 2 ); - - if ( lookup_count ) - { - for ( ; num_lookups > 0; num_lookups-- ) - if ( OTL_NEXT_USHORT( p ) >= lookup_count ) - OTL_INVALID_DATA; - } - } - - - static void - otl_jstf_max_validate( OTL_Bytes table, - OTL_UInt lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_lookups; - - - OTL_CHECK( 2 ); - num_lookups = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_lookups * 2 ); - - /* scan subtable records */ - for ( ; num_lookups > 0; num_lookups-- ) - /* XXX: check lookup types? */ - otl_gpos_subtable_validate( table + OTL_NEXT_USHORT( p ), - lookup_count, glyph_count, valid ); - } - - - static void - otl_jstf_priority_validate( OTL_Bytes table, - OTL_UInt gsub_lookup_count, - OTL_UInt gpos_lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt val; - - - OTL_CHECK( 20 ); - - /* shrinkage GSUB enable/disable */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gsub_lookup_count, - valid ); - - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gsub_lookup_count, - valid ); - - /* shrinkage GPOS enable/disable */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gpos_lookup_count, - valid ); - - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gpos_lookup_count, - valid ); - - /* shrinkage JSTF max */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_max_validate( table + val, gpos_lookup_count, glyph_count, - valid ); - - /* extension GSUB enable/disable */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gsub_lookup_count, - valid ); - - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gsub_lookup_count, - valid ); - - /* extension GPOS enable/disable */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gpos_lookup_count, - valid ); - - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_gsubgpos_mods_validate( table + val, gpos_lookup_count, - valid ); - - /* extension JSTF max */ - val = OTL_NEXT_USHORT( p ); - if ( val ) - otl_jstf_max_validate( table + val, gpos_lookup_count, glyph_count, - valid ); - } - - - static void - otl_jstf_lang_validate( OTL_Bytes table, - OTL_UInt gsub_lookup_count, - OTL_UInt gpos_lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_priorities; - - - OTL_CHECK( 2 ); - num_priorities = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_priorities * 2 ); - - /* scan priority records */ - for ( ; num_priorities > 0; num_priorities-- ) - otl_jstf_priority_validate( table + OTL_NEXT_USHORT( p ), - gsub_lookup_count, gpos_lookup_count, - glyph_count, valid ); - } - - - static void - otl_jstf_script_validate( OTL_Bytes table, - OTL_UInt gsub_lookup_count, - OTL_UInt gpos_lookup_count, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_langsys, extender, default_lang; - - - OTL_CHECK( 6 ); - extender = OTL_NEXT_USHORT( p ); - default_lang = OTL_NEXT_USHORT( p ); - num_langsys = OTL_NEXT_USHORT( p ); - - if ( extender ) - otl_jstf_extender_validate( table + extender, glyph_count, valid ); - - if ( default_lang ) - otl_jstf_lang_validate( table + default_lang, - gsub_lookup_count, gpos_lookup_count, - glyph_count, valid ); - - OTL_CHECK( 6 * num_langsys ); - - /* scan langsys records */ - for ( ; num_langsys > 0; num_langsys-- ) - { - p += 4; /* skip tag */ - - otl_jstf_lang_validate( table + OTL_NEXT_USHORT( p ), - gsub_lookup_count, gpos_lookup_count, - glyph_count, valid ); - } - } - - - OTL_LOCALDEF( void ) - otl_jstf_validate( OTL_Bytes table, - OTL_Bytes gsub, - OTL_Bytes gpos, - OTL_UInt glyph_count, - OTL_Validator valid ) - { - OTL_Bytes p = table; - OTL_UInt num_scripts, gsub_lookup_count, gpos_lookup_count; - - - OTL_CHECK( 6 ); - - if ( OTL_NEXT_ULONG( p ) != 0x10000UL ) - OTL_INVALID_DATA; - - num_scripts = OTL_NEXT_USHORT( p ); - OTL_CHECK( num_scripts * 6 ); - - if ( gsub ) - gsub_lookup_count = otl_gsubgpos_get_lookup_count( gsub ); - else - gsub_lookup_count = 0; - - if ( gpos ) - gpos_lookup_count = otl_gsubgpos_get_lookup_count( gpos ); - else - gpos_lookup_count = 0; - - /* scan script records */ - for ( ; num_scripts > 0; num_scripts-- ) - { - p += 4; /* skip tag */ - - otl_jstf_script_validate( table + OTL_NEXT_USHORT( p ), - gsub_lookup_count, gpos_lookup_count, - glyph_count, valid ); - } - } - - -/* END */ diff --git a/src/otlayout/otljstf.h b/src/otlayout/otljstf.h deleted file mode 100644 index e15e4aa7f..000000000 --- a/src/otlayout/otljstf.h +++ /dev/null @@ -1,44 +0,0 @@ -/***************************************************************************/ -/* */ -/* otljstf.h */ -/* */ -/* OpenType layout support, JSTF table (specification). */ -/* */ -/* Copyright 2002, 2004 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 __OTLJSTF_H__ -#define __OTLJSTF_H__ - -#include "otlayout.h" - - -OTL_BEGIN_HEADER - - - /* validate JSTF table */ - /* GSUB and GPOS tables should already be validated; */ - /* if missing, set corresponding argument to 0 */ - OTL_LOCAL( void ) - otl_jstf_validate( OTL_Bytes table, - OTL_Bytes gsub, - OTL_Bytes gpos, - OTL_UInt glyph_count, - OTL_Validator valid ); - - -OTL_END_HEADER - -#endif /* __OTLJSTF_H__ */ - - -/* END */ diff --git a/src/otlayout/otlparse.c b/src/otlayout/otlparse.c deleted file mode 100644 index 3c197f10c..000000000 --- a/src/otlayout/otlparse.c +++ /dev/null @@ -1,144 +0,0 @@ -#include "otlparse.h" -#include "otlutils.h" - - - static void - otl_string_ensure( OTL_String string, - OTL_UInt count, - OTL_Parser parser ) - { - count += string->length; - - if ( count > string->capacity ) - { - OTL_UInt old_count = string->capacity; - OTL_UInt new_count = old_count; - OTL_Memory memory = parser->memory; - - while ( new_count < count ) - new_count += (new_count >> 1) + 16; - - if ( OTL_MEM_RENEW_ARRAY( string->glyphs, old_count, new_count ) ) - otl_parser_error( parser, OTL_Err_Parser_Memory ); - - string->capacity = new_count; - } - } - - -#define OTL_STRING_ENSURE(str,count,parser) \ - OTL_BEGIN_STMNT \ - if ( (str)->length + (count) > (str)->capacity ) \ - otl_string_ensure( str, count, parser ); \ - OTL_END_STMNT - - - OTL_LOCALDEF( OTL_UInt ) - otl_parser_get_gindex( OTL_Parser parser ) - { - OTL_String in = parser->str_in; - - if ( in->cursor >= in->length ) - otl_parser_error( parser, OTL_Err_Parser_Internal ); - - return in->glyphs[ in->cursor ].gindex; - } - - - OTL_LOCALDEF( void ) - otl_parser_error( OTL_Parser parser, - OTL_ParseError error ) - { - parser->error = error; - otl_longjmp( parser->jump_buffer, 1 ); - } - - - OTL_LOCALDEF( void ) - otl_parser_check_property( OTL_Parser parser, - OTL_UInt gindex, - OTL_UInt *aproperty ) - { - /* XXX: to do */ - } - - - OTL_LOCALDEF( void ) - otl_parser_replace_1( OTL_Parser parser, - OTL_UInt gindex ) - { - OTL_String in = parser->str_in; - OTL_String out = parser->str_out; - OTL_StringGlyph glyph, in_glyph; - - /* sanity check */ - if ( in == 0 || - out == 0 || - in->length == 0 || - in->cursor >= in->length ) - { - /* report as internal error, since these should */ - /* never happen !! */ - otl_parser_error( parser, OTL_Err_Parser_Internal ); - } - - OTL_STRING_ENSURE( out, 1, parser ); - glyph = out->glyphs + out->length; - in_glyph = in->glyphs + in->cursor; - - glyph->gindex = gindex; - glyph->properties = in_glyph->properties; - glyph->lig_component = in_glyph->lig_component; - glyph->lig_id = in_glyph->lig_id; - - out->length += 1; - out->cursor = out->length; - in->cursor += 1; - } - - - OTL_LOCALDEF( void ) - otl_parser_replace_n( OTL_Parser parser, - OTL_UInt count, - OTL_Bytes indices ) - { - OTL_UInt lig_component, lig_id, properties; - OTL_String in = parser->str_in; - OTL_String out = parser->str_out; - OTL_StringGlyph glyph, in_glyph; - OTL_Bytes p = indices; - - /* sanity check */ - if ( in == 0 || - out == 0 || - in->length == 0 || - in->cursor >= in->length ) - { - /* report as internal error, since these should */ - /* never happen !! */ - otl_parser_error( parser, OTL_Err_Parser_Internal ); - } - - OTL_STRING_ENSURE( out, count, parser ); - glyph = out->glyphs + out->length; - in_glyph = in->glyphs + in->cursor; - - glyph->gindex = in_glyph->gindex; - - lig_component = in_glyph->lig_component; - lig_id = in_glyph->lig_id; - properties = in_glyph->properties; - - for ( ; count > 0; count-- ) - { - glyph->gindex = OTL_NEXT_USHORT(p); - glyph->properties = properties; - glyph->lig_component = lig_component; - glyph->lig_id = lig_id; - - out->length ++; - } - - out->cursor = out->length; - in->cursor += 1; - } diff --git a/src/otlayout/otlparse.h b/src/otlayout/otlparse.h deleted file mode 100644 index 1b388ffdb..000000000 --- a/src/otlayout/otlparse.h +++ /dev/null @@ -1,100 +0,0 @@ -#ifndef __OTL_PARSER_H__ -#define __OTL_PARSER_H__ - -#include "otlayout.h" -#include "otlgdef.h" -#include "otlgsub.h" -#include "otlgpos.h" - -OTL_BEGIN_HEADER - - typedef struct OTL_ParserRec_* OTL_Parser; - - typedef struct OTL_StringRec_* OTL_String; - - typedef struct OTL_StringGlyphRec_ - { - OTL_UInt gindex; - OTL_UInt properties; - OTL_UInt lig_component; - OTL_UInt lig_id; - - } OTL_StringGlyphRec, *OTL_StringGlyph; - - typedef struct OTL_StringRec_ - { - OTL_StringGlyph glyphs; - OTL_UInt cursor; - OTL_UInt length; - OTL_UInt capacity; - - } OTL_StringRec; - - typedef struct OTL_ParserRec_ - { - OTL_Bytes tab_gdef; - OTL_Bytes tab_gsub; - OTL_Bytes tab_gpos; - OTL_Bytes tab_base; - OTL_Bytes tab_jstf; - - OTL_GSUB_Alternate alternate; /* external alternate handler */ - - OTL_UInt context_len; - OTL_UInt markup_flags; - - OTL_jmp_buf jump_buffer; - OTL_Memory memory; - OTL_Error error; - - OTL_StringRec strings[2]; - OTL_String str_in; - OTL_String str_out; - - } OTL_ParserRec; - - typedef enum - { - OTL_Err_Parser_Ok = 0, - OTL_Err_Parser_InvalidData, - OTL_Err_Parser_UncoveredGlyph, - OTL_Err_Parser_Memory, - OTL_Err_Parser_Internal, - - } OTL_ParseError; - - OTL_LOCAL( OTL_UInt ) - otl_parser_get_gindex( OTL_Parser parser ); - - - OTL_LOCAL( void ) - otl_parser_error( OTL_Parser parser, - OTL_ParseError error ); - -#define OTL_PARSER_UNCOVERED(x) \ - otl_parser_error( x, OTL_Err_Parser_UncoveredGlyph ) - - OTL_LOCAL( void ) - otl_parser_check_property( OTL_Parser parser, - OTL_UInt gindex, - OTL_UInt *aproperty ); - - /* copy current input glyph to output */ - OTL_LOCAL( void ) - otl_parser_copy_1( OTL_Parser parser ); - - /* copy current input glyph to output, replacing its index */ - OTL_LOCAL( void ) - otl_parser_replace_1( OTL_Parser parser, - OTL_UInt gindex ); - - /* copy current input glyph to output, replacing it by several indices */ - /* read directly from the table */ - OTL_LOCAL( void ) - otl_parser_replace_n( OTL_Parser parser, - OTL_UInt count, - OTL_Bytes indices ); - -OTL_END_HEADER - -#endif /* __OTL_PARSER_H__ */ diff --git a/src/otlayout/otltable.h b/src/otlayout/otltable.h deleted file mode 100644 index ccc04b571..000000000 --- a/src/otlayout/otltable.h +++ /dev/null @@ -1,62 +0,0 @@ -#ifndef __OTL_TABLE_H__ -#define __OTL_TABLE_H__ - -#include "otlayout.h" - -OTL_BEGIN_HEADER - - typedef struct OTL_TableRec_* OTL_Table; - - typedef enum - { - OTL_TABLE_TYPE_GDEF = 1, - OTL_TABLE_TYPE_GSUB, - OTL_TABLE_TYPE_GPOS, - OTL_TABLE_TYPE_BASE, - OTL_TABLE_TYPE_JSTF - - } OTL_TableType; - - - /* this may become a private structure later */ - typedef struct OTL_TableRec_ - { - OTL_TableType type; - OTL_Bytes base; - OTL_Bytes limit; - - OTL_Tag script_tag; - OTL_Tag lang_tag; - - OTL_UInt lookup_count; - OTL_Byte* lookup_flags; - - OTL_UInt feature_count; - OTL_Tag feature_tags; - OTL_Byte* feature_flags; - - } OTL_TableRec; - - -#if 0 - OTL_API( OTL_Error ) - otl_table_validate( OTL_Bytes table, - OTL_Size size, - OTL_TableType type, - OTL_Size *abyte_size ); - - OTL_API( void ) - otl_table_init( OTL_Table table, - OTL_TableType type, - OTL_Bytes base, - OTL_Size size ); - - OTL_API( void ) - otl_table_set_script( OTL_Table table, - OTL_ScriptTag script, - OTL_LangTag language ); -#endif - -OTL_END_HEADER - -#endif /* __OTL_TABLE_H__ */ diff --git a/src/otlayout/otltags.h b/src/otlayout/otltags.h deleted file mode 100644 index a51630c86..000000000 --- a/src/otlayout/otltags.h +++ /dev/null @@ -1,87 +0,0 @@ -/* this file may be included several times by other parts of */ -/* the OpenType Layout library.. don't add #ifdef .. #endif */ -/* delimiters to it... */ - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** SCRIPT TAGS *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - -#ifndef OTL_SCRIPT_TAG -#define OTL_SCRIPT_TAG(c1,c2,c3,c4,s,n) /* void */ -#endif - -OTL_SCRIPT_TAG( 'a','r','a','b', "Arabic", ARABIC ) -OTL_SCRIPT_TAG( 'a','r','m','n', "Armenian", ARMENIAN ) -OTL_SCRIPT_TAG( 'b','e','n','g', "Bengali", BENGALI ) -OTL_SCRIPT_TAG( 'b','o','p','o', "Bopomofo", BOPOMOFO ) -OTL_SCRIPT_TAG( 'b','r','a','i', "Braille", BRAILLE ) -OTL_SCRIPT_TAG( 'b','y','z','m', "Byzantine Music", BYZANTINE_MUSIC ) -OTL_SCRIPT_TAG( 'c','a','n','s', "Canadian Syllabic", CANADIAN ) -OTL_SCRIPT_TAG( 'c','h','e','r', "Cherokee", CHEROKEE ) -OTL_SCRIPT_TAG( 'h','a','n','i', "CJK Ideographic", CJK ) -OTL_SCRIPT_TAG( 'c','y','r','l', "Cyrillic", CYRILLIC ) -OTL_SCRIPT_TAG( 'd','f','l','t', "Default", DEFAULT ) -OTL_SCRIPT_TAG( 'd','e','v','a', "Devanagari", DEVANAGARI ) -OTL_SCRIPT_TAG( 'e','t','h','i', "Ethiopic", ETHIOPIC ) -OTL_SCRIPT_TAG( 'g','e','o','r', "Georgian", GEORGIAN ) -OTL_SCRIPT_TAG( 'g','r','e','k', "Greek", GREEK ) -OTL_SCRIPT_TAG( 'g','u','j','r', "Gujarati", GUJARATI ) -OTL_SCRIPT_TAG( 'g','u','r','u', "Gurmukhi", GURMUKHI ) -OTL_SCRIPT_TAG( 'j','a','m','o', "Hangul Jamo", JAMO ) -OTL_SCRIPT_TAG( 'h','a','n','g', "Hangul", HANGUL ) -OTL_SCRIPT_TAG( 'h','e','b','r', "Hebrew", HEBREW ) -OTL_SCRIPT_TAG( 'h','i','r','a', "Hiragana", HIRAGANA ) /* not in TAGS.txt */ -OTL_SCRIPT_TAG( 'k','n','d','a', "Kannada", KANNADA ) -OTL_SCRIPT_TAG( 'k','a','n','a', "Katakana", KATAKANA ) /* in TAGS.txt, means Hiragana _and_ Katakana */ -OTL_SCRIPT_TAG( 'k','h','m','r', "Khmer", KHMER ) -OTL_SCRIPT_TAG( 'l','a','o',' ', "Lao", LAO ) -OTL_SCRIPT_TAG( 'l','a','t','n', "Latin", LATIN ) -OTL_SCRIPT_TAG( 'm','l','y','m', "Malayalam", MALAYALAM ) -OTL_SCRIPT_TAG( 'm','o','n','g', "Mongolian", MONGOLIAN ) -OTL_SCRIPT_TAG( 'm','y','m','r', "Myanmar", MYANMAR ) -OTL_SCRIPT_TAG( 'o','g','a','m', "Ogham", OGHAM ) -OTL_SCRIPT_TAG( 'o','r','y','a', "Oriya", ORIYA ) -OTL_SCRIPT_TAG( 'r','u','n','r', "Runic", RUNIC ) -OTL_SCRIPT_TAG( 's','i','n','h', "Sinhala", SINHALA ) -OTL_SCRIPT_TAG( 's','y','r','c', "Syriac", SYRIAC ) -OTL_SCRIPT_TAG( 't','a','m','l', "Tamil", TAMIL ) -OTL_SCRIPT_TAG( 't','e','l','u', "Telugu", TELUGU ) -OTL_SCRIPT_TAG( 't','h','a','a', "Thaana", THAANA ) -OTL_SCRIPT_TAG( 't','h','a','i', "Thai", THAI ) -OTL_SCRIPT_TAG( 't','i','b','t', "Tibetan", TIBETAN ) -OTL_SCRIPT_TAG( 'y','i',' ',' ', "Yi", YI ) - -#undef OTL_SCRIPT_TAG - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** LANGUAGE TAGS *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - -#ifndef OTL_LANG_TAG -#define OTL_LANG_TAG(c1,c2,c3,c4,s,n) /* void */ -#endif - -#undef OTL_LANG_TAG - - - /************************************************************************/ - /************************************************************************/ - /***** *****/ - /***** FEATURE TAGS *****/ - /***** *****/ - /************************************************************************/ - /************************************************************************/ - -#ifndef OTL_FEATURE_TAG -#define OTL_FEATURE_TAG(c1,c2,c3,c4,s,n) /* void */ -#endif - -#undef OTL_FEATURE_TAG diff --git a/src/otlayout/otlutils.h b/src/otlayout/otlutils.h deleted file mode 100644 index 9ac2ba1f3..000000000 --- a/src/otlayout/otlutils.h +++ /dev/null @@ -1,33 +0,0 @@ -#ifndef __OTLAYOUT_UTILS_H__ -#define __OTLAYOUT_UTILS_H__ - -#include "otlayout.h" - -OTL_BEGIN_HEADER - - OTL_LOCAL( OTL_Error ) - otl_mem_alloc( OTL_Pointer* pblock, - OTL_ULong size, - OTL_Memory memory ); - - OTL_LOCAL( void ) - otl_mem_free( OTL_Pointer* pblock, - OTL_Memory memory ); - - OTL_LOCAL( OTL_Error ) - otl_mem_realloc( OTL_Pointer *pblock, - OTL_ULong cur_size, - OTL_ULong new_size, - OTL_Memory memory ); - -#define OTL_MEM_ALLOC(p,s) otl_mem_alloc( (void**)&(p), (s), memory ) -#define OTL_MEM_FREE(p) otl_mem_free( (void**)&(p), memory ) -#define OTL_MEM_REALLOC(p,c,s) otl_mem_realloc( (void**)&(p), (c), (s), memory ) - -#define OTL_MEM_NEW(p) OTL_MEM_ALLOC(p,sizeof(*(p))) -#define OTL_MEM_NEW_ARRAY(p,c) OTL_MEM_ALLOC(p,(c)*sizeof(*(p))) -#define OTL_MEM_RENEW_ARRAY(p,c,n) OTL_MEM_REALLOC(p,(c)*sizeof(*(p)),(n)*sizeof(*(p))) - -OTL_END_HEADER - -#endif /* __OTLAYOUT_UTILS_H__ */