misc/libfreetype/src/gxvalid/gxvkern.c
changeset 5172 88f2e05288ba
equal deleted inserted replaced
5171:f9283dc4860d 5172:88f2e05288ba
       
     1 /***************************************************************************/
       
     2 /*                                                                         */
       
     3 /*  gxvkern.c                                                              */
       
     4 /*                                                                         */
       
     5 /*    TrueTypeGX/AAT kern table validation (body).                         */
       
     6 /*                                                                         */
       
     7 /*  Copyright 2004, 2005, 2006, 2007                                       */
       
     8 /*  by suzuki toshiya, Masatake YAMATO, Red Hat K.K.,                      */
       
     9 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
       
    10 /*                                                                         */
       
    11 /*  This file is part of the FreeType project, and may only be used,       */
       
    12 /*  modified, and distributed under the terms of the FreeType project      */
       
    13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
       
    14 /*  this file you indicate that you have read the license and              */
       
    15 /*  understand and accept it fully.                                        */
       
    16 /*                                                                         */
       
    17 /***************************************************************************/
       
    18 
       
    19 /***************************************************************************/
       
    20 /*                                                                         */
       
    21 /* gxvalid is derived from both gxlayout module and otvalid module.        */
       
    22 /* Development of gxlayout is supported by the Information-technology      */
       
    23 /* Promotion Agency(IPA), Japan.                                           */
       
    24 /*                                                                         */
       
    25 /***************************************************************************/
       
    26 
       
    27 
       
    28 #include "gxvalid.h"
       
    29 #include "gxvcommn.h"
       
    30 
       
    31 #include FT_SFNT_NAMES_H
       
    32 #include FT_SERVICE_GX_VALIDATE_H
       
    33 
       
    34 
       
    35   /*************************************************************************/
       
    36   /*                                                                       */
       
    37   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
       
    38   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
       
    39   /* messages during execution.                                            */
       
    40   /*                                                                       */
       
    41 #undef  FT_COMPONENT
       
    42 #define FT_COMPONENT  trace_gxvkern
       
    43 
       
    44 
       
    45   /*************************************************************************/
       
    46   /*************************************************************************/
       
    47   /*****                                                               *****/
       
    48   /*****                      Data and Types                           *****/
       
    49   /*****                                                               *****/
       
    50   /*************************************************************************/
       
    51   /*************************************************************************/
       
    52 
       
    53   typedef enum  GXV_kern_Version_
       
    54   {
       
    55     KERN_VERSION_CLASSIC = 0x0000,
       
    56     KERN_VERSION_NEW     = 0x0001
       
    57 
       
    58   } GXV_kern_Version;
       
    59 
       
    60 
       
    61   typedef enum GXV_kern_Dialect_
       
    62   {
       
    63     KERN_DIALECT_UNKNOWN = 0,
       
    64     KERN_DIALECT_MS      = FT_VALIDATE_MS,
       
    65     KERN_DIALECT_APPLE   = FT_VALIDATE_APPLE,
       
    66     KERN_DIALECT_ANY     = FT_VALIDATE_CKERN
       
    67 
       
    68   } GXV_kern_Dialect;
       
    69 
       
    70 
       
    71   typedef struct  GXV_kern_DataRec_
       
    72   {
       
    73     GXV_kern_Version  version;
       
    74     void             *subtable_data;
       
    75     GXV_kern_Dialect  dialect_request;
       
    76 
       
    77   } GXV_kern_DataRec, *GXV_kern_Data;
       
    78 
       
    79 
       
    80 #define GXV_KERN_DATA( field )  GXV_TABLE_DATA( kern, field )
       
    81 
       
    82 #define KERN_IS_CLASSIC( valid )                               \
       
    83           ( KERN_VERSION_CLASSIC == GXV_KERN_DATA( version ) )
       
    84 #define KERN_IS_NEW( valid )                                   \
       
    85           ( KERN_VERSION_NEW     == GXV_KERN_DATA( version ) )
       
    86 
       
    87 #define KERN_DIALECT( valid )              \
       
    88           GXV_KERN_DATA( dialect_request )
       
    89 #define KERN_ALLOWS_MS( valid )                       \
       
    90           ( KERN_DIALECT( valid ) & KERN_DIALECT_MS )
       
    91 #define KERN_ALLOWS_APPLE( valid )                       \
       
    92           ( KERN_DIALECT( valid ) & KERN_DIALECT_APPLE )
       
    93 
       
    94 #define GXV_KERN_HEADER_SIZE           ( KERN_IS_NEW( valid ) ? 8 : 4 )
       
    95 #define GXV_KERN_SUBTABLE_HEADER_SIZE  ( KERN_IS_NEW( valid ) ? 8 : 6 )
       
    96 
       
    97 
       
    98   /*************************************************************************/
       
    99   /*************************************************************************/
       
   100   /*****                                                               *****/
       
   101   /*****                      SUBTABLE VALIDATORS                      *****/
       
   102   /*****                                                               *****/
       
   103   /*************************************************************************/
       
   104   /*************************************************************************/
       
   105 
       
   106 
       
   107   /* ============================= format 0 ============================== */
       
   108 
       
   109   static void
       
   110   gxv_kern_subtable_fmt0_pairs_validate( FT_Bytes       table,
       
   111                                          FT_Bytes       limit,
       
   112                                          FT_UShort      nPairs,
       
   113                                          GXV_Validator  valid )
       
   114   {
       
   115     FT_Bytes   p = table;
       
   116     FT_UShort  i;
       
   117 
       
   118     FT_UShort  last_gid_left  = 0;
       
   119     FT_UShort  last_gid_right = 0;
       
   120 
       
   121     FT_UNUSED( limit );
       
   122 
       
   123 
       
   124     GXV_NAME_ENTER( "kern format 0 pairs" );
       
   125 
       
   126     for ( i = 0; i < nPairs; i++ )
       
   127     {
       
   128       FT_UShort  gid_left;
       
   129       FT_UShort  gid_right;
       
   130       FT_Short   kernValue;
       
   131 
       
   132 
       
   133       /* left */
       
   134       gid_left  = FT_NEXT_USHORT( p );
       
   135       gxv_glyphid_validate( gid_left, valid );
       
   136 
       
   137       /* right */
       
   138       gid_right = FT_NEXT_USHORT( p );
       
   139       gxv_glyphid_validate( gid_right, valid );
       
   140 
       
   141       /* Pairs of left and right GIDs must be unique and sorted. */
       
   142       GXV_TRACE(( "left gid = %u, right gid = %u\n", gid_left, gid_right ));
       
   143       if ( gid_left == last_gid_left )
       
   144       {
       
   145         if ( last_gid_right < gid_right )
       
   146           last_gid_right = gid_right;
       
   147         else
       
   148           FT_INVALID_DATA;
       
   149       }
       
   150       else if ( last_gid_left < gid_left )
       
   151       {
       
   152         last_gid_left  = gid_left;
       
   153         last_gid_right = gid_right;
       
   154       }
       
   155       else
       
   156         FT_INVALID_DATA;
       
   157 
       
   158       /* skip the kern value */
       
   159       kernValue = FT_NEXT_SHORT( p );
       
   160     }
       
   161 
       
   162     GXV_EXIT;
       
   163   }
       
   164 
       
   165   static void
       
   166   gxv_kern_subtable_fmt0_validate( FT_Bytes       table,
       
   167                                    FT_Bytes       limit,
       
   168                                    GXV_Validator  valid )
       
   169   {
       
   170     FT_Bytes   p = table + GXV_KERN_SUBTABLE_HEADER_SIZE;
       
   171 
       
   172     FT_UShort  nPairs;
       
   173     FT_UShort  unitSize;
       
   174 
       
   175 
       
   176     GXV_NAME_ENTER( "kern subtable format 0" );
       
   177 
       
   178     unitSize = 2 + 2 + 2;
       
   179     nPairs   = 0;
       
   180 
       
   181     /* nPairs, searchRange, entrySelector, rangeShift */
       
   182     GXV_LIMIT_CHECK( 2 + 2 + 2 + 2 );
       
   183     gxv_BinSrchHeader_validate( p, limit, &unitSize, &nPairs, valid );
       
   184     p += 2 + 2 + 2 + 2;
       
   185 
       
   186     gxv_kern_subtable_fmt0_pairs_validate( p, limit, nPairs, valid );
       
   187 
       
   188     GXV_EXIT;
       
   189   }
       
   190 
       
   191 
       
   192   /* ============================= format 1 ============================== */
       
   193 
       
   194 
       
   195   typedef struct  GXV_kern_fmt1_StateOptRec_
       
   196   {
       
   197     FT_UShort  valueTable;
       
   198     FT_UShort  valueTable_length;
       
   199 
       
   200   } GXV_kern_fmt1_StateOptRec, *GXV_kern_fmt1_StateOptRecData;
       
   201 
       
   202 
       
   203   static void
       
   204   gxv_kern_subtable_fmt1_valueTable_load( FT_Bytes       table,
       
   205                                           FT_Bytes       limit,
       
   206                                           GXV_Validator  valid )
       
   207   {
       
   208     FT_Bytes                       p = table;
       
   209     GXV_kern_fmt1_StateOptRecData  optdata =
       
   210       (GXV_kern_fmt1_StateOptRecData)valid->statetable.optdata;
       
   211 
       
   212 
       
   213     GXV_LIMIT_CHECK( 2 );
       
   214     optdata->valueTable = FT_NEXT_USHORT( p );
       
   215   }
       
   216 
       
   217 
       
   218   /*
       
   219    * passed tables_size covers whole StateTable, including kern fmt1 header
       
   220    */
       
   221   static void
       
   222   gxv_kern_subtable_fmt1_subtable_setup( FT_UShort      table_size,
       
   223                                          FT_UShort      classTable,
       
   224                                          FT_UShort      stateArray,
       
   225                                          FT_UShort      entryTable,
       
   226                                          FT_UShort*     classTable_length_p,
       
   227                                          FT_UShort*     stateArray_length_p,
       
   228                                          FT_UShort*     entryTable_length_p,
       
   229                                          GXV_Validator  valid )
       
   230   {
       
   231     FT_UShort  o[4];
       
   232     FT_UShort  *l[4];
       
   233     FT_UShort  buff[5];
       
   234 
       
   235     GXV_kern_fmt1_StateOptRecData  optdata =
       
   236       (GXV_kern_fmt1_StateOptRecData)valid->statetable.optdata;
       
   237 
       
   238 
       
   239     o[0] = classTable;
       
   240     o[1] = stateArray;
       
   241     o[2] = entryTable;
       
   242     o[3] = optdata->valueTable;
       
   243     l[0] = classTable_length_p;
       
   244     l[1] = stateArray_length_p;
       
   245     l[2] = entryTable_length_p;
       
   246     l[3] = &(optdata->valueTable_length);
       
   247 
       
   248     gxv_set_length_by_ushort_offset( o, l, buff, 4, table_size, valid );
       
   249   }
       
   250 
       
   251 
       
   252   /*
       
   253    * passed table & limit are of whole StateTable, not including subtables
       
   254    */
       
   255   static void
       
   256   gxv_kern_subtable_fmt1_entry_validate(
       
   257     FT_Byte                         state,
       
   258     FT_UShort                       flags,
       
   259     GXV_StateTable_GlyphOffsetCPtr  glyphOffset_p,
       
   260     FT_Bytes                        table,
       
   261     FT_Bytes                        limit,
       
   262     GXV_Validator                   valid )
       
   263   {
       
   264     FT_UShort  push;
       
   265     FT_UShort  dontAdvance;
       
   266     FT_UShort  valueOffset;
       
   267     FT_UShort  kernAction;
       
   268     FT_UShort  kernValue;
       
   269 
       
   270     FT_UNUSED( state );
       
   271     FT_UNUSED( glyphOffset_p );
       
   272 
       
   273 
       
   274     push        = (FT_UShort)( ( flags >> 15 ) & 1      );
       
   275     dontAdvance = (FT_UShort)( ( flags >> 14 ) & 1      );
       
   276     valueOffset = (FT_UShort)(   flags         & 0x3FFF );
       
   277 
       
   278     {
       
   279       GXV_kern_fmt1_StateOptRecData  vt_rec =
       
   280         (GXV_kern_fmt1_StateOptRecData)valid->statetable.optdata;
       
   281       FT_Bytes  p;
       
   282 
       
   283 
       
   284       if ( valueOffset < vt_rec->valueTable )
       
   285         FT_INVALID_OFFSET;
       
   286 
       
   287       p     = table + valueOffset;
       
   288       limit = table + vt_rec->valueTable + vt_rec->valueTable_length;
       
   289 
       
   290       GXV_LIMIT_CHECK( 2 + 2 );
       
   291       kernAction = FT_NEXT_USHORT( p );
       
   292       kernValue  = FT_NEXT_USHORT( p );
       
   293     }
       
   294   }
       
   295 
       
   296 
       
   297   static void
       
   298   gxv_kern_subtable_fmt1_validate( FT_Bytes       table,
       
   299                                    FT_Bytes       limit,
       
   300                                    GXV_Validator  valid )
       
   301   {
       
   302     FT_Bytes                   p = table;
       
   303     GXV_kern_fmt1_StateOptRec  vt_rec;
       
   304 
       
   305 
       
   306     GXV_NAME_ENTER( "kern subtable format 1" );
       
   307 
       
   308     valid->statetable.optdata =
       
   309       &vt_rec;
       
   310     valid->statetable.optdata_load_func =
       
   311       gxv_kern_subtable_fmt1_valueTable_load;
       
   312     valid->statetable.subtable_setup_func =
       
   313       gxv_kern_subtable_fmt1_subtable_setup;
       
   314     valid->statetable.entry_glyphoffset_fmt =
       
   315       GXV_GLYPHOFFSET_NONE;
       
   316     valid->statetable.entry_validate_func =
       
   317       gxv_kern_subtable_fmt1_entry_validate;
       
   318 
       
   319     gxv_StateTable_validate( p, limit, valid );
       
   320 
       
   321     GXV_EXIT;
       
   322   }
       
   323 
       
   324 
       
   325   /* ================ Data for Class-Based Subtables 2, 3 ================ */
       
   326 
       
   327   typedef enum  GXV_kern_ClassSpec_
       
   328   {
       
   329     GXV_KERN_CLS_L = 0,
       
   330     GXV_KERN_CLS_R
       
   331 
       
   332   } GXV_kern_ClassSpec;
       
   333 
       
   334 
       
   335   /* ============================= format 2 ============================== */
       
   336 
       
   337   /* ---------------------- format 2 specific data ----------------------- */
       
   338 
       
   339   typedef struct  GXV_kern_subtable_fmt2_DataRec_
       
   340   {
       
   341     FT_UShort         rowWidth;
       
   342     FT_UShort         array;
       
   343     FT_UShort         offset_min[2];
       
   344     FT_UShort         offset_max[2];
       
   345     const FT_String*  class_tag[2];
       
   346     GXV_odtect_Range  odtect;
       
   347 
       
   348   } GXV_kern_subtable_fmt2_DataRec, *GXV_kern_subtable_fmt2_Data;
       
   349 
       
   350 
       
   351 #define GXV_KERN_FMT2_DATA( field )                         \
       
   352         ( ( (GXV_kern_subtable_fmt2_DataRec *)              \
       
   353               ( GXV_KERN_DATA( subtable_data ) ) )->field )
       
   354 
       
   355 
       
   356   /* -------------------------- utility functions ----------------------- */
       
   357 
       
   358   static void
       
   359   gxv_kern_subtable_fmt2_clstbl_validate( FT_Bytes            table,
       
   360                                           FT_Bytes            limit,
       
   361                                           GXV_kern_ClassSpec  spec,
       
   362                                           GXV_Validator       valid )
       
   363   {
       
   364     const FT_String*  tag    = GXV_KERN_FMT2_DATA( class_tag[spec] );
       
   365     GXV_odtect_Range  odtect = GXV_KERN_FMT2_DATA( odtect );
       
   366 
       
   367     FT_Bytes   p = table;
       
   368     FT_UShort  firstGlyph;
       
   369     FT_UShort  nGlyphs;
       
   370 
       
   371 
       
   372     GXV_NAME_ENTER( "kern format 2 classTable" );
       
   373 
       
   374     GXV_LIMIT_CHECK( 2 + 2 );
       
   375     firstGlyph = FT_NEXT_USHORT( p );
       
   376     nGlyphs    = FT_NEXT_USHORT( p );
       
   377     GXV_TRACE(( " %s firstGlyph=%d, nGlyphs=%d\n",
       
   378                 tag, firstGlyph, nGlyphs ));
       
   379 
       
   380     gxv_glyphid_validate( firstGlyph, valid );
       
   381     gxv_glyphid_validate( (FT_UShort)( firstGlyph + nGlyphs - 1 ), valid );
       
   382 
       
   383     gxv_array_getlimits_ushort( p, p + ( 2 * nGlyphs ),
       
   384                                 &( GXV_KERN_FMT2_DATA( offset_min[spec] ) ),
       
   385                                 &( GXV_KERN_FMT2_DATA( offset_max[spec] ) ),
       
   386                                 valid );
       
   387 
       
   388     gxv_odtect_add_range( table, 2 * nGlyphs, tag, odtect );
       
   389 
       
   390     GXV_EXIT;
       
   391   }
       
   392 
       
   393 
       
   394   static void
       
   395   gxv_kern_subtable_fmt2_validate( FT_Bytes       table,
       
   396                                    FT_Bytes       limit,
       
   397                                    GXV_Validator  valid )
       
   398   {
       
   399     GXV_ODTECT( 3, odtect );
       
   400     GXV_kern_subtable_fmt2_DataRec  fmt2_rec =
       
   401       { 0, 0, { 0, 0 }, { 0, 0 }, { "leftClass", "rightClass" }, NULL };
       
   402 
       
   403     FT_Bytes   p = table + GXV_KERN_SUBTABLE_HEADER_SIZE;
       
   404     FT_UShort  leftOffsetTable;
       
   405     FT_UShort  rightOffsetTable;
       
   406 
       
   407 
       
   408     GXV_NAME_ENTER( "kern subtable format 2" );
       
   409 
       
   410     GXV_ODTECT_INIT( odtect );
       
   411     fmt2_rec.odtect = odtect;
       
   412     GXV_KERN_DATA( subtable_data ) = &fmt2_rec;
       
   413 
       
   414     GXV_LIMIT_CHECK( 2 + 2 + 2 + 2 );
       
   415     GXV_KERN_FMT2_DATA( rowWidth ) = FT_NEXT_USHORT( p );
       
   416     leftOffsetTable                = FT_NEXT_USHORT( p );
       
   417     rightOffsetTable               = FT_NEXT_USHORT( p );
       
   418     GXV_KERN_FMT2_DATA( array )    = FT_NEXT_USHORT( p );
       
   419 
       
   420     GXV_TRACE(( "rowWidth = %d\n", GXV_KERN_FMT2_DATA( rowWidth ) ));
       
   421 
       
   422 
       
   423     GXV_LIMIT_CHECK( leftOffsetTable );
       
   424     GXV_LIMIT_CHECK( rightOffsetTable );
       
   425     GXV_LIMIT_CHECK( GXV_KERN_FMT2_DATA( array ) );
       
   426 
       
   427     gxv_kern_subtable_fmt2_clstbl_validate( table + leftOffsetTable, limit,
       
   428                                             GXV_KERN_CLS_L, valid );
       
   429 
       
   430     gxv_kern_subtable_fmt2_clstbl_validate( table + rightOffsetTable, limit,
       
   431                                             GXV_KERN_CLS_R, valid );
       
   432 
       
   433     if ( GXV_KERN_FMT2_DATA( offset_min[GXV_KERN_CLS_L] ) +
       
   434            GXV_KERN_FMT2_DATA( offset_min[GXV_KERN_CLS_R] )
       
   435          < GXV_KERN_FMT2_DATA( array )                      )
       
   436       FT_INVALID_OFFSET;
       
   437 
       
   438     gxv_odtect_add_range( table + GXV_KERN_FMT2_DATA( array ),
       
   439                           GXV_KERN_FMT2_DATA( offset_max[GXV_KERN_CLS_L] )
       
   440                             + GXV_KERN_FMT2_DATA( offset_max[GXV_KERN_CLS_R] )
       
   441                             - GXV_KERN_FMT2_DATA( array ),
       
   442                           "array", odtect );
       
   443 
       
   444     gxv_odtect_validate( odtect, valid );
       
   445 
       
   446     GXV_EXIT;
       
   447   }
       
   448 
       
   449 
       
   450   /* ============================= format 3 ============================== */
       
   451 
       
   452   static void
       
   453   gxv_kern_subtable_fmt3_validate( FT_Bytes       table,
       
   454                                    FT_Bytes       limit,
       
   455                                    GXV_Validator  valid )
       
   456   {
       
   457     FT_Bytes   p = table + GXV_KERN_SUBTABLE_HEADER_SIZE;
       
   458     FT_UShort  glyphCount;
       
   459     FT_Byte    kernValueCount;
       
   460     FT_Byte    leftClassCount;
       
   461     FT_Byte    rightClassCount;
       
   462     FT_Byte    flags;
       
   463 
       
   464 
       
   465     GXV_NAME_ENTER( "kern subtable format 3" );
       
   466 
       
   467     GXV_LIMIT_CHECK( 2 + 1 + 1 + 1 + 1 );
       
   468     glyphCount      = FT_NEXT_USHORT( p );
       
   469     kernValueCount  = FT_NEXT_BYTE( p );
       
   470     leftClassCount  = FT_NEXT_BYTE( p );
       
   471     rightClassCount = FT_NEXT_BYTE( p );
       
   472     flags           = FT_NEXT_BYTE( p );
       
   473 
       
   474     if ( valid->face->num_glyphs != glyphCount )
       
   475     {
       
   476       GXV_TRACE(( "maxGID=%d, but glyphCount=%d\n",
       
   477                   valid->face->num_glyphs, glyphCount ));
       
   478       if ( valid->root->level >= FT_VALIDATE_PARANOID )
       
   479         FT_INVALID_GLYPH_ID;
       
   480     }
       
   481 
       
   482     /*
       
   483      * just skip kernValue[kernValueCount]
       
   484      */
       
   485     GXV_LIMIT_CHECK( 2 * kernValueCount );
       
   486     p += 2 * kernValueCount;
       
   487 
       
   488     /*
       
   489      * check leftClass[gid] < leftClassCount
       
   490      */
       
   491     {
       
   492       FT_Byte  min, max;
       
   493 
       
   494 
       
   495       GXV_LIMIT_CHECK( glyphCount );
       
   496       gxv_array_getlimits_byte( p, p + glyphCount, &min, &max, valid );
       
   497       p += valid->subtable_length;
       
   498 
       
   499       if ( leftClassCount < max )
       
   500         FT_INVALID_DATA;
       
   501     }
       
   502 
       
   503     /*
       
   504      * check rightClass[gid] < rightClassCount
       
   505      */
       
   506     {
       
   507       FT_Byte  min, max;
       
   508 
       
   509 
       
   510       GXV_LIMIT_CHECK( glyphCount );
       
   511       gxv_array_getlimits_byte( p, p + glyphCount, &min, &max, valid );
       
   512       p += valid->subtable_length;
       
   513 
       
   514       if ( rightClassCount < max )
       
   515         FT_INVALID_DATA;
       
   516     }
       
   517 
       
   518     /*
       
   519      * check kernIndex[i, j] < kernValueCount
       
   520      */
       
   521     {
       
   522       FT_UShort  i, j;
       
   523 
       
   524 
       
   525       for ( i = 0; i < leftClassCount; i++ )
       
   526       {
       
   527         for ( j = 0; j < rightClassCount; j++ )
       
   528         {
       
   529           GXV_LIMIT_CHECK( 1 );
       
   530           if ( kernValueCount < FT_NEXT_BYTE( p ) )
       
   531             FT_INVALID_OFFSET;
       
   532         }
       
   533       }
       
   534     }
       
   535 
       
   536     valid->subtable_length = p - table;
       
   537 
       
   538     GXV_EXIT;
       
   539   }
       
   540 
       
   541 
       
   542   static FT_Bool
       
   543   gxv_kern_coverage_new_apple_validate( FT_UShort      coverage,
       
   544                                         FT_UShort*     format,
       
   545                                         GXV_Validator  valid )
       
   546   {
       
   547     /* new Apple-dialect */
       
   548     FT_Bool  kernVertical;
       
   549     FT_Bool  kernCrossStream;
       
   550     FT_Bool  kernVariation;
       
   551 
       
   552     FT_UNUSED( valid );
       
   553 
       
   554 
       
   555     /* reserved bits = 0 */
       
   556     if ( coverage & 0x1FFC )
       
   557       return 0;
       
   558 
       
   559     kernVertical    = FT_BOOL( ( coverage >> 15 ) & 1 );
       
   560     kernCrossStream = FT_BOOL( ( coverage >> 14 ) & 1 );
       
   561     kernVariation   = FT_BOOL( ( coverage >> 13 ) & 1 );
       
   562 
       
   563     *format = (FT_UShort)( coverage & 0x0003 );
       
   564 
       
   565     GXV_TRACE(( "new Apple-dialect: "
       
   566                 "horizontal=%d, cross-stream=%d, variation=%d, format=%d\n",
       
   567                  !kernVertical, kernCrossStream, kernVariation, *format ));
       
   568 
       
   569     GXV_TRACE(( "kerning values in Apple format subtable are ignored\n" ));
       
   570 
       
   571     return 1;
       
   572   }
       
   573 
       
   574 
       
   575   static FT_Bool
       
   576   gxv_kern_coverage_classic_apple_validate( FT_UShort      coverage,
       
   577                                             FT_UShort*     format,
       
   578                                             GXV_Validator  valid )
       
   579   {
       
   580     /* classic Apple-dialect */
       
   581     FT_Bool  horizontal;
       
   582     FT_Bool  cross_stream;
       
   583 
       
   584 
       
   585     /* check expected flags, but don't check if MS-dialect is impossible */
       
   586     if ( !( coverage & 0xFD00 ) && KERN_ALLOWS_MS( valid ) )
       
   587       return 0;
       
   588 
       
   589     /* reserved bits = 0 */
       
   590     if ( coverage & 0x02FC )
       
   591       return 0;
       
   592 
       
   593     horizontal   = FT_BOOL( ( coverage >> 15 ) & 1 );
       
   594     cross_stream = FT_BOOL( ( coverage >> 13 ) & 1 );
       
   595 
       
   596     *format = (FT_UShort)( coverage & 0x0003 );
       
   597 
       
   598     GXV_TRACE(( "classic Apple-dialect: "
       
   599                 "horizontal=%d, cross-stream=%d, format=%d\n",
       
   600                  horizontal, cross_stream, *format ));
       
   601 
       
   602     /* format 1 requires GX State Machine, too new for classic */
       
   603     if ( *format == 1 )
       
   604       return 0;
       
   605 
       
   606     GXV_TRACE(( "kerning values in Apple format subtable are ignored\n" ));
       
   607 
       
   608     return 1;
       
   609   }
       
   610 
       
   611 
       
   612   static FT_Bool
       
   613   gxv_kern_coverage_classic_microsoft_validate( FT_UShort      coverage,
       
   614                                                 FT_UShort*     format,
       
   615                                                 GXV_Validator  valid )
       
   616   {
       
   617     /* classic Microsoft-dialect */
       
   618     FT_Bool  horizontal;
       
   619     FT_Bool  minimum;
       
   620     FT_Bool  cross_stream;
       
   621     FT_Bool  override;
       
   622 
       
   623     FT_UNUSED( valid );
       
   624 
       
   625 
       
   626     /* reserved bits = 0 */
       
   627     if ( coverage & 0xFDF0 )
       
   628       return 0;
       
   629 
       
   630     horizontal   = FT_BOOL(   coverage        & 1 );
       
   631     minimum      = FT_BOOL( ( coverage >> 1 ) & 1 );
       
   632     cross_stream = FT_BOOL( ( coverage >> 2 ) & 1 );
       
   633     override     = FT_BOOL( ( coverage >> 3 ) & 1 );
       
   634 
       
   635     *format = (FT_UShort)( ( coverage >> 8 ) & 0x0003 );
       
   636 
       
   637     GXV_TRACE(( "classic Microsoft-dialect: "
       
   638                 "horizontal=%d, minimum=%d, cross-stream=%d, "
       
   639                 "override=%d, format=%d\n",
       
   640                 horizontal, minimum, cross_stream, override, *format ));
       
   641 
       
   642     if ( *format == 2 )
       
   643       GXV_TRACE((
       
   644         "kerning values in Microsoft format 2 subtable are ignored\n" ));
       
   645 
       
   646     return 1;
       
   647   }
       
   648 
       
   649 
       
   650   /*************************************************************************/
       
   651   /*************************************************************************/
       
   652   /*****                                                               *****/
       
   653   /*****                            MAIN                               *****/
       
   654   /*****                                                               *****/
       
   655   /*************************************************************************/
       
   656   /*************************************************************************/
       
   657 
       
   658   static GXV_kern_Dialect
       
   659   gxv_kern_coverage_validate( FT_UShort      coverage,
       
   660                               FT_UShort*     format,
       
   661                               GXV_Validator  valid )
       
   662   {
       
   663     GXV_kern_Dialect  result = KERN_DIALECT_UNKNOWN;
       
   664 
       
   665 
       
   666     GXV_NAME_ENTER( "validating coverage" );
       
   667 
       
   668     GXV_TRACE(( "interprete coverage 0x%04x by Apple style\n", coverage ));
       
   669 
       
   670     if ( KERN_IS_NEW( valid ) )
       
   671     {
       
   672       if ( gxv_kern_coverage_new_apple_validate( coverage,
       
   673                                                  format,
       
   674                                                  valid ) )
       
   675       {
       
   676         result = KERN_DIALECT_APPLE;
       
   677         goto Exit;
       
   678       }
       
   679     }
       
   680 
       
   681     if ( KERN_IS_CLASSIC( valid ) && KERN_ALLOWS_APPLE( valid ) )
       
   682     {
       
   683       if ( gxv_kern_coverage_classic_apple_validate( coverage,
       
   684                                                      format,
       
   685                                                      valid ) )
       
   686       {
       
   687         result = KERN_DIALECT_APPLE;
       
   688         goto Exit;
       
   689       }
       
   690     }
       
   691 
       
   692     if ( KERN_IS_CLASSIC( valid ) && KERN_ALLOWS_MS( valid ) )
       
   693     {
       
   694       if ( gxv_kern_coverage_classic_microsoft_validate( coverage,
       
   695                                                          format,
       
   696                                                          valid ) )
       
   697       {
       
   698         result = KERN_DIALECT_MS;
       
   699         goto Exit;
       
   700       }
       
   701     }
       
   702 
       
   703     GXV_TRACE(( "cannot interprete coverage, broken kern subtable\n" ));
       
   704 
       
   705   Exit:
       
   706     GXV_EXIT;
       
   707     return result;
       
   708   }
       
   709 
       
   710 
       
   711   static void
       
   712   gxv_kern_subtable_validate( FT_Bytes       table,
       
   713                               FT_Bytes       limit,
       
   714                               GXV_Validator  valid )
       
   715   {
       
   716     FT_Bytes   p = table;
       
   717     FT_UShort  version = 0;    /* MS only: subtable version, unused */
       
   718     FT_ULong   length;         /* MS: 16bit, Apple: 32bit*/
       
   719     FT_UShort  coverage;
       
   720     FT_UShort  tupleIndex = 0; /* Apple only */
       
   721     FT_UShort  u16[2];
       
   722     FT_UShort  format = 255;   /* subtable format */
       
   723 
       
   724 
       
   725     GXV_NAME_ENTER( "kern subtable" );
       
   726 
       
   727     GXV_LIMIT_CHECK( 2 + 2 + 2 );
       
   728     u16[0]   = FT_NEXT_USHORT( p ); /* Apple: length_hi MS: version */
       
   729     u16[1]   = FT_NEXT_USHORT( p ); /* Apple: length_lo MS: length */
       
   730     coverage = FT_NEXT_USHORT( p );
       
   731 
       
   732     switch ( gxv_kern_coverage_validate( coverage, &format, valid ) )
       
   733     {
       
   734     case KERN_DIALECT_MS:
       
   735       version    = u16[0];
       
   736       length     = u16[1];
       
   737       tupleIndex = 0;
       
   738       GXV_TRACE(( "Subtable version = %d\n", version ));
       
   739       GXV_TRACE(( "Subtable length = %d\n", length ));
       
   740       break;
       
   741 
       
   742     case KERN_DIALECT_APPLE:
       
   743       version    = 0;
       
   744       length     = ( u16[0] << 16 ) + u16[1];
       
   745       tupleIndex = 0;
       
   746       GXV_TRACE(( "Subtable length = %d\n", length ));
       
   747 
       
   748       if ( KERN_IS_NEW( valid ) )
       
   749       {
       
   750         GXV_LIMIT_CHECK( 2 );
       
   751         tupleIndex = FT_NEXT_USHORT( p );
       
   752         GXV_TRACE(( "Subtable tupleIndex = %d\n", tupleIndex ));
       
   753       }
       
   754       break;
       
   755 
       
   756     default:
       
   757       length = u16[1];
       
   758       GXV_TRACE(( "cannot detect subtable dialect, "
       
   759                   "just skip %d byte\n", length ));
       
   760       goto Exit;
       
   761     }
       
   762 
       
   763     /* formats 1, 2, 3 require the position of the start of this subtable */
       
   764     if ( format == 0 )
       
   765       gxv_kern_subtable_fmt0_validate( table, table + length, valid );
       
   766     else if ( format == 1 )
       
   767       gxv_kern_subtable_fmt1_validate( table, table + length, valid );
       
   768     else if ( format == 2 )
       
   769       gxv_kern_subtable_fmt2_validate( table, table + length, valid );
       
   770     else if ( format == 3 )
       
   771       gxv_kern_subtable_fmt3_validate( table, table + length, valid );
       
   772     else
       
   773       FT_INVALID_DATA;
       
   774 
       
   775   Exit:
       
   776     valid->subtable_length = length;
       
   777     GXV_EXIT;
       
   778   }
       
   779 
       
   780 
       
   781   /*************************************************************************/
       
   782   /*************************************************************************/
       
   783   /*****                                                               *****/
       
   784   /*****                         kern TABLE                            *****/
       
   785   /*****                                                               *****/
       
   786   /*************************************************************************/
       
   787   /*************************************************************************/
       
   788 
       
   789   static void
       
   790   gxv_kern_validate_generic( FT_Bytes          table,
       
   791                              FT_Face           face,
       
   792                              FT_Bool           classic_only,
       
   793                              GXV_kern_Dialect  dialect_request,
       
   794                              FT_Validator      ftvalid )
       
   795   {
       
   796     GXV_ValidatorRec   validrec;
       
   797     GXV_Validator      valid = &validrec;
       
   798 
       
   799     GXV_kern_DataRec   kernrec;
       
   800     GXV_kern_Data      kern = &kernrec;
       
   801 
       
   802     FT_Bytes           p     = table;
       
   803     FT_Bytes           limit = 0;
       
   804 
       
   805     FT_ULong           nTables = 0;
       
   806     FT_UInt            i;
       
   807 
       
   808 
       
   809     valid->root       = ftvalid;
       
   810     valid->table_data = kern;
       
   811     valid->face       = face;
       
   812 
       
   813     FT_TRACE3(( "validating `kern' table\n" ));
       
   814     GXV_INIT;
       
   815     KERN_DIALECT( valid ) = dialect_request;
       
   816 
       
   817     GXV_LIMIT_CHECK( 2 );
       
   818     GXV_KERN_DATA( version ) = (GXV_kern_Version)FT_NEXT_USHORT( p );
       
   819     GXV_TRACE(( "version 0x%04x (higher 16bit)\n",
       
   820                 GXV_KERN_DATA( version ) ));
       
   821 
       
   822     if ( 0x0001 < GXV_KERN_DATA( version ) )
       
   823       FT_INVALID_FORMAT;
       
   824     else if ( KERN_IS_CLASSIC( valid ) )
       
   825     {
       
   826       GXV_LIMIT_CHECK( 2 );
       
   827       nTables = FT_NEXT_USHORT( p );
       
   828     }
       
   829     else if ( KERN_IS_NEW( valid ) )
       
   830     {
       
   831       if ( classic_only )
       
   832         FT_INVALID_FORMAT;
       
   833 
       
   834       if ( 0x0000 != FT_NEXT_USHORT( p ) )
       
   835         FT_INVALID_FORMAT;
       
   836 
       
   837       GXV_LIMIT_CHECK( 4 );
       
   838       nTables = FT_NEXT_ULONG( p );
       
   839     }
       
   840 
       
   841     for ( i = 0; i < nTables; i++ )
       
   842     {
       
   843       GXV_TRACE(( "validating subtable %d/%d\n", i, nTables ));
       
   844       /* p should be 32bit-aligned? */
       
   845       gxv_kern_subtable_validate( p, 0, valid );
       
   846       p += valid->subtable_length;
       
   847     }
       
   848 
       
   849     FT_TRACE4(( "\n" ));
       
   850   }
       
   851 
       
   852 
       
   853   FT_LOCAL_DEF( void )
       
   854   gxv_kern_validate( FT_Bytes      table,
       
   855                      FT_Face       face,
       
   856                      FT_Validator  ftvalid )
       
   857   {
       
   858     gxv_kern_validate_generic( table, face, 0, KERN_DIALECT_ANY, ftvalid );
       
   859   }
       
   860 
       
   861 
       
   862   FT_LOCAL_DEF( void )
       
   863   gxv_kern_validate_classic( FT_Bytes      table,
       
   864                              FT_Face       face,
       
   865                              FT_Int        dialect_flags,
       
   866                              FT_Validator  ftvalid )
       
   867   {
       
   868     GXV_kern_Dialect  dialect_request;
       
   869 
       
   870 
       
   871     dialect_request = (GXV_kern_Dialect)dialect_flags;
       
   872     gxv_kern_validate_generic( table, face, 1, dialect_request, ftvalid );
       
   873   }
       
   874 
       
   875 
       
   876 /* END */