| /***************************************************************************/ |
| /* */ |
| /* gxstatetbl.c */ |
| /* */ |
| /* AAT/TrueTypeGX state table related types and functions */ |
| /* (body). */ |
| /* */ |
| /* Copyright 2003 by */ |
| /* Masatake YAMATO and Redhat K.K. */ |
| /* */ |
| /* This file 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. */ |
| /* */ |
| /***************************************************************************/ |
| |
| /***************************************************************************/ |
| /* Development of the code in this file is support of */ |
| /* Information-technology Promotion Agency, Japan. */ |
| /***************************************************************************/ |
| |
| #include <ft2build.h> |
| |
| #include FT_INTERNAL_STREAM_H |
| #include FT_INTERNAL_MEMORY_H |
| |
| #include "gxstatetbl.h" |
| #include "gxlookuptbl.h" |
| #include "gxerrors.h" |
| |
| static FT_Error |
| gx_StateTable_load_header( GX_Face face, |
| FT_Stream stream, |
| GX_StateHeader header ) |
| { |
| FT_Error error; |
| static const FT_Frame_Field state_header_fields[] = |
| { |
| #undef FT_STRUCTURE |
| #define FT_STRUCTURE GX_StateHeaderRec |
| FT_FRAME_START ( 8 ), |
| FT_FRAME_USHORT ( stateSize ), |
| FT_FRAME_USHORT ( classTable ), |
| FT_FRAME_USHORT ( stateArray ), |
| FT_FRAME_USHORT ( entryTable ), |
| FT_FRAME_END |
| }; |
| header->position = FT_STREAM_POS(); |
| return FT_STREAM_READ_FIELDS( state_header_fields, header ); |
| } |
| |
| static FT_Error |
| gx_StateTable_load_class_subtable( GX_Face face, |
| FT_Stream stream, |
| FT_ULong pos, |
| GX_ClassSubtable subtable ) |
| { |
| FT_Error error; |
| FT_Memory memory = stream->memory; |
| FT_Byte * classArray; |
| FT_Int i; |
| static const FT_Frame_Field class_subtable_fields[] = |
| { |
| #undef FT_STRUCTURE |
| #define FT_STRUCTURE GX_ClassSubtableRec |
| FT_FRAME_START ( 4 ), |
| FT_FRAME_USHORT ( firstGlyph ), |
| FT_FRAME_USHORT ( nGlyphs ), |
| FT_FRAME_END |
| }; |
| |
| subtable->classArray = NULL; |
| |
| if ( FT_STREAM_SEEK(pos) ) |
| goto Exit; |
| |
| if ( FT_STREAM_READ_FIELDS ( class_subtable_fields, subtable ) ) |
| goto Exit; |
| |
| if ( FT_NEW_ARRAY ( classArray, subtable->nGlyphs ) ) |
| goto Exit; |
| |
| if ( FT_FRAME_ENTER( sizeof (classArray[0]) * subtable->nGlyphs ) ) |
| goto Failure; |
| |
| for ( i = 0; i < subtable->nGlyphs; i++ ) |
| classArray[i] = FT_GET_BYTE(); |
| |
| FT_FRAME_EXIT(); |
| subtable->classArray = classArray; |
| Exit: |
| return error; |
| Failure: |
| FT_FREE( classArray ); |
| return error; |
| } |
| |
| static void |
| gx_StateTable_free_class_subtable( FT_Memory memory, |
| GX_ClassSubtable subtable ) |
| { |
| FT_FREE(subtable->classArray); |
| subtable->classArray = NULL; |
| } |
| |
| static FT_Error |
| gx_StateTable_load_state_array( GX_Face face, |
| FT_Stream stream, |
| FT_ULong pos, |
| FT_UShort length, |
| FT_Byte * state_array ) |
| { |
| FT_Error error; |
| FT_Int i; |
| |
| if ( FT_STREAM_SEEK(pos) ) |
| goto Exit; |
| |
| if ( FT_FRAME_ENTER( sizeof (state_array[0]) * length ) ) |
| goto Exit; |
| |
| for ( i = 0; i < length; i++ ) |
| state_array[i] = FT_GET_BYTE(); |
| |
| FT_FRAME_EXIT(); |
| Exit: |
| return error; |
| } |
| |
| /* - gx_StateTable_load_entry_subtable |
| I assume FUNCS is not NULL. Set any kind of dummy in the caller if |
| necessary. |
| To support both a state table and an extended state table, the type of nEntries |
| is FT_ULong. */ |
| static FT_Error |
| gx_StateTable_load_entry_subtable ( GX_Face face, |
| FT_Stream stream, |
| FT_ULong pos, |
| FT_ULong nEntries, |
| GX_EntrySubtable entry_subtable, |
| GX_StateTable_Entry_Load_Funcs funcs, |
| FT_Pointer user ) |
| { |
| FT_Error error; |
| FT_Memory memory = face->root.driver->root.memory; |
| FT_ULong i, j; |
| |
| static const FT_Frame_Field entry_subtable_fields[] = |
| { |
| #undef FT_STRUCTURE |
| #define FT_STRUCTURE GX_EntrySubtableRec |
| FT_FRAME_START ( 4 ), |
| FT_FRAME_USHORT ( newState ), |
| FT_FRAME_USHORT ( flags ), |
| FT_FRAME_END |
| }; |
| |
| if ( FT_STREAM_SEEK( pos ) ) |
| goto Exit; |
| |
| for ( i = 0; i < nEntries; i++ ) |
| { |
| if ( FT_STREAM_READ_FIELDS ( entry_subtable_fields, &entry_subtable[i] ) ) |
| goto Failure; |
| if (( error = funcs->loader(face, stream, &entry_subtable[i], user) )) |
| goto Failure; |
| } |
| Exit: |
| return error; |
| Failure: |
| for ( j = i; j > 0; j-- ) |
| funcs->finalizer(memory, &entry_subtable[j - 1], user); |
| return error; |
| } |
| |
| static void |
| gx_StateTable_free_entry_subtable ( FT_Memory memory, |
| FT_Byte nEntries, |
| GX_EntrySubtable entry_subtable, |
| GX_StateTable_Entry_Finalizer finalizer, |
| FT_Pointer user ) |
| { |
| FT_Int i; |
| for ( i = 0; i < nEntries; i++ ) |
| finalizer(memory, &entry_subtable[i], user); |
| } |
| |
| static FT_Error |
| gx_StateTable_Entry_default_loader ( GX_Face face, |
| FT_Stream stream, |
| GX_EntrySubtable entry_subtable, |
| FT_Pointer user ) |
| { |
| entry_subtable->glyphOffsets.any = NULL; |
| return GX_Err_Ok; |
| } |
| |
| static void |
| gx_StateTable_Entry_default_finalizer ( FT_Memory memory, |
| GX_EntrySubtable entry_subtable, |
| FT_Pointer user ) |
| { |
| /* Do nothing */; |
| } |
| |
| static FT_Byte |
| gx_StateTable_find_state_array_max_index (FT_UShort array_length, FT_Byte state_array[]) |
| { |
| FT_Int i; |
| FT_Byte max_index = 0; |
| for ( i = 0; i < array_length; i++ ) |
| { |
| /* fprintf(stderr, "->%u\n", state_array[i]); */ |
| if ( state_array[i] > max_index ) |
| max_index = state_array [i]; |
| } |
| return max_index; |
| } |
| |
| FT_LOCAL_DEF ( FT_Error ) |
| gx_face_load_StateTable ( GX_Face face, |
| FT_Stream stream, |
| GX_StateTable state_table, |
| GX_StateTable_Entry_Load_Funcs funcs, |
| FT_Pointer user ) |
| |
| { |
| FT_Error error; |
| FT_Memory memory = stream->memory; |
| GX_StateHeader header; |
| GX_ClassSubtable class_subtable; |
| FT_Byte * state_array = NULL; |
| FT_UShort state_array_len; |
| GX_EntrySubtable entry_subtable = NULL; |
| FT_ULong pos; |
| GX_StateTable_Entry_Load_FuncsRec default_funcs = GX_STATE_TABLE_ENTRY_LOAD_FUNCS_ZERO; |
| |
| default_funcs.loader = gx_StateTable_Entry_default_loader; |
| default_funcs.finalizer = gx_StateTable_Entry_default_finalizer; |
| |
| state_table->state_array = NULL; |
| state_table->entry_subtable = NULL; |
| |
| /* 1. Header */ |
| header = &state_table->header; |
| if (( error = gx_StateTable_load_header( face, stream, |
| header ) )) |
| goto Exit; |
| |
| /* 2. class subtable */ |
| pos = header->position + header->classTable; |
| class_subtable = &state_table->class_subtable; |
| if (( error = gx_StateTable_load_class_subtable( face, |
| stream, |
| pos, |
| class_subtable ) )) |
| goto Exit; |
| |
| |
| /* 3. state array */ |
| /* To calculate the length of stateArray, we assume |
| the order of fields placement is classTable, stateArray, |
| entryTable */ |
| FT_ASSERT( header->classTable < header->stateArray ); |
| FT_ASSERT( header->stateArray < header->entryTable ); |
| |
| pos = header->position + header->stateArray; |
| state_array_len = header->entryTable - header->stateArray; |
| state_table->nStates = state_array_len / header->stateSize; |
| /* Calculate state_array_len again. |
| state_array_len must be a multiple of header->stateSize. */ |
| state_array_len = state_table->nStates * header->stateSize; |
| if (( FT_NEW_ARRAY ( state_array, state_array_len ) )) |
| goto Failure; |
| |
| if (( error = gx_StateTable_load_state_array( face, |
| stream, |
| pos, |
| state_array_len, |
| state_array ) )) |
| goto Failure; |
| |
| /* 4. entry subtable */ |
| if ( funcs ) |
| { |
| if (! funcs->loader ) |
| funcs->loader = gx_StateTable_Entry_default_loader; |
| if (! funcs->finalizer ) |
| funcs->finalizer = gx_StateTable_Entry_default_finalizer; |
| } |
| else |
| funcs = &default_funcs; |
| |
| pos = header->position + header->entryTable; |
| /* gx_StateTable_find_state_array_max_index returns the max index into an array |
| which starts from 0. By adding 1 to the max index, get the length of the array. */ |
| state_table->nEntries = 1+ gx_StateTable_find_state_array_max_index(state_array_len, |
| state_array); |
| |
| if (( FT_NEW_ARRAY( entry_subtable, state_table->nEntries) )) |
| goto Failure; |
| if (( error = gx_StateTable_load_entry_subtable( face, |
| stream, |
| pos, |
| state_table->nEntries, |
| entry_subtable, |
| funcs, |
| user) )) |
| goto Failure; |
| |
| state_table->state_array = state_array; |
| state_table->entry_subtable = entry_subtable; |
| Exit: |
| return error; |
| Failure: |
| if ( entry_subtable ) |
| FT_FREE ( entry_subtable ); |
| if ( state_array ) |
| FT_FREE(state_array); |
| gx_StateTable_free_class_subtable (memory, class_subtable); |
| return error; |
| } |
| |
| FT_LOCAL_DEF ( void ) |
| gx_StateTable_free ( GX_StateTable state_table, |
| FT_Memory memory, |
| GX_StateTable_Entry_Finalizer finalizer, |
| FT_Pointer user ) |
| { |
| if ( finalizer == NULL ) |
| finalizer = gx_StateTable_Entry_default_finalizer; |
| gx_StateTable_free_entry_subtable ( memory, |
| state_table->nEntries, |
| state_table->entry_subtable, |
| finalizer, |
| user ); |
| FT_FREE( state_table->entry_subtable ); |
| state_table->entry_subtable = NULL; |
| |
| FT_FREE( state_table->state_array ); |
| state_table->state_array = NULL; |
| |
| gx_StateTable_free_class_subtable( memory, &state_table->class_subtable ); |
| } |
| |
| static FT_Error |
| gx_EntrySubtable_traverse( GX_EntrySubtable entries, |
| FT_Long nEntries, |
| GX_StateTable_Entry_Action action, |
| FT_Pointer user ) |
| { |
| FT_Error error = GX_Err_Ok; |
| FT_Int i; |
| |
| if (!action) |
| return error; |
| |
| for ( i = 0; i < nEntries; i++ ) |
| { |
| error = action( &entries[i], user ); |
| if ( error ) |
| return error; |
| } |
| return error; |
| } |
| |
| #if 0 |
| FT_LOCAL_DEF ( FT_Error ) |
| gx_StateTable_traverse_entries( GX_StateTable state_table, |
| GX_StateTable_Entry_Action action, |
| FT_Pointer user ) |
| { |
| return gx_EntrySubtable_traverse( state_table->entry_subtable, |
| state_table->nEntries, |
| action, |
| user ); |
| } |
| #endif /* 0 */ |
| |
| FT_LOCAL_DEF ( FT_Byte ) |
| gx_StateTable_get_class ( GX_StateTable state_table, |
| FT_UShort glyph ) |
| { |
| GX_ClassSubtable class_subtable; |
| FT_Byte class_code; |
| FT_UShort first_glyph, last_glyph; |
| |
| class_subtable = &state_table->class_subtable; |
| first_glyph = class_subtable->firstGlyph; |
| last_glyph = first_glyph + class_subtable->nGlyphs; |
| |
| if ( glyph == GX_DELETED_GLYPH_INDEX ) |
| class_code = GX_CLASS_DELETED_GLYPH; |
| else if ( ( first_glyph <= glyph ) && ( glyph < last_glyph ) ) |
| class_code = class_subtable->classArray[glyph - first_glyph]; |
| else |
| class_code = GX_CLASS_OUT_OF_BOUNDS; |
| return class_code; |
| } |
| |
| FT_LOCAL_DEF ( GX_EntrySubtable ) |
| gx_StateTable_get_entry_subtable ( GX_StateTable state_table, |
| FT_UShort current_state, |
| FT_Byte class_code ) |
| { |
| GX_StateHeader header = &state_table->header; |
| FT_Byte * state_array = state_table->state_array; |
| GX_EntrySubtable entry_subtable = state_table->entry_subtable; |
| FT_Byte * state_array_for_current_state; |
| FT_Byte entry_index; |
| |
| state_array_for_current_state = &state_array[current_state - header->stateArray]; |
| entry_index = state_array_for_current_state[class_code]; |
| return &entry_subtable[entry_index]; |
| } |
| |
| /* |
| * Extended State Table |
| */ |
| |
| #define gx_XStateTable_load_entry_subtable gx_StateTable_load_entry_subtable |
| #define gx_XStateTable_free_entry_subtable gx_StateTable_free_entry_subtable |
| |
| #define gx_XStateTable_Entry_default_loader gx_StateTable_Entry_default_loader |
| #define gx_XStateTable_Entry_default_finalizer gx_StateTable_Entry_default_finalizer |
| #define gx_XStateTable_Entry_default_finalizer gx_StateTable_Entry_default_finalizer |
| |
| static FT_Error |
| gx_XStateTable_load_header( GX_Face face, |
| FT_Stream stream, |
| GX_XStateHeader header ) |
| { |
| FT_Error error; |
| static const FT_Frame_Field xstate_header_fields[] = |
| { |
| #undef FT_STRUCTURE |
| #define FT_STRUCTURE GX_XStateHeaderRec |
| FT_FRAME_START ( 16 ), |
| FT_FRAME_ULONG( nClasses ), |
| FT_FRAME_ULONG( classTableOffset ), |
| FT_FRAME_ULONG( stateArrayOffset ), |
| FT_FRAME_ULONG( entryTableOffset ), |
| FT_FRAME_END |
| }; |
| header->position = FT_STREAM_POS(); |
| return FT_STREAM_READ_FIELDS( xstate_header_fields, header ); |
| } |
| |
| static FT_Error |
| gx_XStateTable_load_state_array( GX_Face face, |
| FT_Stream stream, |
| FT_ULong pos, |
| FT_ULong length, |
| FT_UShort* state_array ) |
| { |
| FT_Error error; |
| FT_Int i; |
| |
| if ( FT_STREAM_SEEK(pos) ) |
| goto Exit; |
| |
| if ( FT_FRAME_ENTER( sizeof (state_array[0]) * length ) ) |
| goto Exit; |
| |
| for ( i = 0; i < length; i++ ) |
| state_array[i] = FT_GET_USHORT(); |
| |
| FT_FRAME_EXIT(); |
| Exit: |
| return error; |
| } |
| |
| static FT_UShort |
| gx_XStateTable_find_state_array_max_index (FT_ULong array_length, FT_UShort state_array[]) |
| { |
| FT_ULong i; |
| FT_UShort max_index = 0; |
| for ( i = 0; i < array_length; i++ ) |
| { |
| if ( state_array[i] > max_index ) |
| max_index = state_array [i]; |
| } |
| return max_index; |
| } |
| |
| #define LOOKUP_TABLE_CB_DATA_ZERO {NULL, NULL} |
| typedef struct lookup_table_cb_data_rec_ |
| { |
| FT_Stream stream; |
| GX_LookupTable lookup_table; |
| FT_Long table_end; |
| } lookup_table_cb_data_rec, *lookup_table_cb_data; |
| |
| static FT_Error |
| gx_XStateTable_LookupTable_segment_array_loader( GX_LookupTable_Format format, |
| FT_UShort lastGlyph, |
| FT_UShort firstGlyph, |
| GX_LookupValue value, |
| FT_Pointer user ) |
| { |
| /* generic_lookup_table_segment_array_loader */ |
| FT_Error error; |
| lookup_table_cb_data lookup_data = user; |
| FT_Stream stream = lookup_data->stream; |
| GX_LookupTable lookup_table = lookup_data->lookup_table; |
| FT_Memory memory = stream->memory; |
| FT_Short value_offset = value->raw.s; |
| FT_UShort segment_count = lastGlyph - firstGlyph + 1; |
| FT_UShort * segment; |
| |
| FT_Int i; |
| |
| /* ----------------------------------------------------------------- |
| * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING |
| * This code is correct? |
| * In spec: "Sometimes they are 16-bit offsets from the start of |
| * the table to the data. " The table? Is the table the lookup table |
| * or a table that uses the lookup table? |
| * Here I assume the table is the table that uses the lookup table. |
| * However, I have no conviction. |
| * It seems that pfaedit uses lookup_table_offset + value_offset. |
| * ----------------------------------------------------------------- */ |
| FT_ASSERT(lookup_table->position + value_offset < lookup_data->table_end); |
| if (FT_STREAM_SEEK( lookup_table->position + value_offset ) ) |
| goto Exit; |
| |
| if ( FT_NEW_ARRAY(segment, segment_count ) ) |
| goto Exit; |
| |
| if ( FT_FRAME_ENTER ( sizeof( segment[0] ) * segment_count ) ) |
| goto Failure; |
| for ( i = 0; i < segment_count; i++ ) |
| segment[i] = FT_GET_USHORT(); |
| FT_FRAME_EXIT(); |
| value->extra.word = segment; |
| Exit: |
| return error; |
| Failure: |
| /* TODO |
| Other value->extra.wordS loaded before the visitation to this |
| value->extra.word must be freed if an error is occurred during |
| traverse. */ |
| FT_FREE(segment); |
| return error; |
| } |
| |
| FT_LOCAL_DEF ( FT_Error ) |
| gx_face_load_XStateTable ( GX_Face face, |
| FT_Stream stream, |
| GX_XStateTable state_table, |
| GX_XStateTable_Entry_Load_Funcs funcs, |
| FT_Pointer user ) |
| { |
| FT_Error error; |
| FT_Memory memory = stream->memory; |
| GX_XStateHeader header; |
| FT_ULong state_array_len; /* in word */ |
| FT_UShort * state_array = NULL; |
| GX_EntrySubtable entry_subtable = NULL; |
| FT_ULong pos; |
| GX_XStateTable_Entry_Load_FuncsRec default_XStateTable_funcs = GX_XSTATE_TABLE_ENTRY_LOAD_FUNCS_ZERO; |
| GX_LookupTable_FuncsRec default_LookupTable_funcs = GX_LOOKUP_TABLE_FUNC_ZERO; |
| lookup_table_cb_data_rec lookup_table_cb_data = LOOKUP_TABLE_CB_DATA_ZERO; |
| |
| default_XStateTable_funcs.loader = gx_XStateTable_Entry_default_loader; |
| default_XStateTable_funcs.finalizer = gx_XStateTable_Entry_default_finalizer; |
| |
| default_LookupTable_funcs.segment_array_func = gx_XStateTable_LookupTable_segment_array_loader; |
| |
| state_table->state_array = NULL; |
| state_table->entry_subtable = NULL; |
| |
| |
| /* 1. Header */ |
| header = &state_table->header; |
| if (( error = gx_XStateTable_load_header( face, stream, header ) )) |
| goto Exit; |
| |
| /* 2. class subtable */ |
| pos = header->position + header->classTableOffset; |
| if ( FT_STREAM_SEEK( pos ) ) |
| goto Exit; |
| |
| if (( error = gx_face_load_LookupTable( face, |
| stream, |
| &state_table->class_subtable ) )) |
| goto Exit; |
| |
| if ( state_table->class_subtable.format == GX_LOOKUPTABLE_SEGMENT_ARRAY ) |
| { |
| |
| lookup_table_cb_data.stream = stream; |
| lookup_table_cb_data.lookup_table = &state_table->class_subtable; |
| lookup_table_cb_data.table_end = header->position + header->stateArrayOffset; |
| if (( error = gx_LookupTable_traverse_low( & state_table->class_subtable, |
| & default_LookupTable_funcs, |
| & lookup_table_cb_data ) )) |
| goto Failure; |
| } |
| |
| /* 3. state array */ |
| /* To calculate the length of stateArray, we assume |
| the order of fields placement is classTable, stateArray, |
| entryTable */ |
| FT_ASSERT( header->classTableOffset < header->stateArrayOffset ); |
| FT_ASSERT( header->stateArrayOffset < header->entryTableOffset ); |
| |
| pos = header->position + header->stateArrayOffset; |
| state_array_len = (header->entryTableOffset - header->stateArrayOffset) / sizeof( state_array[0] ); |
| state_table->nStates = state_array_len / header->nClasses; |
| /* Calculate state_array_len again. |
| state_array_len must be a multiple of header->nClasses. */ |
| state_array_len = state_table->nStates * header->nClasses; |
| |
| if (( FT_NEW_ARRAY ( state_array, state_array_len ) )) |
| goto Failure; |
| |
| if (( error = gx_XStateTable_load_state_array( face, |
| stream, |
| pos, |
| state_array_len, |
| state_array ) )) |
| goto Failure; |
| |
| /* 4. entry subtable */ |
| if ( funcs ) |
| { |
| if (! funcs->loader ) |
| funcs->loader = gx_XStateTable_Entry_default_loader; |
| if (! funcs->finalizer ) |
| funcs->finalizer = gx_XStateTable_Entry_default_finalizer; |
| } |
| else |
| funcs = &default_XStateTable_funcs; |
| |
| pos = header->position + header->entryTableOffset; |
| state_table->nEntries = 1+ gx_XStateTable_find_state_array_max_index( state_array_len, |
| state_array ); |
| if (( FT_NEW_ARRAY( entry_subtable, state_table->nEntries) )) |
| goto Failure; |
| if (( error = gx_XStateTable_load_entry_subtable( face, |
| stream, |
| pos, |
| state_table->nEntries, |
| entry_subtable, |
| funcs, |
| user) )) |
| goto Failure; |
| state_table->state_array = state_array; |
| state_table->entry_subtable = entry_subtable; |
| Exit: |
| return error; |
| Failure: |
| if ( entry_subtable ) |
| FT_FREE ( entry_subtable ); |
| if ( state_array ) |
| FT_FREE(state_array); |
| gx_LookupTable_free( & state_table->class_subtable, memory ); |
| return error; |
| } |
| |
| FT_LOCAL_DEF ( FT_Error ) |
| gx_XStateTable_traverse_entries( GX_XStateTable state_table, |
| GX_XStateTable_Entry_Action action, |
| FT_Pointer user ) |
| { |
| return gx_EntrySubtable_traverse( state_table->entry_subtable, |
| state_table->nEntries, |
| action, |
| user ); |
| } |
| |
| static FT_Error |
| gx_XStateTable_LookupTable_segment_array_finalizer ( GX_LookupTable_Format format, |
| FT_UShort lastGlyph, |
| FT_UShort firstGlyph, |
| GX_LookupValue value, |
| FT_Pointer user ) |
| { |
| /* TODO: Merge generic_lookup_table_segment_array_finalizer */ |
| FT_Memory memory = user; |
| FT_UShort * segment = value->extra.word; |
| if ( !segment ) |
| return GX_Err_Ok; |
| |
| value->extra.word = NULL; |
| FT_FREE(segment); |
| return GX_Err_Ok; |
| } |
| |
| FT_LOCAL_DEF ( void ) |
| gx_XStateTable_free ( GX_XStateTable state_table, |
| FT_Memory memory, |
| GX_XStateTable_Entry_Finalizer finalizer, |
| FT_Pointer user ) |
| { |
| GX_LookupTable_FuncsRec lookup_table_funcs = GX_LOOKUP_TABLE_FUNC_ZERO; |
| |
| lookup_table_funcs.segment_array_func = gx_XStateTable_LookupTable_segment_array_finalizer; |
| |
| if ( finalizer == NULL ) |
| finalizer = gx_StateTable_Entry_default_finalizer; |
| gx_XStateTable_free_entry_subtable ( memory, |
| state_table->nEntries, |
| state_table->entry_subtable, |
| finalizer, |
| user ); |
| FT_FREE( state_table->entry_subtable ); |
| state_table->entry_subtable = NULL; |
| |
| FT_FREE( state_table->state_array ); |
| state_table->state_array = NULL; |
| |
| |
| if ( state_table->class_subtable.format == GX_LOOKUPTABLE_SEGMENT_ARRAY ) |
| gx_LookupTable_traverse_low( & state_table->class_subtable, |
| &lookup_table_funcs, |
| memory ); |
| gx_LookupTable_free( & state_table->class_subtable, memory ); |
| } |
| |
| FT_LOCAL_DEF ( FT_UShort ) |
| gx_XStateTable_get_class ( GX_XStateTable state_table, |
| FT_UShort glyph ) |
| { |
| GX_LookupTable class_subtable; |
| GX_LookupResultRec result; |
| FT_UShort class_code; |
| |
| class_subtable = &state_table->class_subtable; |
| result = gx_LookupTable_lookup ( class_subtable, |
| glyph ); |
| |
| if ( result.value == NULL ) |
| class_code = GX_CLASS_OUT_OF_BOUNDS; |
| else if ( result.firstGlyph == GX_LOOKUP_RESULT_NO_FIRST_GLYPH ) |
| class_code = result.value->raw.u; |
| else |
| class_code = result.value->extra.word[glyph - result.firstGlyph]; |
| return class_code; |
| } |
| |
| FT_LOCAL ( GX_EntrySubtable ) |
| gx_XStateTable_get_entry_subtable ( GX_XStateTable state_table, |
| FT_UShort current_state, |
| FT_UShort class_code ) |
| { |
| GX_XStateHeader header = &state_table->header; |
| FT_UShort * state_array = state_table->state_array; |
| FT_UShort * state_array_for_current_state; |
| FT_UShort entry_index; |
| GX_EntrySubtable entry_subtable; |
| |
| FT_ASSERT( current_state < state_table->nStates ); |
| FT_ASSERT( class_code < header->nClasses ); |
| state_array_for_current_state = &state_array[current_state * header->nClasses]; |
| entry_index = state_array_for_current_state[class_code]; |
| FT_ASSERT( entry_index < state_table->nEntries ); |
| entry_subtable = &state_table->entry_subtable[entry_index]; |
| return entry_subtable; |
| } |
| |
| /* END */ |
