自学教程：C++ GXV_TRACE函数代码示例

  static void  gxv_mort_subtable_type0_entry_validate(    FT_Byte                         state,    FT_UShort                       flags,    GXV_StateTable_GlyphOffsetCPtr  glyphOffset_p,    FT_Bytes                        table,    FT_Bytes                        limit,    GXV_Validator                   valid )  {    FT_UShort  markFirst;    FT_UShort  dontAdvance;    FT_UShort  markLast;    FT_UShort  reserved;    FT_UShort  verb = 0;    FT_UNUSED( state );    FT_UNUSED( table );    FT_UNUSED( limit );    FT_UNUSED( GXV_Mort_IndicScript_Msg[verb] ); /* for the non-debugging */    FT_UNUSED( glyphOffset_p );                  /* case                  */    markFirst   = (FT_UShort)( ( flags >> 15 ) & 1 );    dontAdvance = (FT_UShort)( ( flags >> 14 ) & 1 );    markLast    = (FT_UShort)( ( flags >> 13 ) & 1 );    reserved = (FT_UShort)( flags & 0x1FF0 );    verb     = (FT_UShort)( flags & 0x000F );    GXV_TRACE(( "  IndicScript MorphRule for glyphOffset 0x%04x",                glyphOffset_p->u ));    GXV_TRACE(( " markFirst=%01d", markFirst ));    GXV_TRACE(( " dontAdvance=%01d", dontAdvance ));    GXV_TRACE(( " markLast=%01d", markLast ));    GXV_TRACE(( " %02d", verb ));    GXV_TRACE(( " %s/n", GXV_Mort_IndicScript_Msg[verb] ));    if ( markFirst > 0 && markLast > 0 )    {      GXV_TRACE(( "  [odd] a glyph is marked as the first and last"                  "  in Indic rearrangement/n" ));      GXV_SET_ERR_IF_PARANOID( FT_INVALID_DATA );    }    if ( markFirst > 0 && dontAdvance > 0 )    {      GXV_TRACE(( "  [odd] the first glyph is marked as dontAdvance"                  " in Indic rearrangement/n" ));      GXV_SET_ERR_IF_PARANOID( FT_INVALID_DATA );    }    if ( 0 < reserved )    {      GXV_TRACE(( " non-zero bits found in reserved range/n" ));      GXV_SET_ERR_IF_PARANOID( FT_INVALID_DATA );    }    else      GXV_TRACE(( "/n" ));  }

  static FT_Bool  gxv_kern_coverage_classic_apple_validate( FT_UShort      coverage,                                            FT_UShort*     format,                                            GXV_Validator  valid )  {    /* classic Apple-dialect */    FT_Bool  horizontal;    FT_Bool  cross_stream;    /* check expected flags, but don't check if MS-dialect is impossible */    if ( !( coverage & 0xFD00 ) && KERN_ALLOWS_MS( valid ) )      return 0;    /* reserved bits = 0 */    if ( coverage & 0x02FC )      return 0;    horizontal   = FT_BOOL( ( coverage >> 15 ) & 1 );    cross_stream = FT_BOOL( ( coverage >> 13 ) & 1 );    *format = (FT_UShort)( coverage & 0x0003 );    GXV_TRACE(( "classic Apple-dialect: "                "horizontal=%d, cross-stream=%d, format=%d/n",                 horizontal, cross_stream, *format ));    /* format 1 requires GX State Machine, too new for classic */    if ( *format == 1 )      return 0;    GXV_TRACE(( "kerning values in Apple format subtable are ignored/n" ));    return 1;  }

  static FT_Bool  gxv_kern_coverage_new_apple_validate( FT_UShort      coverage,                                        FT_UShort*     format,                                        GXV_Validator  gxvalid )  {    /* new Apple-dialect */#ifdef GXV_LOAD_TRACE_VARS    FT_Bool  kernVertical;    FT_Bool  kernCrossStream;    FT_Bool  kernVariation;#endif    FT_UNUSED( gxvalid );    /* reserved bits = 0 */    if ( coverage & 0x1FFC )      return FALSE;#ifdef GXV_LOAD_TRACE_VARS    kernVertical    = FT_BOOL( ( coverage >> 15 ) & 1 );    kernCrossStream = FT_BOOL( ( coverage >> 14 ) & 1 );    kernVariation   = FT_BOOL( ( coverage >> 13 ) & 1 );#endif    *format = (FT_UShort)( coverage & 0x0003 );    GXV_TRACE(( "new Apple-dialect: "                "horizontal=%d, cross-stream=%d, variation=%d, format=%d/n",                 !kernVertical, kernCrossStream, kernVariation, *format ));    GXV_TRACE(( "kerning values in Apple format subtable are ignored/n" ));    return TRUE;  }

  static void  gxv_just_actSubrecord_type4_validate( FT_Bytes       table,                                        FT_Bytes       limit,                                        GXV_Validator  gxvalid )  {    FT_Bytes  p = table;    FT_ULong  variantsAxis;    FT_Fixed  minimumLimit;    FT_Fixed  noStretchValue;    FT_Fixed  maximumLimit;    GXV_LIMIT_CHECK( 4 + 4 + 4 + 4 );    variantsAxis   = FT_NEXT_ULONG( p );    minimumLimit   = FT_NEXT_ULONG( p );    noStretchValue = FT_NEXT_ULONG( p );    maximumLimit   = FT_NEXT_ULONG( p );    gxvalid->subtable_length = p - table;    if ( variantsAxis != 0x64756374L ) /* 'duct' */      GXV_TRACE(( "variantsAxis 0x%08x is non default value",                   variantsAxis ));    if ( minimumLimit > noStretchValue )      GXV_TRACE(( "type4:minimumLimit 0x%08x > noStretchValue 0x%08x/n",                  minimumLimit, noStretchValue ));    else if ( noStretchValue > maximumLimit )      GXV_TRACE(( "type4:noStretchValue 0x%08x > maximumLimit 0x%08x/n",                  noStretchValue, maximumLimit ));    else if ( !IS_PARANOID_VALIDATION )      return;    FT_INVALID_DATA;  }

  static void  gxv_morx_subtable_type1_entry_validate(    FT_UShort                       state,    FT_UShort                       flags,    GXV_StateTable_GlyphOffsetCPtr  glyphOffset_p,    FT_Bytes                        table,    FT_Bytes                        limit,    GXV_Validator                   valid )  {#ifdef GXV_LOAD_TRACE_VARS    FT_UShort  setMark;    FT_UShort  dontAdvance;#endif    FT_UShort  reserved;    FT_Short   markIndex;    FT_Short   currentIndex;    GXV_morx_subtable_type1_StateOptRecData  optdata =      (GXV_morx_subtable_type1_StateOptRecData)valid->xstatetable.optdata;    FT_UNUSED( state );    FT_UNUSED( table );    FT_UNUSED( limit );#ifdef GXV_LOAD_TRACE_VARS    setMark      = (FT_UShort)( ( flags >> 15 ) & 1 );    dontAdvance  = (FT_UShort)( ( flags >> 14 ) & 1 );#endif    reserved = (FT_UShort)( flags & 0x3FFF );    markIndex    = (FT_Short)( glyphOffset_p->ul >> 16 );    currentIndex = (FT_Short)( glyphOffset_p->ul       );    GXV_TRACE(( " setMark=%01d dontAdvance=%01d/n",                setMark, dontAdvance ));    if ( 0 < reserved )    {      GXV_TRACE(( " non-zero bits found in reserved range/n" ));      GXV_SET_ERR_IF_PARANOID( FT_INVALID_DATA );    }    GXV_TRACE(( "markIndex = %d, currentIndex = %d/n",                markIndex, currentIndex ));    if ( optdata->substitutionTable_num_lookupTables < markIndex + 1 )      optdata->substitutionTable_num_lookupTables =        (FT_Short)( markIndex + 1 );    if ( optdata->substitutionTable_num_lookupTables < currentIndex + 1 )      optdata->substitutionTable_num_lookupTables =        (FT_Short)( currentIndex + 1 );  }

  gxv_opbd_validate( FT_Bytes      table,                     FT_Face       face,                     FT_Validator  ftvalid )  {    GXV_ValidatorRec  gxvalidrec;    GXV_Validator     gxvalid = &gxvalidrec;    GXV_opbd_DataRec  opbdrec;    GXV_opbd_Data     opbd  = &opbdrec;    FT_Bytes          p     = table;    FT_Bytes          limit = 0;    FT_ULong  version;    gxvalid->root       = ftvalid;    gxvalid->table_data = opbd;    gxvalid->face       = face;    FT_TRACE3(( "validating `opbd' table/n" ));    GXV_INIT;    GXV_OPBD_DATA( valueOffset_min ) = 0xFFFFU;    GXV_LIMIT_CHECK( 4 + 2 );    version                 = FT_NEXT_ULONG( p );    GXV_OPBD_DATA( format ) = FT_NEXT_USHORT( p );    /* only 0x00010000 is defined (1996) */    GXV_TRACE(( "(version=0x%08x)/n", version ));    if ( 0x00010000UL != version )      FT_INVALID_FORMAT;    /* only values 0 and 1 are defined (1996) */    GXV_TRACE(( "(format=0x%04x)/n", GXV_OPBD_DATA( format ) ));    if ( 0x0001 < GXV_OPBD_DATA( format ) )      FT_INVALID_FORMAT;    gxvalid->lookupval_sign   = GXV_LOOKUPVALUE_UNSIGNED;    gxvalid->lookupval_func   = gxv_opbd_LookupValue_validate;    gxvalid->lookupfmt4_trans = gxv_opbd_LookupFmt4_transit;    gxv_LookupTable_validate( p, limit, gxvalid );    p += gxvalid->subtable_length;    if ( p > table + GXV_OPBD_DATA( valueOffset_min ) )    {      GXV_TRACE((        "found overlap between LookupTable and opbd_value array/n" ));      FT_INVALID_OFFSET;    }    FT_TRACE4(( "/n" ));  }

  static void  gxv_mort_subtable_type2_ligActionOffset_validate(    FT_Bytes       table,    FT_UShort      ligActionOffset,    GXV_Validator  valid )  {    /* access ligActionTable */    GXV_mort_subtable_type2_StateOptRecData  optdata =      (GXV_mort_subtable_type2_StateOptRecData)valid->statetable.optdata;    FT_Bytes lat_base  = table + optdata->ligActionTable;    FT_Bytes p         = table + ligActionOffset;    FT_Bytes lat_limit = lat_base + optdata->ligActionTable;    GXV_32BIT_ALIGNMENT_VALIDATE( ligActionOffset );    if ( p < lat_base )    {      GXV_TRACE(( "too short offset 0x%04x: p < lat_base (%d byte rewind)/n",                  ligActionOffset, lat_base - p ));      /* FontValidator, ftxvalidator, ftxdumperfuser warn but continue */      if ( valid->root->level >= FT_VALIDATE_PARANOID )        FT_INVALID_OFFSET;    }    else if ( lat_limit < p )    {      GXV_TRACE(( "too large offset 0x%04x: lat_limit < p (%d byte overrun)/n",                  ligActionOffset, p - lat_limit ));      /* FontValidator, ftxvalidator, ftxdumperfuser warn but continue */      if ( valid->root->level >= FT_VALIDATE_PARANOID )        FT_INVALID_OFFSET;    }    else    {      /* validate entry in ligActionTable */      FT_ULong   lig_action;      FT_UShort  last;      FT_UShort  store;      FT_ULong   offset;      lig_action = FT_NEXT_ULONG( p );      last   = (FT_UShort)( ( lig_action >> 31 ) & 1 );      store  = (FT_UShort)( ( lig_action >> 30 ) & 1 );      offset = lig_action & 0x3FFFFFFFUL;    }  }

  static void  gxv_just_justClassTable_validate ( FT_Bytes       table,                                     FT_Bytes       limit,                                     GXV_Validator  valid )  {    FT_Bytes   p = table;    FT_UShort  length;    FT_UShort  coverage;    FT_ULong   subFeatureFlags;    GXV_NAME_ENTER( "just justClassTable" );    GXV_LIMIT_CHECK( 2 + 2 + 4 );    length          = FT_NEXT_USHORT( p );    coverage        = FT_NEXT_USHORT( p );    subFeatureFlags = FT_NEXT_ULONG( p );    GXV_TRACE(( "  justClassTable: coverage = 0x%04x (%s)",                coverage,                ( 0x4000 & coverage ) == 0 ? "ascending" : "descending" ));    valid->statetable.optdata               = NULL;    valid->statetable.optdata_load_func     = NULL;    valid->statetable.subtable_setup_func   = NULL;    valid->statetable.entry_glyphoffset_fmt = GXV_GLYPHOFFSET_NONE;    valid->statetable.entry_validate_func   =      gxv_just_classTable_entry_validate;    gxv_StateTable_validate( p, table + length, valid );    /* subtable_length is set by gxv_LookupTable_validate() */    GXV_EXIT;  }

  static void  gxv_kern_subtable_fmt2_clstbl_validate( FT_Bytes            table,                                          FT_Bytes            limit,                                          GXV_kern_ClassSpec  spec,                                          GXV_Validator       gxvalid )  {    const FT_String*  tag    = GXV_KERN_FMT2_DATA( class_tag[spec] );    GXV_odtect_Range  odtect = GXV_KERN_FMT2_DATA( odtect );    FT_Bytes   p = table;    FT_UShort  firstGlyph;    FT_UShort  nGlyphs;    GXV_NAME_ENTER( "kern format 2 classTable" );    GXV_LIMIT_CHECK( 2 + 2 );    firstGlyph = FT_NEXT_USHORT( p );    nGlyphs    = FT_NEXT_USHORT( p );    GXV_TRACE(( " %s firstGlyph=%d, nGlyphs=%d/n",                tag, firstGlyph, nGlyphs ));    gxv_glyphid_validate( firstGlyph, gxvalid );    gxv_glyphid_validate( (FT_UShort)( firstGlyph + nGlyphs - 1 ), gxvalid );    gxv_array_getlimits_ushort( p, p + ( 2 * nGlyphs ),                                &( GXV_KERN_FMT2_DATA( offset_min[spec] ) ),                                &( GXV_KERN_FMT2_DATA( offset_max[spec] ) ),                                gxvalid );    gxv_odtect_add_range( table, 2 * nGlyphs, tag, odtect );    GXV_EXIT;  }

  static void  gxv_morx_subtable_type0_entry_validate(    FT_UShort                        state,    FT_UShort                        flags,    GXV_XStateTable_GlyphOffsetDesc  glyphOffset,    FT_Bytes                         table,    FT_Bytes                         limit,    GXV_Validator                    valid )  {    FT_UShort  markFirst;    FT_UShort  dontAdvance;    FT_UShort  markLast;    FT_UShort  reserved;    FT_UShort  verb;    FT_UNUSED( state );    FT_UNUSED( glyphOffset );    FT_UNUSED( table );    FT_UNUSED( limit );    markFirst   = (FT_UShort)( ( flags >> 15 ) & 1 );    dontAdvance = (FT_UShort)( ( flags >> 14 ) & 1 );    markLast    = (FT_UShort)( ( flags >> 13 ) & 1 );    reserved = (FT_UShort)( flags & 0x1FF0 );    verb     = (FT_UShort)( flags & 0x000F );    if ( 0 < reserved )    {      GXV_TRACE(( " non-zero bits found in reserved range/n" ));      FT_INVALID_DATA;    }  }

static voidgxv_mort_subtable_type1_substTable_validate( FT_Bytes       table,        FT_Bytes       limit,        GXV_Validator  valid ){    FT_Bytes   p = table;    FT_UShort  num_gids = (FT_UShort)(                              ((GXV_mort_subtable_type1_StateOptRec *)                               (valid->statetable.optdata))->substitutionTable_length / 2 );    FT_UShort  i;    GXV_NAME_ENTER( "validating contents of substitutionTable" );    for ( i = 0; i < num_gids ; i ++ )    {        FT_UShort  dst_gid;        GXV_LIMIT_CHECK( 2 );        dst_gid = FT_NEXT_USHORT( p );        if ( dst_gid >= 0xFFFFU )            continue;        if ( dst_gid < valid->min_gid || valid->max_gid < dst_gid )        {            GXV_TRACE(( "substTable include a strange gid[%d]=%d >"                        " out of define range (%d..%d)/n",                        i, dst_gid, valid->min_gid, valid->max_gid ));            GXV_SET_ERR_IF_PARANOID( FT_INVALID_GLYPH_ID );        }    }    GXV_EXIT;}

  gxv_bsln_validate( FT_Bytes      table,                     FT_Face       face,                     FT_Validator  ftvalid )  {    GXV_ValidatorRec  validrec;    GXV_Validator     valid = &validrec;    GXV_bsln_DataRec  bslnrec;    GXV_bsln_Data     bsln = &bslnrec;    FT_Bytes  p     = table;    FT_Bytes  limit = 0;    FT_ULong   version;    FT_UShort  format;    FT_UShort  defaultBaseline;    GXV_Validate_Func  fmt_funcs_table [] =    {      gxv_bsln_parts_fmt0_validate,      gxv_bsln_parts_fmt1_validate,      gxv_bsln_parts_fmt2_validate,      gxv_bsln_parts_fmt3_validate,    };    valid->root       = ftvalid;    valid->table_data = bsln;    valid->face       = face;    FT_TRACE3(( "validating `bsln' table/n" ));    GXV_INIT;    GXV_LIMIT_CHECK( 4 + 2 + 2 );    version         = FT_NEXT_ULONG( p );    format          = FT_NEXT_USHORT( p );    defaultBaseline = FT_NEXT_USHORT( p );    /* only version 1.0 is defined (1996) */    if ( version != 0x00010000UL )      FT_INVALID_FORMAT;    /* only format 1, 2, 3 are defined (1996) */    GXV_TRACE(( " (format = %d)/n", format ));    if ( format > 3 )      FT_INVALID_FORMAT;    if ( defaultBaseline > 31 )      FT_INVALID_FORMAT;    bsln->defaultBaseline = defaultBaseline;    fmt_funcs_table[format]( p, limit, valid );    FT_TRACE4(( "/n" ));  }

  static void  gxv_kern_subtable_fmt0_pairs_validate( FT_Bytes       table,                                         FT_Bytes       limit,                                         FT_UShort      nPairs,                                         GXV_Validator  valid )  {    FT_Bytes   p = table;    FT_UShort  i;    FT_UShort  last_gid_left  = 0;    FT_UShort  last_gid_right = 0;    FT_UNUSED( limit );    GXV_NAME_ENTER( "kern format 0 pairs" );    for ( i = 0; i < nPairs; i++ )    {      FT_UShort  gid_left;      FT_UShort  gid_right;      FT_Short   kernValue;      /* left */      gid_left  = FT_NEXT_USHORT( p );      gxv_glyphid_validate( gid_left, valid );      /* right */      gid_right = FT_NEXT_USHORT( p );      gxv_glyphid_validate( gid_right, valid );      /* Pairs of left and right GIDs must be unique and sorted. */      GXV_TRACE(( "left gid = %u, right gid = %u/n", gid_left, gid_right ));      if ( gid_left == last_gid_left )      {        if ( last_gid_right < gid_right )          last_gid_right = gid_right;        else          FT_INVALID_DATA;      }      else if ( last_gid_left < gid_left )      {        last_gid_left  = gid_left;        last_gid_right = gid_right;      }      else        FT_INVALID_DATA;      /* skip the kern value */      kernValue = FT_NEXT_SHORT( p );    }    GXV_EXIT;  }

  static void  gxv_kern_subtable_fmt2_validate( FT_Bytes       table,                                   FT_Bytes       limit,                                   GXV_Validator  gxvalid )  {    GXV_ODTECT( 3, odtect );    GXV_kern_subtable_fmt2_DataRec  fmt2_rec =      { 0, 0, { 0, 0 }, { 0, 0 }, { "leftClass", "rightClass" }, NULL };    FT_Bytes   p = table + GXV_KERN_SUBTABLE_HEADER_SIZE;    FT_UShort  leftOffsetTable;    FT_UShort  rightOffsetTable;    GXV_NAME_ENTER( "kern subtable format 2" );    GXV_ODTECT_INIT( odtect );    fmt2_rec.odtect = odtect;    GXV_KERN_DATA( subtable_data ) = &fmt2_rec;    GXV_LIMIT_CHECK( 2 + 2 + 2 + 2 );    GXV_KERN_FMT2_DATA( rowWidth ) = FT_NEXT_USHORT( p );    leftOffsetTable                = FT_NEXT_USHORT( p );    rightOffsetTable               = FT_NEXT_USHORT( p );    GXV_KERN_FMT2_DATA( array )    = FT_NEXT_USHORT( p );    GXV_TRACE(( "rowWidth = %d/n", GXV_KERN_FMT2_DATA( rowWidth ) ));    GXV_LIMIT_CHECK( leftOffsetTable );    GXV_LIMIT_CHECK( rightOffsetTable );    GXV_LIMIT_CHECK( GXV_KERN_FMT2_DATA( array ) );    gxv_kern_subtable_fmt2_clstbl_validate( table + leftOffsetTable, limit,                                            GXV_KERN_CLS_L, gxvalid );    gxv_kern_subtable_fmt2_clstbl_validate( table + rightOffsetTable, limit,                                            GXV_KERN_CLS_R, gxvalid );    if ( GXV_KERN_FMT2_DATA( offset_min[GXV_KERN_CLS_L] ) +           GXV_KERN_FMT2_DATA( offset_min[GXV_KERN_CLS_R] )         < GXV_KERN_FMT2_DATA( array )                      )      FT_INVALID_OFFSET;    gxv_odtect_add_range( table + GXV_KERN_FMT2_DATA( array ),                          GXV_KERN_FMT2_DATA( offset_max[GXV_KERN_CLS_L] )                            + GXV_KERN_FMT2_DATA( offset_max[GXV_KERN_CLS_R] )                            - GXV_KERN_FMT2_DATA( array ),                          "array", odtect );    gxv_odtect_validate( odtect, gxvalid );    GXV_EXIT;  }

  static void  gxv_trak_trackData_validate( FT_Bytes       table,                               FT_Bytes       limit,                               GXV_Validator  gxvalid )  {    FT_Bytes   p = table;    FT_UShort  nTracks;    FT_UShort  nSizes;    FT_ULong   sizeTableOffset;    GXV_ODTECT( 4, odtect );    GXV_ODTECT_INIT( odtect );    GXV_NAME_ENTER( "trackData" );    /* read the header of trackData */    GXV_LIMIT_CHECK( 2 + 2 + 4 );    nTracks         = FT_NEXT_USHORT( p );    nSizes          = FT_NEXT_USHORT( p );    sizeTableOffset = FT_NEXT_ULONG( p );    gxv_odtect_add_range( table, (FT_ULong)( p - table ),                          "trackData header", odtect );    /* validate trackTable */    gxv_trak_trackTable_validate( p, limit, nTracks, gxvalid );    gxv_odtect_add_range( p, gxvalid->subtable_length,                          "trackTable", odtect );    /* sizeTable is array of FT_Fixed, don't check contents */    p = gxvalid->root->base + sizeTableOffset;    GXV_LIMIT_CHECK( nSizes * 4 );    gxv_odtect_add_range( p, nSizes * 4, "sizeTable", odtect );    /* validate trackValueOffet */    p = gxvalid->root->base + GXV_TRAK_DATA( trackValueOffset_min );    if ( limit - p < nTracks * nSizes * 2 )      GXV_TRACE(( "too short trackValue array/n" ));    p = gxvalid->root->base + GXV_TRAK_DATA( trackValueOffset_max );    GXV_LIMIT_CHECK( nSizes * 2 );    gxv_odtect_add_range( gxvalid->root->base                            + GXV_TRAK_DATA( trackValueOffset_min ),                          GXV_TRAK_DATA( trackValueOffset_max )                            - GXV_TRAK_DATA( trackValueOffset_min )                            + nSizes * 2,                          "trackValue array", odtect );    gxv_odtect_validate( odtect, gxvalid );    GXV_EXIT;  }

  static void  gxv_mort_subtable_type5_InsertList_validate( FT_UShort      offset,                                               FT_UShort      count,                                               FT_Bytes       table,                                               FT_Bytes       limit,                                               GXV_Validator  gxvalid )  {    /*     * We don't know the range of insertion-glyph-list.     * Set range by whole of state table.     */    FT_Bytes  p = table + offset;    GXV_mort_subtable_type5_StateOptRecData  optdata =      (GXV_mort_subtable_type5_StateOptRecData)gxvalid->statetable.optdata;    if ( optdata->classTable < offset                                   &&         offset < optdata->classTable + *(optdata->classTable_length_p) )      GXV_TRACE(( " offset runs into ClassTable" ));    if ( optdata->stateArray < offset                                   &&         offset < optdata->stateArray + *(optdata->stateArray_length_p) )      GXV_TRACE(( " offset runs into StateArray" ));    if ( optdata->entryTable < offset                                   &&         offset < optdata->entryTable + *(optdata->entryTable_length_p) )      GXV_TRACE(( " offset runs into EntryTable" ));#ifndef GXV_LOAD_TRACE_VARS    GXV_LIMIT_CHECK( count * 2 );#else    while ( p < table + offset + ( count * 2 ) )    {      FT_UShort insert_glyphID;      GXV_LIMIT_CHECK( 2 );      insert_glyphID = FT_NEXT_USHORT( p );      GXV_TRACE(( " 0x%04x", insert_glyphID ));    }    GXV_TRACE(( "/n" ));#endif  }

  static void  gxv_just_justClassTable_validate ( FT_Bytes       table,                                     FT_Bytes       limit,                                     GXV_Validator  gxvalid )  {    FT_Bytes   p = table;    FT_UShort  length;    FT_UShort  coverage;    FT_ULong   subFeatureFlags;    GXV_NAME_ENTER( "just justClassTable" );    GXV_LIMIT_CHECK( 2 + 2 + 4 );    length          = FT_NEXT_USHORT( p );    coverage        = FT_NEXT_USHORT( p );    subFeatureFlags = FT_NEXT_ULONG( p );    GXV_TRACE(( "  justClassTable: coverage = 0x%04x (%s) ", coverage ));    if ( ( coverage & 0x4000 ) == 0  )      GXV_TRACE(( "ascending/n" ));    else      GXV_TRACE(( "descending/n" ));    if ( subFeatureFlags )      GXV_TRACE(( "  justClassTable: nonzero value (0x%08x)"                  " in unused subFeatureFlags/n", subFeatureFlags ));    gxvalid->statetable.optdata               = NULL;    gxvalid->statetable.optdata_load_func     = NULL;    gxvalid->statetable.subtable_setup_func   = NULL;    gxvalid->statetable.entry_glyphoffset_fmt = GXV_GLYPHOFFSET_NONE;    gxvalid->statetable.entry_validate_func   =      gxv_just_classTable_entry_validate;    gxv_StateTable_validate( p, table + length, gxvalid );    /* subtable_length is set by gxv_LookupTable_validate() */    GXV_EXIT;  }

  static void  gxv_morx_subtable_type1_LookupValue_validate( FT_UShort            glyph,                                                GXV_LookupValueCPtr  value_p,                                                GXV_Validator        valid )  {    FT_UNUSED( glyph ); /* for the non-debugging case */    GXV_TRACE(( "morx subtable type1 subst.: %d -> %d/n", glyph, value_p->u ));    if ( value_p->u > valid->face->num_glyphs )      FT_INVALID_GLYPH_ID;  }

  gxv_mort_coverage_validate( FT_UShort      coverage,                              GXV_Validator  valid )  {    FT_UNUSED( valid );#ifdef FT_DEBUG_LEVEL_TRACE    if ( coverage & 0x8000U )      GXV_TRACE(( " this subtable is for vertical text only/n" ));    else      GXV_TRACE(( " this subtable is for horizontal text only/n" ));    if ( coverage & 0x4000 )      GXV_TRACE(( " this subtable is applied to glyph array "                  "in descending order/n" ));    else      GXV_TRACE(( " this subtable is applied to glyph array "                  "in ascending order/n" ));    if ( coverage & 0x2000 )      GXV_TRACE(( " this subtable is forcibly applied to "                  "vertical/horizontal text/n" ));    if ( coverage & 0x1FF8 )      GXV_TRACE(( " coverage has non-zero bits in reserved area/n" ));#endif  }

  /* GX just table does not define their subset of GID */  static void  gxv_just_check_max_gid( FT_UShort         gid,                          const FT_String*  msg_tag,                          GXV_Validator     gxvalid )  {    if ( gid < gxvalid->face->num_glyphs )      return;    GXV_TRACE(( "just table includes too large %s"                " GID=%d > %d (in maxp)/n",                msg_tag, gid, gxvalid->face->num_glyphs ));    GXV_SET_ERR_IF_PARANOID( FT_INVALID_GLYPH_ID );  }

  static void  gxv_mort_subtable_type2_opttable_load(FT_Bytes       table,                                         FT_Bytes       limit,                                         GXV_Validator  gxvalid)  {    FT_Bytes  p = table;    GXV_mort_subtable_type2_StateOptRecData  optdata =      (GXV_mort_subtable_type2_StateOptRecData)gxvalid->statetable.optdata;    GXV_LIMIT_CHECK(2 + 2 + 2);    optdata->ligActionTable = FT_NEXT_USHORT(p);    optdata->componentTable = FT_NEXT_USHORT(p);    optdata->ligatureTable  = FT_NEXT_USHORT(p);    GXV_TRACE(("offset to ligActionTable=0x%04x/n",                optdata->ligActionTable));    GXV_TRACE(("offset to componentTable=0x%04x/n",                optdata->componentTable));    GXV_TRACE(("offset to ligatureTable=0x%04x/n",                optdata->ligatureTable));  }

  static void  gxv_mort_subtable_type0_entry_validate(    FT_Byte                         state,    FT_UShort                       flags,    GXV_StateTable_GlyphOffsetDesc  glyphOffset,    FT_Bytes                        table,    FT_Bytes                        limit,    GXV_Validator                   valid )  {    FT_UShort  markFirst;    FT_UShort  dontAdvance;    FT_UShort  markLast;    FT_UShort  reserved;    FT_UShort  verb = 0;    FT_UNUSED( state );    FT_UNUSED( table );    FT_UNUSED( limit );    FT_UNUSED( GXV_Mort_IndicScript_Msg[verb] ); /* for the non-debugging */    FT_UNUSED( glyphOffset );                    /* case                  */    markFirst   = (FT_UShort)( ( flags >> 15 ) & 1 );    dontAdvance = (FT_UShort)( ( flags >> 14 ) & 1 );    markLast    = (FT_UShort)( ( flags >> 13 ) & 1 );    reserved = (FT_UShort)( flags & 0x1FF0 );    verb     = (FT_UShort)( flags & 0x000F );    GXV_TRACE(( "  IndicScript MorphRule for glyphOffset 0x%04x",                glyphOffset.u ));    GXV_TRACE(( " markFirst=%01d", markFirst ));    GXV_TRACE(( " dontAdvance=%01d", dontAdvance ));    GXV_TRACE(( " markLast=%01d", markLast ));    GXV_TRACE(( " %02d", verb ));    GXV_TRACE(( " %s/n", GXV_Mort_IndicScript_Msg[verb] ));    if ( 0 < reserved )    {      GXV_TRACE(( " non-zero bits found in reserved range/n" ));      FT_INVALID_DATA;    }    else      GXV_TRACE(( "/n" ));  }

  static void  gxv_feat_registry_validate( FT_UShort      feature,                              FT_UShort      nSettings,                              FT_Bool        exclusive,                              GXV_Validator  valid )  {    GXV_NAME_ENTER( "feature in registry" );    GXV_TRACE(( " (feature = %u)/n", feature ));    if ( feature >= gxv_feat_registry_length )    {      GXV_TRACE(( "feature number %d is out of range %d/n",                  feature, gxv_feat_registry_length ));      if ( valid->root->level == FT_VALIDATE_PARANOID )        FT_INVALID_DATA;      goto Exit;    }    if ( gxv_feat_registry[feature].existence == 0 )    {      GXV_TRACE(( "feature number %d is in defined range but doesn't exist/n",                  feature ));      if ( valid->root->level == FT_VALIDATE_PARANOID )        FT_INVALID_DATA;      goto Exit;    }    if ( gxv_feat_registry[feature].apple_reserved )    {      /* Don't use here. Apple is reserved. */      GXV_TRACE(( "feature number %d is reserved by Apple/n", feature ));      if ( valid->root->level >= FT_VALIDATE_TIGHT )        FT_INVALID_DATA;    }    if ( nSettings != gxv_feat_registry[feature].nSettings )    {      GXV_TRACE(( "feature %d: nSettings %d != defined nSettings %d/n",                  feature, nSettings,                  gxv_feat_registry[feature].nSettings ));      if ( valid->root->level >= FT_VALIDATE_TIGHT )        FT_INVALID_DATA;    }    if ( exclusive != gxv_feat_registry[feature].exclusive )    {      GXV_TRACE(( "exclusive flag %d differs from predefined value/n",                  exclusive ));      if ( valid->root->level >= FT_VALIDATE_TIGHT )        FT_INVALID_DATA;    }  Exit:    GXV_EXIT;  }

  static void  gxv_trak_trackTable_validate( FT_Bytes       table,                                FT_Bytes       limit,                                FT_UShort      nTracks,                                GXV_Validator  gxvalid )  {    FT_Bytes  p = table;    FT_Fixed   track, t;    FT_UShort  nameIndex;    FT_UShort  offset;    FT_UShort  i, j;    GXV_NAME_ENTER( "trackTable" );    GXV_TRAK_DATA( trackValueOffset_min ) = 0xFFFFU;    GXV_TRAK_DATA( trackValueOffset_max ) = 0x0000;    GXV_LIMIT_CHECK( nTracks * ( 4 + 2 + 2 ) );    for ( i = 0; i < nTracks; i ++ )    {      p = table + i * ( 4 + 2 + 2 );      track     = FT_NEXT_LONG( p );      nameIndex = FT_NEXT_USHORT( p );      offset    = FT_NEXT_USHORT( p );      if ( offset < GXV_TRAK_DATA( trackValueOffset_min ) )        GXV_TRAK_DATA( trackValueOffset_min ) = offset;      if ( offset > GXV_TRAK_DATA( trackValueOffset_max ) )        GXV_TRAK_DATA( trackValueOffset_max ) = offset;      gxv_sfntName_validate( nameIndex, 256, 32767, gxvalid );      for ( j = i; j < nTracks; j ++ )      {         p = table + j * ( 4 + 2 + 2 );         t = FT_NEXT_LONG( p );         if ( t == track )           GXV_TRACE(( "duplicated entries found for track value 0x%x/n",                        track ));      }    }    gxvalid->subtable_length = p - table;    GXV_EXIT;  }

static voidgxv_mort_subtable_type1_entry_validate(    FT_Byte                         state,    FT_UShort                       flags,    GXV_StateTable_GlyphOffsetCPtr  glyphOffset_p,    FT_Bytes                        table,    FT_Bytes                        limit,    GXV_Validator                   valid ){#ifdef GXV_LOAD_UNUSED_VARS    FT_UShort  setMark;    FT_UShort  dontAdvance;#endif    FT_UShort  reserved;    FT_Short   markOffset;    FT_Short   currentOffset;    FT_UNUSED( table );    FT_UNUSED( limit );#ifdef GXV_LOAD_UNUSED_VARS    setMark       = (FT_UShort)(   flags >> 15            );    dontAdvance   = (FT_UShort)( ( flags >> 14 ) & 1      );#endif    reserved      = (FT_Short)(    flags         & 0x3FFF );    markOffset    = (FT_Short)( glyphOffset_p->ul >> 16 );    currentOffset = (FT_Short)( glyphOffset_p->ul       );    if ( 0 < reserved )    {        GXV_TRACE(( " non-zero bits found in reserved range/n" ));        GXV_SET_ERR_IF_PARANOID( FT_INVALID_DATA );    }    gxv_mort_subtable_type1_offset_to_subst_validate( markOffset,            "markOffset",            state,            valid );    gxv_mort_subtable_type1_offset_to_subst_validate( currentOffset,            "currentOffset",            state,            valid );}

  static void  gxv_just_actSubrecord_type0_validate( FT_Bytes       table,                                        FT_Bytes       limit,                                        GXV_Validator  gxvalid )  {    FT_Bytes   p = table;    FT_Fixed   lowerLimit;    FT_Fixed   upperLimit;#ifdef GXV_LOAD_UNUSED_VARS    FT_UShort  order;#endif    FT_UShort  decomposedCount;    FT_UInt    i;    GXV_LIMIT_CHECK( 4 + 4 + 2 + 2 );    lowerLimit      = FT_NEXT_ULONG( p );    upperLimit      = FT_NEXT_ULONG( p );#ifdef GXV_LOAD_UNUSED_VARS    order           = FT_NEXT_USHORT( p );#else    p += 2;#endif    decomposedCount = FT_NEXT_USHORT( p );    if ( lowerLimit >= upperLimit )    {      GXV_TRACE(( "just table includes invalid range spec:"                  " lowerLimit(%d) > upperLimit(%d)/n"     ));      GXV_SET_ERR_IF_PARANOID( FT_INVALID_DATA );    }    for ( i = 0; i < decomposedCount; i++ )    {      FT_UShort glyphs;      GXV_LIMIT_CHECK( 2 );      glyphs = FT_NEXT_USHORT( p );      gxv_just_check_max_gid( glyphs, "type0:glyphs", gxvalid );    }    gxvalid->subtable_length = p - table;  }

  static void  gxv_mort_subtable_type2_subtable_setup(FT_UShort      table_size,                                          FT_UShort      classTable,                                          FT_UShort      stateArray,                                          FT_UShort      entryTable,                                          FT_UShort      *classTable_length_p,                                          FT_UShort      *stateArray_length_p,                                          FT_UShort      *entryTable_length_p,                                          GXV_Validator  gxvalid)  {    FT_UShort  o[6];    FT_UShort  *l[6];    FT_UShort  buff[7];    GXV_mort_subtable_type2_StateOptRecData  optdata =      (GXV_mort_subtable_type2_StateOptRecData)gxvalid->statetable.optdata;    GXV_NAME_ENTER("subtable boundaries setup");    o[0] = classTable;    o[1] = stateArray;    o[2] = entryTable;    o[3] = optdata->ligActionTable;    o[4] = optdata->componentTable;    o[5] = optdata->ligatureTable;    l[0] = classTable_length_p;    l[1] = stateArray_length_p;    l[2] = entryTable_length_p;    l[3] = &(optdata->ligActionTable_length);    l[4] = &(optdata->componentTable_length);    l[5] = &(optdata->ligatureTable_length);    gxv_set_length_by_ushort_offset(o, l, buff, 6, table_size, gxvalid);    GXV_TRACE(("classTable: offset=0x%04x length=0x%04x/n",                classTable, *classTable_length_p));    GXV_TRACE(("stateArray: offset=0x%04x length=0x%04x/n",                stateArray, *stateArray_length_p));    GXV_TRACE(("entryTable: offset=0x%04x length=0x%04x/n",                entryTable, *entryTable_length_p));    GXV_TRACE(("ligActionTable: offset=0x%04x length=0x%04x/n",                optdata->ligActionTable,                optdata->ligActionTable_length));    GXV_TRACE(("componentTable: offset=0x%04x length=0x%04x/n",                optdata->componentTable,                optdata->componentTable_length));    GXV_TRACE(("ligatureTable:  offset=0x%04x length=0x%04x/n",                optdata->ligatureTable,                optdata->ligatureTable_length));    GXV_EXIT;  }

static voidgxv_mort_subtable_type1_entry_validate(    FT_Byte                         state,    FT_UShort                       flags,    GXV_StateTable_GlyphOffsetDesc  glyphOffset,    FT_Bytes                        table,    FT_Bytes                        limit,    GXV_Validator                   valid ){    FT_UShort  setMark;    FT_UShort  dontAdvance;    FT_UShort  reserved;    FT_Short   markOffset;    FT_Short   currentOffset;    FT_UNUSED( table );    FT_UNUSED( limit );    setMark       = (FT_UShort)(   flags >> 15            );    dontAdvance   = (FT_UShort)( ( flags >> 14 ) & 1      );    reserved      = (FT_Short)(    flags         & 0x3FFF );    markOffset    = (FT_Short)( glyphOffset.ul >> 16 );    currentOffset = (FT_Short)( glyphOffset.ul       );    if ( 0 < reserved )    {        GXV_TRACE(( " non-zero bits found in reserved range/n" ));        if ( valid->root->level >= FT_VALIDATE_PARANOID )            FT_INVALID_DATA;    }    gxv_mort_subtable_type1_offset_to_subst_validate( markOffset,            "markOffset",            state,            valid );    gxv_mort_subtable_type1_offset_to_subst_validate( currentOffset,            "currentOffset",            state,            valid );}

  static void  gxv_bsln_parts_fmt2_validate( FT_Bytes       tables,                                FT_Bytes       limit,                                GXV_Validator  valid )  {    FT_Bytes   p = tables;    FT_UShort  stdGlyph;    FT_UShort  ctlPoint;    FT_Int     i;    FT_UShort  defaultBaseline = GXV_BSLN_DATA( defaultBaseline );    GXV_NAME_ENTER( "parts format 2" );    GXV_LIMIT_CHECK( 2 + ( 2 * GXV_BSLN_VALUE_COUNT ) );    /* stdGlyph */    stdGlyph = FT_NEXT_USHORT( p );    GXV_TRACE(( " (stdGlyph = %u)/n", stdGlyph ));    gxv_glyphid_validate( stdGlyph, valid );    /* Record the position of ctlPoints */    GXV_BSLN_DATA( ctlPoints_p ) = p;    /* ctlPoints */    for ( i = 0; i < GXV_BSLN_VALUE_COUNT; i++ )    {      ctlPoint = FT_NEXT_USHORT( p );      if ( ctlPoint == GXV_BSLN_VALUE_EMPTY )      {        if ( i == defaultBaseline )          FT_INVALID_DATA;      }      else        gxv_ctlPoint_validate( stdGlyph, (FT_Short)ctlPoint, valid );    }    GXV_EXIT;  }

  static void  gxv_morx_subtable_type0_entry_validate(    FT_UShort                        state,    FT_UShort                        flags,    GXV_XStateTable_GlyphOffsetCPtr  glyphOffset_p,    FT_Bytes                         table,    FT_Bytes                         limit,    GXV_Validator                    gxvalid )  {#ifdef GXV_LOAD_UNUSED_VARS    FT_UShort  markFirst;    FT_UShort  dontAdvance;    FT_UShort  markLast;#endif    FT_UShort  reserved;#ifdef GXV_LOAD_UNUSED_VARS    FT_UShort  verb;#endif    FT_UNUSED( state );    FT_UNUSED( glyphOffset_p );    FT_UNUSED( table );    FT_UNUSED( limit );#ifdef GXV_LOAD_UNUSED_VARS    markFirst   = (FT_UShort)( ( flags >> 15 ) & 1 );    dontAdvance = (FT_UShort)( ( flags >> 14 ) & 1 );    markLast    = (FT_UShort)( ( flags >> 13 ) & 1 );#endif    reserved = (FT_UShort)( flags & 0x1FF0 );#ifdef GXV_LOAD_UNUSED_VARS    verb     = (FT_UShort)( flags & 0x000F );#endif    if ( 0 < reserved )    {      GXV_TRACE(( " non-zero bits found in reserved range/n" ));      FT_INVALID_DATA;    }  }