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

PDF plugin: freetype library updated to version 2.3.5

Location:
trunk/poppler/freetype2/src/type1
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/src/type1/t1load.c

    r209 r251  
    55/*    Type 1 font loader (body).                                           */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    675675      for ( n = 0; n < num_designs; n++ )
    676676      {
    677         T1_TokenRec  axis_tokens[T1_MAX_MM_DESIGNS];
     677        T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];
    678678        T1_Token     token;
    679679        FT_Int       axis, n_axis;
     
    688688        if ( n == 0 )
    689689        {
     690          if ( n_axis <= 0 || n_axis > T1_MAX_MM_AXIS )
     691          {
     692            FT_ERROR(( "parse_blend_design_positions:" ));
     693            FT_ERROR(( "  invalid number of axes: %d\n",
     694                       n_axis ));
     695            error = T1_Err_Invalid_File_Format;
     696            goto Exit;
     697          }
     698
    690699          num_axis = n_axis;
    691700          error = t1_allocate_blend( face, num_designs, num_axis );
     
    13981407
    13991408
    1400         if ( size <= face->type1.private_dict.lenIV )
     1409        /* some fonts define empty subr records -- this is not totally */
     1410        /* compliant to the specification (which says they should at   */
     1411        /* least contain a `return'), but we support them anyway       */
     1412        if ( size < face->type1.private_dict.lenIV )
    14011413        {
    14021414          error = T1_Err_Invalid_File_Format;
  • trunk/poppler/freetype2/src/type1/t1objs.c

    r209 r251  
    55/*    Type 1 objects manager (body).                                       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    9191  T1_Size_Init( T1_Size  size )
    9292  {
    93     FT_Error           error = 0;
     93    FT_Error           error = T1_Err_Ok;
    9494    PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
    9595
     
    255255#endif
    256256
    257       face->root.family_name = 0;
    258       face->root.style_name  = 0;
     257      face->root.family_name = NULL;
     258      face->root.style_name  = NULL;
    259259    }
    260260  }
     
    299299    FT_UNUSED( num_params );
    300300    FT_UNUSED( params );
    301     FT_UNUSED( face_index );
    302301    FT_UNUSED( stream );
    303302
     
    357356      /* XXX: TODO -- add kerning with .afm support */
    358357
     358
     359      /* The following code to extract the family and the style is very   */
     360      /* simplistic and might get some things wrong.  For a full-featured */
     361      /* algorithm you might have a look at the whitepaper given at       */
     362      /*                                                                  */
     363      /*   http://blogs.msdn.com/text/archive/2007/04/23/wpf-font-selection-model.aspx */
     364
    359365      /* get style name -- be careful, some broken fonts only */
    360366      /* have a `/FontName' dictionary entry!                 */
    361367      root->family_name = info->family_name;
    362       /* assume "Regular" style if we don't know better */
    363       root->style_name = (char *)"Regular";
     368      root->style_name  = NULL;
     369
    364370      if ( root->family_name )
    365371      {
     
    370376        if ( full )
    371377        {
     378          FT_Bool  the_same = TRUE;
     379
     380
    372381          while ( *full )
    373382          {
     
    385394              else
    386395              {
     396                the_same = FALSE;
     397
    387398                if ( !*family )
    388399                  root->style_name = full;
     
    391402            }
    392403          }
     404
     405          if ( the_same )
     406            root->style_name = (char *)"Regular";
    393407        }
    394408      }
     
    398412        if ( type1->font_name )
    399413          root->family_name = type1->font_name;
     414      }
     415
     416      if ( !root->style_name )
     417      {
     418        if ( info->weight )
     419          root->style_name = info->weight;
     420        else
     421          /* assume `Regular' style because we don't know better */
     422          root->style_name = (char *)"Regular";
    400423      }
    401424
     
    444467          root->max_advance_width = (FT_Short)max_advance;
    445468        else
    446           error = 0;   /* clear error */
     469          error = T1_Err_Ok;   /* clear error */
    447470      }
    448471
  • trunk/poppler/freetype2/src/type1/t1parse.c

    r209 r251  
    55/*    Type 1 parser (body).                                                */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2008 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6666
    6767
     68  /* see Adobe Technical Note 5040.Download_Fonts.pdf */
     69
    6870  static FT_Error
    6971  read_pfb_tag( FT_Stream   stream,
    7072                FT_UShort  *atag,
    71                 FT_Long    *asize )
     73                FT_ULong   *asize )
    7274  {
    7375    FT_Error   error;
    7476    FT_UShort  tag;
    75     FT_Long    size;
     77    FT_ULong   size;
    7678
    7779
     
    8385      if ( tag == 0x8001U || tag == 0x8002U )
    8486      {
    85         if ( !FT_READ_LONG_LE( size ) )
     87        if ( !FT_READ_ULONG_LE( size ) )
    8688          *asize = size;
    8789      }
     
    101103    FT_Error   error;
    102104    FT_UShort  tag;
    103     FT_Long    size;
     105    FT_ULong   dummy;
    104106
    105107
     
    107109      goto Exit;
    108110
    109     error = read_pfb_tag( stream, &tag, &size );
     111    error = read_pfb_tag( stream, &tag, &dummy );
    110112    if ( error )
    111113      goto Exit;
    112114
     115    /* We assume that the first segment in a PFB is always encoded as   */
     116    /* text.  This might be wrong (and the specification doesn't insist */
     117    /* on that), but we have never seen a counterexample.               */
    113118    if ( tag != 0x8001U && FT_STREAM_SEEK( 0 ) )
    114119      goto Exit;
     
    116121    if ( !FT_FRAME_ENTER( header_length ) )
    117122    {
    118       error = 0;
     123      error = T1_Err_Ok;
    119124
    120125      if ( ft_memcmp( stream->cursor, header_string, header_length ) != 0 )
     
    137142    FT_Error   error;
    138143    FT_UShort  tag;
    139     FT_Long    size;
     144    FT_ULong   size;
    140145
    141146
     
    171176    /*                                                                */
    172177    /*   When creating a new Type 1 parser, we try to locate and load */
    173     /*   the base dictionary if this is possible (i.e. for PFB        */
     178    /*   the base dictionary if this is possible (i.e., for PFB       */
    174179    /*   files).  Otherwise, we load the whole font into memory.      */
    175180    /*                                                                */
     
    178183    /*   allocate and load the base dictionary in it.                 */
    179184    /*                                                                */
    180     /*   parser->in_pfb is set if we are in a binary (".pfb") font.   */
     185    /*   parser->in_pfb is set if we are in a binary (`.pfb') font.   */
    181186    /*   parser->in_memory is set if we have a memory stream.         */
    182187    /*                                                                */
    183188
    184     /* try to compute the size of the base dictionary;   */
    185     /* look for a Postscript binary file tag, i.e 0x8001 */
     189    /* try to compute the size of the base dictionary;     */
     190    /* look for a Postscript binary file tag, i.e., 0x8001 */
    186191    if ( FT_STREAM_SEEK( 0L ) )
    187192      goto Exit;
     
    218223    else
    219224    {
    220       /* read segment in memory - this is clumsy, but so does the format */
     225      /* read segment in memory -- this is clumsy, but so does the format */
    221226      if ( FT_ALLOC( parser->base_dict, size )       ||
    222227           FT_STREAM_READ( parser->base_dict, size ) )
     
    261266    FT_Memory  memory = parser->root.memory;
    262267    FT_Error   error  = T1_Err_Ok;
    263     FT_Long    size;
     268    FT_ULong   size;
    264269
    265270
     
    300305      }
    301306
    302       if ( FT_STREAM_SEEK( start_pos )                             ||
     307      if ( FT_STREAM_SEEK( start_pos )                           ||
    303308           FT_ALLOC( parser->private_dict, parser->private_len ) )
    304309        goto Fail;
     
    410415      }
    411416
    412       size = (FT_Long)( parser->base_len - ( cur - parser->base_dict ) );
     417      size = parser->base_len - ( cur - parser->base_dict );
    413418
    414419      if ( parser->in_memory )
  • trunk/poppler/freetype2/src/type1/t1parse.h

    r209 r251  
    55/*    Type 1 parser (specification).                                       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003 by                                     */
     7/*  Copyright 1996-2001, 2002, 2003, 2008 by                               */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    6565
    6666    FT_Byte*      base_dict;
    67     FT_Long       base_len;
     67    FT_ULong      base_len;
    6868
    6969    FT_Byte*      private_dict;
    70     FT_Long       private_len;
     70    FT_ULong      private_len;
    7171
    7272    FT_Bool       in_pfb;
Note: See TracChangeset for help on using the changeset viewer.