t1decode.h File Reference

#include <freetype/internal/psaux.h>
#include <freetype/internal/t1types.h>

Include dependency graph for t1decode.h:

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

Go to the source code of this file.

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_glyph)
	t1_decoder_done (T1_Decoder decoder)

Variables
FT_BEGIN_HEADER FT_CALLBACK_TABLE const T1_Decoder_FuncsRec	t1_decoder_funcs

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_glyph
	)

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_decoder_funcs

FT_BEGIN_HEADER FT_CALLBACK_TABLE const T1_Decoder_FuncsRec t1_decoder_funcs

Definition at line 31 of file t1decode.h.