gxvmod.c File Reference

#include <ft2build.h>
#include "gxvmod.h"
#include "gxvalid.h"
#include "gxvcommn.h"

Include dependency graph for gxvmod.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FT_COMPONENT   trace_gxvmodule
#define	GXV_TABLE_DECL(_sfnt)
#define	GXV_TABLE_LOAD(_sfnt)
#define	GXV_TABLE_VALIDATE(_sfnt)
#define	GXV_TABLE_SET(_sfnt)

Functions
static FT_Error	gxv_load_table (FT_Face face, FT_Tag tag, FT_Byte *volatile *table, FT_ULong *table_len)
static FT_Error	gxv_validate (FT_Face face, FT_UInt gx_flags, FT_Bytes tables[FT_VALIDATE_GX_LENGTH], FT_UInt table_count)
static FT_Error	classic_kern_validate (FT_Face face, FT_UInt ckern_flags, FT_Bytes *ckern_table)
static FT_Pointer	gxvalid_get_service (FT_Module module, const char *service_id)

Variables
static const FT_Service_GXvalidateRec	gxvalid_interface
static const FT_Service_CKERNvalidateRec	ckernvalid_interface
static const FT_ServiceDescRec	gxvalid_services []
FT_CALLBACK_TABLE_DEF const FT_Module_Class	gxv_module_class

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_gxvmodule

Definition at line 47 of file gxvmod.c.

GXV_TABLE_DECL

#define GXV_TABLE_DECL

(

_sfnt

)

Value:

          FT_Byte* volatile  _sfnt          = NULL; \
          FT_ULong            len_ ## _sfnt = 0

Definition at line 76 of file gxvmod.c.

GXV_TABLE_LOAD

#define GXV_TABLE_LOAD

(

_sfnt

)

Value:

          if ( ( FT_VALIDATE_ ## _sfnt ## _INDEX < table_count ) && \
               ( gx_flags & FT_VALIDATE_ ## _sfnt )            )    \
          {                                                         \
            error = gxv_load_table( face, TTAG_ ## _sfnt,           \
                                    &_sfnt, &len_ ## _sfnt );       \
            if ( error )                                            \
              goto Exit;                                            \
          }

Definition at line 80 of file gxvmod.c.

GXV_TABLE_SET

#define GXV_TABLE_SET

(

_sfnt

)

Value:

          if ( FT_VALIDATE_ ## _sfnt ## _INDEX < table_count )        \
            tables[FT_VALIDATE_ ## _sfnt ## _INDEX] = (FT_Bytes)_sfnt

Definition at line 102 of file gxvmod.c.

GXV_TABLE_VALIDATE

#define GXV_TABLE_VALIDATE

(

_sfnt

)

Value:

          if ( _sfnt )                                               \
          {                                                          \
            ft_validator_init( &valid, _sfnt, _sfnt + len_ ## _sfnt, \
                               FT_VALIDATE_DEFAULT );                \
            if ( ft_setjmp( valid.jump_buffer ) == 0 )               \
              gxv_ ## _sfnt ## _validate( _sfnt, face, &valid );     \
            error = valid.error;                                     \
            if ( error )                                             \
              goto Exit;                                             \
          }

Definition at line 90 of file gxvmod.c.

Function Documentation

classic_kern_validate()

static FT_Error classic_kern_validate ( FT_Face  face, FT_UInt  ckern_flags, FT_Bytes *  ckern_table  )

static

Definition at line 191 of file gxvmod.c.

  {
    FT_Memory volatile        memory = FT_FACE_MEMORY( face );
 
    FT_Byte* volatile         ckern     = NULL;
    FT_ULong                  len_ckern = 0;
 
    /* without volatile on `error' GCC 4.1.1. emits:                         */
    /*  warning: variable 'error' might be clobbered by 'longjmp' or 'vfork' */
    /* this warning seems spurious but ---                                   */
    FT_Error volatile         error;
    FT_ValidatorRec volatile  valid;
 
 
    *ckern_table = NULL;
 
    error = gxv_load_table( face, TTAG_kern, &ckern, &len_ckern );
    if ( error )
      goto Exit;
 
    if ( ckern )
    {
      ft_validator_init( &valid, ckern, ckern + len_ckern,
                         FT_VALIDATE_DEFAULT );
      if ( ft_setjmp( valid.jump_buffer ) == 0 )
        gxv_kern_validate_classic( ckern, face,
                                   ckern_flags & FT_VALIDATE_CKERN, &valid );
      error = valid.error;
      if ( error )
        goto Exit;
    }
 
    *ckern_table = ckern;
 
  Exit:
    if ( error )
      FT_FREE( ckern );
 
    return error;
  }

gxv_load_table()

static FT_Error gxv_load_table ( FT_Face  face, FT_Tag  tag, FT_Byte *volatile *  table, FT_ULong *  table_len  )

static

Definition at line 51 of file gxvmod.c.

  {
    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_ALLOC( *table, *table_len ) )
      goto Exit;
 
    error = FT_Load_Sfnt_Table( face, tag, 0, *table, table_len );
 
  Exit:
    return error;
  }

Referenced by classic_kern_validate().

gxv_validate()

static FT_Error gxv_validate ( FT_Face  face, FT_UInt  gx_flags, FT_Bytes  tables[FT_VALIDATE_GX_LENGTH], FT_UInt  table_count  )

static

Definition at line 108 of file gxvmod.c.

  {
    FT_Memory volatile        memory = FT_FACE_MEMORY( face );
 
    FT_Error                  error = FT_Err_Ok;
    FT_ValidatorRec volatile  valid;
 
    FT_UInt  i;
 
 
    GXV_TABLE_DECL( feat );
    GXV_TABLE_DECL( bsln );
    GXV_TABLE_DECL( trak );
    GXV_TABLE_DECL( just );
    GXV_TABLE_DECL( mort );
    GXV_TABLE_DECL( morx );
    GXV_TABLE_DECL( kern );
    GXV_TABLE_DECL( opbd );
    GXV_TABLE_DECL( prop );
    GXV_TABLE_DECL( lcar );
 
    for ( i = 0; i < table_count; i++ )
      tables[i] = 0;
 
    /* load tables */
    GXV_TABLE_LOAD( feat );
    GXV_TABLE_LOAD( bsln );
    GXV_TABLE_LOAD( trak );
    GXV_TABLE_LOAD( just );
    GXV_TABLE_LOAD( mort );
    GXV_TABLE_LOAD( morx );
    GXV_TABLE_LOAD( kern );
    GXV_TABLE_LOAD( opbd );
    GXV_TABLE_LOAD( prop );
    GXV_TABLE_LOAD( lcar );
 
    /* validate tables */
    GXV_TABLE_VALIDATE( feat );
    GXV_TABLE_VALIDATE( bsln );
    GXV_TABLE_VALIDATE( trak );
    GXV_TABLE_VALIDATE( just );
    GXV_TABLE_VALIDATE( mort );
    GXV_TABLE_VALIDATE( morx );
    GXV_TABLE_VALIDATE( kern );
    GXV_TABLE_VALIDATE( opbd );
    GXV_TABLE_VALIDATE( prop );
    GXV_TABLE_VALIDATE( lcar );
 
    /* Set results */
    GXV_TABLE_SET( feat );
    GXV_TABLE_SET( mort );
    GXV_TABLE_SET( morx );
    GXV_TABLE_SET( bsln );
    GXV_TABLE_SET( just );
    GXV_TABLE_SET( kern );
    GXV_TABLE_SET( opbd );
    GXV_TABLE_SET( trak );
    GXV_TABLE_SET( prop );
    GXV_TABLE_SET( lcar );
 
  Exit:
    if ( error )
    {
      FT_FREE( feat );
      FT_FREE( bsln );
      FT_FREE( trak );
      FT_FREE( just );
      FT_FREE( mort );
      FT_FREE( morx );
      FT_FREE( kern );
      FT_FREE( opbd );
      FT_FREE( prop );
      FT_FREE( lcar );
    }
 
    return error;
  }

gxvalid_get_service()

static FT_Pointer gxvalid_get_service ( FT_Module  module, const char *  service_id  )

static

Definition at line 259 of file gxvmod.c.

  {
    FT_UNUSED( module );
 
    return ft_service_list_lookup( gxvalid_services, service_id );
  }

Variable Documentation

ckernvalid_interface

const FT_Service_CKERNvalidateRec ckernvalid_interface

static

Initial value:

=
  {
    classic_kern_validate     
  }

Definition at line 243 of file gxvmod.c.

gxv_module_class

FT_CALLBACK_TABLE_DEF const FT_Module_Class gxv_module_class

Initial value:

=
  {
    0,
    sizeof ( FT_ModuleRec ),
    "gxvalid",
    0x10000L,
    0x20000L,
 
    NULL,              
 
    (FT_Module_Constructor)NULL,                
    (FT_Module_Destructor) NULL,                
    (FT_Module_Requester)  gxvalid_get_service  
  }

Definition at line 269 of file gxvmod.c.

gxvalid_interface

const FT_Service_GXvalidateRec gxvalid_interface

static

Initial value:

=
  {
    gxv_validate              
  }

Definition at line 236 of file gxvmod.c.

gxvalid_services

const FT_ServiceDescRec gxvalid_services[]

static

Initial value:

=
  {
    { FT_SERVICE_ID_GX_VALIDATE,          &gxvalid_interface },
    { FT_SERVICE_ID_CLASSICKERN_VALIDATE, &ckernvalid_interface },
    { NULL, NULL }
  }

Definition at line 250 of file gxvmod.c.

Referenced by gxvalid_get_service().