t1decode.c File Reference

#include <freetype/internal/ftcalc.h>
#include <freetype/internal/ftdebug.h>
#include <freetype/internal/pshints.h>
#include <freetype/internal/fthash.h>
#include <freetype/ftoutln.h>
#include "t1decode.h"
#include "psobjs.h"
#include "psauxerr.h"

Include dependency graph for t1decode.c:

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

Go to the source code of this file.

Macros
#define	Fix2Int(f)   ( (FT_Int)(FT_Short)( (f) >> 16 ) )
#define	FT_COMPONENT   t1decode

Typedefs
typedef enum T1_Operator_	T1_Operator

Enumerations
enum	T1_Operator_ {   op_none = 0 , op_endchar , op_hsbw , op_seac ,   op_sbw , op_closepath , op_hlineto , op_hmoveto ,   op_hvcurveto , op_rlineto , op_rmoveto , op_rrcurveto ,   op_vhcurveto , op_vlineto , op_vmoveto , op_dotsection ,   op_hstem , op_hstem3 , op_vstem , op_vstem3 ,   op_div , op_callothersubr , op_callsubr , op_pop ,   op_return , op_setcurrentpoint , op_unknown15 , op_max }

Functions
	t1_lookup_glyph_by_stdcharcode_ps (PS_Decoder *decoder, FT_Int charcode)
	t1_decoder_parse_metrics (T1_Decoder decoder, FT_Byte *charstring_base, FT_UInt charstring_len)
	t1_decoder_init (T1_Decoder decoder, FT_Face face, FT_Size size, FT_GlyphSlot slot, FT_Byte **glyph_names, PS_Blend blend, FT_Bool hinting, FT_Render_Mode hint_mode, T1_Decoder_Callback parse_callback)
	t1_decoder_done (T1_Decoder decoder)

Variables
static const FT_Int	t1_args_count [op_max]

Macro Definition Documentation

Fix2Int

#define Fix2Int

(

f

)

( (FT_Int)(FT_Short)( (f) >> 16 ) )

Definition at line 31 of file t1decode.c.

FT_COMPONENT

#define FT_COMPONENT   t1decode

Definition at line 40 of file t1decode.c.

Typedef Documentation

T1_Operator

typedef enum T1_Operator_ T1_Operator

Enumeration Type Documentation

T1_Operator_

enum T1_Operator_

Enumerator
op_none
op_endchar
op_hsbw
op_seac
op_sbw
op_closepath
op_hlineto
op_hmoveto
op_hvcurveto
op_rlineto
op_rmoveto
op_rrcurveto
op_vhcurveto
op_vlineto
op_vmoveto
op_dotsection
op_hstem
op_hstem3
op_vstem
op_vstem3
op_div
op_callothersubr
op_callsubr
op_pop
op_return
op_setcurrentpoint
op_unknown15
op_max

Definition at line 43 of file t1decode.c.

  {
    op_none = 0,
    op_endchar,
    op_hsbw,
    op_seac,
    op_sbw,
    op_closepath,
    op_hlineto,
    op_hmoveto,
    op_hvcurveto,
    op_rlineto,
    op_rmoveto,
    op_rrcurveto,
    op_vhcurveto,
    op_vlineto,
    op_vmoveto,
    op_dotsection,
    op_hstem,
    op_hstem3,
    op_vstem,
    op_vstem3,
    op_div,
    op_callothersubr,
    op_callsubr,
    op_pop,
    op_return,
    op_setcurrentpoint,
    op_unknown15,
 
    op_max    /* never remove this one */
 
  } T1_Operator;

Function Documentation

t1_decoder_done()

t1_decoder_done

(

T1_Decoder

decoder

)

Definition at line 2139 of file t1decode.c.

  {
    FT_Memory  memory = decoder->builder.memory;
 
 
    t1_builder_done( &decoder->builder );
 
    if ( decoder->cf2_instance.finalizer )
    {
      decoder->cf2_instance.finalizer( decoder->cf2_instance.data );
      FT_FREE( decoder->cf2_instance.data );
    }
  }

t1_decoder_init()

t1_decoder_init	(	T1_Decoder	decoder,
		FT_Face	face,
		FT_Size	size,
		FT_GlyphSlot	slot,
		FT_Byte **	glyph_names,
		PS_Blend	blend,
		FT_Bool	hinting,
		FT_Render_Mode	hint_mode,
		T1_Decoder_Callback	parse_callback
	)

Definition at line 2091 of file t1decode.c.

  {
    FT_ZERO( decoder );
 
    /* retrieve `psnames' interface from list of current modules */
    {
      FT_Service_PsCMaps  psnames;
 
 
      FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
      if ( !psnames )
      {
        FT_ERROR(( "t1_decoder_init:"
                   " the `psnames' module is not available\n" ));
        return FT_THROW( Unimplemented_Feature );
      }
 
      decoder->psnames = psnames;
    }
 
    t1_builder_init( &decoder->builder, face, size, slot, hinting );
 
    /* decoder->buildchar and decoder->len_buildchar have to be  */
    /* initialized by the caller since we cannot know the length */
    /* of the BuildCharArray                                     */
 
    decoder->num_glyphs     = (FT_UInt)face->num_glyphs;
    decoder->glyph_names    = glyph_names;
    decoder->hint_mode      = hint_mode;
    decoder->blend          = blend;
    decoder->parse_callback = parse_callback;
 
    decoder->funcs          = t1_decoder_funcs;
 
    return FT_Err_Ok;
  }

t1_decoder_parse_metrics()

t1_decoder_parse_metrics	(	T1_Decoder	decoder,
		FT_Byte *	charstring_base,
		FT_UInt	charstring_len
	)

Definition at line 1691 of file t1decode.c.

  {
    T1_Decoder_Zone  zone;
    FT_Byte*         ip;
    FT_Byte*         limit;
    T1_Builder       builder = &decoder->builder;
    FT_Bool          large_int;
 
#ifdef FT_DEBUG_LEVEL_TRACE
    FT_Bool          bol = TRUE;
#endif
 
 
    /* First of all, initialize the decoder */
    decoder->top  = decoder->stack;
    decoder->zone = decoder->zones;
    zone          = decoder->zones;
 
    builder->parse_state = T1_Parse_Start;
 
    zone->base           = charstring_base;
    limit = zone->limit  = charstring_base + charstring_len;
    ip    = zone->cursor = zone->base;
 
    large_int = FALSE;
 
    /* now, execute loop */
    while ( ip < limit )
    {
      FT_Long*     top   = decoder->top;
      T1_Operator  op    = op_none;
      FT_Int32     value = 0;
 
 
#ifdef FT_DEBUG_LEVEL_TRACE
      if ( bol )
      {
        FT_TRACE5(( " (%ld)", decoder->top - decoder->stack ));
        bol = FALSE;
      }
#endif
 
      /**********************************************************************
       *
       * Decode operator or operand
       *
       */
 
      /* first of all, decompress operator or value */
      switch ( *ip++ )
      {
      case 1:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 14:
      case 15:
      case 21:
      case 22:
      case 30:
      case 31:
        goto No_Width;
 
      case 10:
        op = op_callsubr;
        break;
      case 11:
        op = op_return;
        break;
 
      case 13:
        op = op_hsbw;
        break;
 
      case 12:
        if ( ip >= limit )
        {
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " invalid escape (12+EOF)\n" ));
          goto Syntax_Error;
        }
 
        switch ( *ip++ )
        {
        case 7:
          op = op_sbw;
          break;
        case 12:
          op = op_div;
          break;
 
        default:
          goto No_Width;
        }
        break;
 
      case 255:    /* four bytes integer */
        if ( ip + 4 > limit )
        {
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " unexpected EOF in integer\n" ));
          goto Syntax_Error;
        }
 
        value = (FT_Int32)( ( (FT_UInt32)ip[0] << 24 ) |
                            ( (FT_UInt32)ip[1] << 16 ) |
                            ( (FT_UInt32)ip[2] << 8  ) |
                              (FT_UInt32)ip[3]         );
        ip += 4;
 
        /* According to the specification, values > 32000 or < -32000 must */
        /* be followed by a `div' operator to make the result be in the    */
        /* range [-32000;32000].  We expect that the second argument of    */
        /* `div' is not a large number.  Additionally, we don't handle     */
        /* stuff like `<large1> <large2> <num> div <num> div' or           */
        /* <large1> <large2> <num> div div'.  This is probably not allowed */
        /* anyway.                                                         */
        if ( value > 32000 || value < -32000 )
        {
          if ( large_int )
          {
            FT_ERROR(( "t1_decoder_parse_metrics:"
                       " no `div' after large integer\n" ));
            goto Syntax_Error;
          }
          else
            large_int = TRUE;
        }
        else
        {
          if ( !large_int )
            value = (FT_Int32)( (FT_UInt32)value << 16 );
        }
 
        break;
 
      default:
        if ( ip[-1] >= 32 )
        {
          if ( ip[-1] < 247 )
            value = (FT_Int32)ip[-1] - 139;
          else
          {
            if ( ++ip > limit )
            {
              FT_ERROR(( "t1_decoder_parse_metrics:"
                         " unexpected EOF in integer\n" ));
              goto Syntax_Error;
            }
 
            if ( ip[-2] < 251 )
              value =    ( ( ip[-2] - 247 ) * 256 ) + ip[-1] + 108;
            else
              value = -( ( ( ip[-2] - 251 ) * 256 ) + ip[-1] + 108 );
          }
 
          if ( !large_int )
            value = (FT_Int32)( (FT_UInt32)value << 16 );
        }
        else
        {
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " invalid byte (%d)\n", ip[-1] ));
          goto Syntax_Error;
        }
      }
 
      if ( large_int && !( op == op_none || op == op_div ) )
      {
        FT_ERROR(( "t1_decoder_parse_metrics:"
                   " no `div' after large integer\n" ));
        goto Syntax_Error;
      }
 
      /**********************************************************************
       *
       * Push value on stack, or process operator
       *
       */
      if ( op == op_none )
      {
        if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS )
        {
          FT_ERROR(( "t1_decoder_parse_metrics: stack overflow\n" ));
          goto Syntax_Error;
        }
 
#ifdef FT_DEBUG_LEVEL_TRACE
        if ( large_int )
          FT_TRACE4(( " %d", value ));
        else
          FT_TRACE4(( " %d", value / 65536 ));
#endif
 
        *top++       = value;
        decoder->top = top;
      }
      else  /* general operator */
      {
        FT_Int  num_args = t1_args_count[op];
 
 
        FT_ASSERT( num_args >= 0 );
 
        if ( top - decoder->stack < num_args )
          goto Stack_Underflow;
 
#ifdef FT_DEBUG_LEVEL_TRACE
 
        switch ( op )
        {
        case op_callsubr:
        case op_div:
        case op_return:
          break;
 
        default:
          if ( top - decoder->stack != num_args )
            FT_TRACE0(( "t1_decoder_parse_metrics:"
                        " too much operands on the stack"
                        " (seen %ld, expected %d)\n",
                        top - decoder->stack, num_args ));
          break;
        }
 
#endif /* FT_DEBUG_LEVEL_TRACE */
 
        top -= num_args;
 
        switch ( op )
        {
        case op_hsbw:
          FT_TRACE4(( " hsbw" ));
 
          builder->parse_state = T1_Parse_Have_Width;
 
          builder->left_bearing.x = ADD_LONG( builder->left_bearing.x,
                                              top[0] );
 
          builder->advance.x = top[1];
          builder->advance.y = 0;
 
          /* we only want to compute the glyph's metrics */
          /* (lsb + advance width) without loading the   */
          /* rest of it; so exit immediately             */
          FT_TRACE4(( "\n" ));
          return FT_Err_Ok;
 
        case op_sbw:
          FT_TRACE4(( " sbw" ));
 
          builder->parse_state = T1_Parse_Have_Width;
 
          builder->left_bearing.x = ADD_LONG( builder->left_bearing.x,
                                              top[0] );
          builder->left_bearing.y = ADD_LONG( builder->left_bearing.y,
                                              top[1] );
 
          builder->advance.x = top[2];
          builder->advance.y = top[3];
 
          /* we only want to compute the glyph's metrics */
          /* (lsb + advance width), without loading the  */
          /* rest of it; so exit immediately             */
          FT_TRACE4(( "\n" ));
          return FT_Err_Ok;
 
        case op_div:
          FT_TRACE4(( " div" ));
 
          /* if `large_int' is set, we divide unscaled numbers; */
          /* otherwise, we divide numbers in 16.16 format --    */
          /* in both cases, it is the same operation            */
          *top = FT_DivFix( top[0], top[1] );
          top++;
 
          large_int = FALSE;
          break;
 
        case op_callsubr:
          {
            FT_Int  idx;
 
 
            FT_TRACE4(( " callsubr" ));
 
            idx = Fix2Int( top[0] );
 
            if ( decoder->subrs_hash )
            {
              size_t*  val = ft_hash_num_lookup( idx,
                                                 decoder->subrs_hash );
 
 
              if ( val )
                idx = *val;
              else
                idx = -1;
            }
 
            if ( idx < 0 || idx >= decoder->num_subrs )
            {
              FT_ERROR(( "t1_decoder_parse_metrics:"
                         " invalid subrs index\n" ));
              goto Syntax_Error;
            }
 
            if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS )
            {
              FT_ERROR(( "t1_decoder_parse_metrics:"
                         " too many nested subrs\n" ));
              goto Syntax_Error;
            }
 
            zone->cursor = ip;  /* save current instruction pointer */
 
            zone++;
 
            /* The Type 1 driver stores subroutines without the seed bytes. */
            /* The CID driver stores subroutines with seed bytes.  This     */
            /* case is taken care of when decoder->subrs_len == 0.          */
            zone->base = decoder->subrs[idx];
 
            if ( decoder->subrs_len )
              zone->limit = zone->base + decoder->subrs_len[idx];
            else
            {
              /* We are using subroutines from a CID font.  We must adjust */
              /* for the seed bytes.                                       */
              zone->base  += ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
              zone->limit  = decoder->subrs[idx + 1];
            }
 
            zone->cursor = zone->base;
 
            if ( !zone->base )
            {
              FT_ERROR(( "t1_decoder_parse_metrics:"
                         " invoking empty subrs\n" ));
              goto Syntax_Error;
            }
 
            decoder->zone = zone;
            ip            = zone->base;
            limit         = zone->limit;
            break;
          }
 
        case op_return:
          FT_TRACE4(( " return" ));
 
          if ( zone <= decoder->zones )
          {
            FT_ERROR(( "t1_decoder_parse_metrics:"
                       " unexpected return\n" ));
            goto Syntax_Error;
          }
 
          zone--;
          ip            = zone->cursor;
          limit         = zone->limit;
          decoder->zone = zone;
          break;
 
        default:
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " unhandled opcode %d\n", op ));
          goto Syntax_Error;
        }
 
        decoder->top = top;
 
      } /* general operator processing */
 
    } /* while ip < limit */
 
    FT_TRACE4(( "..end..\n\n" ));
 
  No_Width:
    FT_ERROR(( "t1_decoder_parse_metrics:"
               " no width, found op %d instead\n",
               ip[-1] ));
  Syntax_Error:
    return FT_THROW( Syntax_Error );
 
  Stack_Underflow:
    return FT_THROW( Stack_Underflow );
  }

t1_lookup_glyph_by_stdcharcode_ps()

t1_lookup_glyph_by_stdcharcode_ps	(	PS_Decoder *	decoder,
		FT_Int	charcode
	)

Definition at line 132 of file t1decode.c.

  {
    FT_UInt             n;
    const FT_String*    glyph_name;
    FT_Service_PsCMaps  psnames = decoder->psnames;
 
 
    /* check range of standard char code */
    if ( charcode < 0 || charcode > 255 )
      return -1;
 
    glyph_name = psnames->adobe_std_strings(
                   psnames->adobe_std_encoding[charcode]);
 
    for ( n = 0; n < decoder->num_glyphs; n++ )
    {
      FT_String*  name = (FT_String*)decoder->glyph_names[n];
 
 
      if ( name                               &&
           name[0] == glyph_name[0]           &&
           ft_strcmp( name, glyph_name ) == 0 )
        return (FT_Int)n;
    }
 
    return -1;
  }

Referenced by cf2_interpT2CharString().

Variable Documentation

t1_args_count

const FT_Int t1_args_count[op_max]

static

Initial value:

=
  {
    0, 
    0, 
    2, 
    5, 
    4, 
    0, 
    1, 
    1, 
    4, 
    2, 
    2, 
    6, 
    4, 
    1, 
    1, 
    0, 
    2, 
    6, 
    2, 
    6, 
    2, 
   -1, 
    1, 
    0, 
    0, 
    2, 
    2  
  }

Definition at line 79 of file t1decode.c.

Referenced by t1_decoder_parse_metrics().