src/psaux/psobjs.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  psobjs.c                                                               */
   4 /*                                                                         */
   5 /*    Auxiliary functions for PostScript fonts (body).                     */
   6 /*                                                                         */
   7 /*  Copyright 1996-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
  19 #include <ft2build.h>
  20 #include FT_INTERNAL_POSTSCRIPT_AUX_H
  21 #include FT_INTERNAL_DEBUG_H
  22 #include FT_INTERNAL_CALC_H
  23
  24 #include "psobjs.h"
  25 #include "psconv.h"
  26
  27 #include "psauxerr.h"
  28
  29
  30   /*************************************************************************/
  31   /*                                                                       */
  32   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  33   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  34   /* messages during execution.                                            */
  35   /*                                                                       */
  36 #undef  FT_COMPONENT
  37 #define FT_COMPONENT  trace_psobjs
  38
  39
  40   /*************************************************************************/
  41   /*************************************************************************/
  42   /*****                                                               *****/
  43   /*****                             PS_TABLE                          *****/
  44   /*****                                                               *****/
  45   /*************************************************************************/
  46   /*************************************************************************/
  47
  48   /*************************************************************************/
  49   /*                                                                       */
  50   /* <Function>                                                            */
  51   /*    ps_table_new                                                       */
  52   /*                                                                       */
  53   /* <Description>                                                         */
  54   /*    Initializes a PS_Table.                                            */
  55   /*                                                                       */
  56   /* <InOut>                                                               */
  57   /*    table  :: The address of the target table.                         */
  58   /*                                                                       */
  59   /* <Input>                                                               */
  60   /*    count  :: The table size = the maximum number of elements.         */
  61   /*                                                                       */
  62   /*    memory :: The memory object to use for all subsequent              */
  63   /*              reallocations.                                           */
  64   /*                                                                       */
  65   /* <Return>                                                              */
  66   /*    FreeType error code.  0 means success.                             */
  67   /*                                                                       */
  68   FT_LOCAL_DEF( FT_Error )
  69   ps_table_new( PS_Table   table,
  70                 FT_Int     count,
  71                 FT_Memory  memory )
  72   {
  73     FT_Error  error;
  74
  75
  76     table->memory = memory;
  77     if ( FT_NEW_ARRAY( table->elements, count ) ||
  78          FT_NEW_ARRAY( table->lengths,  count ) )
  79       goto Exit;
  80
  81     table->max_elems = count;
  82     table->init      = 0xDEADBEEFUL;
  83     table->num_elems = 0;
  84     table->block     = 0;
  85     table->capacity  = 0;
  86     table->cursor    = 0;
  87
  88     *(PS_Table_FuncsRec*)&table->funcs = ps_table_funcs;
  89
  90   Exit:
  91     if ( error )
  92       FT_FREE( table->elements );
  93
  94     return error;
  95   }
  96
  97
  98   static void
  99   shift_elements( PS_Table  table,
 100                   FT_Byte*  old_base )
 101   {
 102     FT_PtrDist  delta  = table->block - old_base;
 103     FT_Byte**   offset = table->elements;
 104     FT_Byte**   limit  = offset + table->max_elems;
 105
 106
 107     for ( ; offset < limit; offset++ )
 108     {
 109       if ( offset[0] )
 110         offset[0] += delta;
 111     }
 112   }
 113
 114
 115   static FT_Error
 116   reallocate_t1_table( PS_Table  table,
 117                        FT_Long   new_size )
 118   {
 119     FT_Memory  memory   = table->memory;
 120     FT_Byte*   old_base = table->block;
 121     FT_Error   error;
 122
 123
 124     /* allocate new base block */
 125     if ( FT_ALLOC( table->block, new_size ) )
 126     {
 127       table->block = old_base;
 128       return error;
 129     }
 130
 131     /* copy elements and shift offsets */
 132     if ( old_base )
 133     {
 134       FT_MEM_COPY( table->block, old_base, table->capacity );
 135       shift_elements( table, old_base );
 136       FT_FREE( old_base );
 137     }
 138
 139     table->capacity = new_size;
 140
 141     return PSaux_Err_Ok;
 142   }
 143
 144
 145   /*************************************************************************/
 146   /*                                                                       */
 147   /* <Function>                                                            */
 148   /*    ps_table_add                                                       */
 149   /*                                                                       */
 150   /* <Description>                                                         */
 151   /*    Adds an object to a PS_Table, possibly growing its memory block.   */
 152   /*                                                                       */
 153   /* <InOut>                                                               */
 154   /*    table  :: The target table.                                        */
 155   /*                                                                       */
 156   /* <Input>                                                               */
 157   /*    idx    :: The index of the object in the table.                    */
 158   /*                                                                       */
 159   /*    object :: The address of the object to copy in memory.             */
 160   /*                                                                       */
 161   /*    length :: The length in bytes of the source object.                */
 162   /*                                                                       */
 163   /* <Return>                                                              */
 164   /*    FreeType error code.  0 means success.  An error is returned if a  */
 165   /*    reallocation fails.                                                */
 166   /*                                                                       */
 167   FT_LOCAL_DEF( FT_Error )
 168   ps_table_add( PS_Table    table,
 169                 FT_Int      idx,
 170                 void*       object,
 171                 FT_PtrDist  length )
 172   {
 173     if ( idx < 0 || idx >= table->max_elems )
 174     {
 175       FT_ERROR(( "ps_table_add: invalid index\n" ));
 176       return PSaux_Err_Invalid_Argument;
 177     }
 178
 179     if ( length < 0 )
 180     {
 181       FT_ERROR(( "ps_table_add: invalid length\n" ));
 182       return PSaux_Err_Invalid_Argument;
 183     }
 184
 185     /* grow the base block if needed */
 186     if ( table->cursor + length > table->capacity )
 187     {
 188       FT_Error    error;
 189       FT_Offset   new_size = table->capacity;
 190       FT_PtrDist  in_offset;
 191
 192
 193       in_offset = (FT_Byte*)object - table->block;
 194       if ( in_offset < 0 || (FT_Offset)in_offset >= table->capacity )
 195         in_offset = -1;
 196
 197       while ( new_size < table->cursor + length )
 198       {
 199         /* increase size by 25% and round up to the nearest multiple
 200            of 1024 */
 201         new_size += ( new_size >> 2 ) + 1;
 202         new_size  = FT_PAD_CEIL( new_size, 1024 );
 203       }
 204
 205       error = reallocate_t1_table( table, new_size );
 206       if ( error )
 207         return error;
 208
 209       if ( in_offset >= 0 )
 210         object = table->block + in_offset;
 211     }
 212
 213     /* add the object to the base block and adjust offset */
 214     table->elements[idx] = table->block + table->cursor;
 215     table->lengths [idx] = length;
 216     FT_MEM_COPY( table->block + table->cursor, object, length );
 217
 218     table->cursor += length;
 219     return PSaux_Err_Ok;
 220   }
 221
 222
 223   /*************************************************************************/
 224   /*                                                                       */
 225   /* <Function>                                                            */
 226   /*    ps_table_done                                                      */
 227   /*                                                                       */
 228   /* <Description>                                                         */
 229   /*    Finalizes a PS_TableRec (i.e., reallocate it to its current        */
 230   /*    cursor).                                                           */
 231   /*                                                                       */
 232   /* <InOut>                                                               */
 233   /*    table :: The target table.                                         */
 234   /*                                                                       */
 235   /* <Note>                                                                */
 236   /*    This function does NOT release the heap's memory block.  It is up  */
 237   /*    to the caller to clean it, or reference it in its own structures.  */
 238   /*                                                                       */
 239   FT_LOCAL_DEF( void )
 240   ps_table_done( PS_Table  table )
 241   {
 242     FT_Memory  memory = table->memory;
 243     FT_Error   error;
 244     FT_Byte*   old_base = table->block;
 245
 246
 247     /* should never fail, because rec.cursor <= rec.size */
 248     if ( !old_base )
 249       return;
 250
 251     if ( FT_ALLOC( table->block, table->cursor ) )
 252       return;
 253     FT_MEM_COPY( table->block, old_base, table->cursor );
 254     shift_elements( table, old_base );
 255
 256     table->capacity = table->cursor;
 257     FT_FREE( old_base );
 258
 259     FT_UNUSED( error );
 260   }
 261
 262
 263   FT_LOCAL_DEF( void )
 264   ps_table_release( PS_Table  table )
 265   {
 266     FT_Memory  memory = table->memory;
 267
 268
 269     if ( (FT_ULong)table->init == 0xDEADBEEFUL )
 270     {
 271       FT_FREE( table->block );
 272       FT_FREE( table->elements );
 273       FT_FREE( table->lengths );
 274       table->init = 0;
 275     }
 276   }
 277
 278
 279   /*************************************************************************/
 280   /*************************************************************************/
 281   /*****                                                               *****/
 282   /*****                            T1 PARSER                          *****/
 283   /*****                                                               *****/
 284   /*************************************************************************/
 285   /*************************************************************************/
 286
 287
 288   /* first character must be already part of the comment */
 289
 290   static void
 291   skip_comment( FT_Byte*  *acur,
 292                 FT_Byte*   limit )
 293   {
 294     FT_Byte*  cur = *acur;
 295
 296
 297     while ( cur < limit )
 298     {
 299       if ( IS_PS_NEWLINE( *cur ) )
 300         break;
 301       cur++;
 302     }
 303
 304     *acur = cur;
 305   }
 306
 307
 308   static void
 309   skip_spaces( FT_Byte*  *acur,
 310                FT_Byte*   limit )
 311   {
 312     FT_Byte*  cur = *acur;
 313
 314
 315     while ( cur < limit )
 316     {
 317       if ( !IS_PS_SPACE( *cur ) )
 318       {
 319         if ( *cur == '%' )
 320           /* According to the PLRM, a comment is equal to a space. */
 321           skip_comment( &cur, limit );
 322         else
 323           break;
 324       }
 325       cur++;
 326     }
 327
 328     *acur = cur;
 329   }
 330
 331
 332 #define IS_OCTAL_DIGIT( c ) ( '0' <= (c) && (c) <= '7' )
 333
 334
 335   /* first character must be `(';                               */
 336   /* *acur is positioned at the character after the closing `)' */
 337
 338   static FT_Error
 339   skip_literal_string( FT_Byte*  *acur,
 340                        FT_Byte*   limit )
 341   {
 342     FT_Byte*      cur   = *acur;
 343     FT_Int        embed = 0;
 344     FT_Error      error = PSaux_Err_Invalid_File_Format;
 345     unsigned int  i;
 346
 347
 348     while ( cur < limit )
 349     {
 350       FT_Byte  c = *cur;
 351
 352
 353       ++cur;
 354
 355       if ( c == '\\' )
 356       {
 357         /* Red Book 3rd ed., section `Literal Text Strings', p. 29:     */
 358         /* A backslash can introduce three different types              */
 359         /* of escape sequences:                                         */
 360         /*   - a special escaped char like \r, \n, etc.                 */
 361         /*   - a one-, two-, or three-digit octal number                */
 362         /*   - none of the above in which case the backslash is ignored */
 363
 364         if ( cur == limit )
 365           /* error (or to be ignored?) */
 366           break;
 367
 368         switch ( *cur )
 369         {
 370           /* skip `special' escape */
 371         case 'n':
 372         case 'r':
 373         case 't':
 374         case 'b':
 375         case 'f':
 376         case '\\':
 377         case '(':
 378         case ')':
 379           ++cur;
 380           break;
 381
 382         default:
 383           /* skip octal escape or ignore backslash */
 384           for ( i = 0; i < 3 && cur < limit; ++i )
 385           {
 386             if ( !IS_OCTAL_DIGIT( *cur ) )
 387               break;
 388
 389             ++cur;
 390           }
 391         }
 392       }
 393       else if ( c == '(' )
 394         embed++;
 395       else if ( c == ')' )
 396       {
 397         embed--;
 398         if ( embed == 0 )
 399         {
 400           error = PSaux_Err_Ok;
 401           break;
 402         }
 403       }
 404     }
 405
 406     *acur = cur;
 407
 408     return error;
 409   }
 410
 411
 412   /* first character must be `<' */
 413
 414   static FT_Error
 415   skip_string( FT_Byte*  *acur,
 416                FT_Byte*   limit )
 417   {
 418     FT_Byte*  cur = *acur;
 419     FT_Error  err =  PSaux_Err_Ok;
 420
 421
 422     while ( ++cur < limit )
 423     {
 424       /* All whitespace characters are ignored. */
 425       skip_spaces( &cur, limit );
 426       if ( cur >= limit )
 427         break;
 428
 429       if ( !IS_PS_XDIGIT( *cur ) )
 430         break;
 431     }
 432
 433     if ( cur < limit && *cur != '>' )
 434     {
 435       FT_ERROR(( "skip_string: missing closing delimiter `>'\n" ));
 436       err = PSaux_Err_Invalid_File_Format;
 437     }
 438     else
 439       cur++;
 440
 441     *acur = cur;
 442     return err;
 443   }
 444
 445
 446   /* first character must be the opening brace that */
 447   /* starts the procedure                           */
 448
 449   /* NB: [ and ] need not match:                    */
 450   /* `/foo {[} def' is a valid PostScript fragment, */
 451   /* even within a Type1 font                       */
 452
 453   static FT_Error
 454   skip_procedure( FT_Byte*  *acur,
 455                   FT_Byte*   limit )
 456   {
 457     FT_Byte*  cur;
 458     FT_Int    embed = 0;
 459     FT_Error  error = PSaux_Err_Ok;
 460
 461
 462     FT_ASSERT( **acur == '{' );
 463
 464     for ( cur = *acur; cur < limit && error == PSaux_Err_Ok; ++cur )
 465     {
 466       switch ( *cur )
 467       {
 468       case '{':
 469         ++embed;
 470         break;
 471
 472       case '}':
 473         --embed;
 474         if ( embed == 0 )
 475         {
 476           ++cur;
 477           goto end;
 478         }
 479         break;
 480
 481       case '(':
 482         error = skip_literal_string( &cur, limit );
 483         break;
 484
 485       case '<':
 486         error = skip_string( &cur, limit );
 487         break;
 488
 489       case '%':
 490         skip_comment( &cur, limit );
 491         break;
 492       }
 493     }
 494
 495   end:
 496     if ( embed != 0 )
 497       error = PSaux_Err_Invalid_File_Format;
 498
 499     *acur = cur;
 500
 501     return error;
 502   }
 503
 504
 505   /***********************************************************************/
 506   /*                                                                     */
 507   /* All exported parsing routines handle leading whitespace and stop at */
 508   /* the first character which isn't part of the just handled token.     */
 509   /*                                                                     */
 510   /***********************************************************************/
 511
 512
 513   FT_LOCAL_DEF( void )
 514   ps_parser_skip_PS_token( PS_Parser  parser )
 515   {
 516     /* Note: PostScript allows any non-delimiting, non-whitespace        */
 517     /*       character in a name (PS Ref Manual, 3rd ed, p31).           */
 518     /*       PostScript delimiters are (, ), <, >, [, ], {, }, /, and %. */
 519
 520     FT_Byte*  cur   = parser->cursor;
 521     FT_Byte*  limit = parser->limit;
 522     FT_Error  error = PSaux_Err_Ok;
 523
 524
 525     skip_spaces( &cur, limit );             /* this also skips comments */
 526     if ( cur >= limit )
 527       goto Exit;
 528
 529     /* self-delimiting, single-character tokens */
 530     if ( *cur == '[' || *cur == ']' )
 531     {
 532       cur++;
 533       goto Exit;
 534     }
 535
 536     /* skip balanced expressions (procedures and strings) */
 537
 538     if ( *cur == '{' )                              /* {...} */
 539     {
 540       error = skip_procedure( &cur, limit );
 541       goto Exit;
 542     }
 543
 544     if ( *cur == '(' )                              /* (...) */
 545     {
 546       error = skip_literal_string( &cur, limit );
 547       goto Exit;
 548     }
 549
 550     if ( *cur == '<' )                              /* <...> */
 551     {
 552       if ( cur + 1 < limit && *(cur + 1) == '<' )   /* << */
 553       {
 554         cur++;
 555         cur++;
 556       }
 557       else
 558         error = skip_string( &cur, limit );
 559
 560       goto Exit;
 561     }
 562
 563     if ( *cur == '>' )
 564     {
 565       cur++;
 566       if ( cur >= limit || *cur != '>' )             /* >> */
 567       {
 568         FT_ERROR(( "ps_parser_skip_PS_token:"
 569                    " unexpected closing delimiter `>'\n" ));
 570         error = PSaux_Err_Invalid_File_Format;
 571         goto Exit;
 572       }
 573       cur++;
 574       goto Exit;
 575     }
 576
 577     if ( *cur == '/' )
 578       cur++;
 579
 580     /* anything else */
 581     while ( cur < limit )
 582     {
 583       /* *cur might be invalid (e.g., ')' or '}'), but this   */
 584       /* is handled by the test `cur == parser->cursor' below */
 585       if ( IS_PS_DELIM( *cur ) )
 586         break;
 587
 588       cur++;
 589     }
 590
 591   Exit:
 592     if ( cur < limit && cur == parser->cursor )
 593     {
 594       FT_ERROR(( "ps_parser_skip_PS_token:"
 595                  " current token is `%c' which is self-delimiting\n"
 596                  "                        "
 597                  " but invalid at this point\n",
 598                  *cur ));
 599
 600       error = PSaux_Err_Invalid_File_Format;
 601     }
 602
 603     parser->error  = error;
 604     parser->cursor = cur;
 605   }
 606
 607
 608   FT_LOCAL_DEF( void )
 609   ps_parser_skip_spaces( PS_Parser  parser )
 610   {
 611     skip_spaces( &parser->cursor, parser->limit );
 612   }
 613
 614
 615   /* `token' here means either something between balanced delimiters */
 616   /* or the next token; the delimiters are not removed.              */
 617
 618   FT_LOCAL_DEF( void )
 619   ps_parser_to_token( PS_Parser  parser,
 620                       T1_Token   token )
 621   {
 622     FT_Byte*  cur;
 623     FT_Byte*  limit;
 624     FT_Int    embed;
 625
 626
 627     token->type  = T1_TOKEN_TYPE_NONE;
 628     token->start = 0;
 629     token->limit = 0;
 630
 631     /* first of all, skip leading whitespace */
 632     ps_parser_skip_spaces( parser );
 633
 634     cur   = parser->cursor;
 635     limit = parser->limit;
 636
 637     if ( cur >= limit )
 638       return;
 639
 640     switch ( *cur )
 641     {
 642       /************* check for literal string *****************/
 643     case '(':
 644       token->type  = T1_TOKEN_TYPE_STRING;
 645       token->start = cur;
 646
 647       if ( skip_literal_string( &cur, limit ) == PSaux_Err_Ok )
 648         token->limit = cur;
 649       break;
 650
 651       /************* check for programs/array *****************/
 652     case '{':
 653       token->type  = T1_TOKEN_TYPE_ARRAY;
 654       token->start = cur;
 655
 656       if ( skip_procedure( &cur, limit ) == PSaux_Err_Ok )
 657         token->limit = cur;
 658       break;
 659
 660       /************* check for table/array ********************/
 661       /* XXX: in theory we should also look for "<<"          */
 662       /*      since this is semantically equivalent to "[";   */
 663       /*      in practice it doesn't matter (?)               */
 664     case '[':
 665       token->type  = T1_TOKEN_TYPE_ARRAY;
 666       embed        = 1;
 667       token->start = cur++;
 668
 669       /* we need this to catch `[ ]' */
 670       parser->cursor = cur;
 671       ps_parser_skip_spaces( parser );
 672       cur = parser->cursor;
 673
 674       while ( cur < limit && !parser->error )
 675       {
 676         /* XXX: this is wrong because it does not      */
 677         /*      skip comments, procedures, and strings */
 678         if ( *cur == '[' )
 679           embed++;
 680         else if ( *cur == ']' )
 681         {
 682           embed--;
 683           if ( embed <= 0 )
 684           {
 685             token->limit = ++cur;
 686             break;
 687           }
 688         }
 689
 690         parser->cursor = cur;
 691         ps_parser_skip_PS_token( parser );
 692         /* we need this to catch `[XXX ]' */
 693         ps_parser_skip_spaces  ( parser );
 694         cur = parser->cursor;
 695       }
 696       break;
 697
 698       /* ************ otherwise, it is any token **************/
 699     default:
 700       token->start = cur;
 701       token->type  = ( *cur == '/' ? T1_TOKEN_TYPE_KEY : T1_TOKEN_TYPE_ANY );
 702       ps_parser_skip_PS_token( parser );
 703       cur = parser->cursor;
 704       if ( !parser->error )
 705         token->limit = cur;
 706     }
 707
 708     if ( !token->limit )
 709     {
 710       token->start = 0;
 711       token->type  = T1_TOKEN_TYPE_NONE;
 712     }
 713
 714     parser->cursor = cur;
 715   }
 716
 717
 718   /* NB: `tokens' can be NULL if we only want to count */
 719   /* the number of array elements                      */
 720
 721   FT_LOCAL_DEF( void )
 722   ps_parser_to_token_array( PS_Parser  parser,
 723                             T1_Token   tokens,
 724                             FT_UInt    max_tokens,
 725                             FT_Int*    pnum_tokens )
 726   {
 727     T1_TokenRec  master;
 728
 729
 730     *pnum_tokens = -1;
 731
 732     /* this also handles leading whitespace */
 733     ps_parser_to_token( parser, &master );
 734
 735     if ( master.type == T1_TOKEN_TYPE_ARRAY )
 736     {
 737       FT_Byte*  old_cursor = parser->cursor;
 738       FT_Byte*  old_limit  = parser->limit;
 739       T1_Token  cur        = tokens;
 740       T1_Token  limit      = cur + max_tokens;
 741
 742
 743       /* don't include outermost delimiters */
 744       parser->cursor = master.start + 1;
 745       parser->limit  = master.limit - 1;
 746
 747       while ( parser->cursor < parser->limit )
 748       {
 749         T1_TokenRec  token;
 750
 751
 752         ps_parser_to_token( parser, &token );
 753         if ( !token.type )
 754           break;
 755
 756         if ( tokens != NULL && cur < limit )
 757           *cur = token;
 758
 759         cur++;
 760       }
 761
 762       *pnum_tokens = (FT_Int)( cur - tokens );
 763
 764       parser->cursor = old_cursor;
 765       parser->limit  = old_limit;
 766     }
 767   }
 768
 769
 770   /* first character must be a delimiter or a part of a number */
 771   /* NB: `coords' can be NULL if we just want to skip the      */
 772   /*     array; in this case we ignore `max_coords'            */
 773
 774   static FT_Int
 775   ps_tocoordarray( FT_Byte*  *acur,
 776                    FT_Byte*   limit,
 777                    FT_Int     max_coords,
 778                    FT_Short*  coords )
 779   {
 780     FT_Byte*  cur   = *acur;
 781     FT_Int    count = 0;
 782     FT_Byte   c, ender;
 783
 784
 785     if ( cur >= limit )
 786       goto Exit;
 787
 788     /* check for the beginning of an array; otherwise, only one number */
 789     /* will be read                                                    */
 790     c     = *cur;
 791     ender = 0;
 792
 793     if ( c == '[' )
 794       ender = ']';
 795     else if ( c == '{' )
 796       ender = '}';
 797
 798     if ( ender )
 799       cur++;
 800
 801     /* now, read the coordinates */
 802     while ( cur < limit )
 803     {
 804       FT_Short  dummy;
 805       FT_Byte*  old_cur;
 806
 807
 808       /* skip whitespace in front of data */
 809       skip_spaces( &cur, limit );
 810       if ( cur >= limit )
 811         goto Exit;
 812
 813       if ( *cur == ender )
 814       {
 815         cur++;
 816         break;
 817       }
 818
 819       old_cur = cur;
 820
 821       if ( coords != NULL && count >= max_coords )
 822         break;
 823
 824       /* call PS_Conv_ToFixed() even if coords == NULL */
 825       /* to properly parse number at `cur'             */
 826       *( coords != NULL ? &coords[count] : &dummy ) =
 827         (FT_Short)( PS_Conv_ToFixed( &cur, limit, 0 ) >> 16 );
 828
 829       if ( old_cur == cur )
 830       {
 831         count = -1;
 832         goto Exit;
 833       }
 834       else
 835         count++;
 836
 837       if ( !ender )
 838         break;
 839     }
 840
 841   Exit:
 842     *acur = cur;
 843     return count;
 844   }
 845
 846
 847   /* first character must be a delimiter or a part of a number */
 848   /* NB: `values' can be NULL if we just want to skip the      */
 849   /*     array; in this case we ignore `max_values'            */
 850
 851   static FT_Int
 852   ps_tofixedarray( FT_Byte*  *acur,
 853                    FT_Byte*   limit,
 854                    FT_Int     max_values,
 855                    FT_Fixed*  values,
 856                    FT_Int     power_ten )
 857   {
 858     FT_Byte*  cur   = *acur;
 859     FT_Int    count = 0;
 860     FT_Byte   c, ender;
 861
 862
 863     if ( cur >= limit )
 864       goto Exit;
 865
 866     /* Check for the beginning of an array.  Otherwise, only one number */
 867     /* will be read.                                                    */
 868     c     = *cur;
 869     ender = 0;
 870
 871     if ( c == '[' )
 872       ender = ']';
 873     else if ( c == '{' )
 874       ender = '}';
 875
 876     if ( ender )
 877       cur++;
 878
 879     /* now, read the values */
 880     while ( cur < limit )
 881     {
 882       FT_Fixed  dummy;
 883       FT_Byte*  old_cur;
 884
 885
 886       /* skip whitespace in front of data */
 887       skip_spaces( &cur, limit );
 888       if ( cur >= limit )
 889         goto Exit;
 890
 891       if ( *cur == ender )
 892       {
 893         cur++;
 894         break;
 895       }
 896
 897       old_cur = cur;
 898
 899       if ( values != NULL && count >= max_values )
 900         break;
 901
 902       /* call PS_Conv_ToFixed() even if coords == NULL */
 903       /* to properly parse number at `cur'             */
 904       *( values != NULL ? &values[count] : &dummy ) =
 905         PS_Conv_ToFixed( &cur, limit, power_ten );
 906
 907       if ( old_cur == cur )
 908       {
 909         count = -1;
 910         goto Exit;
 911       }
 912       else
 913         count++;
 914
 915       if ( !ender )
 916         break;
 917     }
 918
 919   Exit:
 920     *acur = cur;
 921     return count;
 922   }
 923
 924
 925 #if 0
 926
 927   static FT_String*
 928   ps_tostring( FT_Byte**  cursor,
 929                FT_Byte*   limit,
 930                FT_Memory  memory )
 931   {
 932     FT_Byte*    cur = *cursor;
 933     FT_PtrDist  len = 0;
 934     FT_Int      count;
 935     FT_String*  result;
 936     FT_Error    error;
 937
 938
 939     /* XXX: some stupid fonts have a `Notice' or `Copyright' string     */
 940     /*      that simply doesn't begin with an opening parenthesis, even */
 941     /*      though they have a closing one!  E.g. "amuncial.pfb"        */
 942     /*                                                                  */
 943     /*      We must deal with these ill-fated cases there.  Note that   */
 944     /*      these fonts didn't work with the old Type 1 driver as the   */
 945     /*      notice/copyright was not recognized as a valid string token */
 946     /*      and made the old token parser commit errors.                */
 947
 948     while ( cur < limit && ( *cur == ' ' || *cur == '\t' ) )
 949       cur++;
 950     if ( cur + 1 >= limit )
 951       return 0;
 952
 953     if ( *cur == '(' )
 954       cur++;  /* skip the opening parenthesis, if there is one */
 955
 956     *cursor = cur;
 957     count   = 0;
 958
 959     /* then, count its length */
 960     for ( ; cur < limit; cur++ )
 961     {
 962       if ( *cur == '(' )
 963         count++;
 964
 965       else if ( *cur == ')' )
 966       {
 967         count--;
 968         if ( count < 0 )
 969           break;
 970       }
 971     }
 972
 973     len = cur - *cursor;
 974     if ( cur >= limit || FT_ALLOC( result, len + 1 ) )
 975       return 0;
 976
 977     /* now copy the string */
 978     FT_MEM_COPY( result, *cursor, len );
 979     result[len] = '\0';
 980     *cursor = cur;
 981     return result;
 982   }
 983
 984 #endif /* 0 */
 985
 986
 987   static int
 988   ps_tobool( FT_Byte*  *acur,
 989              FT_Byte*   limit )
 990   {
 991     FT_Byte*  cur    = *acur;
 992     FT_Bool   result = 0;
 993
 994
 995     /* return 1 if we find `true', 0 otherwise */
 996     if ( cur + 3 < limit &&
 997          cur[0] == 't'   &&
 998          cur[1] == 'r'   &&
 999          cur[2] == 'u'   &&
1000          cur[3] == 'e'   )
1001     {
1002       result = 1;
1003       cur   += 5;
1004     }
1005     else if ( cur + 4 < limit &&
1006               cur[0] == 'f'   &&
1007               cur[1] == 'a'   &&
1008               cur[2] == 'l'   &&
1009               cur[3] == 's'   &&
1010               cur[4] == 'e'   )
1011     {
1012       result = 0;
1013       cur   += 6;
1014     }
1015
1016     *acur = cur;
1017     return result;
1018   }
1019
1020
1021   /* load a simple field (i.e. non-table) into the current list of objects */
1022
1023   FT_LOCAL_DEF( FT_Error )
1024   ps_parser_load_field( PS_Parser       parser,
1025                         const T1_Field  field,
1026                         void**          objects,
1027                         FT_UInt         max_objects,
1028                         FT_ULong*       pflags )
1029   {
1030     T1_TokenRec  token;
1031     FT_Byte*     cur;
1032     FT_Byte*     limit;
1033     FT_UInt      count;
1034     FT_UInt      idx;
1035     FT_Error     error;
1036
1037
1038     /* this also skips leading whitespace */
1039     ps_parser_to_token( parser, &token );
1040     if ( !token.type )
1041       goto Fail;
1042
1043     count = 1;
1044     idx   = 0;
1045     cur   = token.start;
1046     limit = token.limit;
1047
1048     /* we must detect arrays in /FontBBox */
1049     if ( field->type == T1_FIELD_TYPE_BBOX )
1050     {
1051       T1_TokenRec  token2;
1052       FT_Byte*     old_cur   = parser->cursor;
1053       FT_Byte*     old_limit = parser->limit;
1054
1055
1056       /* don't include delimiters */
1057       parser->cursor = token.start + 1;
1058       parser->limit  = token.limit - 1;
1059
1060       ps_parser_to_token( parser, &token2 );
1061       parser->cursor = old_cur;
1062       parser->limit  = old_limit;
1063
1064       if ( token2.type == T1_TOKEN_TYPE_ARRAY )
1065         goto FieldArray;
1066     }
1067     else if ( token.type == T1_TOKEN_TYPE_ARRAY )
1068     {
1069     FieldArray:
1070       /* if this is an array and we have no blend, an error occurs */
1071       if ( max_objects == 0 )
1072         goto Fail;
1073
1074       count = max_objects;
1075       idx   = 1;
1076
1077       /* don't include delimiters */
1078       cur++;
1079       limit--;
1080     }
1081
1082     for ( ; count > 0; count--, idx++ )
1083     {
1084       FT_Byte*    q = (FT_Byte*)objects[idx] + field->offset;
1085       FT_Long     val;
1086       FT_String*  string;
1087
1088
1089       skip_spaces( &cur, limit );
1090
1091       switch ( field->type )
1092       {
1093       case T1_FIELD_TYPE_BOOL:
1094         val = ps_tobool( &cur, limit );
1095         goto Store_Integer;
1096
1097       case T1_FIELD_TYPE_FIXED:
1098         val = PS_Conv_ToFixed( &cur, limit, 0 );
1099         goto Store_Integer;
1100
1101       case T1_FIELD_TYPE_FIXED_1000:
1102         val = PS_Conv_ToFixed( &cur, limit, 3 );
1103         goto Store_Integer;
1104
1105       case T1_FIELD_TYPE_INTEGER:
1106         val = PS_Conv_ToInt( &cur, limit );
1107         /* fall through */
1108
1109       Store_Integer:
1110         switch ( field->size )
1111         {
1112         case (8 / FT_CHAR_BIT):
1113           *(FT_Byte*)q = (FT_Byte)val;
1114           break;
1115
1116         case (16 / FT_CHAR_BIT):
1117           *(FT_UShort*)q = (FT_UShort)val;
1118           break;
1119
1120         case (32 / FT_CHAR_BIT):
1121           *(FT_UInt32*)q = (FT_UInt32)val;
1122           break;
1123
1124         default:                /* for 64-bit systems */
1125           *(FT_Long*)q = val;
1126         }
1127         break;
1128
1129       case T1_FIELD_TYPE_STRING:
1130       case T1_FIELD_TYPE_KEY:
1131         {
1132           FT_Memory  memory = parser->memory;
1133           FT_UInt    len    = (FT_UInt)( limit - cur );
1134
1135
1136           if ( cur >= limit )
1137             break;
1138
1139           /* we allow both a string or a name   */
1140           /* for cases like /FontName (foo) def */
1141           if ( token.type == T1_TOKEN_TYPE_KEY )
1142           {
1143             /* don't include leading `/' */
1144             len--;
1145             cur++;
1146           }
1147           else if ( token.type == T1_TOKEN_TYPE_STRING )
1148           {
1149             /* don't include delimiting parentheses    */
1150             /* XXX we don't handle <<...>> here        */
1151             /* XXX should we convert octal escapes?    */
1152             /*     if so, what encoding should we use? */
1153             cur++;
1154             len -= 2;
1155           }
1156           else
1157           {
1158             FT_ERROR(( "ps_parser_load_field:"
1159                        " expected a name or string\n"
1160                        "                     "
1161                        " but found token of type %d instead\n",
1162                        token.type ));
1163             error = PSaux_Err_Invalid_File_Format;
1164             goto Exit;
1165           }
1166
1167           /* for this to work (FT_String**)q must have been */
1168           /* initialized to NULL                            */
1169           if ( *(FT_String**)q != NULL )
1170           {
1171             FT_TRACE0(( "ps_parser_load_field: overwriting field %s\n",
1172                         field->ident ));
1173             FT_FREE( *(FT_String**)q );
1174             *(FT_String**)q = NULL;
1175           }
1176
1177           if ( FT_ALLOC( string, len + 1 ) )
1178             goto Exit;
1179
1180           FT_MEM_COPY( string, cur, len );
1181           string[len] = 0;
1182
1183           *(FT_String**)q = string;
1184         }
1185         break;
1186
1187       case T1_FIELD_TYPE_BBOX:
1188         {
1189           FT_Fixed  temp[4];
1190           FT_BBox*  bbox = (FT_BBox*)q;
1191           FT_Int    result;
1192
1193
1194           result = ps_tofixedarray( &cur, limit, 4, temp, 0 );
1195
1196           if ( result < 0 )
1197           {
1198             FT_ERROR(( "ps_parser_load_field:"
1199                        " expected four integers in bounding box\n" ));
1200             error = PSaux_Err_Invalid_File_Format;
1201             goto Exit;
1202           }
1203
1204           bbox->xMin = FT_RoundFix( temp[0] );
1205           bbox->yMin = FT_RoundFix( temp[1] );
1206           bbox->xMax = FT_RoundFix( temp[2] );
1207           bbox->yMax = FT_RoundFix( temp[3] );
1208         }
1209         break;
1210
1211       default:
1212         /* an error occurred */
1213         goto Fail;
1214       }
1215     }
1216
1217 #if 0  /* obsolete -- keep for reference */
1218     if ( pflags )
1219       *pflags |= 1L << field->flag_bit;
1220 #else
1221     FT_UNUSED( pflags );
1222 #endif
1223
1224     error = PSaux_Err_Ok;
1225
1226   Exit:
1227     return error;
1228
1229   Fail:
1230     error = PSaux_Err_Invalid_File_Format;
1231     goto Exit;
1232   }
1233
1234
1235 #define T1_MAX_TABLE_ELEMENTS  32
1236
1237
1238   FT_LOCAL_DEF( FT_Error )
1239   ps_parser_load_field_table( PS_Parser       parser,
1240                               const T1_Field  field,
1241                               void**          objects,
1242                               FT_UInt         max_objects,
1243                               FT_ULong*       pflags )
1244   {
1245     T1_TokenRec  elements[T1_MAX_TABLE_ELEMENTS];
1246     T1_Token     token;
1247     FT_Int       num_elements;
1248     FT_Error     error = PSaux_Err_Ok;
1249     FT_Byte*     old_cursor;
1250     FT_Byte*     old_limit;
1251     T1_FieldRec  fieldrec = *(T1_Field)field;
1252
1253
1254     fieldrec.type = T1_FIELD_TYPE_INTEGER;
1255     if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY ||
1256          field->type == T1_FIELD_TYPE_BBOX        )
1257       fieldrec.type = T1_FIELD_TYPE_FIXED;
1258
1259     ps_parser_to_token_array( parser, elements,
1260                               T1_MAX_TABLE_ELEMENTS, &num_elements );
1261     if ( num_elements < 0 )
1262     {
1263       error = PSaux_Err_Ignore;
1264       goto Exit;
1265     }
1266     if ( (FT_UInt)num_elements > field->array_max )
1267       num_elements = field->array_max;
1268
1269     old_cursor = parser->cursor;
1270     old_limit  = parser->limit;
1271
1272     /* we store the elements count if necessary;           */
1273     /* we further assume that `count_offset' can't be zero */
1274     if ( field->type != T1_FIELD_TYPE_BBOX && field->count_offset != 0 )
1275       *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) =
1276         (FT_Byte)num_elements;
1277
1278     /* we now load each element, adjusting the field.offset on each one */
1279     token = elements;
1280     for ( ; num_elements > 0; num_elements--, token++ )
1281     {
1282       parser->cursor = token->start;
1283       parser->limit  = token->limit;
1284       ps_parser_load_field( parser, &fieldrec, objects, max_objects, 0 );
1285       fieldrec.offset += fieldrec.size;
1286     }
1287
1288 #if 0  /* obsolete -- keep for reference */
1289     if ( pflags )
1290       *pflags |= 1L << field->flag_bit;
1291 #else
1292     FT_UNUSED( pflags );
1293 #endif
1294
1295     parser->cursor = old_cursor;
1296     parser->limit  = old_limit;
1297
1298   Exit:
1299     return error;
1300   }
1301
1302
1303   FT_LOCAL_DEF( FT_Long )
1304   ps_parser_to_int( PS_Parser  parser )
1305   {
1306     ps_parser_skip_spaces( parser );
1307     return PS_Conv_ToInt( &parser->cursor, parser->limit );
1308   }
1309
1310
1311   /* first character must be `<' if `delimiters' is non-zero */
1312
1313   FT_LOCAL_DEF( FT_Error )
1314   ps_parser_to_bytes( PS_Parser  parser,
1315                       FT_Byte*   bytes,
1316                       FT_Offset  max_bytes,
1317                       FT_Long*   pnum_bytes,
1318                       FT_Bool    delimiters )
1319   {
1320     FT_Error  error = PSaux_Err_Ok;
1321     FT_Byte*  cur;
1322
1323
1324     ps_parser_skip_spaces( parser );
1325     cur = parser->cursor;
1326
1327     if ( cur >= parser->limit )
1328       goto Exit;
1329
1330     if ( delimiters )
1331     {
1332       if ( *cur != '<' )
1333       {
1334         FT_ERROR(( "ps_parser_to_bytes: Missing starting delimiter `<'\n" ));
1335         error = PSaux_Err_Invalid_File_Format;
1336         goto Exit;
1337       }
1338
1339       cur++;
1340     }
1341
1342     *pnum_bytes = PS_Conv_ASCIIHexDecode( &cur,
1343                                           parser->limit,
1344                                           bytes,
1345                                           max_bytes );
1346
1347     if ( delimiters )
1348     {
1349       if ( cur < parser->limit && *cur != '>' )
1350       {
1351         FT_ERROR(( "ps_parser_to_bytes: Missing closing delimiter `>'\n" ));
1352         error = PSaux_Err_Invalid_File_Format;
1353         goto Exit;
1354       }
1355
1356       cur++;
1357     }
1358
1359     parser->cursor = cur;
1360
1361   Exit:
1362     return error;
1363   }
1364
1365
1366   FT_LOCAL_DEF( FT_Fixed )
1367   ps_parser_to_fixed( PS_Parser  parser,
1368                       FT_Int     power_ten )
1369   {
1370     ps_parser_skip_spaces( parser );
1371     return PS_Conv_ToFixed( &parser->cursor, parser->limit, power_ten );
1372   }
1373
1374
1375   FT_LOCAL_DEF( FT_Int )
1376   ps_parser_to_coord_array( PS_Parser  parser,
1377                             FT_Int     max_coords,
1378                             FT_Short*  coords )
1379   {
1380     ps_parser_skip_spaces( parser );
1381     return ps_tocoordarray( &parser->cursor, parser->limit,
1382                             max_coords, coords );
1383   }
1384
1385
1386   FT_LOCAL_DEF( FT_Int )
1387   ps_parser_to_fixed_array( PS_Parser  parser,
1388                             FT_Int     max_values,
1389                             FT_Fixed*  values,
1390                             FT_Int     power_ten )
1391   {
1392     ps_parser_skip_spaces( parser );
1393     return ps_tofixedarray( &parser->cursor, parser->limit,
1394                             max_values, values, power_ten );
1395   }
1396
1397
1398 #if 0
1399
1400   FT_LOCAL_DEF( FT_String* )
1401   T1_ToString( PS_Parser  parser )
1402   {
1403     return ps_tostring( &parser->cursor, parser->limit, parser->memory );
1404   }
1405
1406
1407   FT_LOCAL_DEF( FT_Bool )
1408   T1_ToBool( PS_Parser  parser )
1409   {
1410     return ps_tobool( &parser->cursor, parser->limit );
1411   }
1412
1413 #endif /* 0 */
1414
1415
1416   FT_LOCAL_DEF( void )
1417   ps_parser_init( PS_Parser  parser,
1418                   FT_Byte*   base,
1419                   FT_Byte*   limit,
1420                   FT_Memory  memory )
1421   {
1422     parser->error  = PSaux_Err_Ok;
1423     parser->base   = base;
1424     parser->limit  = limit;
1425     parser->cursor = base;
1426     parser->memory = memory;
1427     parser->funcs  = ps_parser_funcs;
1428   }
1429
1430
1431   FT_LOCAL_DEF( void )
1432   ps_parser_done( PS_Parser  parser )
1433   {
1434     FT_UNUSED( parser );
1435   }
1436
1437
1438   /*************************************************************************/
1439   /*************************************************************************/
1440   /*****                                                               *****/
1441   /*****                            T1 BUILDER                         *****/
1442   /*****                                                               *****/
1443   /*************************************************************************/
1444   /*************************************************************************/
1445
1446   /*************************************************************************/
1447   /*                                                                       */
1448   /* <Function>                                                            */
1449   /*    t1_builder_init                                                    */
1450   /*                                                                       */
1451   /* <Description>                                                         */
1452   /*    Initializes a given glyph builder.                                 */
1453   /*                                                                       */
1454   /* <InOut>                                                               */
1455   /*    builder :: A pointer to the glyph builder to initialize.           */
1456   /*                                                                       */
1457   /* <Input>                                                               */
1458   /*    face    :: The current face object.                                */
1459   /*                                                                       */
1460   /*    size    :: The current size object.                                */
1461   /*                                                                       */
1462   /*    glyph   :: The current glyph object.                               */
1463   /*                                                                       */
1464   /*    hinting :: Whether hinting should be applied.                      */
1465   /*                                                                       */
1466   FT_LOCAL_DEF( void )
1467   t1_builder_init( T1_Builder    builder,
1468                    FT_Face       face,
1469                    FT_Size       size,
1470                    FT_GlyphSlot  glyph,
1471                    FT_Bool       hinting )
1472   {
1473     builder->parse_state = T1_Parse_Start;
1474     builder->load_points = 1;
1475
1476     builder->face   = face;
1477     builder->glyph  = glyph;
1478     builder->memory = face->memory;
1479
1480     if ( glyph )
1481     {
1482       FT_GlyphLoader  loader = glyph->internal->loader;
1483
1484
1485       builder->loader  = loader;
1486       builder->base    = &loader->base.outline;
1487       builder->current = &loader->current.outline;
1488       FT_GlyphLoader_Rewind( loader );
1489
1490       builder->hints_globals = size->internal;
1491       builder->hints_funcs   = 0;
1492
1493       if ( hinting )
1494         builder->hints_funcs = glyph->internal->glyph_hints;
1495     }
1496
1497     builder->pos_x = 0;
1498     builder->pos_y = 0;
1499
1500     builder->left_bearing.x = 0;
1501     builder->left_bearing.y = 0;
1502     builder->advance.x      = 0;
1503     builder->advance.y      = 0;
1504
1505     builder->funcs = t1_builder_funcs;
1506   }
1507
1508
1509   /*************************************************************************/
1510   /*                                                                       */
1511   /* <Function>                                                            */
1512   /*    t1_builder_done                                                    */
1513   /*                                                                       */
1514   /* <Description>                                                         */
1515   /*    Finalizes a given glyph builder.  Its contents can still be used   */
1516   /*    after the call, but the function saves important information       */
1517   /*    within the corresponding glyph slot.                               */
1518   /*                                                                       */
1519   /* <Input>                                                               */
1520   /*    builder :: A pointer to the glyph builder to finalize.             */
1521   /*                                                                       */
1522   FT_LOCAL_DEF( void )
1523   t1_builder_done( T1_Builder  builder )
1524   {
1525     FT_GlyphSlot  glyph = builder->glyph;
1526
1527
1528     if ( glyph )
1529       glyph->outline = *builder->base;
1530   }
1531
1532
1533   /* check that there is enough space for `count' more points */
1534   FT_LOCAL_DEF( FT_Error )
1535   t1_builder_check_points( T1_Builder  builder,
1536                            FT_Int      count )
1537   {
1538     return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
1539   }
1540
1541
1542   /* add a new point, do not check space */
1543   FT_LOCAL_DEF( void )
1544   t1_builder_add_point( T1_Builder  builder,
1545                         FT_Pos      x,
1546                         FT_Pos      y,
1547                         FT_Byte     flag )
1548   {
1549     FT_Outline*  outline = builder->current;
1550
1551
1552     if ( builder->load_points )
1553     {
1554       FT_Vector*  point   = outline->points + outline->n_points;
1555       FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points;
1556
1557
1558       point->x = FIXED_TO_INT( x );
1559       point->y = FIXED_TO_INT( y );
1560       *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
1561     }
1562     outline->n_points++;
1563   }
1564
1565
1566   /* check space for a new on-curve point, then add it */
1567   FT_LOCAL_DEF( FT_Error )
1568   t1_builder_add_point1( T1_Builder  builder,
1569                          FT_Pos      x,
1570                          FT_Pos      y )
1571   {
1572     FT_Error  error;
1573
1574
1575     error = t1_builder_check_points( builder, 1 );
1576     if ( !error )
1577       t1_builder_add_point( builder, x, y, 1 );
1578
1579     return error;
1580   }
1581
1582
1583   /* check space for a new contour, then add it */
1584   FT_LOCAL_DEF( FT_Error )
1585   t1_builder_add_contour( T1_Builder  builder )
1586   {
1587     FT_Outline*  outline = builder->current;
1588     FT_Error     error;
1589
1590
1591     /* this might happen in invalid fonts */
1592     if ( !outline )
1593     {
1594       FT_ERROR(( "t1_builder_add_contour: no outline to add points to\n" ));
1595       return PSaux_Err_Invalid_File_Format;
1596     }
1597
1598     if ( !builder->load_points )
1599     {
1600       outline->n_contours++;
1601       return PSaux_Err_Ok;
1602     }
1603
1604     error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
1605     if ( !error )
1606     {
1607       if ( outline->n_contours > 0 )
1608         outline->contours[outline->n_contours - 1] =
1609           (short)( outline->n_points - 1 );
1610
1611       outline->n_contours++;
1612     }
1613
1614     return error;
1615   }
1616
1617
1618   /* if a path was begun, add its first on-curve point */
1619   FT_LOCAL_DEF( FT_Error )
1620   t1_builder_start_point( T1_Builder  builder,
1621                           FT_Pos      x,
1622                           FT_Pos      y )
1623   {
1624     FT_Error  error = PSaux_Err_Invalid_File_Format;
1625
1626
1627     /* test whether we are building a new contour */
1628
1629     if ( builder->parse_state == T1_Parse_Have_Path )
1630       error = PSaux_Err_Ok;
1631     else
1632     {
1633       builder->parse_state = T1_Parse_Have_Path;
1634       error = t1_builder_add_contour( builder );
1635       if ( !error )
1636         error = t1_builder_add_point1( builder, x, y );
1637     }
1638
1639     return error;
1640   }
1641
1642
1643   /* close the current contour */
1644   FT_LOCAL_DEF( void )
1645   t1_builder_close_contour( T1_Builder  builder )
1646   {
1647     FT_Outline*  outline = builder->current;
1648     FT_Int       first;
1649
1650
1651     if ( !outline )
1652       return;
1653
1654     first = outline->n_contours <= 1
1655             ? 0 : outline->contours[outline->n_contours - 2] + 1;
1656
1657     /* We must not include the last point in the path if it */
1658     /* is located on the first point.                       */
1659     if ( outline->n_points > 1 )
1660     {
1661       FT_Vector*  p1      = outline->points + first;
1662       FT_Vector*  p2      = outline->points + outline->n_points - 1;
1663       FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points - 1;
1664
1665
1666       /* `delete' last point only if it coincides with the first */
1667       /* point and it is not a control point (which can happen). */
1668       if ( p1->x == p2->x && p1->y == p2->y )
1669         if ( *control == FT_CURVE_TAG_ON )
1670           outline->n_points--;
1671     }
1672
1673     if ( outline->n_contours > 0 )
1674     {
1675       /* Don't add contours only consisting of one point, i.e.,  */
1676       /* check whether the first and the last point is the same. */
1677       if ( first == outline->n_points - 1 )
1678       {
1679         outline->n_contours--;
1680         outline->n_points--;
1681       }
1682       else
1683         outline->contours[outline->n_contours - 1] =
1684           (short)( outline->n_points - 1 );
1685     }
1686   }
1687
1688
1689   /*************************************************************************/
1690   /*************************************************************************/
1691   /*****                                                               *****/
1692   /*****                            OTHER                              *****/
1693   /*****                                                               *****/
1694   /*************************************************************************/
1695   /*************************************************************************/
1696
1697   FT_LOCAL_DEF( void )
1698   t1_decrypt( FT_Byte*   buffer,
1699               FT_Offset  length,
1700               FT_UShort  seed )
1701   {
1702     PS_Conv_EexecDecode( &buffer,
1703                          buffer + length,
1704                          buffer,
1705                          length,
1706                          &seed );
1707   }
1708
1709
1710 /* END */