src/type42/t42parse.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  t42parse.c                                                             */
   4 /*                                                                         */
   5 /*    Type 42 font parser (body).                                          */
   6 /*                                                                         */
   7 /*  Copyright 2002-2012 by                                                 */
   8 /*  Roberto Alameda.                                                       */
   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 "t42parse.h"
  20 #include "t42error.h"
  21 #include FT_INTERNAL_DEBUG_H
  22 #include FT_INTERNAL_STREAM_H
  23 #include FT_INTERNAL_POSTSCRIPT_AUX_H
  24
  25
  26   /*************************************************************************/
  27   /*                                                                       */
  28   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  29   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  30   /* messages during execution.                                            */
  31   /*                                                                       */
  32 #undef  FT_COMPONENT
  33 #define FT_COMPONENT  trace_t42
  34
  35
  36   static void
  37   t42_parse_font_matrix( T42_Face    face,
  38                          T42_Loader  loader );
  39   static void
  40   t42_parse_encoding( T42_Face    face,
  41                       T42_Loader  loader );
  42
  43   static void
  44   t42_parse_charstrings( T42_Face    face,
  45                          T42_Loader  loader );
  46
  47   static void
  48   t42_parse_sfnts( T42_Face    face,
  49                    T42_Loader  loader );
  50
  51
  52   /* as Type42 fonts have no Private dict,         */
  53   /* we set the last argument of T1_FIELD_XXX to 0 */
  54   static const
  55   T1_FieldRec  t42_keywords[] =
  56   {
  57
  58 #undef  FT_STRUCTURE
  59 #define FT_STRUCTURE  T1_FontInfo
  60 #undef  T1CODE
  61 #define T1CODE        T1_FIELD_LOCATION_FONT_INFO
  62
  63     T1_FIELD_STRING( "version",            version,             0 )
  64     T1_FIELD_STRING( "Notice",             notice,              0 )
  65     T1_FIELD_STRING( "FullName",           full_name,           0 )
  66     T1_FIELD_STRING( "FamilyName",         family_name,         0 )
  67     T1_FIELD_STRING( "Weight",             weight,              0 )
  68     T1_FIELD_NUM   ( "ItalicAngle",        italic_angle,        0 )
  69     T1_FIELD_BOOL  ( "isFixedPitch",       is_fixed_pitch,      0 )
  70     T1_FIELD_NUM   ( "UnderlinePosition",  underline_position,  0 )
  71     T1_FIELD_NUM   ( "UnderlineThickness", underline_thickness, 0 )
  72
  73 #undef  FT_STRUCTURE
  74 #define FT_STRUCTURE  PS_FontExtraRec
  75 #undef  T1CODE
  76 #define T1CODE        T1_FIELD_LOCATION_FONT_EXTRA
  77
  78     T1_FIELD_NUM   ( "FSType",             fs_type,             0 )
  79
  80 #undef  FT_STRUCTURE
  81 #define FT_STRUCTURE  T1_FontRec
  82 #undef  T1CODE
  83 #define T1CODE        T1_FIELD_LOCATION_FONT_DICT
  84
  85     T1_FIELD_KEY  ( "FontName",    font_name,    0 )
  86     T1_FIELD_NUM  ( "PaintType",   paint_type,   0 )
  87     T1_FIELD_NUM  ( "FontType",    font_type,    0 )
  88     T1_FIELD_FIXED( "StrokeWidth", stroke_width, 0 )
  89
  90 #undef  FT_STRUCTURE
  91 #define FT_STRUCTURE  FT_BBox
  92 #undef  T1CODE
  93 #define T1CODE        T1_FIELD_LOCATION_BBOX
  94
  95     T1_FIELD_BBOX("FontBBox", xMin, 0 )
  96
  97     T1_FIELD_CALLBACK( "FontMatrix",  t42_parse_font_matrix, 0 )
  98     T1_FIELD_CALLBACK( "Encoding",    t42_parse_encoding,    0 )
  99     T1_FIELD_CALLBACK( "CharStrings", t42_parse_charstrings, 0 )
 100     T1_FIELD_CALLBACK( "sfnts",       t42_parse_sfnts,       0 )
 101
 102     { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0, 0 }
 103   };
 104
 105
 106 #define T1_Add_Table( p, i, o, l )  (p)->funcs.add( (p), i, o, l )
 107 #define T1_Done_Table( p )          \
 108           do                        \
 109           {                         \
 110             if ( (p)->funcs.done )  \
 111               (p)->funcs.done( p ); \
 112           } while ( 0 )
 113 #define T1_Release_Table( p )          \
 114           do                           \
 115           {                            \
 116             if ( (p)->funcs.release )  \
 117               (p)->funcs.release( p ); \
 118           } while ( 0 )
 119
 120 #define T1_Skip_Spaces( p )    (p)->root.funcs.skip_spaces( &(p)->root )
 121 #define T1_Skip_PS_Token( p )  (p)->root.funcs.skip_PS_token( &(p)->root )
 122
 123 #define T1_ToInt( p )                          \
 124           (p)->root.funcs.to_int( &(p)->root )
 125 #define T1_ToBytes( p, b, m, n, d )                          \
 126           (p)->root.funcs.to_bytes( &(p)->root, b, m, n, d )
 127
 128 #define T1_ToFixedArray( p, m, f, t )                           \
 129           (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
 130 #define T1_ToToken( p, t )                          \
 131           (p)->root.funcs.to_token( &(p)->root, t )
 132
 133 #define T1_Load_Field( p, f, o, m, pf )                         \
 134           (p)->root.funcs.load_field( &(p)->root, f, o, m, pf )
 135 #define T1_Load_Field_Table( p, f, o, m, pf )                         \
 136           (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf )
 137
 138
 139   /********************* Parsing Functions ******************/
 140
 141   FT_LOCAL_DEF( FT_Error )
 142   t42_parser_init( T42_Parser     parser,
 143                    FT_Stream      stream,
 144                    FT_Memory      memory,
 145                    PSAux_Service  psaux )
 146   {
 147     FT_Error  error = T42_Err_Ok;
 148     FT_Long   size;
 149
 150
 151     psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
 152
 153     parser->stream    = stream;
 154     parser->base_len  = 0;
 155     parser->base_dict = 0;
 156     parser->in_memory = 0;
 157
 158     /*******************************************************************/
 159     /*                                                                 */
 160     /* Here a short summary of what is going on:                       */
 161     /*                                                                 */
 162     /*   When creating a new Type 42 parser, we try to locate and load */
 163     /*   the base dictionary, loading the whole font into memory.      */
 164     /*                                                                 */
 165     /*   When `loading' the base dictionary, we only set up pointers   */
 166     /*   in the case of a memory-based stream.  Otherwise, we allocate */
 167     /*   and load the base dictionary in it.                           */
 168     /*                                                                 */
 169     /*   parser->in_memory is set if we have a memory stream.          */
 170     /*                                                                 */
 171
 172     if ( FT_STREAM_SEEK( 0L ) ||
 173          FT_FRAME_ENTER( 17 ) )
 174       goto Exit;
 175
 176     if ( ft_memcmp( stream->cursor, "%!PS-TrueTypeFont", 17 ) != 0 )
 177     {
 178       FT_TRACE2(( "  not a Type42 font\n" ));
 179       error = T42_Err_Unknown_File_Format;
 180     }
 181
 182     FT_FRAME_EXIT();
 183
 184     if ( error || FT_STREAM_SEEK( 0 ) )
 185       goto Exit;
 186
 187     size = stream->size;
 188
 189     /* now, try to load `size' bytes of the `base' dictionary we */
 190     /* found previously                                          */
 191
 192     /* if it is a memory-based resource, set up pointers */
 193     if ( !stream->read )
 194     {
 195       parser->base_dict = (FT_Byte*)stream->base + stream->pos;
 196       parser->base_len  = size;
 197       parser->in_memory = 1;
 198
 199       /* check that the `size' field is valid */
 200       if ( FT_STREAM_SKIP( size ) )
 201         goto Exit;
 202     }
 203     else
 204     {
 205       /* read segment in memory */
 206       if ( FT_ALLOC( parser->base_dict, size )       ||
 207            FT_STREAM_READ( parser->base_dict, size ) )
 208         goto Exit;
 209
 210       parser->base_len = size;
 211     }
 212
 213     parser->root.base   = parser->base_dict;
 214     parser->root.cursor = parser->base_dict;
 215     parser->root.limit  = parser->root.cursor + parser->base_len;
 216
 217   Exit:
 218     if ( error && !parser->in_memory )
 219       FT_FREE( parser->base_dict );
 220
 221     return error;
 222   }
 223
 224
 225   FT_LOCAL_DEF( void )
 226   t42_parser_done( T42_Parser  parser )
 227   {
 228     FT_Memory  memory = parser->root.memory;
 229
 230
 231     /* free the base dictionary only when we have a disk stream */
 232     if ( !parser->in_memory )
 233       FT_FREE( parser->base_dict );
 234
 235     parser->root.funcs.done( &parser->root );
 236   }
 237
 238
 239   static int
 240   t42_is_space( FT_Byte  c )
 241   {
 242     return ( c == ' '  || c == '\t'              ||
 243              c == '\r' || c == '\n' || c == '\f' ||
 244              c == '\0'                           );
 245   }
 246
 247
 248   static void
 249   t42_parse_font_matrix( T42_Face    face,
 250                          T42_Loader  loader )
 251   {
 252     T42_Parser  parser = &loader->parser;
 253     FT_Matrix*  matrix = &face->type1.font_matrix;
 254     FT_Vector*  offset = &face->type1.font_offset;
 255     FT_Face     root   = (FT_Face)&face->root;
 256     FT_Fixed    temp[6];
 257     FT_Fixed    temp_scale;
 258
 259
 260     (void)T1_ToFixedArray( parser, 6, temp, 3 );
 261
 262     temp_scale = FT_ABS( temp[3] );
 263
 264     /* Set Units per EM based on FontMatrix values.  We set the value to */
 265     /* 1000 / temp_scale, because temp_scale was already multiplied by   */
 266     /* 1000 (in t1_tofixed, from psobjs.c).                              */
 267
 268     root->units_per_EM = (FT_UShort)( FT_DivFix( 1000 * 0x10000L,
 269                                                  temp_scale ) >> 16 );
 270
 271     /* we need to scale the values by 1.0/temp_scale */
 272     if ( temp_scale != 0x10000L )
 273     {
 274       temp[0] = FT_DivFix( temp[0], temp_scale );
 275       temp[1] = FT_DivFix( temp[1], temp_scale );
 276       temp[2] = FT_DivFix( temp[2], temp_scale );
 277       temp[4] = FT_DivFix( temp[4], temp_scale );
 278       temp[5] = FT_DivFix( temp[5], temp_scale );
 279       temp[3] = 0x10000L;
 280     }
 281
 282     matrix->xx = temp[0];
 283     matrix->yx = temp[1];
 284     matrix->xy = temp[2];
 285     matrix->yy = temp[3];
 286
 287     /* note that the offsets must be expressed in integer font units */
 288     offset->x = temp[4] >> 16;
 289     offset->y = temp[5] >> 16;
 290   }
 291
 292
 293   static void
 294   t42_parse_encoding( T42_Face    face,
 295                       T42_Loader  loader )
 296   {
 297     T42_Parser  parser = &loader->parser;
 298     FT_Byte*    cur;
 299     FT_Byte*    limit  = parser->root.limit;
 300
 301     PSAux_Service  psaux  = (PSAux_Service)face->psaux;
 302
 303
 304     T1_Skip_Spaces( parser );
 305     cur = parser->root.cursor;
 306     if ( cur >= limit )
 307     {
 308       FT_ERROR(( "t42_parse_encoding: out of bounds\n" ));
 309       parser->root.error = T42_Err_Invalid_File_Format;
 310       return;
 311     }
 312
 313     /* if we have a number or `[', the encoding is an array, */
 314     /* and we must load it now                               */
 315     if ( ft_isdigit( *cur ) || *cur == '[' )
 316     {
 317       T1_Encoding  encode          = &face->type1.encoding;
 318       FT_UInt      count, n;
 319       PS_Table     char_table      = &loader->encoding_table;
 320       FT_Memory    memory          = parser->root.memory;
 321       FT_Error     error;
 322       FT_Bool      only_immediates = 0;
 323
 324
 325       /* read the number of entries in the encoding; should be 256 */
 326       if ( *cur == '[' )
 327       {
 328         count           = 256;
 329         only_immediates = 1;
 330         parser->root.cursor++;
 331       }
 332       else
 333         count = (FT_UInt)T1_ToInt( parser );
 334
 335       T1_Skip_Spaces( parser );
 336       if ( parser->root.cursor >= limit )
 337         return;
 338
 339       /* we use a T1_Table to store our charnames */
 340       loader->num_chars = encode->num_chars = count;
 341       if ( FT_NEW_ARRAY( encode->char_index, count )     ||
 342            FT_NEW_ARRAY( encode->char_name,  count )     ||
 343            FT_SET_ERROR( psaux->ps_table_funcs->init(
 344                            char_table, count, memory ) ) )
 345       {
 346         parser->root.error = error;
 347         return;
 348       }
 349
 350       /* We need to `zero' out encoding_table.elements */
 351       for ( n = 0; n < count; n++ )
 352       {
 353         char*  notdef = (char *)".notdef";
 354
 355
 356         T1_Add_Table( char_table, n, notdef, 8 );
 357       }
 358
 359       /* Now we need to read records of the form                */
 360       /*                                                        */
 361       /*   ... charcode /charname ...                           */
 362       /*                                                        */
 363       /* for each entry in our table.                           */
 364       /*                                                        */
 365       /* We simply look for a number followed by an immediate   */
 366       /* name.  Note that this ignores correctly the sequence   */
 367       /* that is often seen in type42 fonts:                    */
 368       /*                                                        */
 369       /*   0 1 255 { 1 index exch /.notdef put } for dup        */
 370       /*                                                        */
 371       /* used to clean the encoding array before anything else. */
 372       /*                                                        */
 373       /* Alternatively, if the array is directly given as       */
 374       /*                                                        */
 375       /*   /Encoding [ ... ]                                    */
 376       /*                                                        */
 377       /* we only read immediates.                               */
 378
 379       n = 0;
 380       T1_Skip_Spaces( parser );
 381
 382       while ( parser->root.cursor < limit )
 383       {
 384         cur = parser->root.cursor;
 385
 386         /* we stop when we encounter `def' or `]' */
 387         if ( *cur == 'd' && cur + 3 < limit )
 388         {
 389           if ( cur[1] == 'e'          &&
 390                cur[2] == 'f'          &&
 391                t42_is_space( cur[3] ) )
 392           {
 393             FT_TRACE6(( "encoding end\n" ));
 394             cur += 3;
 395             break;
 396           }
 397         }
 398         if ( *cur == ']' )
 399         {
 400           FT_TRACE6(( "encoding end\n" ));
 401           cur++;
 402           break;
 403         }
 404
 405         /* check whether we have found an entry */
 406         if ( ft_isdigit( *cur ) || only_immediates )
 407         {
 408           FT_Int  charcode;
 409
 410
 411           if ( only_immediates )
 412             charcode = n;
 413           else
 414           {
 415             charcode = (FT_Int)T1_ToInt( parser );
 416             T1_Skip_Spaces( parser );
 417           }
 418
 419           cur = parser->root.cursor;
 420
 421           if ( *cur == '/' && cur + 2 < limit && n < count )
 422           {
 423             FT_PtrDist  len;
 424
 425
 426             cur++;
 427
 428             parser->root.cursor = cur;
 429             T1_Skip_PS_Token( parser );
 430             if ( parser->root.error )
 431               return;
 432
 433             len = parser->root.cursor - cur;
 434
 435             parser->root.error = T1_Add_Table( char_table, charcode,
 436                                                cur, len + 1 );
 437             if ( parser->root.error )
 438               return;
 439             char_table->elements[charcode][len] = '\0';
 440
 441             n++;
 442           }
 443         }
 444         else
 445         {
 446           T1_Skip_PS_Token( parser );
 447           if ( parser->root.error )
 448             return;
 449         }
 450
 451         T1_Skip_Spaces( parser );
 452       }
 453
 454       face->type1.encoding_type  = T1_ENCODING_TYPE_ARRAY;
 455       parser->root.cursor        = cur;
 456     }
 457
 458     /* Otherwise, we should have either `StandardEncoding', */
 459     /* `ExpertEncoding', or `ISOLatin1Encoding'             */
 460     else
 461     {
 462       if ( cur + 17 < limit                                            &&
 463            ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
 464         face->type1.encoding_type = T1_ENCODING_TYPE_STANDARD;
 465
 466       else if ( cur + 15 < limit                                          &&
 467                 ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
 468         face->type1.encoding_type = T1_ENCODING_TYPE_EXPERT;
 469
 470       else if ( cur + 18 < limit                                             &&
 471                 ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )
 472         face->type1.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;
 473
 474       else
 475       {
 476         FT_ERROR(( "t42_parse_encoding: invalid token\n" ));
 477         parser->root.error = T42_Err_Invalid_File_Format;
 478       }
 479     }
 480   }
 481
 482
 483   typedef enum  T42_Load_Status_
 484   {
 485     BEFORE_START,
 486     BEFORE_TABLE_DIR,
 487     OTHER_TABLES
 488
 489   } T42_Load_Status;
 490
 491
 492   static void
 493   t42_parse_sfnts( T42_Face    face,
 494                    T42_Loader  loader )
 495   {
 496     T42_Parser  parser = &loader->parser;
 497     FT_Memory   memory = parser->root.memory;
 498     FT_Byte*    cur;
 499     FT_Byte*    limit  = parser->root.limit;
 500     FT_Error    error;
 501     FT_Int      num_tables = 0;
 502     FT_ULong    count, ttf_size = 0;
 503
 504     FT_Long     n, string_size, old_string_size, real_size;
 505     FT_Byte*    string_buf = NULL;
 506     FT_Bool     allocated  = 0;
 507
 508     T42_Load_Status  status;
 509
 510
 511     /* The format is                                */
 512     /*                                              */
 513     /*   /sfnts [ <hexstring> <hexstring> ... ] def */
 514     /*                                              */
 515     /* or                                           */
 516     /*                                              */
 517     /*   /sfnts [                                   */
 518     /*      <num_bin_bytes> RD <binary data>        */
 519     /*      <num_bin_bytes> RD <binary data>        */
 520     /*      ...                                     */
 521     /*   ] def                                      */
 522     /*                                              */
 523     /* with exactly one space after the `RD' token. */
 524
 525     T1_Skip_Spaces( parser );
 526
 527     if ( parser->root.cursor >= limit || *parser->root.cursor++ != '[' )
 528     {
 529       FT_ERROR(( "t42_parse_sfnts: can't find begin of sfnts vector\n" ));
 530       error = T42_Err_Invalid_File_Format;
 531       goto Fail;
 532     }
 533
 534     T1_Skip_Spaces( parser );
 535     status          = BEFORE_START;
 536     string_size     = 0;
 537     old_string_size = 0;
 538     count           = 0;
 539
 540     while ( parser->root.cursor < limit )
 541     {
 542       cur = parser->root.cursor;
 543
 544       if ( *cur == ']' )
 545       {
 546         parser->root.cursor++;
 547         goto Exit;
 548       }
 549
 550       else if ( *cur == '<' )
 551       {
 552         T1_Skip_PS_Token( parser );
 553         if ( parser->root.error )
 554           goto Exit;
 555
 556         /* don't include delimiters */
 557         string_size = (FT_Long)( ( parser->root.cursor - cur - 2 + 1 ) / 2 );
 558         if ( FT_REALLOC( string_buf, old_string_size, string_size ) )
 559           goto Fail;
 560
 561         allocated = 1;
 562
 563         parser->root.cursor = cur;
 564         (void)T1_ToBytes( parser, string_buf, string_size, &real_size, 1 );
 565         old_string_size = string_size;
 566         string_size = real_size;
 567       }
 568
 569       else if ( ft_isdigit( *cur ) )
 570       {
 571         if ( allocated )
 572         {
 573           FT_ERROR(( "t42_parse_sfnts: "
 574                      "can't handle mixed binary and hex strings\n" ));
 575           error = T42_Err_Invalid_File_Format;
 576           goto Fail;
 577         }
 578
 579         string_size = T1_ToInt( parser );
 580         if ( string_size < 0 )
 581         {
 582           FT_ERROR(( "t42_parse_sfnts: invalid string size\n" ));
 583           error = T42_Err_Invalid_File_Format;
 584           goto Fail;
 585         }
 586
 587         T1_Skip_PS_Token( parser );             /* `RD' */
 588         if ( parser->root.error )
 589           return;
 590
 591         string_buf = parser->root.cursor + 1;   /* one space after `RD' */
 592
 593         if ( limit - parser->root.cursor < string_size )
 594         {
 595           FT_ERROR(( "t42_parse_sfnts: too many binary data\n" ));
 596           error = T42_Err_Invalid_File_Format;
 597           goto Fail;
 598         }
 599         else
 600           parser->root.cursor += string_size + 1;
 601       }
 602
 603       if ( !string_buf )
 604       {
 605         FT_ERROR(( "t42_parse_sfnts: invalid data in sfnts array\n" ));
 606         error = T42_Err_Invalid_File_Format;
 607         goto Fail;
 608       }
 609
 610       /* A string can have a trailing zero (odd) byte for padding. */
 611       /* Ignore it.                                                */
 612       if ( ( string_size & 1 ) && string_buf[string_size - 1] == 0 )
 613         string_size--;
 614
 615       if ( !string_size )
 616       {
 617         FT_ERROR(( "t42_parse_sfnts: invalid string\n" ));
 618         error = T42_Err_Invalid_File_Format;
 619         goto Fail;
 620       }
 621
 622       for ( n = 0; n < string_size; n++ )
 623       {
 624         switch ( status )
 625         {
 626         case BEFORE_START:
 627           /* load offset table, 12 bytes */
 628           if ( count < 12 )
 629           {
 630             face->ttf_data[count++] = string_buf[n];
 631             continue;
 632           }
 633           else
 634           {
 635             num_tables = 16 * face->ttf_data[4] + face->ttf_data[5];
 636             status     = BEFORE_TABLE_DIR;
 637             ttf_size   = 12 + 16 * num_tables;
 638
 639             if ( FT_REALLOC( face->ttf_data, 12, ttf_size ) )
 640               goto Fail;
 641           }
 642           /* fall through */
 643
 644         case BEFORE_TABLE_DIR:
 645           /* the offset table is read; read the table directory */
 646           if ( count < ttf_size )
 647           {
 648             face->ttf_data[count++] = string_buf[n];
 649             continue;
 650           }
 651           else
 652           {
 653             int       i;
 654             FT_ULong  len;
 655
 656
 657             for ( i = 0; i < num_tables; i++ )
 658             {
 659               FT_Byte*  p = face->ttf_data + 12 + 16 * i + 12;
 660
 661
 662               len = FT_PEEK_ULONG( p );
 663
 664               /* Pad to a 4-byte boundary length */
 665               ttf_size += ( len + 3 ) & ~3;
 666             }
 667
 668             status         = OTHER_TABLES;
 669             face->ttf_size = ttf_size;
 670
 671             /* there are no more than 256 tables, so no size check here */
 672             if ( FT_REALLOC( face->ttf_data, 12 + 16 * num_tables,
 673                              ttf_size + 1 ) )
 674               goto Fail;
 675           }
 676           /* fall through */
 677
 678         case OTHER_TABLES:
 679           /* all other tables are just copied */
 680           if ( count >= ttf_size )
 681           {
 682             FT_ERROR(( "t42_parse_sfnts: too many binary data\n" ));
 683             error = T42_Err_Invalid_File_Format;
 684             goto Fail;
 685           }
 686           face->ttf_data[count++] = string_buf[n];
 687         }
 688       }
 689
 690       T1_Skip_Spaces( parser );
 691     }
 692
 693     /* if control reaches this point, the format was not valid */
 694     error = T42_Err_Invalid_File_Format;
 695
 696   Fail:
 697     parser->root.error = error;
 698
 699   Exit:
 700     if ( allocated )
 701       FT_FREE( string_buf );
 702   }
 703
 704
 705   static void
 706   t42_parse_charstrings( T42_Face    face,
 707                          T42_Loader  loader )
 708   {
 709     T42_Parser     parser       = &loader->parser;
 710     PS_Table       code_table   = &loader->charstrings;
 711     PS_Table       name_table   = &loader->glyph_names;
 712     PS_Table       swap_table   = &loader->swap_table;
 713     FT_Memory      memory       = parser->root.memory;
 714     FT_Error       error;
 715
 716     PSAux_Service  psaux        = (PSAux_Service)face->psaux;
 717
 718     FT_Byte*       cur;
 719     FT_Byte*       limit        = parser->root.limit;
 720     FT_UInt        n;
 721     FT_UInt        notdef_index = 0;
 722     FT_Byte        notdef_found = 0;
 723
 724
 725     T1_Skip_Spaces( parser );
 726
 727     if ( parser->root.cursor >= limit )
 728     {
 729       FT_ERROR(( "t42_parse_charstrings: out of bounds\n" ));
 730       error = T42_Err_Invalid_File_Format;
 731       goto Fail;
 732     }
 733
 734     if ( ft_isdigit( *parser->root.cursor ) )
 735     {
 736       loader->num_glyphs = (FT_UInt)T1_ToInt( parser );
 737       if ( parser->root.error )
 738         return;
 739     }
 740     else if ( *parser->root.cursor == '<' )
 741     {
 742       /* We have `<< ... >>'.  Count the number of `/' in the dictionary */
 743       /* to get its size.                                                */
 744       FT_UInt  count = 0;
 745
 746
 747       T1_Skip_PS_Token( parser );
 748       if ( parser->root.error )
 749         return;
 750       T1_Skip_Spaces( parser );
 751       cur = parser->root.cursor;
 752
 753       while ( parser->root.cursor < limit )
 754       {
 755         if ( *parser->root.cursor == '/' )
 756           count++;
 757         else if ( *parser->root.cursor == '>' )
 758         {
 759           loader->num_glyphs  = count;
 760           parser->root.cursor = cur;        /* rewind */
 761           break;
 762         }
 763         T1_Skip_PS_Token( parser );
 764         if ( parser->root.error )
 765           return;
 766         T1_Skip_Spaces( parser );
 767       }
 768     }
 769     else
 770     {
 771       FT_ERROR(( "t42_parse_charstrings: invalid token\n" ));
 772       error = T42_Err_Invalid_File_Format;
 773       goto Fail;
 774     }
 775
 776     if ( parser->root.cursor >= limit )
 777     {
 778       FT_ERROR(( "t42_parse_charstrings: out of bounds\n" ));
 779       error = T42_Err_Invalid_File_Format;
 780       goto Fail;
 781     }
 782
 783     /* initialize tables */
 784
 785     error = psaux->ps_table_funcs->init( code_table,
 786                                          loader->num_glyphs,
 787                                          memory );
 788     if ( error )
 789       goto Fail;
 790
 791     error = psaux->ps_table_funcs->init( name_table,
 792                                          loader->num_glyphs,
 793                                          memory );
 794     if ( error )
 795       goto Fail;
 796
 797     /* Initialize table for swapping index notdef_index and */
 798     /* index 0 names and codes (if necessary).              */
 799
 800     error = psaux->ps_table_funcs->init( swap_table, 4, memory );
 801     if ( error )
 802       goto Fail;
 803
 804     n = 0;
 805
 806     for (;;)
 807     {
 808       /* The format is simple:                   */
 809       /*   `/glyphname' + index [+ def]          */
 810
 811       T1_Skip_Spaces( parser );
 812
 813       cur = parser->root.cursor;
 814       if ( cur >= limit )
 815         break;
 816
 817       /* We stop when we find an `end' keyword or '>' */
 818       if ( *cur   == 'e'          &&
 819            cur + 3 < limit        &&
 820            cur[1] == 'n'          &&
 821            cur[2] == 'd'          &&
 822            t42_is_space( cur[3] ) )
 823         break;
 824       if ( *cur == '>' )
 825         break;
 826
 827       T1_Skip_PS_Token( parser );
 828       if ( parser->root.error )
 829         return;
 830
 831       if ( *cur == '/' )
 832       {
 833         FT_PtrDist  len;
 834
 835
 836         if ( cur + 1 >= limit )
 837         {
 838           FT_ERROR(( "t42_parse_charstrings: out of bounds\n" ));
 839           error = T42_Err_Invalid_File_Format;
 840           goto Fail;
 841         }
 842
 843         cur++;                              /* skip `/' */
 844         len = parser->root.cursor - cur;
 845
 846         error = T1_Add_Table( name_table, n, cur, len + 1 );
 847         if ( error )
 848           goto Fail;
 849
 850         /* add a trailing zero to the name table */
 851         name_table->elements[n][len] = '\0';
 852
 853         /* record index of /.notdef */
 854         if ( *cur == '.'                                              &&
 855              ft_strcmp( ".notdef",
 856                         (const char*)(name_table->elements[n]) ) == 0 )
 857         {
 858           notdef_index = n;
 859           notdef_found = 1;
 860         }
 861
 862         T1_Skip_Spaces( parser );
 863
 864         cur = parser->root.cursor;
 865
 866         (void)T1_ToInt( parser );
 867         if ( parser->root.cursor >= limit )
 868         {
 869           FT_ERROR(( "t42_parse_charstrings: out of bounds\n" ));
 870           error = T42_Err_Invalid_File_Format;
 871           goto Fail;
 872         }
 873
 874         len = parser->root.cursor - cur;
 875
 876         error = T1_Add_Table( code_table, n, cur, len + 1 );
 877         if ( error )
 878           goto Fail;
 879
 880         code_table->elements[n][len] = '\0';
 881
 882         n++;
 883         if ( n >= loader->num_glyphs )
 884           break;
 885       }
 886     }
 887
 888     loader->num_glyphs = n;
 889
 890     if ( !notdef_found )
 891     {
 892       FT_ERROR(( "t42_parse_charstrings: no /.notdef glyph\n" ));
 893       error = T42_Err_Invalid_File_Format;
 894       goto Fail;
 895     }
 896
 897     /* if /.notdef does not occupy index 0, do our magic. */
 898     if ( ft_strcmp( (const char*)".notdef",
 899                     (const char*)name_table->elements[0] ) )
 900     {
 901       /* Swap glyph in index 0 with /.notdef glyph.  First, add index 0  */
 902       /* name and code entries to swap_table.  Then place notdef_index   */
 903       /* name and code entries into swap_table.  Then swap name and code */
 904       /* entries at indices notdef_index and 0 using values stored in    */
 905       /* swap_table.                                                     */
 906
 907       /* Index 0 name */
 908       error = T1_Add_Table( swap_table, 0,
 909                             name_table->elements[0],
 910                             name_table->lengths [0] );
 911       if ( error )
 912         goto Fail;
 913
 914       /* Index 0 code */
 915       error = T1_Add_Table( swap_table, 1,
 916                             code_table->elements[0],
 917                             code_table->lengths [0] );
 918       if ( error )
 919         goto Fail;
 920
 921       /* Index notdef_index name */
 922       error = T1_Add_Table( swap_table, 2,
 923                             name_table->elements[notdef_index],
 924                             name_table->lengths [notdef_index] );
 925       if ( error )
 926         goto Fail;
 927
 928       /* Index notdef_index code */
 929       error = T1_Add_Table( swap_table, 3,
 930                             code_table->elements[notdef_index],
 931                             code_table->lengths [notdef_index] );
 932       if ( error )
 933         goto Fail;
 934
 935       error = T1_Add_Table( name_table, notdef_index,
 936                             swap_table->elements[0],
 937                             swap_table->lengths [0] );
 938       if ( error )
 939         goto Fail;
 940
 941       error = T1_Add_Table( code_table, notdef_index,
 942                             swap_table->elements[1],
 943                             swap_table->lengths [1] );
 944       if ( error )
 945         goto Fail;
 946
 947       error = T1_Add_Table( name_table, 0,
 948                             swap_table->elements[2],
 949                             swap_table->lengths [2] );
 950       if ( error )
 951         goto Fail;
 952
 953       error = T1_Add_Table( code_table, 0,
 954                             swap_table->elements[3],
 955                             swap_table->lengths [3] );
 956       if ( error )
 957         goto Fail;
 958
 959     }
 960
 961     return;
 962
 963   Fail:
 964     parser->root.error = error;
 965   }
 966
 967
 968   static FT_Error
 969   t42_load_keyword( T42_Face    face,
 970                     T42_Loader  loader,
 971                     T1_Field    field )
 972   {
 973     FT_Error  error;
 974     void*     dummy_object;
 975     void**    objects;
 976     FT_UInt   max_objects = 0;
 977
 978
 979     /* if the keyword has a dedicated callback, call it */
 980     if ( field->type == T1_FIELD_TYPE_CALLBACK )
 981     {
 982       field->reader( (FT_Face)face, loader );
 983       error = loader->parser.root.error;
 984       goto Exit;
 985     }
 986
 987     /* now the keyword is either a simple field or a table of fields; */
 988     /* we are now going to take care of it                            */
 989
 990     switch ( field->location )
 991     {
 992     case T1_FIELD_LOCATION_FONT_INFO:
 993       dummy_object = &face->type1.font_info;
 994       break;
 995
 996     case T1_FIELD_LOCATION_FONT_EXTRA:
 997       dummy_object = &face->type1.font_extra;
 998       break;
 999
1000     case T1_FIELD_LOCATION_BBOX:
1001       dummy_object = &face->type1.font_bbox;
1002       break;
1003
1004     default:
1005       dummy_object = &face->type1;
1006     }
1007
1008     objects = &dummy_object;
1009
1010     if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
1011          field->type == T1_FIELD_TYPE_FIXED_ARRAY   )
1012       error = T1_Load_Field_Table( &loader->parser, field,
1013                                    objects, max_objects, 0 );
1014     else
1015       error = T1_Load_Field( &loader->parser, field,
1016                              objects, max_objects, 0 );
1017
1018    Exit:
1019     return error;
1020   }
1021
1022
1023   FT_LOCAL_DEF( FT_Error )
1024   t42_parse_dict( T42_Face    face,
1025                   T42_Loader  loader,
1026                   FT_Byte*    base,
1027                   FT_Long     size )
1028   {
1029     T42_Parser  parser     = &loader->parser;
1030     FT_Byte*    limit;
1031     FT_Int      n_keywords = (FT_Int)( sizeof ( t42_keywords ) /
1032                                          sizeof ( t42_keywords[0] ) );
1033
1034
1035     parser->root.cursor = base;
1036     parser->root.limit  = base + size;
1037     parser->root.error  = T42_Err_Ok;
1038
1039     limit = parser->root.limit;
1040
1041     T1_Skip_Spaces( parser );
1042
1043     while ( parser->root.cursor < limit )
1044     {
1045       FT_Byte*  cur;
1046
1047
1048       cur = parser->root.cursor;
1049
1050       /* look for `FontDirectory' which causes problems for some fonts */
1051       if ( *cur == 'F' && cur + 25 < limit                    &&
1052            ft_strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
1053       {
1054         FT_Byte*  cur2;
1055
1056
1057         /* skip the `FontDirectory' keyword */
1058         T1_Skip_PS_Token( parser );
1059         T1_Skip_Spaces  ( parser );
1060         cur = cur2 = parser->root.cursor;
1061
1062         /* look up the `known' keyword */
1063         while ( cur < limit )
1064         {
1065           if ( *cur == 'k' && cur + 5 < limit             &&
1066                 ft_strncmp( (char*)cur, "known", 5 ) == 0 )
1067             break;
1068
1069           T1_Skip_PS_Token( parser );
1070           if ( parser->root.error )
1071             goto Exit;
1072           T1_Skip_Spaces  ( parser );
1073           cur = parser->root.cursor;
1074         }
1075
1076         if ( cur < limit )
1077         {
1078           T1_TokenRec  token;
1079
1080
1081           /* skip the `known' keyword and the token following it */
1082           T1_Skip_PS_Token( parser );
1083           T1_ToToken( parser, &token );
1084
1085           /* if the last token was an array, skip it! */
1086           if ( token.type == T1_TOKEN_TYPE_ARRAY )
1087             cur2 = parser->root.cursor;
1088         }
1089         parser->root.cursor = cur2;
1090       }
1091
1092       /* look for immediates */
1093       else if ( *cur == '/' && cur + 2 < limit )
1094       {
1095         FT_PtrDist  len;
1096
1097
1098         cur++;
1099
1100         parser->root.cursor = cur;
1101         T1_Skip_PS_Token( parser );
1102         if ( parser->root.error )
1103           goto Exit;
1104
1105         len = parser->root.cursor - cur;
1106
1107         if ( len > 0 && len < 22 && parser->root.cursor < limit )
1108         {
1109           int  i;
1110
1111
1112           /* now compare the immediate name to the keyword table */
1113
1114           /* loop through all known keywords */
1115           for ( i = 0; i < n_keywords; i++ )
1116           {
1117             T1_Field  keyword = (T1_Field)&t42_keywords[i];
1118             FT_Byte   *name   = (FT_Byte*)keyword->ident;
1119
1120
1121             if ( !name )
1122               continue;
1123
1124             if ( cur[0] == name[0]                                  &&
1125                  len == (FT_PtrDist)ft_strlen( (const char *)name ) &&
1126                  ft_memcmp( cur, name, len ) == 0                   )
1127             {
1128               /* we found it -- run the parsing callback! */
1129               parser->root.error = t42_load_keyword( face,
1130                                                      loader,
1131                                                      keyword );
1132               if ( parser->root.error )
1133                 return parser->root.error;
1134               break;
1135             }
1136           }
1137         }
1138       }
1139       else
1140       {
1141         T1_Skip_PS_Token( parser );
1142         if ( parser->root.error )
1143           goto Exit;
1144       }
1145
1146       T1_Skip_Spaces( parser );
1147     }
1148
1149   Exit:
1150     return parser->root.error;
1151   }
1152
1153
1154   FT_LOCAL_DEF( void )
1155   t42_loader_init( T42_Loader  loader,
1156                    T42_Face    face )
1157   {
1158     FT_UNUSED( face );
1159
1160     FT_MEM_ZERO( loader, sizeof ( *loader ) );
1161     loader->num_glyphs = 0;
1162     loader->num_chars  = 0;
1163
1164     /* initialize the tables -- simply set their `init' field to 0 */
1165     loader->encoding_table.init = 0;
1166     loader->charstrings.init    = 0;
1167     loader->glyph_names.init    = 0;
1168   }
1169
1170
1171   FT_LOCAL_DEF( void )
1172   t42_loader_done( T42_Loader  loader )
1173   {
1174     T42_Parser  parser = &loader->parser;
1175
1176
1177     /* finalize tables */
1178     T1_Release_Table( &loader->encoding_table );
1179     T1_Release_Table( &loader->charstrings );
1180     T1_Release_Table( &loader->glyph_names );
1181     T1_Release_Table( &loader->swap_table );
1182
1183     /* finalize parser */
1184     t42_parser_done( parser );
1185   }
1186
1187
1188 /* END */