Edit

kc3-lang/freetype/src/psaux/psconv.c

Branch :

  • Show log

    Commit

  • Author : suzuki toshiya
    Date : 2009-08-01 00:30:17
    Hash : d200982d
    Message : psaux: Use size_t variable to pass the buffer size.

  • src/psaux/psconv.c
  • /***************************************************************************/
    /*                                                                         */
    /*  psconv.c                                                               */
    /*                                                                         */
    /*    Some convenience conversions (body).                                 */
    /*                                                                         */
    /*  Copyright 2006, 2008, 2009 by                                          */
    /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    /*                                                                         */
    /*  This file is part of the FreeType project, and may only be used,       */
    /*  modified, and distributed under the terms of the FreeType project      */
    /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
    /*  this file you indicate that you have read the license and              */
    /*  understand and accept it fully.                                        */
    /*                                                                         */
    /***************************************************************************/
    
    
    #include <ft2build.h>
    #include FT_INTERNAL_POSTSCRIPT_AUX_H
    
    #include "psconv.h"
    #include "psauxerr.h"
    
    
      /* The following array is used by various functions to quickly convert */
      /* digits (both decimal and non-decimal) into numbers.                 */
    
    #if 'A' == 65
      /* ASCII */
    
      static const FT_Char  ft_char_table[128] =
      {
        /* 0x00 */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
      };
    
      /* no character >= 0x80 can represent a valid number */
    #define OP  >=
    
    #endif /* 'A' == 65 */
    
    #if 'A' == 193
      /* EBCDIC */
    
      static const FT_Char  ft_char_table[128] =
      {
        /* 0x80 */
        -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
        -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
        -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
        -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
        -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
      };
    
      /* no character < 0x80 can represent a valid number */
    #define OP  <
    
    #endif /* 'A' == 193 */
    
    
      FT_LOCAL_DEF( FT_Int )
      PS_Conv_Strtol( FT_Byte**  cursor,
                      FT_Byte*   limit,
                      FT_Int     base )
      {
        FT_Byte*  p = *cursor;
        FT_Int    num = 0;
        FT_Bool   sign = 0;
    
    
        if ( p == limit || base < 2 || base > 36 )
          return 0;
    
        if ( *p == '-' || *p == '+' )
        {
          sign = FT_BOOL( *p == '-' );
    
          p++;
          if ( p == limit )
            return 0;
        }
    
        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;
    
          num = num * base + c;
        }
    
        if ( sign )
          num = -num;
    
        *cursor = p;
    
        return num;
      }
    
    
      FT_LOCAL_DEF( FT_Int )
      PS_Conv_ToInt( FT_Byte**  cursor,
                     FT_Byte*   limit )
    
      {
        FT_Byte*  p;
        FT_Int    num;
    
    
        num = PS_Conv_Strtol( cursor, limit, 10 );
        p   = *cursor;
    
        if ( p < limit && *p == '#' )
        {
          *cursor = p + 1;
    
          return PS_Conv_Strtol( cursor, limit, num );
        }
        else
          return num;
      }
    
    
      FT_LOCAL_DEF( FT_Fixed )
      PS_Conv_ToFixed( FT_Byte**  cursor,
                       FT_Byte*   limit,
                       FT_Int     power_ten )
      {
        FT_Byte*  p = *cursor;
        FT_Fixed  integral;
        FT_Long   decimal = 0, divider = 1;
        FT_Bool   sign = 0;
    
    
        if ( p == limit )
          return 0;
    
        if ( *p == '-' || *p == '+' )
        {
          sign = FT_BOOL( *p == '-' );
    
          p++;
          if ( p == limit )
            return 0;
        }
    
        if ( *p != '.' )
          integral = PS_Conv_ToInt( &p, limit ) << 16;
        else
          integral = 0;
    
        /* 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;
    
            if ( !integral && power_ten > 0 )
            {
              power_ten--;
              decimal = decimal * 10 + c;
            }
            else
            {
              if ( divider < 10000000L )
              {
                decimal = decimal * 10 + c;
                divider *= 10;
              }
            }
          }
        }
    
        /* read exponent, if any */
        if ( p + 1 < limit && ( *p == 'e' || *p == 'E' ) )
        {
          p++;
          power_ten += PS_Conv_ToInt( &p, limit );
        }
    
        while ( power_ten > 0 )
        {
          integral *= 10;
          decimal  *= 10;
          power_ten--;
        }
    
        while ( power_ten < 0 )
        {
          integral /= 10;
          divider  *= 10;
          power_ten++;
        }
    
        if ( decimal )
          integral += FT_DivFix( decimal, divider );
    
        if ( sign )
          integral = -integral;
    
        *cursor = p;
    
        return integral;
      }
    
    
    #if 0
      FT_LOCAL_DEF( FT_UInt )
      PS_Conv_StringDecode( FT_Byte**  cursor,
                            FT_Byte*   limit,
                            FT_Byte*   buffer,
                            FT_Offset  n )
      {
        FT_Byte*  p;
        FT_UInt   r = 0;
    
    
        for ( p = *cursor; r < n && p < limit; p++ )
        {
          FT_Byte  b;
    
    
          if ( *p != '\\' )
          {
            buffer[r++] = *p;
    
            continue;
          }
    
          p++;
    
          switch ( *p )
          {
          case 'n':
            b = '\n';
            break;
          case 'r':
            b = '\r';
            break;
          case 't':
            b = '\t';
            break;
          case 'b':
            b = '\b';
            break;
          case 'f':
            b = '\f';
            break;
          case '\r':
            p++;
            if ( *p != '\n' )
            {
              b = *p;
    
              break;
            }
            /* no break */
          case '\n':
            continue;
            break;
          default:
            if ( IS_PS_DIGIT( *p ) )
            {
              b = *p - '0';
    
              p++;
    
              if ( IS_PS_DIGIT( *p ) )
              {
                b = b * 8 + *p - '0';
    
                p++;
    
                if ( IS_PS_DIGIT( *p ) )
                  b = b * 8 + *p - '0';
                else
                {
                  buffer[r++] = b;
                  b = *p;
                }
              }
              else
              {
                buffer[r++] = b;
                b = *p;
              }
            }
            else
              b = *p;
            break;
          }
    
          buffer[r++] = b;
        }
    
        *cursor = p;
    
        return r;
      }
    #endif /* 0 */
    
    
      FT_LOCAL_DEF( FT_UInt )
      PS_Conv_ASCIIHexDecode( FT_Byte**  cursor,
                              FT_Byte*   limit,
                              FT_Byte*   buffer,
                              FT_Offset  n )
      {
        FT_Byte*  p;
        FT_UInt   r   = 0;
        FT_UInt   w   = 0;
        FT_UInt   pad = 0x01;
    
    
        n *= 2;
    
    #if 1
    
        p  = *cursor;
        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_char_table[c & 0x7F];
          if ( (unsigned)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 */
    
      }
    
    
      FT_LOCAL_DEF( FT_UInt )
      PS_Conv_EexecDecode( FT_Byte**   cursor,
                           FT_Byte*    limit,
                           FT_Byte*    buffer,
                           FT_Offset   n,
                           FT_UShort*  seed )
      {
        FT_Byte*  p;
        FT_UInt   r;
        FT_UInt   s = *seed;
    
    
    #if 1
    
        p = *cursor;
        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;
      }
    
    
    /* END */