src/cff/cffparse.c

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