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