| /**************************************************************************** |
| * |
| * otvmod.c |
| * |
| * FreeType's OpenType validation module implementation (body). |
| * |
| * Copyright (C) 2004-2022 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 <freetype/tttables.h> |
| #include <freetype/tttags.h> |
| #include <freetype/ftotval.h> |
| #include <freetype/internal/ftobjs.h> |
| #include <freetype/internal/services/svotval.h> |
| |
| #include "otvmod.h" |
| #include "otvalid.h" |
| #include "otvcommn.h" |
| |
| |
| /************************************************************************** |
| * |
| * The macro FT_COMPONENT is used in trace mode. It is an implicit |
| * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log |
| * messages during execution. |
| */ |
| #undef FT_COMPONENT |
| #define FT_COMPONENT otvmodule |
| |
| |
| static FT_Error |
| otv_load_table( FT_Face face, |
| FT_Tag tag, |
| FT_Byte* volatile* table, |
| FT_ULong* table_len ) |
| { |
| FT_Error error; |
| FT_Memory memory = FT_FACE_MEMORY( face ); |
| |
| |
| error = FT_Load_Sfnt_Table( face, tag, 0, NULL, table_len ); |
| if ( FT_ERR_EQ( error, Table_Missing ) ) |
| return FT_Err_Ok; |
| if ( error ) |
| goto Exit; |
| |
| if ( FT_QALLOC( *table, *table_len ) ) |
| goto Exit; |
| |
| error = FT_Load_Sfnt_Table( face, tag, 0, *table, table_len ); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| static FT_Error |
| otv_validate( FT_Face volatile face, |
| FT_UInt ot_flags, |
| FT_Bytes *ot_base, |
| FT_Bytes *ot_gdef, |
| FT_Bytes *ot_gpos, |
| FT_Bytes *ot_gsub, |
| FT_Bytes *ot_jstf ) |
| { |
| FT_Error error = FT_Err_Ok; |
| FT_Byte* volatile base; |
| FT_Byte* volatile gdef; |
| FT_Byte* volatile gpos; |
| FT_Byte* volatile gsub; |
| FT_Byte* volatile jstf; |
| FT_Byte* volatile math; |
| FT_ULong len_base, len_gdef, len_gpos, len_gsub, len_jstf; |
| FT_ULong len_math; |
| FT_UInt num_glyphs = (FT_UInt)face->num_glyphs; |
| FT_ValidatorRec volatile valid; |
| |
| |
| base = gdef = gpos = gsub = jstf = math = NULL; |
| len_base = len_gdef = len_gpos = len_gsub = len_jstf = len_math = 0; |
| |
| /* |
| * XXX: OpenType tables cannot handle 32-bit glyph index, |
| * although broken TrueType can have 32-bit glyph index. |
| */ |
| if ( face->num_glyphs > 0xFFFFL ) |
| { |
| FT_TRACE1(( "otv_validate: Invalid glyphs index (0x0000FFFF - 0x%08lx) ", |
| face->num_glyphs )); |
| FT_TRACE1(( "are not handled by OpenType tables\n" )); |
| num_glyphs = 0xFFFF; |
| } |
| |
| /* load tables */ |
| |
| if ( ot_flags & FT_VALIDATE_BASE ) |
| { |
| error = otv_load_table( face, TTAG_BASE, &base, &len_base ); |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( ot_flags & FT_VALIDATE_GDEF ) |
| { |
| error = otv_load_table( face, TTAG_GDEF, &gdef, &len_gdef ); |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( ot_flags & FT_VALIDATE_GPOS ) |
| { |
| error = otv_load_table( face, TTAG_GPOS, &gpos, &len_gpos ); |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( ot_flags & FT_VALIDATE_GSUB ) |
| { |
| error = otv_load_table( face, TTAG_GSUB, &gsub, &len_gsub ); |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( ot_flags & FT_VALIDATE_JSTF ) |
| { |
| error = otv_load_table( face, TTAG_JSTF, &jstf, &len_jstf ); |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( ot_flags & FT_VALIDATE_MATH ) |
| { |
| error = otv_load_table( face, TTAG_MATH, &math, &len_math ); |
| if ( error ) |
| goto Exit; |
| } |
| |
| /* validate tables */ |
| |
| if ( base ) |
| { |
| ft_validator_init( &valid, base, base + len_base, FT_VALIDATE_DEFAULT ); |
| if ( ft_setjmp( valid.jump_buffer ) == 0 ) |
| otv_BASE_validate( base, &valid ); |
| error = valid.error; |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( gpos ) |
| { |
| ft_validator_init( &valid, gpos, gpos + len_gpos, FT_VALIDATE_DEFAULT ); |
| if ( ft_setjmp( valid.jump_buffer ) == 0 ) |
| otv_GPOS_validate( gpos, num_glyphs, &valid ); |
| error = valid.error; |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( gsub ) |
| { |
| ft_validator_init( &valid, gsub, gsub + len_gsub, FT_VALIDATE_DEFAULT ); |
| if ( ft_setjmp( valid.jump_buffer ) == 0 ) |
| otv_GSUB_validate( gsub, num_glyphs, &valid ); |
| error = valid.error; |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( gdef ) |
| { |
| ft_validator_init( &valid, gdef, gdef + len_gdef, FT_VALIDATE_DEFAULT ); |
| if ( ft_setjmp( valid.jump_buffer ) == 0 ) |
| otv_GDEF_validate( gdef, gsub, gpos, num_glyphs, &valid ); |
| error = valid.error; |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( jstf ) |
| { |
| ft_validator_init( &valid, jstf, jstf + len_jstf, FT_VALIDATE_DEFAULT ); |
| if ( ft_setjmp( valid.jump_buffer ) == 0 ) |
| otv_JSTF_validate( jstf, gsub, gpos, num_glyphs, &valid ); |
| error = valid.error; |
| if ( error ) |
| goto Exit; |
| } |
| |
| if ( math ) |
| { |
| ft_validator_init( &valid, math, math + len_math, FT_VALIDATE_DEFAULT ); |
| if ( ft_setjmp( valid.jump_buffer ) == 0 ) |
| otv_MATH_validate( math, num_glyphs, &valid ); |
| error = valid.error; |
| if ( error ) |
| goto Exit; |
| } |
| |
| *ot_base = (FT_Bytes)base; |
| *ot_gdef = (FT_Bytes)gdef; |
| *ot_gpos = (FT_Bytes)gpos; |
| *ot_gsub = (FT_Bytes)gsub; |
| *ot_jstf = (FT_Bytes)jstf; |
| |
| Exit: |
| if ( error ) |
| { |
| FT_Memory memory = FT_FACE_MEMORY( face ); |
| |
| |
| FT_FREE( base ); |
| FT_FREE( gdef ); |
| FT_FREE( gpos ); |
| FT_FREE( gsub ); |
| FT_FREE( jstf ); |
| } |
| |
| { |
| FT_Memory memory = FT_FACE_MEMORY( face ); |
| |
| |
| FT_FREE( math ); /* Can't return this as API is frozen */ |
| } |
| |
| return error; |
| } |
| |
| |
| static |
| const FT_Service_OTvalidateRec otvalid_interface = |
| { |
| otv_validate /* validate */ |
| }; |
| |
| |
| static |
| const FT_ServiceDescRec otvalid_services[] = |
| { |
| { FT_SERVICE_ID_OPENTYPE_VALIDATE, &otvalid_interface }, |
| { NULL, NULL } |
| }; |
| |
| |
| static FT_Pointer |
| otvalid_get_service( FT_Module module, |
| const char* service_id ) |
| { |
| FT_UNUSED( module ); |
| |
| return ft_service_list_lookup( otvalid_services, service_id ); |
| } |
| |
| |
| FT_CALLBACK_TABLE_DEF |
| const FT_Module_Class otv_module_class = |
| { |
| 0, |
| sizeof ( FT_ModuleRec ), |
| "otvalid", |
| 0x10000L, |
| 0x20000L, |
| |
| NULL, /* module-specific interface */ |
| |
| (FT_Module_Constructor)NULL, /* module_init */ |
| (FT_Module_Destructor) NULL, /* module_done */ |
| (FT_Module_Requester) otvalid_get_service /* get_interface */ |
| }; |
| |
| |
| /* END */ |
