pfrload.c File Reference

#include "pfrload.h"
#include "pfrerror.h"

Include dependency graph for pfrload.c:

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

Go to the source code of this file.

Macros
#define	FT_COMPONENT   trace_pfr
#define	FT_STRUCTURE   PFR_HeaderRec

Functions
	pfr_extra_items_skip (FT_Byte **pp, FT_Byte *limit)
	pfr_extra_items_parse (FT_Byte **pp, FT_Byte *limit, PFR_ExtraItem item_list, FT_Pointer item_data)
	pfr_header_load (PFR_Header header, FT_Stream stream)
	pfr_header_check (PFR_Header header)
	pfr_log_font_count (FT_Stream stream, FT_UInt32 section_offset, FT_Long *acount)
	pfr_log_font_load (PFR_LogFont log_font, FT_Stream stream, FT_UInt idx, FT_UInt32 section_offset, FT_Bool size_increment)
	pfr_extra_item_load_bitmap_info (FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
	pfr_extra_item_load_font_id (FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
	pfr_extra_item_load_stem_snaps (FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
	pfr_extra_item_load_kerning_pairs (FT_Byte *p, FT_Byte *limit, PFR_PhyFont phy_font)
static FT_Error	pfr_aux_name_load (FT_Byte *p, FT_UInt len, FT_Memory memory, FT_String **astring)
	pfr_phy_font_done (PFR_PhyFont phy_font, FT_Memory memory)
	pfr_phy_font_load (PFR_PhyFont phy_font, FT_Stream stream, FT_UInt32 offset, FT_UInt32 size)

Variables
static const FT_Frame_Field	pfr_header_fields []
static const PFR_ExtraItemRec	pfr_phy_font_extra_items []

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_pfr

Definition at line 26 of file pfrload.c.

FT_STRUCTURE

#define FT_STRUCTURE   PFR_HeaderRec

Function Documentation

pfr_aux_name_load()

static FT_Error pfr_aux_name_load ( FT_Byte *  p, FT_UInt  len, FT_Memory  memory, FT_String **  astring  )

static

Definition at line 736 of file pfrload.c.

  {
    FT_Error    error  = FT_Err_Ok;
    FT_String*  result = NULL;
    FT_UInt     n, ok;
 
 
    if ( *astring )
      FT_FREE( *astring );
 
    if ( len > 0 && p[len - 1] == 0 )
      len--;
 
    /* check that each character is ASCII  */
    /* for making sure not to load garbage */
    ok = ( len > 0 );
    for ( n = 0; n < len; n++ )
      if ( p[n] < 32 || p[n] > 127 )
      {
        ok = 0;
        break;
      }
 
    if ( ok )
    {
      if ( FT_ALLOC( result, len + 1 ) )
        goto Exit;
 
      FT_MEM_COPY( result, p, len );
      result[len] = 0;
    }
 
  Exit:
    *astring = result;
    return error;
  }

Referenced by pfr_phy_font_load().

pfr_extra_item_load_bitmap_info()

pfr_extra_item_load_bitmap_info	(	FT_Byte *	p,
		FT_Byte *	limit,
		PFR_PhyFont	phy_font
	)

Definition at line 456 of file pfrload.c.

  {
    FT_Memory   memory = phy_font->memory;
    PFR_Strike  strike;
    FT_UInt     flags0;
    FT_UInt     n, count, size1;
    FT_Error    error = FT_Err_Ok;
 
 
    PFR_CHECK( 5 );
 
    p     += 3;  /* skip bctSize */
    flags0 = PFR_NEXT_BYTE( p );
    count  = PFR_NEXT_BYTE( p );
 
    /* re-allocate when needed */
    if ( phy_font->num_strikes + count > phy_font->max_strikes )
    {
      FT_UInt  new_max = FT_PAD_CEIL( phy_font->num_strikes + count, 4 );
 
 
      if ( FT_RENEW_ARRAY( phy_font->strikes,
                           phy_font->num_strikes,
                           new_max ) )
        goto Exit;
 
      phy_font->max_strikes = new_max;
    }
 
    size1 = 1 + 1 + 1 + 2 + 2 + 1;
    if ( flags0 & PFR_STRIKE_2BYTE_XPPM )
      size1++;
 
    if ( flags0 & PFR_STRIKE_2BYTE_YPPM )
      size1++;
 
    if ( flags0 & PFR_STRIKE_3BYTE_SIZE )
      size1++;
 
    if ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
      size1++;
 
    if ( flags0 & PFR_STRIKE_2BYTE_COUNT )
      size1++;
 
    strike = phy_font->strikes + phy_font->num_strikes;
 
    PFR_CHECK( count * size1 );
 
    for ( n = 0; n < count; n++, strike++ )
    {
      strike->x_ppm       = ( flags0 & PFR_STRIKE_2BYTE_XPPM )
                            ? PFR_NEXT_USHORT( p )
                            : PFR_NEXT_BYTE( p );
 
      strike->y_ppm       = ( flags0 & PFR_STRIKE_2BYTE_YPPM )
                            ? PFR_NEXT_USHORT( p )
                            : PFR_NEXT_BYTE( p );
 
      strike->flags       = PFR_NEXT_BYTE( p );
 
      strike->bct_size    = ( flags0 & PFR_STRIKE_3BYTE_SIZE )
                            ? PFR_NEXT_ULONG( p )
                            : PFR_NEXT_USHORT( p );
 
      strike->bct_offset  = ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
                            ? PFR_NEXT_ULONG( p )
                            : PFR_NEXT_USHORT( p );
 
      strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT )
                            ? PFR_NEXT_USHORT( p )
                            : PFR_NEXT_BYTE( p );
    }
 
    phy_font->num_strikes += count;
 
  Exit:
    return error;
 
  Too_Short:
    error = FT_THROW( Invalid_Table );
    FT_ERROR(( "pfr_extra_item_load_bitmap_info:"
               " invalid bitmap info table\n" ));
    goto Exit;
  }

pfr_extra_item_load_font_id()

pfr_extra_item_load_font_id	(	FT_Byte *	p,
		FT_Byte *	limit,
		PFR_PhyFont	phy_font
	)

Definition at line 556 of file pfrload.c.

  {
    FT_Error   error  = FT_Err_Ok;
    FT_Memory  memory = phy_font->memory;
    FT_UInt    len    = (FT_UInt)( limit - p );
 
 
    if ( phy_font->font_id )
      goto Exit;
 
    if ( FT_ALLOC( phy_font->font_id, len + 1 ) )
      goto Exit;
 
    /* copy font ID name, and terminate it for safety */
    FT_MEM_COPY( phy_font->font_id, p, len );
    phy_font->font_id[len] = 0;
 
  Exit:
    return error;
  }

pfr_extra_item_load_kerning_pairs()

pfr_extra_item_load_kerning_pairs	(	FT_Byte *	p,
		FT_Byte *	limit,
		PFR_PhyFont	phy_font
	)

Definition at line 627 of file pfrload.c.

  {
    PFR_KernItem  item   = NULL;
    FT_Error      error  = FT_Err_Ok;
    FT_Memory     memory = phy_font->memory;
 
 
    if ( FT_NEW( item ) )
      goto Exit;
 
    PFR_CHECK( 4 );
 
    item->pair_count = PFR_NEXT_BYTE( p );
    item->base_adj   = PFR_NEXT_SHORT( p );
    item->flags      = PFR_NEXT_BYTE( p );
    item->offset     = phy_font->offset +
                       (FT_Offset)( p - phy_font->cursor );
 
#ifndef PFR_CONFIG_NO_CHECKS
    item->pair_size = 3;
 
    if ( item->flags & PFR_KERN_2BYTE_CHAR )
      item->pair_size += 2;
 
    if ( item->flags & PFR_KERN_2BYTE_ADJ )
      item->pair_size += 1;
 
    PFR_CHECK( item->pair_count * item->pair_size );
#endif
 
    /* load first and last pairs into the item to speed up */
    /* lookup later...                                     */
    if ( item->pair_count > 0 )
    {
      FT_UInt   char1, char2;
      FT_Byte*  q;
 
 
      if ( item->flags & PFR_KERN_2BYTE_CHAR )
      {
        q     = p;
        char1 = PFR_NEXT_USHORT( q );
        char2 = PFR_NEXT_USHORT( q );
 
        item->pair1 = PFR_KERN_INDEX( char1, char2 );
 
        q = p + item->pair_size * ( item->pair_count - 1 );
        char1 = PFR_NEXT_USHORT( q );
        char2 = PFR_NEXT_USHORT( q );
 
        item->pair2 = PFR_KERN_INDEX( char1, char2 );
      }
      else
      {
        q     = p;
        char1 = PFR_NEXT_BYTE( q );
        char2 = PFR_NEXT_BYTE( q );
 
        item->pair1 = PFR_KERN_INDEX( char1, char2 );
 
        q = p + item->pair_size * ( item->pair_count - 1 );
        char1 = PFR_NEXT_BYTE( q );
        char2 = PFR_NEXT_BYTE( q );
 
        item->pair2 = PFR_KERN_INDEX( char1, char2 );
      }
 
      /* add new item to the current list */
      item->next                 = NULL;
      *phy_font->kern_items_tail = item;
      phy_font->kern_items_tail  = &item->next;
      phy_font->num_kern_pairs  += item->pair_count;
    }
    else
    {
      /* empty item! */
      FT_FREE( item );
    }
 
  Exit:
    return error;
 
  Too_Short:
    FT_FREE( item );
 
    error = FT_THROW( Invalid_Table );
    FT_ERROR(( "pfr_extra_item_load_kerning_pairs:"
               " invalid kerning pairs table\n" ));
    goto Exit;
  }

pfr_extra_item_load_stem_snaps()

pfr_extra_item_load_stem_snaps	(	FT_Byte *	p,
		FT_Byte *	limit,
		PFR_PhyFont	phy_font
	)

Definition at line 582 of file pfrload.c.

  {
    FT_UInt    count, num_vert, num_horz;
    FT_Int*    snaps  = NULL;
    FT_Error   error  = FT_Err_Ok;
    FT_Memory  memory = phy_font->memory;
 
 
    if ( phy_font->vertical.stem_snaps )
      goto Exit;
 
    PFR_CHECK( 1 );
    count = PFR_NEXT_BYTE( p );
 
    num_vert = count & 15;
    num_horz = count >> 4;
    count    = num_vert + num_horz;
 
    PFR_CHECK( count * 2 );
 
    if ( FT_NEW_ARRAY( snaps, count ) )
      goto Exit;
 
    phy_font->vertical.stem_snaps = snaps;
    phy_font->horizontal.stem_snaps = snaps + num_vert;
 
    for ( ; count > 0; count--, snaps++ )
      *snaps = FT_NEXT_SHORT( p );
 
  Exit:
    return error;
 
  Too_Short:
    error = FT_THROW( Invalid_Table );
    FT_ERROR(( "pfr_extra_item_load_stem_snaps:"
               " invalid stem snaps table\n" ));
    goto Exit;
  }

pfr_extra_items_parse()

pfr_extra_items_parse	(	FT_Byte **	pp,
		FT_Byte *	limit,
		PFR_ExtraItem	item_list,
		FT_Pointer	item_data
	)

Definition at line 134 of file pfrload.c.

  {
    FT_Error  error = FT_Err_Ok;
    FT_Byte*  p     = *pp;
    FT_UInt   num_items, item_type, item_size;
 
 
    PFR_CHECK( 1 );
    num_items = PFR_NEXT_BYTE( p );
 
    for ( ; num_items > 0; num_items-- )
    {
      PFR_CHECK( 2 );
      item_size = PFR_NEXT_BYTE( p );
      item_type = PFR_NEXT_BYTE( p );
 
      PFR_CHECK( item_size );
 
      if ( item_list )
      {
        PFR_ExtraItem  extra = item_list;
 
 
        for ( extra = item_list; extra->parser != NULL; extra++ )
        {
          if ( extra->type == item_type )
          {
            error = extra->parser( p, p + item_size, item_data );
            if ( error )
              goto Exit;
 
            break;
          }
        }
      }
 
      p += item_size;
    }
 
  Exit:
    *pp = p;
    return error;
 
  Too_Short:
    FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" ));
    error = FT_THROW( Invalid_Table );
    goto Exit;
  }

Referenced by pfr_extra_items_skip(), and pfr_phy_font_load().

pfr_extra_items_skip()

pfr_extra_items_skip	(	FT_Byte **	pp,
		FT_Byte *	limit
	)

Definition at line 126 of file pfrload.c.

  {
    return pfr_extra_items_parse( pp, limit, NULL, NULL );
  }

Referenced by pfr_glyph_load_compound(), pfr_glyph_load_simple(), and pfr_log_font_load().

pfr_header_check()

pfr_header_check

(

PFR_Header

header

)

Definition at line 261 of file pfrload.c.

  {
    FT_Bool  result = 1;
 
 
    /* check signature and header size */
    if ( header->signature  != 0x50465230L ||   /* "PFR0" */
         header->version     > 4           ||
         header->header_size < 58          ||
         header->signature2 != 0x0D0A      )    /* CR/LF  */
    {
      result = 0;
    }
 
    return result;
  }

Referenced by pfr_face_init().

pfr_header_load()

pfr_header_load	(	PFR_Header	header,
		FT_Stream	stream
	)

Definition at line 241 of file pfrload.c.

  {
    FT_Error  error;
 
 
    /* read header directly */
    if ( !FT_STREAM_SEEK( 0 )                                &&
         !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) )
    {
      /* make a few adjustments to the header */
      header->phy_font_max_size +=
        (FT_UInt32)header->phy_font_max_size_high << 16;
    }
 
    return error;
  }

Referenced by pfr_face_init().

pfr_log_font_count()

pfr_log_font_count	(	FT_Stream	stream,
		FT_UInt32	section_offset,
		FT_Long *	acount
	)

Definition at line 289 of file pfrload.c.

  {
    FT_Error  error;
    FT_UInt   count;
    FT_UInt   result = 0;
 
 
    if ( FT_STREAM_SEEK( section_offset ) ||
         FT_READ_USHORT( count )          )
      goto Exit;
 
    /* check maximum value and a rough minimum size:     */
    /* - no more than 13106 log fonts                    */
    /* - we need 5 bytes for a log header record         */
    /* - we need at least 18 bytes for a log font record */
    /* - the overall size is at least 95 bytes plus the  */
    /*   log header and log font records                 */
    if ( count > ( ( 1 << 16 ) - 2 ) / 5                ||
         2 + count * 5 >= stream->size - section_offset ||
         95 + count * ( 5 + 18 ) >= stream->size        )
    {
      FT_ERROR(( "pfr_log_font_count:"
                 " invalid number of logical fonts\n" ));
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
 
    result = count;
 
  Exit:
    *acount = (FT_Long)result;
    return error;
  }

Referenced by pfr_face_init().

pfr_log_font_load()

pfr_log_font_load	(	PFR_LogFont	log_font,
		FT_Stream	stream,
		FT_UInt	idx,
		FT_UInt32	section_offset,
		FT_Bool	size_increment
	)

Definition at line 327 of file pfrload.c.

  {
    FT_UInt    num_log_fonts;
    FT_UInt    flags;
    FT_UInt32  offset;
    FT_UInt32  size;
    FT_Error   error;
 
 
    if ( FT_STREAM_SEEK( section_offset ) ||
         FT_READ_USHORT( num_log_fonts )  )
      goto Exit;
 
    if ( idx >= num_log_fonts )
      return FT_THROW( Invalid_Argument );
 
    if ( FT_STREAM_SKIP( idx * 5 ) ||
         FT_READ_USHORT( size )    ||
         FT_READ_UOFF3 ( offset )  )
      goto Exit;
 
    /* save logical font size and offset */
    log_font->size   = size;
    log_font->offset = offset;
 
    /* now, check the rest of the table before loading it */
    {
      FT_Byte*  p;
      FT_Byte*  limit;
      FT_UInt   local;
 
 
      if ( FT_STREAM_SEEK( offset ) ||
           FT_FRAME_ENTER( size )   )
        goto Exit;
 
      p     = stream->cursor;
      limit = p + size;
 
      PFR_CHECK( 13 );
 
      log_font->matrix[0] = PFR_NEXT_LONG( p );
      log_font->matrix[1] = PFR_NEXT_LONG( p );
      log_font->matrix[2] = PFR_NEXT_LONG( p );
      log_font->matrix[3] = PFR_NEXT_LONG( p );
 
      flags = PFR_NEXT_BYTE( p );
 
      local = 0;
      if ( flags & PFR_LOG_STROKE )
      {
        local++;
        if ( flags & PFR_LOG_2BYTE_STROKE )
          local++;
 
        if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )
          local += 3;
      }
      if ( flags & PFR_LOG_BOLD )
      {
        local++;
        if ( flags & PFR_LOG_2BYTE_BOLD )
          local++;
      }
 
      PFR_CHECK( local );
 
      if ( flags & PFR_LOG_STROKE )
      {
        log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE )
                                     ? PFR_NEXT_SHORT( p )
                                     : PFR_NEXT_BYTE( p );
 
        if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )
          log_font->miter_limit = PFR_NEXT_LONG( p );
      }
 
      if ( flags & PFR_LOG_BOLD )
      {
        log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD )
                                   ? PFR_NEXT_SHORT( p )
                                   : PFR_NEXT_BYTE( p );
      }
 
      if ( flags & PFR_LOG_EXTRA_ITEMS )
      {
        error = pfr_extra_items_skip( &p, limit );
        if ( error )
          goto Fail;
      }
 
      PFR_CHECK( 5 );
      log_font->phys_size   = PFR_NEXT_USHORT( p );
      log_font->phys_offset = PFR_NEXT_ULONG( p );
      if ( size_increment )
      {
        PFR_CHECK( 1 );
        log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16;
      }
    }
 
  Fail:
    FT_FRAME_EXIT();
 
  Exit:
    return error;
 
  Too_Short:
    FT_ERROR(( "pfr_log_font_load: invalid logical font table\n" ));
    error = FT_THROW( Invalid_Table );
    goto Fail;
  }

Referenced by pfr_face_init().

pfr_phy_font_done()

pfr_phy_font_done	(	PFR_PhyFont	phy_font,
		FT_Memory	memory
	)

Definition at line 778 of file pfrload.c.

  {
    FT_FREE( phy_font->font_id );
    FT_FREE( phy_font->family_name );
    FT_FREE( phy_font->style_name );
 
    FT_FREE( phy_font->vertical.stem_snaps );
    phy_font->vertical.num_stem_snaps = 0;
 
    phy_font->horizontal.stem_snaps     = NULL;
    phy_font->horizontal.num_stem_snaps = 0;
 
    FT_FREE( phy_font->strikes );
    phy_font->num_strikes = 0;
    phy_font->max_strikes = 0;
 
    FT_FREE( phy_font->chars );
    phy_font->num_chars    = 0;
    phy_font->chars_offset = 0;
 
    FT_FREE( phy_font->blue_values );
    phy_font->num_blue_values = 0;
 
    {
      PFR_KernItem  item, next;
 
 
      item = phy_font->kern_items;
      while ( item )
      {
        next = item->next;
        FT_FREE( item );
        item = next;
      }
      phy_font->kern_items      = NULL;
      phy_font->kern_items_tail = NULL;
    }
 
    phy_font->num_kern_pairs = 0;
  }

Referenced by pfr_face_done().

pfr_phy_font_load()

pfr_phy_font_load	(	PFR_PhyFont	phy_font,
		FT_Stream	stream,
		FT_UInt32	offset,
		FT_UInt32	size
	)

Definition at line 822 of file pfrload.c.

  {
    FT_Error   error;
    FT_Memory  memory = stream->memory;
    FT_UInt    flags;
    FT_ULong   num_aux;
    FT_Byte*   p;
    FT_Byte*   limit;
 
 
    phy_font->memory = memory;
    phy_font->offset = offset;
 
    phy_font->kern_items      = NULL;
    phy_font->kern_items_tail = &phy_font->kern_items;
 
    if ( FT_STREAM_SEEK( offset ) ||
         FT_FRAME_ENTER( size )   )
      goto Exit;
 
    phy_font->cursor = stream->cursor;
 
    p     = stream->cursor;
    limit = p + size;
 
    PFR_CHECK( 15 );
    phy_font->font_ref_number    = PFR_NEXT_USHORT( p );
    phy_font->outline_resolution = PFR_NEXT_USHORT( p );
    phy_font->metrics_resolution = PFR_NEXT_USHORT( p );
    phy_font->bbox.xMin          = PFR_NEXT_SHORT( p );
    phy_font->bbox.yMin          = PFR_NEXT_SHORT( p );
    phy_font->bbox.xMax          = PFR_NEXT_SHORT( p );
    phy_font->bbox.yMax          = PFR_NEXT_SHORT( p );
    phy_font->flags      = flags = PFR_NEXT_BYTE( p );
 
    /* get the standard advance for non-proportional fonts */
    if ( !(flags & PFR_PHY_PROPORTIONAL) )
    {
      PFR_CHECK( 2 );
      phy_font->standard_advance = PFR_NEXT_SHORT( p );
    }
 
    /* load the extra items when present */
    if ( flags & PFR_PHY_EXTRA_ITEMS )
    {
      error = pfr_extra_items_parse( &p, limit,
                                     pfr_phy_font_extra_items, phy_font );
 
      if ( error )
        goto Fail;
    }
 
    /* In certain fonts, the auxiliary bytes contain interesting   */
    /* information.  These are not in the specification but can be */
    /* guessed by looking at the content of a few PFR0 fonts.      */
    PFR_CHECK( 3 );
    num_aux = PFR_NEXT_ULONG( p );
 
    if ( num_aux > 0 )
    {
      FT_Byte*  q = p;
      FT_Byte*  q2;
 
 
      PFR_CHECK_SIZE( num_aux );
      p += num_aux;
 
      while ( num_aux > 0 )
      {
        FT_UInt  length, type;
 
 
        if ( q + 4 > p )
          break;
 
        length = PFR_NEXT_USHORT( q );
        if ( length < 4 || length > num_aux )
          break;
 
        q2   = q + length - 2;
        type = PFR_NEXT_USHORT( q );
 
        switch ( type )
        {
        case 1:
          /* this seems to correspond to the font's family name, padded to */
          /* an even number of bytes with a zero byte appended if needed   */
          error = pfr_aux_name_load( q, length - 4U, memory,
                                     &phy_font->family_name );
          if ( error )
            goto Exit;
          break;
 
        case 2:
          if ( q + 32 > q2 )
            break;
 
          q += 10;
          phy_font->ascent  = PFR_NEXT_SHORT( q );
          phy_font->descent = PFR_NEXT_SHORT( q );
          phy_font->leading = PFR_NEXT_SHORT( q );
          break;
 
        case 3:
          /* this seems to correspond to the font's style name, padded to */
          /* an even number of bytes with a zero byte appended if needed  */
          error = pfr_aux_name_load( q, length - 4U, memory,
                                     &phy_font->style_name );
          if ( error )
            goto Exit;
          break;
 
        default:
          ;
        }
 
        q        = q2;
        num_aux -= length;
      }
    }
 
    /* read the blue values */
    {
      FT_UInt  n, count;
 
 
      PFR_CHECK( 1 );
      phy_font->num_blue_values = count = PFR_NEXT_BYTE( p );
 
      PFR_CHECK( count * 2 );
 
      if ( FT_NEW_ARRAY( phy_font->blue_values, count ) )
        goto Fail;
 
      for ( n = 0; n < count; n++ )
        phy_font->blue_values[n] = PFR_NEXT_SHORT( p );
    }
 
    PFR_CHECK( 8 );
    phy_font->blue_fuzz  = PFR_NEXT_BYTE( p );
    phy_font->blue_scale = PFR_NEXT_BYTE( p );
 
    phy_font->vertical.standard   = PFR_NEXT_USHORT( p );
    phy_font->horizontal.standard = PFR_NEXT_USHORT( p );
 
    /* read the character descriptors */
    {
      FT_UInt  n, count, Size;
 
 
      phy_font->num_chars    = count = PFR_NEXT_USHORT( p );
      phy_font->chars_offset = offset + (FT_Offset)( p - stream->cursor );
 
      Size = 1 + 1 + 2;
      if ( flags & PFR_PHY_2BYTE_CHARCODE )
        Size += 1;
 
      if ( flags & PFR_PHY_PROPORTIONAL )
        Size += 2;
 
      if ( flags & PFR_PHY_ASCII_CODE )
        Size += 1;
 
      if ( flags & PFR_PHY_2BYTE_GPS_SIZE )
        Size += 1;
 
      if ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
        Size += 1;
 
      PFR_CHECK_SIZE( count * Size );
 
      if ( FT_NEW_ARRAY( phy_font->chars, count ) )
        goto Fail;
 
      for ( n = 0; n < count; n++ )
      {
        PFR_Char  cur = &phy_font->chars[n];
 
 
        cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
                         ? PFR_NEXT_USHORT( p )
                         : PFR_NEXT_BYTE( p );
 
        cur->advance   = ( flags & PFR_PHY_PROPORTIONAL )
                         ? PFR_NEXT_SHORT( p )
                         : phy_font->standard_advance;
 
#if 0
        cur->ascii     = ( flags & PFR_PHY_ASCII_CODE )
                         ? PFR_NEXT_BYTE( p )
                         : 0;
#else
        if ( flags & PFR_PHY_ASCII_CODE )
          p += 1;
#endif
        cur->gps_size  = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
                         ? PFR_NEXT_USHORT( p )
                         : PFR_NEXT_BYTE( p );
 
        cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
                          ? PFR_NEXT_ULONG( p )
                          : PFR_NEXT_USHORT( p );
      }
    }
 
    /* that's it! */
 
  Fail:
    FT_FRAME_EXIT();
 
    /* save position of bitmap info */
    phy_font->bct_offset = FT_STREAM_POS();
    phy_font->cursor     = NULL;
 
  Exit:
    return error;
 
  Too_Short:
    error = FT_THROW( Invalid_Table );
    FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" ));
    goto Fail;
  }

Referenced by pfr_face_init().

Variable Documentation

pfr_header_fields

const FT_Frame_Field pfr_header_fields[]

static

Definition at line 195 of file pfrload.c.

Referenced by pfr_header_load().

pfr_phy_font_extra_items

const PFR_ExtraItemRec pfr_phy_font_extra_items[]

static

Initial value:

=
  {
    { 1, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_bitmap_info },
    { 2, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_font_id },
    { 3, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_stem_snaps },
    { 4, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_kerning_pairs },
    { 0, NULL }
  }

Definition at line 721 of file pfrload.c.

Referenced by pfr_phy_font_load().