src/third_party/freetype2/src/src/cff/cffparse.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  cffparse.c                                                             */
   4 /*                                                                         */
   5 /*    CFF token stream parser (body)                                       */
   6 /*                                                                         */
   7 /*  Copyright 1996-2004, 2007-2011 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 "cffparse.h"
  21 #include FT_INTERNAL_STREAM_H
  22 #include FT_INTERNAL_DEBUG_H
  23
  24 #include "cfferrs.h"
  25 #include "cffpic.h"
  26
  27
  28   /*************************************************************************/
  29   /*                                                                       */
  30   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  31   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  32   /* messages during execution.                                            */
  33   /*                                                                       */
  34 #undef  FT_COMPONENT
  35 #define FT_COMPONENT  trace_cffparse
  36
  37
  38   FT_LOCAL_DEF( void )
  39   cff_parser_init( CFF_Parser  parser,
  40                    FT_UInt     code,
  41                    void*       object,
  42                    FT_Library  library)
  43   {
  44     FT_MEM_ZERO( parser, sizeof ( *parser ) );
  45
  46     parser->top         = parser->stack;
  47     parser->object_code = code;
  48     parser->object      = object;
  49     parser->library     = library;
  50   }
  51
  52
  53   /* read an integer */
  54   static FT_Long
  55   cff_parse_integer( FT_Byte*  start,
  56                      FT_Byte*  limit )
  57   {
  58     FT_Byte*  p   = start;
  59     FT_Int    v   = *p++;
  60     FT_Long   val = 0;
  61
  62
  63     if ( v == 28 )
  64     {
  65       if ( p + 2 > limit )
  66         goto Bad;
  67
  68       val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] );
  69       p  += 2;
  70     }
  71     else if ( v == 29 )
  72     {
  73       if ( p + 4 > limit )
  74         goto Bad;
  75
  76       val = ( (FT_Long)p[0] << 24 ) |
  77             ( (FT_Long)p[1] << 16 ) |
  78             ( (FT_Long)p[2] <<  8 ) |
  79                        p[3];
  80       p += 4;
  81     }
  82     else if ( v < 247 )
  83     {
  84       val = v - 139;
  85     }
  86     else if ( v < 251 )
  87     {
  88       if ( p + 1 > limit )
  89         goto Bad;
  90
  91       val = ( v - 247 ) * 256 + p[0] + 108;
  92       p++;
  93     }
  94     else
  95     {
  96       if ( p + 1 > limit )
  97         goto Bad;
  98
  99       val = -( v - 251 ) * 256 - p[0] - 108;
 100       p++;
 101     }
 102
 103   Exit:
 104     return val;
 105
 106   Bad:
 107     val = 0;
 108     goto Exit;
 109   }
 110
 111
 112   static const FT_Long power_tens[] =
 113   {
 114     1L,
 115     10L,
 116     100L,
 117     1000L,
 118     10000L,
 119     100000L,
 120     1000000L,
 121     10000000L,
 122     100000000L,
 123     1000000000L
 124   };
 125
 126
 127   /* read a real */
 128   static FT_Fixed
 129   cff_parse_real( FT_Byte*  start,
 130                   FT_Byte*  limit,
 131                   FT_Long   power_ten,
 132                   FT_Long*  scaling )
 133   {
 134     FT_Byte*  p = start;
 135     FT_UInt   nib;
 136     FT_UInt   phase;
 137
 138     FT_Long   result, number, exponent;
 139     FT_Int    sign = 0, exponent_sign = 0;
 140     FT_Long   exponent_add, integer_length, fraction_length;
 141
 142
 143     if ( scaling )
 144       *scaling = 0;
 145
 146     result = 0;
 147
 148     number   = 0;
 149     exponent = 0;
 150
 151     exponent_add    = 0;
 152     integer_length  = 0;
 153     fraction_length = 0;
 154
 155     /* First of all, read the integer part. */
 156     phase = 4;
 157
 158     for (;;)
 159     {
 160       /* If we entered this iteration with phase == 4, we need to */
 161       /* read a new byte.  This also skips past the initial 0x1E. */
 162       if ( phase )
 163       {
 164         p++;
 165
 166         /* Make sure we don't read past the end. */
 167         if ( p >= limit )
 168           goto Exit;
 169       }
 170
 171       /* Get the nibble. */
 172       nib   = ( p[0] >> phase ) & 0xF;
 173       phase = 4 - phase;
 174
 175       if ( nib == 0xE )
 176         sign = 1;
 177       else if ( nib > 9 )
 178         break;
 179       else
 180       {
 181         /* Increase exponent if we can't add the digit. */
 182         if ( number >= 0xCCCCCCCL )
 183           exponent_add++;
 184         /* Skip leading zeros. */
 185         else if ( nib || number )
 186         {
 187           integer_length++;
 188           number = number * 10 + nib;
 189         }
 190       }
 191     }
 192
 193     /* Read fraction part, if any. */
 194     if ( nib == 0xa )
 195       for (;;)
 196       {
 197         /* If we entered this iteration with phase == 4, we need */
 198         /* to read a new byte.                                   */
 199         if ( phase )
 200         {
 201           p++;
 202
 203           /* Make sure we don't read past the end. */
 204           if ( p >= limit )
 205             goto Exit;
 206         }
 207
 208         /* Get the nibble. */
 209         nib   = ( p[0] >> phase ) & 0xF;
 210         phase = 4 - phase;
 211         if ( nib >= 10 )
 212           break;
 213
 214         /* Skip leading zeros if possible. */
 215         if ( !nib && !number )
 216           exponent_add--;
 217         /* Only add digit if we don't overflow. */
 218         else if ( number < 0xCCCCCCCL && fraction_length < 9 )
 219         {
 220           fraction_length++;
 221           number = number * 10 + nib;
 222         }
 223       }
 224
 225     /* Read exponent, if any. */
 226     if ( nib == 12 )
 227     {
 228       exponent_sign = 1;
 229       nib           = 11;
 230     }
 231
 232     if ( nib == 11 )
 233     {
 234       for (;;)
 235       {
 236         /* If we entered this iteration with phase == 4, */
 237         /* we need to read a new byte.                   */
 238         if ( phase )
 239         {
 240           p++;
 241
 242           /* Make sure we don't read past the end. */
 243           if ( p >= limit )
 244             goto Exit;
 245         }
 246
 247         /* Get the nibble. */
 248         nib   = ( p[0] >> phase ) & 0xF;
 249         phase = 4 - phase;
 250         if ( nib >= 10 )
 251           break;
 252
 253         exponent = exponent * 10 + nib;
 254
 255         /* Arbitrarily limit exponent. */
 256         if ( exponent > 1000 )
 257           goto Exit;
 258       }
 259
 260       if ( exponent_sign )
 261         exponent = -exponent;
 262     }
 263
 264     /* We don't check `power_ten' and `exponent_add'. */
 265     exponent += power_ten + exponent_add;
 266
 267     if ( scaling )
 268     {
 269       /* Only use `fraction_length'. */
 270       fraction_length += integer_length;
 271       exponent        += integer_length;
 272
 273       if ( fraction_length <= 5 )
 274       {
 275         if ( number > 0x7FFFL )
 276         {
 277           result   = FT_DivFix( number, 10 );
 278           *scaling = exponent - fraction_length + 1;
 279         }
 280         else
 281         {
 282           if ( exponent > 0 )
 283           {
 284             FT_Long  new_fraction_length, shift;
 285
 286
 287             /* Make `scaling' as small as possible. */
 288             new_fraction_length = FT_MIN( exponent, 5 );
 289             exponent           -= new_fraction_length;
 290             shift               = new_fraction_length - fraction_length;
 291
 292             number *= power_tens[shift];
 293             if ( number > 0x7FFFL )
 294             {
 295               number   /= 10;
 296               exponent += 1;
 297             }
 298           }
 299           else
 300             exponent -= fraction_length;
 301
 302           result   = number << 16;
 303           *scaling = exponent;
 304         }
 305       }
 306       else
 307       {
 308         if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
 309         {
 310           result   = FT_DivFix( number, power_tens[fraction_length - 4] );
 311           *scaling = exponent - 4;
 312         }
 313         else
 314         {
 315           result   = FT_DivFix( number, power_tens[fraction_length - 5] );
 316           *scaling = exponent - 5;
 317         }
 318       }
 319     }
 320     else
 321     {
 322       integer_length  += exponent;
 323       fraction_length -= exponent;
 324
 325       /* Check for overflow and underflow. */
 326       if ( FT_ABS( integer_length ) > 5 )
 327         goto Exit;
 328
 329       /* Remove non-significant digits. */
 330       if ( integer_length < 0 )
 331       {
 332         number          /= power_tens[-integer_length];
 333         fraction_length += integer_length;
 334       }
 335
 336       /* this can only happen if exponent was non-zero */
 337       if ( fraction_length == 10 )
 338       {
 339         number          /= 10;
 340         fraction_length -= 1;
 341       }
 342
 343       /* Convert into 16.16 format. */
 344       if ( fraction_length > 0 )
 345       {
 346         if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
 347           goto Exit;
 348
 349         result = FT_DivFix( number, power_tens[fraction_length] );
 350       }
 351       else
 352       {
 353         number *= power_tens[-fraction_length];
 354
 355         if ( number > 0x7FFFL )
 356           goto Exit;
 357
 358         result = number << 16;
 359       }
 360     }
 361
 362     if ( sign )
 363       result = -result;
 364
 365   Exit:
 366     return result;
 367   }
 368
 369
 370   /* read a number, either integer or real */
 371   static FT_Long
 372   cff_parse_num( FT_Byte**  d )
 373   {
 374     return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 )
 375                      :   cff_parse_integer( d[0], d[1] );
 376   }
 377
 378
 379   /* read a floating point number, either integer or real */
 380   static FT_Fixed
 381   cff_parse_fixed( FT_Byte**  d )
 382   {
 383     return **d == 30 ? cff_parse_real( d[0], d[1], 0, NULL )
 384                      : cff_parse_integer( d[0], d[1] ) << 16;
 385   }
 386
 387
 388   /* read a floating point number, either integer or real, */
 389   /* but return `10^scaling' times the number read in      */
 390   static FT_Fixed
 391   cff_parse_fixed_scaled( FT_Byte**  d,
 392                           FT_Long    scaling )
 393   {
 394     return **d == 30 ? cff_parse_real( d[0], d[1], scaling, NULL )
 395                      : ( cff_parse_integer( d[0], d[1] ) *
 396                            power_tens[scaling] ) << 16;
 397   }
 398
 399
 400   /* read a floating point number, either integer or real,     */
 401   /* and return it as precise as possible -- `scaling' returns */
 402   /* the scaling factor (as a power of 10)                     */
 403   static FT_Fixed
 404   cff_parse_fixed_dynamic( FT_Byte**  d,
 405                            FT_Long*   scaling )
 406   {
 407     FT_ASSERT( scaling );
 408
 409     if ( **d == 30 )
 410       return cff_parse_real( d[0], d[1], 0, scaling );
 411     else
 412     {
 413       FT_Long  number;
 414       FT_Int   integer_length;
 415
 416
 417       number = cff_parse_integer( d[0], d[1] );
 418
 419       if ( number > 0x7FFFL )
 420       {
 421         for ( integer_length = 5; integer_length < 10; integer_length++ )
 422           if ( number < power_tens[integer_length] )
 423             break;
 424
 425         if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL )
 426         {
 427           *scaling = integer_length - 4;
 428           return FT_DivFix( number, power_tens[integer_length - 4] );
 429         }
 430         else
 431         {
 432           *scaling = integer_length - 5;
 433           return FT_DivFix( number, power_tens[integer_length - 5] );
 434         }
 435       }
 436       else
 437       {
 438         *scaling = 0;
 439         return number << 16;
 440       }
 441     }
 442   }
 443
 444
 445   static FT_Error
 446   cff_parse_font_matrix( CFF_Parser  parser )
 447   {
 448     CFF_FontRecDict  dict   = (CFF_FontRecDict)parser->object;
 449     FT_Matrix*       matrix = &dict->font_matrix;
 450     FT_Vector*       offset = &dict->font_offset;
 451     FT_ULong*        upm    = &dict->units_per_em;
 452     FT_Byte**        data   = parser->stack;
 453     FT_Error         error  = CFF_Err_Stack_Underflow;
 454
 455
 456     if ( parser->top >= parser->stack + 6 )
 457     {
 458       FT_Long  scaling;
 459
 460
 461       error = CFF_Err_Ok;
 462
 463       dict->has_font_matrix = TRUE;
 464
 465       /* We expect a well-formed font matrix, this is, the matrix elements */
 466       /* `xx' and `yy' are of approximately the same magnitude.  To avoid  */
 467       /* loss of precision, we use the magnitude of element `xx' to scale  */
 468       /* all other elements.  The scaling factor is then contained in the  */
 469       /* `units_per_em' value.                                             */
 470
 471       matrix->xx = cff_parse_fixed_dynamic( data++, &scaling );
 472
 473       scaling = -scaling;
 474
 475       if ( scaling < 0 || scaling > 9 )
 476       {
 477         /* Return default matrix in case of unlikely values. */
 478
 479         FT_TRACE1(( "cff_parse_font_matrix:"
 480                     " strange scaling value for xx element (%d),\n"
 481                     "                      "
 482                     " using default matrix\n", scaling ));
 483
 484         matrix->xx = 0x10000L;
 485         matrix->yx = 0;
 486         matrix->xy = 0;
 487         matrix->yy = 0x10000L;
 488         offset->x  = 0;
 489         offset->y  = 0;
 490         *upm       = 1;
 491
 492         goto Exit;
 493       }
 494
 495       matrix->yx = cff_parse_fixed_scaled( data++, scaling );
 496       matrix->xy = cff_parse_fixed_scaled( data++, scaling );
 497       matrix->yy = cff_parse_fixed_scaled( data++, scaling );
 498       offset->x  = cff_parse_fixed_scaled( data++, scaling );
 499       offset->y  = cff_parse_fixed_scaled( data,   scaling );
 500
 501       *upm = power_tens[scaling];
 502
 503       FT_TRACE4(( " [%f %f %f %f %f %f]\n",
 504                   (double)matrix->xx / *upm / 65536,
 505                   (double)matrix->xy / *upm / 65536,
 506                   (double)matrix->yx / *upm / 65536,
 507                   (double)matrix->yy / *upm / 65536,
 508                   (double)offset->x  / *upm / 65536,
 509                   (double)offset->y  / *upm / 65536 ));
 510     }
 511
 512   Exit:
 513     return error;
 514   }
 515
 516
 517   static FT_Error
 518   cff_parse_font_bbox( CFF_Parser  parser )
 519   {
 520     CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
 521     FT_BBox*         bbox = &dict->font_bbox;
 522     FT_Byte**        data = parser->stack;
 523     FT_Error         error;
 524
 525
 526     error = CFF_Err_Stack_Underflow;
 527
 528     if ( parser->top >= parser->stack + 4 )
 529     {
 530       bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) );
 531       bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) );
 532       bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) );
 533       bbox->yMax = FT_RoundFix( cff_parse_fixed( data   ) );
 534       error = CFF_Err_Ok;
 535
 536       FT_TRACE4(( " [%d %d %d %d]\n",
 537                   bbox->xMin / 65536,
 538                   bbox->yMin / 65536,
 539                   bbox->xMax / 65536,
 540                   bbox->yMax / 65536 ));
 541     }
 542
 543     return error;
 544   }
 545
 546
 547   static FT_Error
 548   cff_parse_private_dict( CFF_Parser  parser )
 549   {
 550     CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
 551     FT_Byte**        data = parser->stack;
 552     FT_Error         error;
 553
 554
 555     error = CFF_Err_Stack_Underflow;
 556
 557     if ( parser->top >= parser->stack + 2 )
 558     {
 559       dict->private_size   = cff_parse_num( data++ );
 560       dict->private_offset = cff_parse_num( data   );
 561       FT_TRACE4(( " %lu %lu\n",
 562                   dict->private_size, dict->private_offset ));
 563
 564       error = CFF_Err_Ok;
 565     }
 566
 567     return error;
 568   }
 569
 570
 571   static FT_Error
 572   cff_parse_cid_ros( CFF_Parser  parser )
 573   {
 574     CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
 575     FT_Byte**        data = parser->stack;
 576     FT_Error         error;
 577
 578
 579     error = CFF_Err_Stack_Underflow;
 580
 581     if ( parser->top >= parser->stack + 3 )
 582     {
 583       dict->cid_registry = (FT_UInt)cff_parse_num( data++ );
 584       dict->cid_ordering = (FT_UInt)cff_parse_num( data++ );
 585       if ( **data == 30 )
 586         FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
 587       dict->cid_supplement = cff_parse_num( data );
 588       if ( dict->cid_supplement < 0 )
 589         FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n",
 590                    dict->cid_supplement ));
 591       error = CFF_Err_Ok;
 592
 593       FT_TRACE4(( " %d %d %d\n",
 594                   dict->cid_registry,
 595                   dict->cid_ordering,
 596                   dict->cid_supplement ));
 597     }
 598
 599     return error;
 600   }
 601
 602
 603 #define CFF_FIELD_NUM( code, name, id )             \
 604           CFF_FIELD( code, name, id, cff_kind_num )
 605 #define CFF_FIELD_FIXED( code, name, id )             \
 606           CFF_FIELD( code, name, id, cff_kind_fixed )
 607 #define CFF_FIELD_FIXED_1000( code, name, id )                 \
 608           CFF_FIELD( code, name, id, cff_kind_fixed_thousand )
 609 #define CFF_FIELD_STRING( code, name, id )             \
 610           CFF_FIELD( code, name, id, cff_kind_string )
 611 #define CFF_FIELD_BOOL( code, name, id )             \
 612           CFF_FIELD( code, name, id, cff_kind_bool )
 613
 614 #define CFFCODE_TOPDICT  0x1000
 615 #define CFFCODE_PRIVATE  0x2000
 616
 617
 618 #ifndef FT_CONFIG_OPTION_PIC
 619
 620
 621 #undef  CFF_FIELD
 622 #undef  CFF_FIELD_DELTA
 623
 624
 625 #ifndef FT_DEBUG_LEVEL_TRACE
 626
 627
 628 #define CFF_FIELD_CALLBACK( code, name, id ) \
 629           {                                  \
 630             cff_kind_callback,               \
 631             code | CFFCODE,                  \
 632             0, 0,                            \
 633             cff_parse_ ## name,              \
 634             0, 0                             \
 635           },
 636
 637 #define CFF_FIELD( code, name, id, kind ) \
 638           {                               \
 639             kind,                         \
 640             code | CFFCODE,               \
 641             FT_FIELD_OFFSET( name ),      \
 642             FT_FIELD_SIZE( name ),        \
 643             0, 0, 0                       \
 644           },
 645
 646 #define CFF_FIELD_DELTA( code, name, max, id ) \
 647           {                                    \
 648             cff_kind_delta,                    \
 649             code | CFFCODE,                    \
 650             FT_FIELD_OFFSET( name ),           \
 651             FT_FIELD_SIZE_DELTA( name ),       \
 652             0,                                 \
 653             max,                               \
 654             FT_FIELD_OFFSET( num_ ## name )    \
 655           },
 656
 657   static const CFF_Field_Handler  cff_field_handlers[] =
 658   {
 659
 660 #include "cfftoken.h"
 661
 662     { 0, 0, 0, 0, 0, 0, 0 }
 663   };
 664
 665
 666 #else /* FT_DEBUG_LEVEL_TRACE */
 667
 668
 669
 670 #define CFF_FIELD_CALLBACK( code, name, id ) \
 671           {                                  \
 672             cff_kind_callback,               \
 673             code | CFFCODE,                  \
 674             0, 0,                            \
 675             cff_parse_ ## name,              \
 676             0, 0,                            \
 677             id                               \
 678           },
 679
 680 #define CFF_FIELD( code, name, id, kind ) \
 681           {                               \
 682             kind,                         \
 683             code | CFFCODE,               \
 684             FT_FIELD_OFFSET( name ),      \
 685             FT_FIELD_SIZE( name ),        \
 686             0, 0, 0,                      \
 687             id                            \
 688           },
 689
 690 #define CFF_FIELD_DELTA( code, name, max, id ) \
 691           {                                    \
 692             cff_kind_delta,                    \
 693             code | CFFCODE,                    \
 694             FT_FIELD_OFFSET( name ),           \
 695             FT_FIELD_SIZE_DELTA( name ),       \
 696             0,                                 \
 697             max,                               \
 698             FT_FIELD_OFFSET( num_ ## name ),   \
 699             id                                 \
 700           },
 701
 702   static const CFF_Field_Handler  cff_field_handlers[] =
 703   {
 704
 705 #include "cfftoken.h"
 706
 707     { 0, 0, 0, 0, 0, 0, 0, 0 }
 708   };
 709
 710
 711 #endif /* FT_DEBUG_LEVEL_TRACE */
 712
 713
 714 #else /* FT_CONFIG_OPTION_PIC */
 715
 716
 717   void
 718   FT_Destroy_Class_cff_field_handlers( FT_Library          library,
 719                                        CFF_Field_Handler*  clazz )
 720   {
 721     FT_Memory  memory = library->memory;
 722
 723
 724     if ( clazz )
 725       FT_FREE( clazz );
 726   }
 727
 728
 729   FT_Error
 730   FT_Create_Class_cff_field_handlers( FT_Library           library,
 731                                       CFF_Field_Handler**  output_class )
 732   {
 733     CFF_Field_Handler*  clazz;
 734     FT_Error            error;
 735     FT_Memory           memory = library->memory;
 736
 737     int  i = 0;
 738
 739
 740 #undef CFF_FIELD
 741 #define CFF_FIELD( code, name, id, kind ) i++;
 742 #undef CFF_FIELD_DELTA
 743 #define CFF_FIELD_DELTA( code, name, max, id ) i++;
 744 #undef CFF_FIELD_CALLBACK
 745 #define CFF_FIELD_CALLBACK( code, name, id ) i++;
 746
 747 #include "cfftoken.h"
 748
 749     i++; /* { 0, 0, 0, 0, 0, 0, 0 } */
 750
 751     if ( FT_ALLOC( clazz, sizeof ( CFF_Field_Handler ) * i ) )
 752       return error;
 753
 754     i = 0;
 755
 756
 757 #ifndef FT_DEBUG_LEVEL_TRACE
 758
 759
 760 #undef CFF_FIELD_CALLBACK
 761 #define CFF_FIELD_CALLBACK( code_, name_, id_ )        \
 762           clazz[i].kind         = cff_kind_callback;   \
 763           clazz[i].code         = code_ | CFFCODE;     \
 764           clazz[i].offset       = 0;                   \
 765           clazz[i].size         = 0;                   \
 766           clazz[i].reader       = cff_parse_ ## name_; \
 767           clazz[i].array_max    = 0;                   \
 768           clazz[i].count_offset = 0;                   \
 769           i++;
 770
 771 #undef  CFF_FIELD
 772 #define CFF_FIELD( code_, name_, id_, kind_ )               \
 773           clazz[i].kind         = kind_;                    \
 774           clazz[i].code         = code_ | CFFCODE;          \
 775           clazz[i].offset       = FT_FIELD_OFFSET( name_ ); \
 776           clazz[i].size         = FT_FIELD_SIZE( name_ );   \
 777           clazz[i].reader       = 0;                        \
 778           clazz[i].array_max    = 0;                        \
 779           clazz[i].count_offset = 0;                        \
 780           i++;                                              \
 781
 782 #undef  CFF_FIELD_DELTA
 783 #define CFF_FIELD_DELTA( code_, name_, max_, id_ )                  \
 784           clazz[i].kind         = cff_kind_delta;                   \
 785           clazz[i].code         = code_ | CFFCODE;                  \
 786           clazz[i].offset       = FT_FIELD_OFFSET( name_ );         \
 787           clazz[i].size         = FT_FIELD_SIZE_DELTA( name_ );     \
 788           clazz[i].reader       = 0;                                \
 789           clazz[i].array_max    = max_;                             \
 790           clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
 791           i++;
 792
 793 #include "cfftoken.h"
 794
 795     clazz[i].kind         = 0;
 796     clazz[i].code         = 0;
 797     clazz[i].offset       = 0;
 798     clazz[i].size         = 0;
 799     clazz[i].reader       = 0;
 800     clazz[i].array_max    = 0;
 801     clazz[i].count_offset = 0;
 802
 803
 804 #else /* FT_DEBUG_LEVEL_TRACE */
 805
 806
 807 #undef CFF_FIELD_CALLBACK
 808 #define CFF_FIELD_CALLBACK( code_, name_, id_ )        \
 809           clazz[i].kind         = cff_kind_callback;   \
 810           clazz[i].code         = code_ | CFFCODE;     \
 811           clazz[i].offset       = 0;                   \
 812           clazz[i].size         = 0;                   \
 813           clazz[i].reader       = cff_parse_ ## name_; \
 814           clazz[i].array_max    = 0;                   \
 815           clazz[i].count_offset = 0;                   \
 816           clazz[i].id           = id_;                 \
 817           i++;
 818
 819 #undef  CFF_FIELD
 820 #define CFF_FIELD( code_, name_, id_, kind_ )               \
 821           clazz[i].kind         = kind_;                    \
 822           clazz[i].code         = code_ | CFFCODE;          \
 823           clazz[i].offset       = FT_FIELD_OFFSET( name_ ); \
 824           clazz[i].size         = FT_FIELD_SIZE( name_ );   \
 825           clazz[i].reader       = 0;                        \
 826           clazz[i].array_max    = 0;                        \
 827           clazz[i].count_offset = 0;                        \
 828           clazz[i].id           = id_;                      \
 829           i++;                                              \
 830
 831 #undef  CFF_FIELD_DELTA
 832 #define CFF_FIELD_DELTA( code_, name_, max_, id_ )                  \
 833           clazz[i].kind         = cff_kind_delta;                   \
 834           clazz[i].code         = code_ | CFFCODE;                  \
 835           clazz[i].offset       = FT_FIELD_OFFSET( name_ );         \
 836           clazz[i].size         = FT_FIELD_SIZE_DELTA( name_ );     \
 837           clazz[i].reader       = 0;                                \
 838           clazz[i].array_max    = max_;                             \
 839           clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
 840           clazz[i].id           = id_;                              \
 841           i++;
 842
 843 #include "cfftoken.h"
 844
 845     clazz[i].kind         = 0;
 846     clazz[i].code         = 0;
 847     clazz[i].offset       = 0;
 848     clazz[i].size         = 0;
 849     clazz[i].reader       = 0;
 850     clazz[i].array_max    = 0;
 851     clazz[i].count_offset = 0;
 852     clazz[i].id           = 0;
 853
 854
 855 #endif /* FT_DEBUG_LEVEL_TRACE */
 856
 857
 858     *output_class = clazz;
 859
 860     return CFF_Err_Ok;
 861   }
 862
 863
 864 #endif /* FT_CONFIG_OPTION_PIC */
 865
 866
 867   FT_LOCAL_DEF( FT_Error )
 868   cff_parser_run( CFF_Parser  parser,
 869                   FT_Byte*    start,
 870                   FT_Byte*    limit )
 871   {
 872     FT_Byte*    p       = start;
 873     FT_Error    error   = CFF_Err_Ok;
 874     FT_Library  library = parser->library;
 875     FT_UNUSED( library );
 876
 877
 878     parser->top    = parser->stack;
 879     parser->start  = start;
 880     parser->limit  = limit;
 881     parser->cursor = start;
 882
 883     while ( p < limit )
 884     {
 885       FT_UInt  v = *p;
 886
 887
 888       if ( v >= 27 && v != 31 )
 889       {
 890         /* it's a number; we will push its position on the stack */
 891         if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH )
 892           goto Stack_Overflow;
 893
 894         *parser->top ++ = p;
 895
 896         /* now, skip it */
 897         if ( v == 30 )
 898         {
 899           /* skip real number */
 900           p++;
 901           for (;;)
 902           {
 903             /* An unterminated floating point number at the */
 904             /* end of a dictionary is invalid but harmless. */
 905             if ( p >= limit )
 906               goto Exit;
 907             v = p[0] >> 4;
 908             if ( v == 15 )
 909               break;
 910             v = p[0] & 0xF;
 911             if ( v == 15 )
 912               break;
 913             p++;
 914           }
 915         }
 916         else if ( v == 28 )
 917           p += 2;
 918         else if ( v == 29 )
 919           p += 4;
 920         else if ( v > 246 )
 921           p += 1;
 922       }
 923       else
 924       {
 925         /* This is not a number, hence it's an operator.  Compute its code */
 926         /* and look for it in our current list.                            */
 927
 928         FT_UInt                   code;
 929         FT_UInt                   num_args = (FT_UInt)
 930                                              ( parser->top - parser->stack );
 931         const CFF_Field_Handler*  field;
 932
 933
 934         *parser->top = p;
 935         code = v;
 936         if ( v == 12 )
 937         {
 938           /* two byte operator */
 939           p++;
 940           if ( p >= limit )
 941             goto Syntax_Error;
 942
 943           code = 0x100 | p[0];
 944         }
 945         code = code | parser->object_code;
 946
 947         for ( field = FT_CFF_FIELD_HANDLERS_GET; field->kind; field++ )
 948         {
 949           if ( field->code == (FT_Int)code )
 950           {
 951             /* we found our field's handler; read it */
 952             FT_Long   val;
 953             FT_Byte*  q = (FT_Byte*)parser->object + field->offset;
 954
 955
 956 #ifdef FT_DEBUG_LEVEL_TRACE
 957             FT_TRACE4(( "  %s", field->id ));
 958 #endif
 959
 960             /* check that we have enough arguments -- except for */
 961             /* delta encoded arrays, which can be empty          */
 962             if ( field->kind != cff_kind_delta && num_args < 1 )
 963               goto Stack_Underflow;
 964
 965             switch ( field->kind )
 966             {
 967             case cff_kind_bool:
 968             case cff_kind_string:
 969             case cff_kind_num:
 970               val = cff_parse_num( parser->stack );
 971               goto Store_Number;
 972
 973             case cff_kind_fixed:
 974               val = cff_parse_fixed( parser->stack );
 975               goto Store_Number;
 976
 977             case cff_kind_fixed_thousand:
 978               val = cff_parse_fixed_scaled( parser->stack, 3 );
 979
 980             Store_Number:
 981               switch ( field->size )
 982               {
 983               case (8 / FT_CHAR_BIT):
 984                 *(FT_Byte*)q = (FT_Byte)val;
 985                 break;
 986
 987               case (16 / FT_CHAR_BIT):
 988                 *(FT_Short*)q = (FT_Short)val;
 989                 break;
 990
 991               case (32 / FT_CHAR_BIT):
 992                 *(FT_Int32*)q = (FT_Int)val;
 993                 break;
 994
 995               default:  /* for 64-bit systems */
 996                 *(FT_Long*)q = val;
 997               }
 998
 999 #ifdef FT_DEBUG_LEVEL_TRACE
1000               switch ( field->kind )
1001               {
1002               case cff_kind_bool:
1003                 FT_TRACE4(( " %s\n", val ? "true" : "false" ));
1004                 break;
1005
1006               case cff_kind_string:
1007                 FT_TRACE4(( " %ld (SID)\n", val ));
1008                 break;
1009
1010               case cff_kind_num:
1011                 FT_TRACE4(( " %ld\n", val ));
1012                 break;
1013
1014               case cff_kind_fixed:
1015                 FT_TRACE4(( " %f\n", (double)val / 65536 ));
1016                 break;
1017
1018               case cff_kind_fixed_thousand:
1019                 FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
1020
1021               default:
1022                 ; /* never reached */
1023               }
1024 #endif
1025
1026               break;
1027
1028             case cff_kind_delta:
1029               {
1030                 FT_Byte*   qcount = (FT_Byte*)parser->object +
1031                                       field->count_offset;
1032
1033                 FT_Byte**  data = parser->stack;
1034
1035
1036                 if ( num_args > field->array_max )
1037                   num_args = field->array_max;
1038
1039                 FT_TRACE4(( " [" ));
1040
1041                 /* store count */
1042                 *qcount = (FT_Byte)num_args;
1043
1044                 val = 0;
1045                 while ( num_args > 0 )
1046                 {
1047                   val += cff_parse_num( data++ );
1048                   switch ( field->size )
1049                   {
1050                   case (8 / FT_CHAR_BIT):
1051                     *(FT_Byte*)q = (FT_Byte)val;
1052                     break;
1053
1054                   case (16 / FT_CHAR_BIT):
1055                     *(FT_Short*)q = (FT_Short)val;
1056                     break;
1057
1058                   case (32 / FT_CHAR_BIT):
1059                     *(FT_Int32*)q = (FT_Int)val;
1060                     break;
1061
1062                   default:  /* for 64-bit systems */
1063                     *(FT_Long*)q = val;
1064                   }
1065
1066                   FT_TRACE4(( " %ld", val ));
1067
1068                   q += field->size;
1069                   num_args--;
1070                 }
1071
1072                 FT_TRACE4(( "]\n" ));
1073               }
1074               break;
1075
1076             default:  /* callback */
1077               error = field->reader( parser );
1078               if ( error )
1079                 goto Exit;
1080             }
1081             goto Found;
1082           }
1083         }
1084
1085         /* this is an unknown operator, or it is unsupported; */
1086         /* we will ignore it for now.                         */
1087
1088       Found:
1089         /* clear stack */
1090         parser->top = parser->stack;
1091       }
1092       p++;
1093     }
1094
1095   Exit:
1096     return error;
1097
1098   Stack_Overflow:
1099     error = CFF_Err_Invalid_Argument;
1100     goto Exit;
1101
1102   Stack_Underflow:
1103     error = CFF_Err_Invalid_Argument;
1104     goto Exit;
1105
1106   Syntax_Error:
1107     error = CFF_Err_Invalid_Argument;
1108     goto Exit;
1109   }
1110
1111
1112 /* END */