psconv.h File Reference

#include <freetype/internal/psaux.h>

Include dependency graph for psconv.h:

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

Go to the source code of this file.

Functions
FT_BEGIN_HEADER	PS_Conv_Strtol (FT_Byte **cursor, FT_Byte *limit, FT_Long base)
	PS_Conv_ToInt (FT_Byte **cursor, FT_Byte *limit)
	PS_Conv_ToFixed (FT_Byte **cursor, FT_Byte *limit, FT_Long power_ten)
	PS_Conv_ASCIIHexDecode (FT_Byte **cursor, FT_Byte *limit, FT_Byte *buffer, FT_Offset n)
	PS_Conv_EexecDecode (FT_Byte **cursor, FT_Byte *limit, FT_Byte *buffer, FT_Offset n, FT_UShort *seed)

Function Documentation

PS_Conv_ASCIIHexDecode()

PS_Conv_ASCIIHexDecode	(	FT_Byte **	cursor,
		FT_Byte *	limit,
		FT_Byte *	buffer,
		FT_Offset	n
	)

Definition at line 464 of file psconv.c.

  {
    FT_Byte*  p;
    FT_UInt   r   = 0;
    FT_UInt   w   = 0;
    FT_UInt   pad = 0x01;
 
 
    n *= 2;
 
#if 1
 
    p = *cursor;
 
    if ( p >= limit )
      return 0;
 
    if ( n > (FT_UInt)( limit - p ) )
      n = (FT_UInt)( limit - p );
 
    /* we try to process two nibbles at a time to be as fast as possible */
    for ( ; r < n; r++ )
    {
      FT_UInt  c = p[r];
 
 
      if ( IS_PS_SPACE( c ) )
        continue;
 
      if ( c OP 0x80 )
        break;
 
      c = (FT_UInt)ft_char_table[c & 0x7F];
      if ( c >= 16 )
        break;
 
      pad = ( pad << 4 ) | c;
      if ( pad & 0x100 )
      {
        buffer[w++] = (FT_Byte)pad;
        pad         = 0x01;
      }
    }
 
    if ( pad != 0x01 )
      buffer[w++] = (FT_Byte)( pad << 4 );
 
    *cursor = p + r;
 
    return w;
 
#else /* 0 */
 
    for ( r = 0; r < n; r++ )
    {
      FT_Char  c;
 
 
      if ( IS_PS_SPACE( *p ) )
        continue;
 
      if ( *p OP 0x80 )
        break;
 
      c = ft_char_table[*p & 0x7F];
 
      if ( (unsigned)c >= 16 )
        break;
 
      if ( r & 1 )
      {
        *buffer = (FT_Byte)(*buffer + c);
        buffer++;
      }
      else
        *buffer = (FT_Byte)(c << 4);
 
      r++;
    }
 
    *cursor = p;
 
    return ( r + 1 ) / 2;
 
#endif /* 0 */
 
  }

Referenced by ps_parser_to_bytes().

PS_Conv_EexecDecode()

PS_Conv_EexecDecode	(	FT_Byte **	cursor,
		FT_Byte *	limit,
		FT_Byte *	buffer,
		FT_Offset	n,
		FT_UShort *	seed
	)

Definition at line 557 of file psconv.c.

  {
    FT_Byte*  p;
    FT_UInt   r;
    FT_UInt   s = *seed;
 
 
#if 1
 
    p = *cursor;
 
    if ( p >= limit )
      return 0;
 
    if ( n > (FT_UInt)(limit - p) )
      n = (FT_UInt)(limit - p);
 
    for ( r = 0; r < n; r++ )
    {
      FT_UInt  val = p[r];
      FT_UInt  b   = ( val ^ ( s >> 8 ) );
 
 
      s         = ( (val + s)*52845U + 22719 ) & 0xFFFFU;
      buffer[r] = (FT_Byte) b;
    }
 
    *cursor = p + n;
    *seed   = (FT_UShort)s;
 
#else /* 0 */
 
    for ( r = 0, p = *cursor; r < n && p < limit; r++, p++ )
    {
      FT_Byte  b = (FT_Byte)( *p ^ ( s >> 8 ) );
 
 
      s = (FT_UShort)( ( *p + s ) * 52845U + 22719 );
      *buffer++ = b;
    }
    *cursor = p;
    *seed   = s;
 
#endif /* 0 */
 
    return r;
  }

Referenced by t1_decrypt().

PS_Conv_Strtol()

FT_BEGIN_HEADER PS_Conv_Strtol	(	FT_Byte **	cursor,
		FT_Byte *	limit,
		FT_Long	base
	)

Definition at line 83 of file psconv.c.

  {
    FT_Byte*  p = *cursor;
 
    FT_Long   num           = 0;
    FT_Bool   sign          = 0;
    FT_Bool   have_overflow = 0;
 
    FT_Long   num_limit;
    FT_Char   c_limit;
 
 
    if ( p >= limit )
      goto Bad;
 
    if ( base < 2 || base > 36 )
    {
      FT_TRACE4(( "!!!INVALID BASE:!!!" ));
      return 0;
    }
 
    if ( *p == '-' || *p == '+' )
    {
      sign = FT_BOOL( *p == '-' );
 
      p++;
      if ( p == limit )
        goto Bad;
 
      /* only a single sign is allowed */
      if ( *p == '-' || *p == '+' )
        return 0;
    }
 
    num_limit = 0x7FFFFFFFL / base;
    c_limit   = (FT_Char)( 0x7FFFFFFFL % base );
 
    for ( ; p < limit; p++ )
    {
      FT_Char  c;
 
 
      if ( IS_PS_SPACE( *p ) || *p OP 0x80 )
        break;
 
      c = ft_char_table[*p & 0x7F];
 
      if ( c < 0 || c >= base )
        break;
 
      if ( num > num_limit || ( num == num_limit && c > c_limit ) )
        have_overflow = 1;
      else
        num = num * base + c;
    }
 
    *cursor = p;
 
    if ( have_overflow )
    {
      num = 0x7FFFFFFFL;
      FT_TRACE4(( "!!!OVERFLOW:!!!" ));
    }
 
    if ( sign )
      num = -num;
 
    return num;
 
  Bad:
    FT_TRACE4(( "!!!END OF DATA:!!!" ));
    return 0;
  }

Referenced by PS_Conv_ToInt().

PS_Conv_ToFixed()

PS_Conv_ToFixed	(	FT_Byte **	cursor,
		FT_Byte *	limit,
		FT_Long	power_ten
	)

Definition at line 195 of file psconv.c.

  {
    FT_Byte*  p = *cursor;
    FT_Byte*  curp;
 
    FT_Fixed  integral = 0;
    FT_Long   decimal  = 0;
    FT_Long   divider  = 1;
 
    FT_Bool   sign           = 0;
    FT_Bool   have_overflow  = 0;
    FT_Bool   have_underflow = 0;
 
 
    if ( p >= limit )
      goto Bad;
 
    if ( *p == '-' || *p == '+' )
    {
      sign = FT_BOOL( *p == '-' );
 
      p++;
      if ( p == limit )
        goto Bad;
 
      /* only a single sign is allowed */
      if ( *p == '-' || *p == '+' )
        return 0;
    }
 
    /* read the integer part */
    if ( *p != '.' )
    {
      curp     = p;
      integral = PS_Conv_ToInt( &p, limit );
 
      if ( p == curp )
        return 0;
 
      if ( integral > 0x7FFF )
        have_overflow = 1;
      else
        integral = (FT_Fixed)( (FT_UInt32)integral << 16 );
    }
 
    /* read the decimal part */
    if ( p < limit && *p == '.' )
    {
      p++;
 
      for ( ; p < limit; p++ )
      {
        FT_Char  c;
 
 
        if ( IS_PS_SPACE( *p ) || *p OP 0x80 )
          break;
 
        c = ft_char_table[*p & 0x7F];
 
        if ( c < 0 || c >= 10 )
          break;
 
        /* only add digit if we don't overflow */
        if ( divider < 0xCCCCCCCL && decimal < 0xCCCCCCCL )
        {
          decimal = decimal * 10 + c;
 
          if ( !integral && power_ten > 0 )
            power_ten--;
          else
            divider *= 10;
        }
      }
    }
 
    /* read exponent, if any */
    if ( p + 1 < limit && ( *p == 'e' || *p == 'E' ) )
    {
      FT_Long  exponent;
 
 
      p++;
 
      curp     = p;
      exponent = PS_Conv_ToInt( &p, limit );
 
      if ( curp == p )
        return 0;
 
      /* arbitrarily limit exponent */
      if ( exponent > 1000 )
        have_overflow = 1;
      else if ( exponent < -1000 )
        have_underflow = 1;
      else
        power_ten += exponent;
    }
 
    *cursor = p;
 
    if ( !integral && !decimal )
      return 0;
 
    if ( have_overflow )
      goto Overflow;
    if ( have_underflow )
      goto Underflow;
 
    while ( power_ten > 0 )
    {
      if ( integral >= 0xCCCCCCCL )
        goto Overflow;
      integral *= 10;
 
      if ( decimal >= 0xCCCCCCCL )
      {
        if ( divider == 1 )
          goto Overflow;
        divider /= 10;
      }
      else
        decimal *= 10;
 
      power_ten--;
    }
 
    while ( power_ten < 0 )
    {
      integral /= 10;
      if ( divider < 0xCCCCCCCL )
        divider *= 10;
      else
        decimal /= 10;
 
      if ( !integral && !decimal )
        goto Underflow;
 
      power_ten++;
    }
 
    if ( decimal )
    {
      decimal = FT_DivFix( decimal, divider );
      /* it's not necessary to check this addition for overflow */
      /* due to the structure of the real number representation */
      integral += decimal;
    }
 
  Exit:
    if ( sign )
      integral = -integral;
 
    return integral;
 
  Bad:
    FT_TRACE4(( "!!!END OF DATA:!!!" ));
    return 0;
 
  Overflow:
    integral = 0x7FFFFFFFL;
    FT_TRACE4(( "!!!OVERFLOW:!!!" ));
    goto Exit;
 
  Underflow:
    FT_TRACE4(( "!!!UNDERFLOW:!!!" ));
    return 0;
  }

Referenced by afm_parser_read_vals(), ps_parser_load_field(), ps_parser_to_fixed(), ps_tocoordarray(), and ps_tofixedarray().

PS_Conv_ToInt()

PS_Conv_ToInt	(	FT_Byte **	cursor,
		FT_Byte *	limit
	)

Definition at line 161 of file psconv.c.

  {
    FT_Byte*  p = *cursor;
    FT_Byte*  curp;
 
    FT_Long   num;
 
 
    curp = p;
    num  = PS_Conv_Strtol( &p, limit, 10 );
 
    if ( p == curp )
      return 0;
 
    if ( p < limit && *p == '#' )
    {
      p++;
 
      curp = p;
      num  = PS_Conv_Strtol( &p, limit, num );
 
      if ( p == curp )
        return 0;
    }
 
    *cursor = p;
 
    return num;
  }

Referenced by afm_parser_read_vals(), PS_Conv_ToFixed(), ps_parser_load_field(), and ps_parser_to_int().