lib/3rdparty/freetype/src/psaux/psconv.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  psconv.c                                                               */
   4 /*                                                                         */
   5 /*    Some convenience conversions (body).                                 */
   6 /*                                                                         */
   7 /*  Copyright 2006, 2008, 2009 by                                          */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include FT_INTERNAL_POSTSCRIPT_AUX_H
  21
  22 #include "psconv.h"
  23 #include "psauxerr.h"
  24
  25
  26   /* The following array is used by various functions to quickly convert */
  27   /* digits (both decimal and non-decimal) into numbers.                 */
  28
  29 #if 'A' == 65
  30   /* ASCII */
  31
  32   static const FT_Char  ft_char_table[128] =
  33   {
  34     /* 0x00 */
  35     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  36     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  37     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  38      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
  39     -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
  40     25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
  41     -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
  42     25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
  43   };
  44
  45   /* no character >= 0x80 can represent a valid number */
  46 #define OP  >=
  47
  48 #endif /* 'A' == 65 */
  49
  50 #if 'A' == 193
  51   /* EBCDIC */
  52
  53   static const FT_Char  ft_char_table[128] =
  54   {
  55     /* 0x80 */
  56     -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
  57     -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
  58     -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
  59     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  60     -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
  61     -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
  62     -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
  63      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
  64   };
  65
  66   /* no character < 0x80 can represent a valid number */
  67 #define OP  <
  68
  69 #endif /* 'A' == 193 */
  70
  71
  72   FT_LOCAL_DEF( FT_Int )
  73   PS_Conv_Strtol( FT_Byte**  cursor,
  74                   FT_Byte*   limit,
  75                   FT_Int     base )
  76   {
  77     FT_Byte*  p = *cursor;
  78     FT_Int    num = 0;
  79     FT_Bool   sign = 0;
  80
  81
  82     if ( p == limit || base < 2 || base > 36 )
  83       return 0;
  84
  85     if ( *p == '-' || *p == '+' )
  86     {
  87       sign = FT_BOOL( *p == '-' );
  88
  89       p++;
  90       if ( p == limit )
  91         return 0;
  92     }
  93
  94     for ( ; p < limit; p++ )
  95     {
  96       FT_Char  c;
  97
  98
  99       if ( IS_PS_SPACE( *p ) || *p OP 0x80 )
 100         break;
 101
 102       c = ft_char_table[*p & 0x7f];
 103
 104       if ( c < 0 || c >= base )
 105         break;
 106
 107       num = num * base + c;
 108     }
 109
 110     if ( sign )
 111       num = -num;
 112
 113     *cursor = p;
 114
 115     return num;
 116   }
 117
 118
 119   FT_LOCAL_DEF( FT_Int )
 120   PS_Conv_ToInt( FT_Byte**  cursor,
 121                  FT_Byte*   limit )
 122
 123   {
 124     FT_Byte*  p;
 125     FT_Int    num;
 126
 127
 128     num = PS_Conv_Strtol( cursor, limit, 10 );
 129     p   = *cursor;
 130
 131     if ( p < limit && *p == '#' )
 132     {
 133       *cursor = p + 1;
 134
 135       return PS_Conv_Strtol( cursor, limit, num );
 136     }
 137     else
 138       return num;
 139   }
 140
 141
 142   FT_LOCAL_DEF( FT_Fixed )
 143   PS_Conv_ToFixed( FT_Byte**  cursor,
 144                    FT_Byte*   limit,
 145                    FT_Int     power_ten )
 146   {
 147     FT_Byte*  p = *cursor;
 148     FT_Fixed  integral;
 149     FT_Long   decimal = 0, divider = 1;
 150     FT_Bool   sign = 0;
 151
 152
 153     if ( p == limit )
 154       return 0;
 155
 156     if ( *p == '-' || *p == '+' )
 157     {
 158       sign = FT_BOOL( *p == '-' );
 159
 160       p++;
 161       if ( p == limit )
 162         return 0;
 163     }
 164
 165     if ( *p != '.' )
 166       integral = PS_Conv_ToInt( &p, limit ) << 16;
 167     else
 168       integral = 0;
 169
 170     /* read the decimal part */
 171     if ( p < limit && *p == '.' )
 172     {
 173       p++;
 174
 175       for ( ; p < limit; p++ )
 176       {
 177         FT_Char  c;
 178
 179
 180         if ( IS_PS_SPACE( *p ) || *p OP 0x80 )
 181           break;
 182
 183         c = ft_char_table[*p & 0x7f];
 184
 185         if ( c < 0 || c >= 10 )
 186           break;
 187
 188         if ( !integral && power_ten > 0 )
 189         {
 190           power_ten--;
 191           decimal = decimal * 10 + c;
 192         }
 193         else
 194         {
 195           if ( divider < 10000000L )
 196           {
 197             decimal = decimal * 10 + c;
 198             divider *= 10;
 199           }
 200         }
 201       }
 202     }
 203
 204     /* read exponent, if any */
 205     if ( p + 1 < limit && ( *p == 'e' || *p == 'E' ) )
 206     {
 207       p++;
 208       power_ten += PS_Conv_ToInt( &p, limit );
 209     }
 210
 211     while ( power_ten > 0 )
 212     {
 213       integral *= 10;
 214       decimal  *= 10;
 215       power_ten--;
 216     }
 217
 218     while ( power_ten < 0 )
 219     {
 220       integral /= 10;
 221       divider  *= 10;
 222       power_ten++;
 223     }
 224
 225     if ( decimal )
 226       integral += FT_DivFix( decimal, divider );
 227
 228     if ( sign )
 229       integral = -integral;
 230
 231     *cursor = p;
 232
 233     return integral;
 234   }
 235
 236
 237 #if 0
 238   FT_LOCAL_DEF( FT_UInt )
 239   PS_Conv_StringDecode( FT_Byte**  cursor,
 240                         FT_Byte*   limit,
 241                         FT_Byte*   buffer,
 242                         FT_Offset  n )
 243   {
 244     FT_Byte*  p;
 245     FT_UInt   r = 0;
 246
 247
 248     for ( p = *cursor; r < n && p < limit; p++ )
 249     {
 250       FT_Byte  b;
 251
 252
 253       if ( *p != '\\' )
 254       {
 255         buffer[r++] = *p;
 256
 257         continue;
 258       }
 259
 260       p++;
 261
 262       switch ( *p )
 263       {
 264       case 'n':
 265         b = '\n';
 266         break;
 267       case 'r':
 268         b = '\r';
 269         break;
 270       case 't':
 271         b = '\t';
 272         break;
 273       case 'b':
 274         b = '\b';
 275         break;
 276       case 'f':
 277         b = '\f';
 278         break;
 279       case '\r':
 280         p++;
 281         if ( *p != '\n' )
 282         {
 283           b = *p;
 284
 285           break;
 286         }
 287         /* no break */
 288       case '\n':
 289         continue;
 290         break;
 291       default:
 292         if ( IS_PS_DIGIT( *p ) )
 293         {
 294           b = *p - '0';
 295
 296           p++;
 297
 298           if ( IS_PS_DIGIT( *p ) )
 299           {
 300             b = b * 8 + *p - '0';
 301
 302             p++;
 303
 304             if ( IS_PS_DIGIT( *p ) )
 305               b = b * 8 + *p - '0';
 306             else
 307             {
 308               buffer[r++] = b;
 309               b = *p;
 310             }
 311           }
 312           else
 313           {
 314             buffer[r++] = b;
 315             b = *p;
 316           }
 317         }
 318         else
 319           b = *p;
 320         break;
 321       }
 322
 323       buffer[r++] = b;
 324     }
 325
 326     *cursor = p;
 327
 328     return r;
 329   }
 330 #endif /* 0 */
 331
 332
 333   FT_LOCAL_DEF( FT_UInt )
 334   PS_Conv_ASCIIHexDecode( FT_Byte**  cursor,
 335                           FT_Byte*   limit,
 336                           FT_Byte*   buffer,
 337                           FT_Offset  n )
 338   {
 339     FT_Byte*  p;
 340     FT_UInt   r   = 0;
 341     FT_UInt   w   = 0;
 342     FT_UInt   pad = 0x01;
 343
 344
 345     n *= 2;
 346
 347 #if 1
 348
 349     p  = *cursor;
 350     if ( n > (FT_UInt)( limit - p ) )
 351       n = (FT_UInt)( limit - p );
 352
 353     /* we try to process two nibbles at a time to be as fast as possible */
 354     for ( ; r < n; r++ )
 355     {
 356       FT_UInt  c = p[r];
 357
 358
 359       if ( IS_PS_SPACE( c ) )
 360         continue;
 361
 362       if ( c OP 0x80 )
 363         break;
 364
 365       c = ft_char_table[c & 0x7F];
 366       if ( (unsigned)c >= 16 )
 367         break;
 368
 369       pad = ( pad << 4 ) | c;
 370       if ( pad & 0x100 )
 371       {
 372         buffer[w++] = (FT_Byte)pad;
 373         pad         = 0x01;
 374       }
 375     }
 376
 377     if ( pad != 0x01 )
 378       buffer[w++] = (FT_Byte)( pad << 4 );
 379
 380     *cursor = p + r;
 381
 382     return w;
 383
 384 #else /* 0 */
 385
 386     for ( r = 0; r < n; r++ )
 387     {
 388       FT_Char  c;
 389
 390
 391       if ( IS_PS_SPACE( *p ) )
 392         continue;
 393
 394       if ( *p OP 0x80 )
 395         break;
 396
 397       c = ft_char_table[*p & 0x7f];
 398
 399       if ( (unsigned)c >= 16 )
 400         break;
 401
 402       if ( r & 1 )
 403       {
 404         *buffer = (FT_Byte)(*buffer + c);
 405         buffer++;
 406       }
 407       else
 408         *buffer = (FT_Byte)(c << 4);
 409
 410       r++;
 411     }
 412
 413     *cursor = p;
 414
 415     return ( r + 1 ) / 2;
 416
 417 #endif /* 0 */
 418
 419   }
 420
 421
 422   FT_LOCAL_DEF( FT_UInt )
 423   PS_Conv_EexecDecode( FT_Byte**   cursor,
 424                        FT_Byte*    limit,
 425                        FT_Byte*    buffer,
 426                        FT_Offset   n,
 427                        FT_UShort*  seed )
 428   {
 429     FT_Byte*  p;
 430     FT_UInt   r;
 431     FT_UInt   s = *seed;
 432
 433
 434 #if 1
 435
 436     p = *cursor;
 437     if ( n > (FT_UInt)(limit - p) )
 438       n = (FT_UInt)(limit - p);
 439
 440     for ( r = 0; r < n; r++ )
 441     {
 442       FT_UInt  val = p[r];
 443       FT_UInt  b   = ( val ^ ( s >> 8 ) );
 444
 445
 446       s         = ( (val + s)*52845U + 22719 ) & 0xFFFFU;
 447       buffer[r] = (FT_Byte) b;
 448     }
 449
 450     *cursor = p + n;
 451     *seed   = (FT_UShort)s;
 452
 453 #else /* 0 */
 454
 455     for ( r = 0, p = *cursor; r < n && p < limit; r++, p++ )
 456     {
 457       FT_Byte  b = (FT_Byte)( *p ^ ( s >> 8 ) );
 458
 459
 460       s = (FT_UShort)( ( *p + s ) * 52845U + 22719 );
 461       *buffer++ = b;
 462     }
 463     *cursor = p;
 464     *seed   = s;
 465
 466 #endif /* 0 */
 467
 468     return r;
 469   }
 470
 471
 472 /* END */