src/psaux/afmparse.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  afmparse.c                                                             */
   4 /*                                                                         */
   5 /*    AFM parser (body).                                                   */
   6 /*                                                                         */
   7 /*  Copyright 2006-2010, 2012 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 #include <ft2build.h>
  19 #include FT_FREETYPE_H
  20 #include FT_INTERNAL_POSTSCRIPT_AUX_H
  21
  22 #include "afmparse.h"
  23 #include "psconv.h"
  24
  25 #include "psauxerr.h"
  26
  27
  28 /***************************************************************************/
  29 /*                                                                         */
  30 /*    AFM_Stream                                                           */
  31 /*                                                                         */
  32 /* The use of AFM_Stream is largely inspired by parseAFM.[ch] from t1lib.  */
  33 /*                                                                         */
  34 /*                                                                         */
  35
  36   enum
  37   {
  38     AFM_STREAM_STATUS_NORMAL,
  39     AFM_STREAM_STATUS_EOC,
  40     AFM_STREAM_STATUS_EOL,
  41     AFM_STREAM_STATUS_EOF
  42   };
  43
  44
  45   typedef struct  AFM_StreamRec_
  46   {
  47     FT_Byte*  cursor;
  48     FT_Byte*  base;
  49     FT_Byte*  limit;
  50
  51     FT_Int    status;
  52
  53   } AFM_StreamRec;
  54
  55
  56 #ifndef EOF
  57 #define EOF -1
  58 #endif
  59
  60
  61   /* this works because empty lines are ignored */
  62 #define AFM_IS_NEWLINE( ch )  ( (ch) == '\r' || (ch) == '\n' )
  63
  64 #define AFM_IS_EOF( ch )      ( (ch) == EOF  || (ch) == '\x1a' )
  65 #define AFM_IS_SPACE( ch )    ( (ch) == ' '  || (ch) == '\t' )
  66
  67   /* column separator; there is no `column' in the spec actually */
  68 #define AFM_IS_SEP( ch )      ( (ch) == ';' )
  69
  70 #define AFM_GETC()                                                       \
  71           ( ( (stream)->cursor < (stream)->limit ) ? *(stream)->cursor++ \
  72                                                    : EOF )
  73
  74 #define AFM_STREAM_KEY_BEGIN( stream )    \
  75           (char*)( (stream)->cursor - 1 )
  76
  77 #define AFM_STREAM_KEY_LEN( stream, key )       \
  78           ( (char*)(stream)->cursor - key - 1 )
  79
  80 #define AFM_STATUS_EOC( stream ) \
  81           ( (stream)->status >= AFM_STREAM_STATUS_EOC )
  82
  83 #define AFM_STATUS_EOL( stream ) \
  84           ( (stream)->status >= AFM_STREAM_STATUS_EOL )
  85
  86 #define AFM_STATUS_EOF( stream ) \
  87           ( (stream)->status >= AFM_STREAM_STATUS_EOF )
  88
  89
  90   static int
  91   afm_stream_skip_spaces( AFM_Stream  stream )
  92   {
  93     int  ch = 0;  /* make stupid compiler happy */
  94
  95
  96     if ( AFM_STATUS_EOC( stream ) )
  97       return ';';
  98
  99     while ( 1 )
 100     {
 101       ch = AFM_GETC();
 102       if ( !AFM_IS_SPACE( ch ) )
 103         break;
 104     }
 105
 106     if ( AFM_IS_NEWLINE( ch ) )
 107       stream->status = AFM_STREAM_STATUS_EOL;
 108     else if ( AFM_IS_SEP( ch ) )
 109       stream->status = AFM_STREAM_STATUS_EOC;
 110     else if ( AFM_IS_EOF( ch ) )
 111       stream->status = AFM_STREAM_STATUS_EOF;
 112
 113     return ch;
 114   }
 115
 116
 117   /* read a key or value in current column */
 118   static char*
 119   afm_stream_read_one( AFM_Stream  stream )
 120   {
 121     char*  str;
 122     int    ch;
 123
 124
 125     afm_stream_skip_spaces( stream );
 126     if ( AFM_STATUS_EOC( stream ) )
 127       return NULL;
 128
 129     str = AFM_STREAM_KEY_BEGIN( stream );
 130
 131     while ( 1 )
 132     {
 133       ch = AFM_GETC();
 134       if ( AFM_IS_SPACE( ch ) )
 135         break;
 136       else if ( AFM_IS_NEWLINE( ch ) )
 137       {
 138         stream->status = AFM_STREAM_STATUS_EOL;
 139         break;
 140       }
 141       else if ( AFM_IS_SEP( ch ) )
 142       {
 143         stream->status = AFM_STREAM_STATUS_EOC;
 144         break;
 145       }
 146       else if ( AFM_IS_EOF( ch ) )
 147       {
 148         stream->status = AFM_STREAM_STATUS_EOF;
 149         break;
 150       }
 151     }
 152
 153     return str;
 154   }
 155
 156
 157   /* read a string (i.e., read to EOL) */
 158   static char*
 159   afm_stream_read_string( AFM_Stream  stream )
 160   {
 161     char*  str;
 162     int    ch;
 163
 164
 165     afm_stream_skip_spaces( stream );
 166     if ( AFM_STATUS_EOL( stream ) )
 167       return NULL;
 168
 169     str = AFM_STREAM_KEY_BEGIN( stream );
 170
 171     /* scan to eol */
 172     while ( 1 )
 173     {
 174       ch = AFM_GETC();
 175       if ( AFM_IS_NEWLINE( ch ) )
 176       {
 177         stream->status = AFM_STREAM_STATUS_EOL;
 178         break;
 179       }
 180       else if ( AFM_IS_EOF( ch ) )
 181       {
 182         stream->status = AFM_STREAM_STATUS_EOF;
 183         break;
 184       }
 185     }
 186
 187     return str;
 188   }
 189
 190
 191   /*************************************************************************/
 192   /*                                                                       */
 193   /*    AFM_Parser                                                         */
 194   /*                                                                       */
 195   /*                                                                       */
 196
 197   /* all keys defined in Ch. 7-10 of 5004.AFM_Spec.pdf */
 198   typedef enum  AFM_Token_
 199   {
 200     AFM_TOKEN_ASCENDER,
 201     AFM_TOKEN_AXISLABEL,
 202     AFM_TOKEN_AXISTYPE,
 203     AFM_TOKEN_B,
 204     AFM_TOKEN_BLENDAXISTYPES,
 205     AFM_TOKEN_BLENDDESIGNMAP,
 206     AFM_TOKEN_BLENDDESIGNPOSITIONS,
 207     AFM_TOKEN_C,
 208     AFM_TOKEN_CC,
 209     AFM_TOKEN_CH,
 210     AFM_TOKEN_CAPHEIGHT,
 211     AFM_TOKEN_CHARWIDTH,
 212     AFM_TOKEN_CHARACTERSET,
 213     AFM_TOKEN_CHARACTERS,
 214     AFM_TOKEN_DESCENDER,
 215     AFM_TOKEN_ENCODINGSCHEME,
 216     AFM_TOKEN_ENDAXIS,
 217     AFM_TOKEN_ENDCHARMETRICS,
 218     AFM_TOKEN_ENDCOMPOSITES,
 219     AFM_TOKEN_ENDDIRECTION,
 220     AFM_TOKEN_ENDFONTMETRICS,
 221     AFM_TOKEN_ENDKERNDATA,
 222     AFM_TOKEN_ENDKERNPAIRS,
 223     AFM_TOKEN_ENDTRACKKERN,
 224     AFM_TOKEN_ESCCHAR,
 225     AFM_TOKEN_FAMILYNAME,
 226     AFM_TOKEN_FONTBBOX,
 227     AFM_TOKEN_FONTNAME,
 228     AFM_TOKEN_FULLNAME,
 229     AFM_TOKEN_ISBASEFONT,
 230     AFM_TOKEN_ISCIDFONT,
 231     AFM_TOKEN_ISFIXEDPITCH,
 232     AFM_TOKEN_ISFIXEDV,
 233     AFM_TOKEN_ITALICANGLE,
 234     AFM_TOKEN_KP,
 235     AFM_TOKEN_KPH,
 236     AFM_TOKEN_KPX,
 237     AFM_TOKEN_KPY,
 238     AFM_TOKEN_L,
 239     AFM_TOKEN_MAPPINGSCHEME,
 240     AFM_TOKEN_METRICSSETS,
 241     AFM_TOKEN_N,
 242     AFM_TOKEN_NOTICE,
 243     AFM_TOKEN_PCC,
 244     AFM_TOKEN_STARTAXIS,
 245     AFM_TOKEN_STARTCHARMETRICS,
 246     AFM_TOKEN_STARTCOMPOSITES,
 247     AFM_TOKEN_STARTDIRECTION,
 248     AFM_TOKEN_STARTFONTMETRICS,
 249     AFM_TOKEN_STARTKERNDATA,
 250     AFM_TOKEN_STARTKERNPAIRS,
 251     AFM_TOKEN_STARTKERNPAIRS0,
 252     AFM_TOKEN_STARTKERNPAIRS1,
 253     AFM_TOKEN_STARTTRACKKERN,
 254     AFM_TOKEN_STDHW,
 255     AFM_TOKEN_STDVW,
 256     AFM_TOKEN_TRACKKERN,
 257     AFM_TOKEN_UNDERLINEPOSITION,
 258     AFM_TOKEN_UNDERLINETHICKNESS,
 259     AFM_TOKEN_VV,
 260     AFM_TOKEN_VVECTOR,
 261     AFM_TOKEN_VERSION,
 262     AFM_TOKEN_W,
 263     AFM_TOKEN_W0,
 264     AFM_TOKEN_W0X,
 265     AFM_TOKEN_W0Y,
 266     AFM_TOKEN_W1,
 267     AFM_TOKEN_W1X,
 268     AFM_TOKEN_W1Y,
 269     AFM_TOKEN_WX,
 270     AFM_TOKEN_WY,
 271     AFM_TOKEN_WEIGHT,
 272     AFM_TOKEN_WEIGHTVECTOR,
 273     AFM_TOKEN_XHEIGHT,
 274     N_AFM_TOKENS,
 275     AFM_TOKEN_UNKNOWN
 276
 277   } AFM_Token;
 278
 279
 280   static const char*  const afm_key_table[N_AFM_TOKENS] =
 281   {
 282     "Ascender",
 283     "AxisLabel",
 284     "AxisType",
 285     "B",
 286     "BlendAxisTypes",
 287     "BlendDesignMap",
 288     "BlendDesignPositions",
 289     "C",
 290     "CC",
 291     "CH",
 292     "CapHeight",
 293     "CharWidth",
 294     "CharacterSet",
 295     "Characters",
 296     "Descender",
 297     "EncodingScheme",
 298     "EndAxis",
 299     "EndCharMetrics",
 300     "EndComposites",
 301     "EndDirection",
 302     "EndFontMetrics",
 303     "EndKernData",
 304     "EndKernPairs",
 305     "EndTrackKern",
 306     "EscChar",
 307     "FamilyName",
 308     "FontBBox",
 309     "FontName",
 310     "FullName",
 311     "IsBaseFont",
 312     "IsCIDFont",
 313     "IsFixedPitch",
 314     "IsFixedV",
 315     "ItalicAngle",
 316     "KP",
 317     "KPH",
 318     "KPX",
 319     "KPY",
 320     "L",
 321     "MappingScheme",
 322     "MetricsSets",
 323     "N",
 324     "Notice",
 325     "PCC",
 326     "StartAxis",
 327     "StartCharMetrics",
 328     "StartComposites",
 329     "StartDirection",
 330     "StartFontMetrics",
 331     "StartKernData",
 332     "StartKernPairs",
 333     "StartKernPairs0",
 334     "StartKernPairs1",
 335     "StartTrackKern",
 336     "StdHW",
 337     "StdVW",
 338     "TrackKern",
 339     "UnderlinePosition",
 340     "UnderlineThickness",
 341     "VV",
 342     "VVector",
 343     "Version",
 344     "W",
 345     "W0",
 346     "W0X",
 347     "W0Y",
 348     "W1",
 349     "W1X",
 350     "W1Y",
 351     "WX",
 352     "WY",
 353     "Weight",
 354     "WeightVector",
 355     "XHeight"
 356   };
 357
 358
 359   /*
 360    * `afm_parser_read_vals' and `afm_parser_next_key' provide
 361    * high-level operations to an AFM_Stream.  The rest of the
 362    * parser functions should use them without accessing the
 363    * AFM_Stream directly.
 364    */
 365
 366   FT_LOCAL_DEF( FT_Int )
 367   afm_parser_read_vals( AFM_Parser  parser,
 368                         AFM_Value   vals,
 369                         FT_UInt     n )
 370   {
 371     AFM_Stream  stream = parser->stream;
 372     char*       str;
 373     FT_UInt     i;
 374
 375
 376     if ( n > AFM_MAX_ARGUMENTS )
 377       return 0;
 378
 379     for ( i = 0; i < n; i++ )
 380     {
 381       FT_Offset  len;
 382       AFM_Value  val = vals + i;
 383
 384
 385       if ( val->type == AFM_VALUE_TYPE_STRING )
 386         str = afm_stream_read_string( stream );
 387       else
 388         str = afm_stream_read_one( stream );
 389
 390       if ( !str )
 391         break;
 392
 393       len = AFM_STREAM_KEY_LEN( stream, str );
 394
 395       switch ( val->type )
 396       {
 397       case AFM_VALUE_TYPE_STRING:
 398       case AFM_VALUE_TYPE_NAME:
 399         {
 400           FT_Memory  memory = parser->memory;
 401           FT_Error   error;
 402
 403
 404           if ( !FT_QALLOC( val->u.s, len + 1 ) )
 405           {
 406             ft_memcpy( val->u.s, str, len );
 407             val->u.s[len] = '\0';
 408           }
 409         }
 410         break;
 411
 412       case AFM_VALUE_TYPE_FIXED:
 413         val->u.f = PS_Conv_ToFixed( (FT_Byte**)(void*)&str,
 414                                     (FT_Byte*)str + len, 0 );
 415         break;
 416
 417       case AFM_VALUE_TYPE_INTEGER:
 418         val->u.i = PS_Conv_ToInt( (FT_Byte**)(void*)&str,
 419                                   (FT_Byte*)str + len );
 420         break;
 421
 422       case AFM_VALUE_TYPE_BOOL:
 423         val->u.b = FT_BOOL( len == 4                      &&
 424                             !ft_strncmp( str, "true", 4 ) );
 425         break;
 426
 427       case AFM_VALUE_TYPE_INDEX:
 428         if ( parser->get_index )
 429           val->u.i = parser->get_index( str, len, parser->user_data );
 430         else
 431           val->u.i = 0;
 432         break;
 433       }
 434     }
 435
 436     return i;
 437   }
 438
 439
 440   FT_LOCAL_DEF( char* )
 441   afm_parser_next_key( AFM_Parser  parser,
 442                        FT_Bool     line,
 443                        FT_Offset*  len )
 444   {
 445     AFM_Stream  stream = parser->stream;
 446     char*       key    = 0;  /* make stupid compiler happy */
 447
 448
 449     if ( line )
 450     {
 451       while ( 1 )
 452       {
 453         /* skip current line */
 454         if ( !AFM_STATUS_EOL( stream ) )
 455           afm_stream_read_string( stream );
 456
 457         stream->status = AFM_STREAM_STATUS_NORMAL;
 458         key = afm_stream_read_one( stream );
 459
 460         /* skip empty line */
 461         if ( !key                      &&
 462              !AFM_STATUS_EOF( stream ) &&
 463              AFM_STATUS_EOL( stream )  )
 464           continue;
 465
 466         break;
 467       }
 468     }
 469     else
 470     {
 471       while ( 1 )
 472       {
 473         /* skip current column */
 474         while ( !AFM_STATUS_EOC( stream ) )
 475           afm_stream_read_one( stream );
 476
 477         stream->status = AFM_STREAM_STATUS_NORMAL;
 478         key = afm_stream_read_one( stream );
 479
 480         /* skip empty column */
 481         if ( !key                      &&
 482              !AFM_STATUS_EOF( stream ) &&
 483              AFM_STATUS_EOC( stream )  )
 484           continue;
 485
 486         break;
 487       }
 488     }
 489
 490     if ( len )
 491       *len = ( key ) ? (FT_Offset)AFM_STREAM_KEY_LEN( stream, key )
 492                      : 0;
 493
 494     return key;
 495   }
 496
 497
 498   static AFM_Token
 499   afm_tokenize( const char*  key,
 500                 FT_Offset    len )
 501   {
 502     int  n;
 503
 504
 505     for ( n = 0; n < N_AFM_TOKENS; n++ )
 506     {
 507       if ( *( afm_key_table[n] ) == *key )
 508       {
 509         for ( ; n < N_AFM_TOKENS; n++ )
 510         {
 511           if ( *( afm_key_table[n] ) != *key )
 512             return AFM_TOKEN_UNKNOWN;
 513
 514           if ( ft_strncmp( afm_key_table[n], key, len ) == 0 )
 515             return (AFM_Token) n;
 516         }
 517       }
 518     }
 519
 520     return AFM_TOKEN_UNKNOWN;
 521   }
 522
 523
 524   FT_LOCAL_DEF( FT_Error )
 525   afm_parser_init( AFM_Parser  parser,
 526                    FT_Memory   memory,
 527                    FT_Byte*    base,
 528                    FT_Byte*    limit )
 529   {
 530     AFM_Stream  stream = NULL;
 531     FT_Error    error;
 532
 533
 534     if ( FT_NEW( stream ) )
 535       return error;
 536
 537     stream->cursor = stream->base = base;
 538     stream->limit  = limit;
 539
 540     /* don't skip the first line during the first call */
 541     stream->status = AFM_STREAM_STATUS_EOL;
 542
 543     parser->memory    = memory;
 544     parser->stream    = stream;
 545     parser->FontInfo  = NULL;
 546     parser->get_index = NULL;
 547
 548     return PSaux_Err_Ok;
 549   }
 550
 551
 552   FT_LOCAL( void )
 553   afm_parser_done( AFM_Parser  parser )
 554   {
 555     FT_Memory  memory = parser->memory;
 556
 557
 558     FT_FREE( parser->stream );
 559   }
 560
 561
 562   FT_LOCAL_DEF( FT_Error )
 563   afm_parser_read_int( AFM_Parser  parser,
 564                        FT_Int*     aint )
 565   {
 566     AFM_ValueRec  val;
 567
 568
 569     val.type = AFM_VALUE_TYPE_INTEGER;
 570
 571     if ( afm_parser_read_vals( parser, &val, 1 ) == 1 )
 572     {
 573       *aint = val.u.i;
 574
 575       return PSaux_Err_Ok;
 576     }
 577     else
 578       return PSaux_Err_Syntax_Error;
 579   }
 580
 581
 582   static FT_Error
 583   afm_parse_track_kern( AFM_Parser  parser )
 584   {
 585     AFM_FontInfo   fi = parser->FontInfo;
 586     AFM_TrackKern  tk;
 587     char*          key;
 588     FT_Offset      len;
 589     int            n = -1;
 590
 591
 592     if ( afm_parser_read_int( parser, &fi->NumTrackKern ) )
 593         goto Fail;
 594
 595     if ( fi->NumTrackKern )
 596     {
 597       FT_Memory  memory = parser->memory;
 598       FT_Error   error;
 599
 600
 601       if ( FT_QNEW_ARRAY( fi->TrackKerns, fi->NumTrackKern ) )
 602         return error;
 603     }
 604
 605     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
 606     {
 607       AFM_ValueRec  shared_vals[5];
 608
 609
 610       switch ( afm_tokenize( key, len ) )
 611       {
 612       case AFM_TOKEN_TRACKKERN:
 613         n++;
 614
 615         if ( n >= fi->NumTrackKern )
 616           goto Fail;
 617
 618         tk = fi->TrackKerns + n;
 619
 620         shared_vals[0].type = AFM_VALUE_TYPE_INTEGER;
 621         shared_vals[1].type = AFM_VALUE_TYPE_FIXED;
 622         shared_vals[2].type = AFM_VALUE_TYPE_FIXED;
 623         shared_vals[3].type = AFM_VALUE_TYPE_FIXED;
 624         shared_vals[4].type = AFM_VALUE_TYPE_FIXED;
 625         if ( afm_parser_read_vals( parser, shared_vals, 5 ) != 5 )
 626           goto Fail;
 627
 628         tk->degree     = shared_vals[0].u.i;
 629         tk->min_ptsize = shared_vals[1].u.f;
 630         tk->min_kern   = shared_vals[2].u.f;
 631         tk->max_ptsize = shared_vals[3].u.f;
 632         tk->max_kern   = shared_vals[4].u.f;
 633
 634         break;
 635
 636       case AFM_TOKEN_ENDTRACKKERN:
 637       case AFM_TOKEN_ENDKERNDATA:
 638       case AFM_TOKEN_ENDFONTMETRICS:
 639         fi->NumTrackKern = n + 1;
 640         return PSaux_Err_Ok;
 641
 642       case AFM_TOKEN_UNKNOWN:
 643         break;
 644
 645       default:
 646         goto Fail;
 647       }
 648     }
 649
 650   Fail:
 651     return PSaux_Err_Syntax_Error;
 652   }
 653
 654
 655 #undef  KERN_INDEX
 656 #define KERN_INDEX( g1, g2 )  ( ( (FT_ULong)g1 << 16 ) | g2 )
 657
 658
 659   /* compare two kerning pairs */
 660   FT_CALLBACK_DEF( int )
 661   afm_compare_kern_pairs( const void*  a,
 662                           const void*  b )
 663   {
 664     AFM_KernPair  kp1 = (AFM_KernPair)a;
 665     AFM_KernPair  kp2 = (AFM_KernPair)b;
 666
 667     FT_ULong  index1 = KERN_INDEX( kp1->index1, kp1->index2 );
 668     FT_ULong  index2 = KERN_INDEX( kp2->index1, kp2->index2 );
 669
 670
 671     if ( index1 > index2 )
 672       return 1;
 673     else if ( index1 < index2 )
 674       return -1;
 675     else
 676       return 0;
 677   }
 678
 679
 680   static FT_Error
 681   afm_parse_kern_pairs( AFM_Parser  parser )
 682   {
 683     AFM_FontInfo  fi = parser->FontInfo;
 684     AFM_KernPair  kp;
 685     char*         key;
 686     FT_Offset     len;
 687     int           n = -1;
 688
 689
 690     if ( afm_parser_read_int( parser, &fi->NumKernPair ) )
 691       goto Fail;
 692
 693     if ( fi->NumKernPair )
 694     {
 695       FT_Memory  memory = parser->memory;
 696       FT_Error   error;
 697
 698
 699       if ( FT_QNEW_ARRAY( fi->KernPairs, fi->NumKernPair ) )
 700         return error;
 701     }
 702
 703     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
 704     {
 705       AFM_Token  token = afm_tokenize( key, len );
 706
 707
 708       switch ( token )
 709       {
 710       case AFM_TOKEN_KP:
 711       case AFM_TOKEN_KPX:
 712       case AFM_TOKEN_KPY:
 713         {
 714           FT_Int        r;
 715           AFM_ValueRec  shared_vals[4];
 716
 717
 718           n++;
 719
 720           if ( n >= fi->NumKernPair )
 721             goto Fail;
 722
 723           kp = fi->KernPairs + n;
 724
 725           shared_vals[0].type = AFM_VALUE_TYPE_INDEX;
 726           shared_vals[1].type = AFM_VALUE_TYPE_INDEX;
 727           shared_vals[2].type = AFM_VALUE_TYPE_INTEGER;
 728           shared_vals[3].type = AFM_VALUE_TYPE_INTEGER;
 729           r = afm_parser_read_vals( parser, shared_vals, 4 );
 730           if ( r < 3 )
 731             goto Fail;
 732
 733           kp->index1 = shared_vals[0].u.i;
 734           kp->index2 = shared_vals[1].u.i;
 735           if ( token == AFM_TOKEN_KPY )
 736           {
 737             kp->x = 0;
 738             kp->y = shared_vals[2].u.i;
 739           }
 740           else
 741           {
 742             kp->x = shared_vals[2].u.i;
 743             kp->y = ( token == AFM_TOKEN_KP && r == 4 )
 744                       ? shared_vals[3].u.i : 0;
 745           }
 746         }
 747         break;
 748
 749       case AFM_TOKEN_ENDKERNPAIRS:
 750       case AFM_TOKEN_ENDKERNDATA:
 751       case AFM_TOKEN_ENDFONTMETRICS:
 752         fi->NumKernPair = n + 1;
 753         ft_qsort( fi->KernPairs, fi->NumKernPair,
 754                   sizeof ( AFM_KernPairRec ),
 755                   afm_compare_kern_pairs );
 756         return PSaux_Err_Ok;
 757
 758       case AFM_TOKEN_UNKNOWN:
 759         break;
 760
 761       default:
 762         goto Fail;
 763       }
 764     }
 765
 766   Fail:
 767     return PSaux_Err_Syntax_Error;
 768   }
 769
 770
 771   static FT_Error
 772   afm_parse_kern_data( AFM_Parser  parser )
 773   {
 774     FT_Error   error;
 775     char*      key;
 776     FT_Offset  len;
 777
 778
 779     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
 780     {
 781       switch ( afm_tokenize( key, len ) )
 782       {
 783       case AFM_TOKEN_STARTTRACKKERN:
 784         error = afm_parse_track_kern( parser );
 785         if ( error )
 786           return error;
 787         break;
 788
 789       case AFM_TOKEN_STARTKERNPAIRS:
 790       case AFM_TOKEN_STARTKERNPAIRS0:
 791         error = afm_parse_kern_pairs( parser );
 792         if ( error )
 793           return error;
 794         break;
 795
 796       case AFM_TOKEN_ENDKERNDATA:
 797       case AFM_TOKEN_ENDFONTMETRICS:
 798         return PSaux_Err_Ok;
 799
 800       case AFM_TOKEN_UNKNOWN:
 801         break;
 802
 803       default:
 804         goto Fail;
 805       }
 806     }
 807
 808   Fail:
 809     return PSaux_Err_Syntax_Error;
 810   }
 811
 812
 813   static FT_Error
 814   afm_parser_skip_section( AFM_Parser  parser,
 815                            FT_UInt     n,
 816                            AFM_Token   end_section )
 817   {
 818     char*      key;
 819     FT_Offset  len;
 820
 821
 822     while ( n-- > 0 )
 823     {
 824       key = afm_parser_next_key( parser, 1, NULL );
 825       if ( !key )
 826         goto Fail;
 827     }
 828
 829     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
 830     {
 831       AFM_Token  token = afm_tokenize( key, len );
 832
 833
 834       if ( token == end_section || token == AFM_TOKEN_ENDFONTMETRICS )
 835         return PSaux_Err_Ok;
 836     }
 837
 838   Fail:
 839     return PSaux_Err_Syntax_Error;
 840   }
 841
 842
 843   FT_LOCAL_DEF( FT_Error )
 844   afm_parser_parse( AFM_Parser  parser )
 845   {
 846     FT_Memory     memory = parser->memory;
 847     AFM_FontInfo  fi     = parser->FontInfo;
 848     FT_Error      error  = PSaux_Err_Syntax_Error;
 849     char*         key;
 850     FT_Offset     len;
 851     FT_Int        metrics_sets = 0;
 852
 853
 854     if ( !fi )
 855       return PSaux_Err_Invalid_Argument;
 856
 857     key = afm_parser_next_key( parser, 1, &len );
 858     if ( !key || len != 16                              ||
 859          ft_strncmp( key, "StartFontMetrics", 16 ) != 0 )
 860       return PSaux_Err_Unknown_File_Format;
 861
 862     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
 863     {
 864       AFM_ValueRec  shared_vals[4];
 865
 866
 867       switch ( afm_tokenize( key, len ) )
 868       {
 869       case AFM_TOKEN_METRICSSETS:
 870         if ( afm_parser_read_int( parser, &metrics_sets ) )
 871           goto Fail;
 872
 873         if ( metrics_sets != 0 && metrics_sets != 2 )
 874         {
 875           error = PSaux_Err_Unimplemented_Feature;
 876
 877           goto Fail;
 878         }
 879         break;
 880
 881       case AFM_TOKEN_ISCIDFONT:
 882         shared_vals[0].type = AFM_VALUE_TYPE_BOOL;
 883         if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
 884           goto Fail;
 885
 886         fi->IsCIDFont = shared_vals[0].u.b;
 887         break;
 888
 889       case AFM_TOKEN_FONTBBOX:
 890         shared_vals[0].type = AFM_VALUE_TYPE_FIXED;
 891         shared_vals[1].type = AFM_VALUE_TYPE_FIXED;
 892         shared_vals[2].type = AFM_VALUE_TYPE_FIXED;
 893         shared_vals[3].type = AFM_VALUE_TYPE_FIXED;
 894         if ( afm_parser_read_vals( parser, shared_vals, 4 ) != 4 )
 895           goto Fail;
 896
 897         fi->FontBBox.xMin = shared_vals[0].u.f;
 898         fi->FontBBox.yMin = shared_vals[1].u.f;
 899         fi->FontBBox.xMax = shared_vals[2].u.f;
 900         fi->FontBBox.yMax = shared_vals[3].u.f;
 901         break;
 902
 903       case AFM_TOKEN_ASCENDER:
 904         shared_vals[0].type = AFM_VALUE_TYPE_FIXED;
 905         if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
 906           goto Fail;
 907
 908         fi->Ascender = shared_vals[0].u.f;
 909         break;
 910
 911       case AFM_TOKEN_DESCENDER:
 912         shared_vals[0].type = AFM_VALUE_TYPE_FIXED;
 913         if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
 914           goto Fail;
 915
 916         fi->Descender = shared_vals[0].u.f;
 917         break;
 918
 919       case AFM_TOKEN_STARTCHARMETRICS:
 920         {
 921           FT_Int  n = 0;
 922
 923
 924           if ( afm_parser_read_int( parser, &n ) )
 925             goto Fail;
 926
 927           error = afm_parser_skip_section( parser, n,
 928                                            AFM_TOKEN_ENDCHARMETRICS );
 929           if ( error )
 930             return error;
 931         }
 932         break;
 933
 934       case AFM_TOKEN_STARTKERNDATA:
 935         error = afm_parse_kern_data( parser );
 936         if ( error )
 937           goto Fail;
 938         /* fall through since we only support kern data */
 939
 940       case AFM_TOKEN_ENDFONTMETRICS:
 941         return PSaux_Err_Ok;
 942
 943       default:
 944         break;
 945       }
 946     }
 947
 948   Fail:
 949     FT_FREE( fi->TrackKerns );
 950     fi->NumTrackKern = 0;
 951
 952     FT_FREE( fi->KernPairs );
 953     fi->NumKernPair = 0;
 954
 955     fi->IsCIDFont = 0;
 956
 957     return error;
 958   }
 959
 960
 961 /* END */