Ignore:
Timestamp:
Jun 30, 2008, 6:26:14 PM (13 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: freetype library updated to version 2.3.5

Location:
trunk/poppler/freetype2/src/otvalid
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/src/otvalid/otvalid.c

    r150 r251  
    55/*    FreeType validator for OpenType tables (body only).                  */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2626#include "otvgsub.c"
    2727#include "otvjstf.c"
     28#include "otvmath.c"
    2829#include "otvmod.c"
    2930
  • trunk/poppler/freetype2/src/otvalid/otvalid.h

    r150 r251  
    55/*    OpenType table validation (specification only).                      */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2008 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6464                     FT_Validator  valid );
    6565
     66  FT_LOCAL( void )
     67  otv_MATH_validate( FT_Bytes      table,
     68                     FT_UInt       glyph_count,
     69                     FT_Validator  ftvalid );
     70
    6671
    6772FT_END_HEADER
  • trunk/poppler/freetype2/src/otvalid/otvbase.c

    r150 r251  
    55/*    OpenType BASE table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6363
    6464    default:
    65       FT_INVALID_DATA;
     65      FT_INVALID_FORMAT;
    6666    }
    6767
     
    298298
    299299    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    300       FT_INVALID_DATA;
     300      FT_INVALID_FORMAT;
    301301
    302302    table_size = 6;
  • trunk/poppler/freetype2/src/otvalid/otvcommn.c

    r209 r251  
    55/*    OpenType common tables validation (body).                            */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005, 2006 by                                          */
     7/*  Copyright 2004, 2005, 2006, 2007 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    4040  FT_LOCAL_DEF( void )
    4141  otv_Coverage_validate( FT_Bytes       table,
    42                          OTV_Validator  valid )
     42                         OTV_Validator  valid,
     43                         FT_Int         expected_count )
    4344  {
    4445    FT_Bytes  p = table;
    4546    FT_UInt   CoverageFormat;
     47    FT_UInt   total = 0;
    4648
    4749
     
    5860      {
    5961        FT_UInt  GlyphCount;
     62        FT_UInt  i;
    6063
    6164
     
    6568
    6669        OTV_LIMIT_CHECK( GlyphCount * 2 );        /* GlyphArray */
     70
     71        for ( i = 0; i < GlyphCount; ++i )
     72        {
     73          FT_UInt  gid;
     74
     75
     76          gid = FT_NEXT_USHORT( p );
     77          if ( gid >= valid->glyph_count )
     78            FT_INVALID_GLYPH_ID;
     79        }
     80
     81        total = GlyphCount;
    6782      }
    6883      break;
     
    7186      {
    7287        FT_UInt  n, RangeCount;
    73         FT_UInt  Start, End, StartCoverageIndex, total = 0, last = 0;
     88        FT_UInt  Start, End, StartCoverageIndex, last = 0;
    7489
    7590
     
    90105            FT_INVALID_DATA;
    91106
     107          if ( End >= valid->glyph_count )
     108            FT_INVALID_GLYPH_ID;
     109
    92110          if ( n > 0 && Start <= last )
    93111            FT_INVALID_DATA;
     
    103121    }
    104122
    105     /* no need to check glyph indices used as input to coverage tables */
    106     /* since even invalid glyph indices return a meaningful result     */
     123    /* Generally, a coverage table offset has an associated count field.  */
     124    /* The number of glyphs in the table should match this field.  If     */
     125    /* there is no associated count, a value of -1 tells us not to check. */
     126    if ( expected_count != -1 && (FT_UInt)expected_count != total )
     127      FT_INVALID_DATA;
    107128
    108129    OTV_EXIT;
     
    216237    case 1:     /* ClassDefFormat1 */
    217238      {
     239        FT_UInt  StartGlyph;
    218240        FT_UInt  GlyphCount;
    219241
    220242
    221         p += 2;         /* skip StartGlyph */
    222 
    223         OTV_LIMIT_CHECK( 2 );
    224 
     243        OTV_LIMIT_CHECK( 4 );
     244
     245        StartGlyph = FT_NEXT_USHORT( p );
    225246        GlyphCount = FT_NEXT_USHORT( p );
    226247
     
    228249
    229250        OTV_LIMIT_CHECK( GlyphCount * 2 );    /* ClassValueArray */
     251
     252        if ( StartGlyph + GlyphCount - 1 >= valid->glyph_count )
     253          FT_INVALID_GLYPH_ID;
    230254      }
    231255      break;
     
    253277            FT_INVALID_DATA;
    254278
     279          if ( End >= valid->glyph_count )
     280            FT_INVALID_GLYPH_ID;
     281
    255282          last = End;
    256283        }
     
    292319    DeltaFormat = FT_NEXT_USHORT( p );
    293320
    294     if ( DeltaFormat < 1 || DeltaFormat > 3 || EndSize < StartSize )
     321    if ( DeltaFormat < 1 || DeltaFormat > 3 )
     322      FT_INVALID_FORMAT;
     323
     324    if ( EndSize < StartSize )
    295325      FT_INVALID_DATA;
    296326
     
    331361    OTV_TRACE(( " (type %d)\n", LookupType ));
    332362
    333     if ( LookupType == 0 || LookupType >= valid->type_count )
     363    if ( LookupType == 0 || LookupType > valid->type_count )
    334364      FT_INVALID_DATA;
    335365
     
    658688    OTV_TRACE(( " (Count = %d)\n", Count ));
    659689
    660     otv_Coverage_validate( table + Coverage, valid );
     690    otv_Coverage_validate( table + Coverage, valid, Count );
    661691
    662692    OTV_LIMIT_CHECK( Count * 2 );
     
    730760
    731761    OTV_LIMIT_CHECK( ( Count1 - 1 ) * 2 + Count2 * 4 );
     762    p += ( Count1 - 1 ) * 2;
    732763
    733764    for ( ; Count2 > 0; Count2-- )
     
    825856    OTV_TRACE(( " (ClassSetCount = %d)\n", ClassSetCount ));
    826857
    827     otv_Coverage_validate( table + Coverage, valid );
     858    otv_Coverage_validate( table + Coverage, valid, -1 );
    828859    otv_ClassDef_validate( table + ClassDef, valid );
    829860
     
    873904
    874905    for ( count1 = GlyphCount; count1 > 0; count1-- )
    875       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     906      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    876907
    877908    for ( ; Count > 0; Count-- )
     
    914945    OTV_TRACE(( " (ChainClassSetCount = %d)\n", ChainClassSetCount ));
    915946
    916     otv_Coverage_validate( table + Coverage, valid );
     947    otv_Coverage_validate( table + Coverage, valid, -1 );
    917948
    918949    otv_ClassDef_validate( table + BacktrackClassDef,  valid );
     
    964995
    965996    for ( ; BacktrackGlyphCount > 0; BacktrackGlyphCount-- )
    966       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     997      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    967998
    968999    InputGlyphCount = FT_NEXT_USHORT( p );
     
    9731004
    9741005    for ( count1 = InputGlyphCount; count1 > 0; count1-- )
    975       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     1006      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    9761007
    9771008    LookaheadGlyphCount = FT_NEXT_USHORT( p );
     
    9821013
    9831014    for ( ; LookaheadGlyphCount > 0; LookaheadGlyphCount-- )
    984       otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     1015      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    9851016
    9861017    count2 = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvcommn.h

    r209 r251  
    55/*    OpenType common tables validation (specification).                   */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by                                                */
     7/*  Copyright 2004, 2005, 2007 by                                          */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    216216  FT_LOCAL( void )
    217217  otv_Coverage_validate( FT_Bytes       table,
    218                          OTV_Validator  valid );
     218                         OTV_Validator  valid,
     219                         FT_Int         expected_count );
    219220
    220221  /* return first covered glyph */
  • trunk/poppler/freetype2/src/otvalid/otvgdef.c

    r150 r251  
    55/*    OpenType GDEF table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by                                                */
     7/*  Copyright 2004, 2005, 2007 by                                          */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6262    OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));
    6363
    64     otv_Coverage_validate( Coverage, valid );
     64    otv_Coverage_validate( Coverage, valid, GlyphCount );
    6565    if ( GlyphCount != otv_Coverage_get_count( Coverage ) )
    6666      FT_INVALID_DATA;
     
    127127
    128128    default:
    129       FT_INVALID_DATA;
     129      FT_INVALID_FORMAT;
    130130    }
    131131
  • trunk/poppler/freetype2/src/otvalid/otvgpos.c

    r150 r251  
    55/*    OpenType GPOS table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2002, 2004, 2005, 2006 by                                    */
     7/*  Copyright 2002, 2004, 2005, 2006, 2007, 2008 by                        */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    125125    Array2     = FT_NEXT_USHORT( p );
    126126
    127     otv_Coverage_validate( table + Coverage1, valid );
    128     otv_Coverage_validate( table + Coverage2, valid );
     127    otv_Coverage_validate( table + Coverage1, valid, -1 );
     128    otv_Coverage_validate( table + Coverage2, valid, -1 );
    129129
    130130    otv_MarkArray_validate( table + Array1, valid );
     
    192192
    193193    if ( format >= 0x100 )
    194       FT_INVALID_DATA;
     194      FT_INVALID_FORMAT;
    195195
    196196    for ( count = 4; count > 0; count-- )
     
    295295
    296296    default:
    297       FT_INVALID_DATA;
     297      FT_INVALID_FORMAT;
    298298    }
    299299
     
    377377        ValueFormat = FT_NEXT_USHORT( p );
    378378
    379         otv_Coverage_validate( table + Coverage, valid );
     379        otv_Coverage_validate( table + Coverage, valid, -1 );
    380380        otv_ValueRecord_validate( p, ValueFormat, valid ); /* Value */
    381381      }
     
    396396        len_value = otv_value_length( ValueFormat );
    397397
    398         otv_Coverage_validate( table + Coverage, valid );
     398        otv_Coverage_validate( table + Coverage, valid, ValueCount );
    399399
    400400        OTV_LIMIT_CHECK( ValueCount * len_value );
     
    410410
    411411    default:
    412       FT_INVALID_DATA;
     412      FT_INVALID_FORMAT;
    413413    }
    414414
     
    499499        OTV_TRACE(( " (PairSetCount = %d)\n", PairSetCount ));
    500500
    501         otv_Coverage_validate( table + Coverage, valid );
     501        otv_Coverage_validate( table + Coverage, valid, -1 );
    502502
    503503        OTV_LIMIT_CHECK( PairSetCount * 2 );
     
    531531        len_value2 = otv_value_length( ValueFormat2 );
    532532
    533         otv_Coverage_validate( table + Coverage, valid );
     533        otv_Coverage_validate( table + Coverage, valid, -1 );
    534534        otv_ClassDef_validate( table + ClassDef1, valid );
    535535        otv_ClassDef_validate( table + ClassDef2, valid );
     
    559559
    560560    default:
    561       FT_INVALID_DATA;
     561      FT_INVALID_FORMAT;
    562562    }
    563563
     
    606606        OTV_TRACE(( " (EntryExitCount = %d)\n", EntryExitCount ));
    607607
    608         otv_Coverage_validate( table + Coverage, valid );
     608        otv_Coverage_validate( table + Coverage, valid, EntryExitCount );
    609609
    610610        OTV_LIMIT_CHECK( EntryExitCount * 4 );
     
    630630
    631631    default:
    632       FT_INVALID_DATA;
     632      FT_INVALID_FORMAT;
    633633    }
    634634
     
    645645  /*************************************************************************/
    646646
    647   /* sets valid->extra2 (0) */
     647  /* UNDOCUMENTED (in OpenType 1.5):              */
     648  /* BaseRecord tables can contain NULL pointers. */
     649
     650  /* sets valid->extra2 (1) */
    648651
    649652  static void
     
    665668    {
    666669    case 1:
    667       valid->extra2 = 0;
     670      valid->extra2 = 1;
    668671      OTV_NEST2( MarkBasePosFormat1, BaseArray );
    669672      OTV_RUN( table, valid );
     
    671674
    672675    default:
    673       FT_INVALID_DATA;
     676      FT_INVALID_FORMAT;
    674677    }
    675678
     
    712715
    713716    default:
    714       FT_INVALID_DATA;
     717      FT_INVALID_FORMAT;
    715718    }
    716719
     
    753756
    754757    default:
    755       FT_INVALID_DATA;
     758      FT_INVALID_FORMAT;
    756759    }
    757760
     
    812815
    813816    default:
    814       FT_INVALID_DATA;
     817      FT_INVALID_FORMAT;
    815818    }
    816819
     
    873876
    874877    default:
    875       FT_INVALID_DATA;
     878      FT_INVALID_FORMAT;
    876879    }
    877880
     
    926929
    927930    default:
    928       FT_INVALID_DATA;
     931      FT_INVALID_FORMAT;
    929932    }
    930933
     
    990993
    991994    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    992       FT_INVALID_DATA;
     995      FT_INVALID_FORMAT;
    993996
    994997    ScriptList  = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvgsub.c

    r150 r251  
    55/*    OpenType GSUB table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005 by                                                */
     7/*  Copyright 2004, 2005, 2007 by                                          */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6969        DeltaGlyphID = FT_NEXT_SHORT( p );
    7070
    71         otv_Coverage_validate( Coverage, valid );
     71        otv_Coverage_validate( Coverage, valid, -1 );
    7272
    7373        idx = otv_Coverage_get_first( Coverage ) + DeltaGlyphID;
     
    9292        OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));
    9393
    94         otv_Coverage_validate( table + Coverage, valid );
     94        otv_Coverage_validate( table + Coverage, valid, GlyphCount );
    9595
    9696        OTV_LIMIT_CHECK( GlyphCount * 2 );
     
    9999        for ( ; GlyphCount > 0; GlyphCount-- )
    100100          if ( FT_NEXT_USHORT( p ) >= valid->glyph_count )
    101             FT_INVALID_DATA;
     101            FT_INVALID_GLYPH_ID;
    102102      }
    103103      break;
    104104
    105105    default:
    106       FT_INVALID_DATA;
     106      FT_INVALID_FORMAT;
    107107    }
    108108
     
    145145
    146146    default:
    147       FT_INVALID_DATA;
     147      FT_INVALID_FORMAT;
    148148    }
    149149
     
    186186
    187187    default:
    188       FT_INVALID_DATA;
     188      FT_INVALID_FORMAT;
    189189    }
    190190
     
    260260
    261261    default:
    262       FT_INVALID_DATA;
     262      FT_INVALID_FORMAT;
    263263    }
    264264
     
    319319
    320320    default:
    321       FT_INVALID_DATA;
     321      FT_INVALID_FORMAT;
    322322    }
    323323
     
    380380
    381381    default:
    382       FT_INVALID_DATA;
     382      FT_INVALID_FORMAT;
    383383    }
    384384
     
    435435
    436436    default:
    437       FT_INVALID_DATA;
     437      FT_INVALID_FORMAT;
    438438    }
    439439
     
    477477      OTV_TRACE(( " (BacktrackGlyphCount = %d)\n", BacktrackGlyphCount ));
    478478
    479       otv_Coverage_validate( Coverage, valid );
     479      otv_Coverage_validate( Coverage, valid, -1 );
    480480
    481481      OTV_LIMIT_CHECK( BacktrackGlyphCount * 2 + 2 );
    482482
    483483      for ( ; BacktrackGlyphCount > 0; BacktrackGlyphCount-- )
    484         otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     484        otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    485485
    486486      LookaheadGlyphCount = FT_NEXT_USHORT( p );
     
    491491
    492492      for ( ; LookaheadGlyphCount > 0; LookaheadGlyphCount-- )
    493         otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid );
     493        otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );
    494494
    495495      GlyphCount = FT_NEXT_USHORT( p );
     
    510510
    511511    default:
    512       FT_INVALID_DATA;
     512      FT_INVALID_FORMAT;
    513513    }
    514514
     
    561561
    562562    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    563       FT_INVALID_DATA;
     563      FT_INVALID_FORMAT;
    564564
    565565    ScriptList  = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvjstf.c

    r150 r251  
    55/*    OpenType JSTF table validation (body).                               */
    66/*                                                                         */
    7 /*  Copyright 2004 by                                                      */
     7/*  Copyright 2004, 2007 by                                                */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    223223
    224224    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
    225       FT_INVALID_DATA;
     225      FT_INVALID_FORMAT;
    226226
    227227    JstfScriptCount = FT_NEXT_USHORT( p );
  • trunk/poppler/freetype2/src/otvalid/otvmod.c

    r209 r251  
    55/*    FreeType's OpenType validation module implementation (body).         */
    66/*                                                                         */
    7 /*  Copyright 2004, 2005, 2006 by                                          */
     7/*  Copyright 2004, 2005, 2006, 2007 by                                    */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    8080    FT_Byte* volatile         gsub;
    8181    FT_Byte* volatile         jstf;
     82    FT_Byte* volatile         math;
    8283    FT_ULong                  len_base, len_gdef, len_gpos, len_gsub, len_jstf;
     84    FT_ULong                  len_math;
    8385    FT_ValidatorRec volatile  valid;
    8486
    8587
    86     base     = gdef     = gpos     = gsub     = jstf     = NULL;
    87     len_base = len_gdef = len_gpos = len_gsub = len_jstf = 0;
     88    base     = gdef     = gpos     = gsub     = jstf     = math     = NULL;
     89    len_base = len_gdef = len_gpos = len_gsub = len_jstf = len_math = 0;
    8890
    8991    /* load tables */
     
    124126    }
    125127
     128    if ( ot_flags & FT_VALIDATE_MATH )
     129    {
     130      error = otv_load_table( face, TTAG_MATH, &math, &len_math );
     131      if ( error )
     132        goto Exit;
     133    }
     134
    126135    /* validate tables */
    127136
     
    171180      if ( ft_setjmp( valid.jump_buffer ) == 0 )
    172181        otv_JSTF_validate( jstf, gsub, gpos, face->num_glyphs, &valid );
     182      error = valid.error;
     183      if ( error )
     184        goto Exit;
     185    }
     186
     187    if ( math )
     188    {
     189      ft_validator_init( &valid, math, math + len_math, FT_VALIDATE_DEFAULT );
     190      if ( ft_setjmp( valid.jump_buffer ) == 0 )
     191        otv_MATH_validate( math, face->num_glyphs, &valid );
    173192      error = valid.error;
    174193      if ( error )
     
    193212      FT_FREE( jstf );
    194213    }
     214    {
     215      FT_Memory  memory = FT_FACE_MEMORY( face );
     216
     217
     218      FT_FREE( math );                 /* Can't return this as API is frozen */
     219    }
    195220
    196221    return error;
Note: See TracChangeset for help on using the changeset viewer.