t1decode.h File Reference

#include <ft2build.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 1973 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 1925 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 1662 of file t1decode.c.

  {
    T1_Decoder_Zone  zone;
    FT_Byte*         ip;
    FT_Byte*         limit;
    T1_Builder       builder = &decoder->builder;
 
#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;
 
    FT_TRACE4(( "\n"
                "Start charstring: get width\n" ));
 
    zone->base           = charstring_base;
    limit = zone->limit  = charstring_base + charstring_len;
    ip    = zone->cursor = zone->base;
 
    /* 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(( " (%d)", 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 10:
      case 11:
      case 14:
      case 15:
      case 21:
      case 22:
      case 30:
      case 31:
        goto No_Width;
 
      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;
 
        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 )
        {
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " large integer found for width\n" ));
          goto Syntax_Error;
        }
        else
        {
          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 );
          }
 
          value = (FT_Int32)( (FT_UInt32)value << 16 );
        }
        else
        {
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " invalid byte (%d)\n", ip[-1] ));
          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
          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
 
        if ( top - decoder->stack != num_args )
          FT_TRACE0(( "t1_decoder_parse_metrics:"
                      " too much operands on the stack"
                      " (seen %d, expected %d)\n",
                      top - decoder->stack, num_args ));
 
#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), not load the rest of */
          /* it; so exit immediately                     */
          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), not load the rest of */
          /* it; so exit immediately                     */
          return FT_Err_Ok;
 
        default:
          FT_ERROR(( "t1_decoder_parse_metrics:"
                     " unhandled opcode %d\n", op ));
          goto Syntax_Error;
        }
 
      } /* 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 131 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 32 of file t1decode.h.