XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / src / psaux / psobjs.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  psobjs.c                                                               */
4 /*                                                                         */
5 /*    Auxiliary functions for PostScript fonts (body).                     */
6 /*                                                                         */
7 /*  Copyright 1996-2014 by                                                 */
8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9 /*                                                                         */
10 /*  This file is part of the FreeType project, and may only be used,       */
11 /*  modified, and distributed under the terms of the FreeType project      */
12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13 /*  this file you indicate that you have read the license and              */
14 /*  understand and accept it fully.                                        */
15 /*                                                                         */
16 /***************************************************************************/
17
18
19 #include <ft2build.h>
20 #include 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_Offset  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 FT_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 FT_THROW( Invalid_Argument );
177     }
178
179     if ( length < 0 )
180     {
181       FT_ERROR(( "ps_table_add: invalid length\n" ));
182       return FT_THROW( 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 FT_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 = FT_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 = FT_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 =  FT_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 = FT_THROW( 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 = FT_Err_Ok;
460
461
462     FT_ASSERT( **acur == '{' );
463
464     for ( cur = *acur; cur < limit && error == FT_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 = FT_THROW( 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 = FT_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 = FT_THROW( 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 = FT_THROW( 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 ) == FT_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 ) == FT_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   /* return number of successfully parsed values               */
852
853   static FT_Int
854   ps_tofixedarray( FT_Byte*  *acur,
855                    FT_Byte*   limit,
856                    FT_Int     max_values,
857                    FT_Fixed*  values,
858                    FT_Int     power_ten )
859   {
860     FT_Byte*  cur   = *acur;
861     FT_Int    count = 0;
862     FT_Byte   c, ender;
863
864
865     if ( cur >= limit )
866       goto Exit;
867
868     /* Check for the beginning of an array.  Otherwise, only one number */
869     /* will be read.                                                    */
870     c     = *cur;
871     ender = 0;
872
873     if ( c == '[' )
874       ender = ']';
875     else if ( c == '{' )
876       ender = '}';
877
878     if ( ender )
879       cur++;
880
881     /* now, read the values */
882     while ( cur < limit )
883     {
884       FT_Fixed  dummy;
885       FT_Byte*  old_cur;
886
887
888       /* skip whitespace in front of data */
889       skip_spaces( &cur, limit );
890       if ( cur >= limit )
891         goto Exit;
892
893       if ( *cur == ender )
894       {
895         cur++;
896         break;
897       }
898
899       old_cur = cur;
900
901       if ( values != NULL && count >= max_values )
902         break;
903
904       /* call PS_Conv_ToFixed() even if coords == NULL */
905       /* to properly parse number at `cur'             */
906       *( values != NULL ? &values[count] : &dummy ) =
907         PS_Conv_ToFixed( &cur, limit, power_ten );
908
909       if ( old_cur == cur )
910       {
911         count = -1;
912         goto Exit;
913       }
914       else
915         count++;
916
917       if ( !ender )
918         break;
919     }
920
921   Exit:
922     *acur = cur;
923     return count;
924   }
925
926
927 #if 0
928
929   static FT_String*
930   ps_tostring( FT_Byte**  cursor,
931                FT_Byte*   limit,
932                FT_Memory  memory )
933   {
934     FT_Byte*    cur = *cursor;
935     FT_PtrDist  len = 0;
936     FT_Int      count;
937     FT_String*  result;
938     FT_Error    error;
939
940
941     /* XXX: some stupid fonts have a `Notice' or `Copyright' string     */
942     /*      that simply doesn't begin with an opening parenthesis, even */
943     /*      though they have a closing one!  E.g. "amuncial.pfb"        */
944     /*                                                                  */
945     /*      We must deal with these ill-fated cases there.  Note that   */
946     /*      these fonts didn't work with the old Type 1 driver as the   */
947     /*      notice/copyright was not recognized as a valid string token */
948     /*      and made the old token parser commit errors.                */
949
950     while ( cur < limit && ( *cur == ' ' || *cur == '\t' ) )
951       cur++;
952     if ( cur + 1 >= limit )
953       return 0;
954
955     if ( *cur == '(' )
956       cur++;  /* skip the opening parenthesis, if there is one */
957
958     *cursor = cur;
959     count   = 0;
960
961     /* then, count its length */
962     for ( ; cur < limit; cur++ )
963     {
964       if ( *cur == '(' )
965         count++;
966
967       else if ( *cur == ')' )
968       {
969         count--;
970         if ( count < 0 )
971           break;
972       }
973     }
974
975     len = cur - *cursor;
976     if ( cur >= limit || FT_ALLOC( result, len + 1 ) )
977       return 0;
978
979     /* now copy the string */
980     FT_MEM_COPY( result, *cursor, len );
981     result[len] = '\0';
982     *cursor = cur;
983     return result;
984   }
985
986 #endif /* 0 */
987
988
989   static int
990   ps_tobool( FT_Byte*  *acur,
991              FT_Byte*   limit )
992   {
993     FT_Byte*  cur    = *acur;
994     FT_Bool   result = 0;
995
996
997     /* return 1 if we find `true', 0 otherwise */
998     if ( cur + 3 < limit &&
999          cur[0] == 't'   &&
1000          cur[1] == 'r'   &&
1001          cur[2] == 'u'   &&
1002          cur[3] == 'e'   )
1003     {
1004       result = 1;
1005       cur   += 5;
1006     }
1007     else if ( cur + 4 < limit &&
1008               cur[0] == 'f'   &&
1009               cur[1] == 'a'   &&
1010               cur[2] == 'l'   &&
1011               cur[3] == 's'   &&
1012               cur[4] == 'e'   )
1013     {
1014       result = 0;
1015       cur   += 6;
1016     }
1017
1018     *acur = cur;
1019     return result;
1020   }
1021
1022
1023   /* load a simple field (i.e. non-table) into the current list of objects */
1024
1025   FT_LOCAL_DEF( FT_Error )
1026   ps_parser_load_field( PS_Parser       parser,
1027                         const T1_Field  field,
1028                         void**          objects,
1029                         FT_UInt         max_objects,
1030                         FT_ULong*       pflags )
1031   {
1032     T1_TokenRec   token;
1033     FT_Byte*      cur;
1034     FT_Byte*      limit;
1035     FT_UInt       count;
1036     FT_UInt       idx;
1037     FT_Error      error;
1038     T1_FieldType  type;
1039
1040
1041     /* this also skips leading whitespace */
1042     ps_parser_to_token( parser, &token );
1043     if ( !token.type )
1044       goto Fail;
1045
1046     count = 1;
1047     idx   = 0;
1048     cur   = token.start;
1049     limit = token.limit;
1050
1051     type = field->type;
1052
1053     /* we must detect arrays in /FontBBox */
1054     if ( type == T1_FIELD_TYPE_BBOX )
1055     {
1056       T1_TokenRec  token2;
1057       FT_Byte*     old_cur   = parser->cursor;
1058       FT_Byte*     old_limit = parser->limit;
1059
1060
1061       /* don't include delimiters */
1062       parser->cursor = token.start + 1;
1063       parser->limit  = token.limit - 1;
1064
1065       ps_parser_to_token( parser, &token2 );
1066       parser->cursor = old_cur;
1067       parser->limit  = old_limit;
1068
1069       if ( token2.type == T1_TOKEN_TYPE_ARRAY )
1070       {
1071         type = T1_FIELD_TYPE_MM_BBOX;
1072         goto FieldArray;
1073       }
1074     }
1075     else if ( token.type == T1_TOKEN_TYPE_ARRAY )
1076     {
1077       count = max_objects;
1078
1079     FieldArray:
1080       /* if this is an array and we have no blend, an error occurs */
1081       if ( max_objects == 0 )
1082         goto Fail;
1083
1084       idx = 1;
1085
1086       /* don't include delimiters */
1087       cur++;
1088       limit--;
1089     }
1090
1091     for ( ; count > 0; count--, idx++ )
1092     {
1093       FT_Byte*    q = (FT_Byte*)objects[idx] + field->offset;
1094       FT_Long     val;
1095       FT_String*  string;
1096
1097
1098       skip_spaces( &cur, limit );
1099
1100       switch ( type )
1101       {
1102       case T1_FIELD_TYPE_BOOL:
1103         val = ps_tobool( &cur, limit );
1104         goto Store_Integer;
1105
1106       case T1_FIELD_TYPE_FIXED:
1107         val = PS_Conv_ToFixed( &cur, limit, 0 );
1108         goto Store_Integer;
1109
1110       case T1_FIELD_TYPE_FIXED_1000:
1111         val = PS_Conv_ToFixed( &cur, limit, 3 );
1112         goto Store_Integer;
1113
1114       case T1_FIELD_TYPE_INTEGER:
1115         val = PS_Conv_ToInt( &cur, limit );
1116         /* fall through */
1117
1118       Store_Integer:
1119         switch ( field->size )
1120         {
1121         case (8 / FT_CHAR_BIT):
1122           *(FT_Byte*)q = (FT_Byte)val;
1123           break;
1124
1125         case (16 / FT_CHAR_BIT):
1126           *(FT_UShort*)q = (FT_UShort)val;
1127           break;
1128
1129         case (32 / FT_CHAR_BIT):
1130           *(FT_UInt32*)q = (FT_UInt32)val;
1131           break;
1132
1133         default:                /* for 64-bit systems */
1134           *(FT_Long*)q = val;
1135         }
1136         break;
1137
1138       case T1_FIELD_TYPE_STRING:
1139       case T1_FIELD_TYPE_KEY:
1140         {
1141           FT_Memory  memory = parser->memory;
1142           FT_UInt    len    = (FT_UInt)( limit - cur );
1143
1144
1145           if ( cur >= limit )
1146             break;
1147
1148           /* we allow both a string or a name   */
1149           /* for cases like /FontName (foo) def */
1150           if ( token.type == T1_TOKEN_TYPE_KEY )
1151           {
1152             /* don't include leading `/' */
1153             len--;
1154             cur++;
1155           }
1156           else if ( token.type == T1_TOKEN_TYPE_STRING )
1157           {
1158             /* don't include delimiting parentheses    */
1159             /* XXX we don't handle <<...>> here        */
1160             /* XXX should we convert octal escapes?    */
1161             /*     if so, what encoding should we use? */
1162             cur++;
1163             len -= 2;
1164           }
1165           else
1166           {
1167             FT_ERROR(( "ps_parser_load_field:"
1168                        " expected a name or string\n"
1169                        "                     "
1170                        " but found token of type %d instead\n",
1171                        token.type ));
1172             error = FT_THROW( Invalid_File_Format );
1173             goto Exit;
1174           }
1175
1176           /* for this to work (FT_String**)q must have been */
1177           /* initialized to NULL                            */
1178           if ( *(FT_String**)q != NULL )
1179           {
1180             FT_TRACE0(( "ps_parser_load_field: overwriting field %s\n",
1181                         field->ident ));
1182             FT_FREE( *(FT_String**)q );
1183             *(FT_String**)q = NULL;
1184           }
1185
1186           if ( FT_ALLOC( string, len + 1 ) )
1187             goto Exit;
1188
1189           FT_MEM_COPY( string, cur, len );
1190           string[len] = 0;
1191
1192           *(FT_String**)q = string;
1193         }
1194         break;
1195
1196       case T1_FIELD_TYPE_BBOX:
1197         {
1198           FT_Fixed  temp[4];
1199           FT_BBox*  bbox = (FT_BBox*)q;
1200           FT_Int    result;
1201
1202
1203           result = ps_tofixedarray( &cur, limit, 4, temp, 0 );
1204
1205           if ( result < 4 )
1206           {
1207             FT_ERROR(( "ps_parser_load_field:"
1208                        " expected four integers in bounding box\n" ));
1209             error = FT_THROW( Invalid_File_Format );
1210             goto Exit;
1211           }
1212
1213           bbox->xMin = FT_RoundFix( temp[0] );
1214           bbox->yMin = FT_RoundFix( temp[1] );
1215           bbox->xMax = FT_RoundFix( temp[2] );
1216           bbox->yMax = FT_RoundFix( temp[3] );
1217         }
1218         break;
1219
1220       case T1_FIELD_TYPE_MM_BBOX:
1221         {
1222           FT_Memory  memory = parser->memory;
1223           FT_Fixed*  temp;
1224           FT_Int     result;
1225           FT_UInt    i;
1226
1227
1228           if ( FT_NEW_ARRAY( temp, max_objects * 4 ) )
1229             goto Exit;
1230
1231           for ( i = 0; i < 4; i++ )
1232           {
1233             result = ps_tofixedarray( &cur, limit, max_objects,
1234                                       temp + i * max_objects, 0 );
1235             if ( result < 0 || (FT_UInt)result < max_objects )
1236             {
1237               FT_ERROR(( "ps_parser_load_field:"
1238                          " expected %d integers in the %s subarray\n"
1239                          "                     "
1240                          " of /FontBBox in the /Blend dictionary\n",
1241                          max_objects,
1242                          i == 0 ? "first"
1243                                 : ( i == 1 ? "second"
1244                                            : ( i == 2 ? "third"
1245                                                       : "fourth" ) ) ));
1246               error = FT_THROW( Invalid_File_Format );
1247               goto Exit;
1248             }
1249
1250             skip_spaces( &cur, limit );
1251           }
1252
1253           for ( i = 0; i < max_objects; i++ )
1254           {
1255             FT_BBox*  bbox = (FT_BBox*)objects[i];
1256
1257
1258             bbox->xMin = FT_RoundFix( temp[i                  ] );
1259             bbox->yMin = FT_RoundFix( temp[i +     max_objects] );
1260             bbox->xMax = FT_RoundFix( temp[i + 2 * max_objects] );
1261             bbox->yMax = FT_RoundFix( temp[i + 3 * max_objects] );
1262           }
1263
1264           FT_FREE( temp );
1265         }
1266         break;
1267
1268       default:
1269         /* an error occurred */
1270         goto Fail;
1271       }
1272     }
1273
1274 #if 0  /* obsolete -- keep for reference */
1275     if ( pflags )
1276       *pflags |= 1L << field->flag_bit;
1277 #else
1278     FT_UNUSED( pflags );
1279 #endif
1280
1281     error = FT_Err_Ok;
1282
1283   Exit:
1284     return error;
1285
1286   Fail:
1287     error = FT_THROW( Invalid_File_Format );
1288     goto Exit;
1289   }
1290
1291
1292 #define T1_MAX_TABLE_ELEMENTS  32
1293
1294
1295   FT_LOCAL_DEF( FT_Error )
1296   ps_parser_load_field_table( PS_Parser       parser,
1297                               const T1_Field  field,
1298                               void**          objects,
1299                               FT_UInt         max_objects,
1300                               FT_ULong*       pflags )
1301   {
1302     T1_TokenRec  elements[T1_MAX_TABLE_ELEMENTS];
1303     T1_Token     token;
1304     FT_Int       num_elements;
1305     FT_Error     error = FT_Err_Ok;
1306     FT_Byte*     old_cursor;
1307     FT_Byte*     old_limit;
1308     T1_FieldRec  fieldrec = *(T1_Field)field;
1309
1310
1311     fieldrec.type = T1_FIELD_TYPE_INTEGER;
1312     if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY ||
1313          field->type == T1_FIELD_TYPE_BBOX        )
1314       fieldrec.type = T1_FIELD_TYPE_FIXED;
1315
1316     ps_parser_to_token_array( parser, elements,
1317                               T1_MAX_TABLE_ELEMENTS, &num_elements );
1318     if ( num_elements < 0 )
1319     {
1320       error = FT_ERR( Ignore );
1321       goto Exit;
1322     }
1323     if ( (FT_UInt)num_elements > field->array_max )
1324       num_elements = field->array_max;
1325
1326     old_cursor = parser->cursor;
1327     old_limit  = parser->limit;
1328
1329     /* we store the elements count if necessary;           */
1330     /* we further assume that `count_offset' can't be zero */
1331     if ( field->type != T1_FIELD_TYPE_BBOX && field->count_offset != 0 )
1332       *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) =
1333         (FT_Byte)num_elements;
1334
1335     /* we now load each element, adjusting the field.offset on each one */
1336     token = elements;
1337     for ( ; num_elements > 0; num_elements--, token++ )
1338     {
1339       parser->cursor = token->start;
1340       parser->limit  = token->limit;
1341
1342       error = ps_parser_load_field( parser,
1343                                     &fieldrec,
1344                                     objects,
1345                                     max_objects,
1346                                     0 );
1347       if ( error )
1348         break;
1349
1350       fieldrec.offset += fieldrec.size;
1351     }
1352
1353 #if 0  /* obsolete -- keep for reference */
1354     if ( pflags )
1355       *pflags |= 1L << field->flag_bit;
1356 #else
1357     FT_UNUSED( pflags );
1358 #endif
1359
1360     parser->cursor = old_cursor;
1361     parser->limit  = old_limit;
1362
1363   Exit:
1364     return error;
1365   }
1366
1367
1368   FT_LOCAL_DEF( FT_Long )
1369   ps_parser_to_int( PS_Parser  parser )
1370   {
1371     ps_parser_skip_spaces( parser );
1372     return PS_Conv_ToInt( &parser->cursor, parser->limit );
1373   }
1374
1375
1376   /* first character must be `<' if `delimiters' is non-zero */
1377
1378   FT_LOCAL_DEF( FT_Error )
1379   ps_parser_to_bytes( PS_Parser  parser,
1380                       FT_Byte*   bytes,
1381                       FT_Offset  max_bytes,
1382                       FT_Long*   pnum_bytes,
1383                       FT_Bool    delimiters )
1384   {
1385     FT_Error  error = FT_Err_Ok;
1386     FT_Byte*  cur;
1387
1388
1389     ps_parser_skip_spaces( parser );
1390     cur = parser->cursor;
1391
1392     if ( cur >= parser->limit )
1393       goto Exit;
1394
1395     if ( delimiters )
1396     {
1397       if ( *cur != '<' )
1398       {
1399         FT_ERROR(( "ps_parser_to_bytes: Missing starting delimiter `<'\n" ));
1400         error = FT_THROW( Invalid_File_Format );
1401         goto Exit;
1402       }
1403
1404       cur++;
1405     }
1406
1407     *pnum_bytes = PS_Conv_ASCIIHexDecode( &cur,
1408                                           parser->limit,
1409                                           bytes,
1410                                           max_bytes );
1411
1412     if ( delimiters )
1413     {
1414       if ( cur < parser->limit && *cur != '>' )
1415       {
1416         FT_ERROR(( "ps_parser_to_bytes: Missing closing delimiter `>'\n" ));
1417         error = FT_THROW( Invalid_File_Format );
1418         goto Exit;
1419       }
1420
1421       cur++;
1422     }
1423
1424     parser->cursor = cur;
1425
1426   Exit:
1427     return error;
1428   }
1429
1430
1431   FT_LOCAL_DEF( FT_Fixed )
1432   ps_parser_to_fixed( PS_Parser  parser,
1433                       FT_Int     power_ten )
1434   {
1435     ps_parser_skip_spaces( parser );
1436     return PS_Conv_ToFixed( &parser->cursor, parser->limit, power_ten );
1437   }
1438
1439
1440   FT_LOCAL_DEF( FT_Int )
1441   ps_parser_to_coord_array( PS_Parser  parser,
1442                             FT_Int     max_coords,
1443                             FT_Short*  coords )
1444   {
1445     ps_parser_skip_spaces( parser );
1446     return ps_tocoordarray( &parser->cursor, parser->limit,
1447                             max_coords, coords );
1448   }
1449
1450
1451   FT_LOCAL_DEF( FT_Int )
1452   ps_parser_to_fixed_array( PS_Parser  parser,
1453                             FT_Int     max_values,
1454                             FT_Fixed*  values,
1455                             FT_Int     power_ten )
1456   {
1457     ps_parser_skip_spaces( parser );
1458     return ps_tofixedarray( &parser->cursor, parser->limit,
1459                             max_values, values, power_ten );
1460   }
1461
1462
1463 #if 0
1464
1465   FT_LOCAL_DEF( FT_String* )
1466   T1_ToString( PS_Parser  parser )
1467   {
1468     return ps_tostring( &parser->cursor, parser->limit, parser->memory );
1469   }
1470
1471
1472   FT_LOCAL_DEF( FT_Bool )
1473   T1_ToBool( PS_Parser  parser )
1474   {
1475     return ps_tobool( &parser->cursor, parser->limit );
1476   }
1477
1478 #endif /* 0 */
1479
1480
1481   FT_LOCAL_DEF( void )
1482   ps_parser_init( PS_Parser  parser,
1483                   FT_Byte*   base,
1484                   FT_Byte*   limit,
1485                   FT_Memory  memory )
1486   {
1487     parser->error  = FT_Err_Ok;
1488     parser->base   = base;
1489     parser->limit  = limit;
1490     parser->cursor = base;
1491     parser->memory = memory;
1492     parser->funcs  = ps_parser_funcs;
1493   }
1494
1495
1496   FT_LOCAL_DEF( void )
1497   ps_parser_done( PS_Parser  parser )
1498   {
1499     FT_UNUSED( parser );
1500   }
1501
1502
1503   /*************************************************************************/
1504   /*************************************************************************/
1505   /*****                                                               *****/
1506   /*****                            T1 BUILDER                         *****/
1507   /*****                                                               *****/
1508   /*************************************************************************/
1509   /*************************************************************************/
1510
1511   /*************************************************************************/
1512   /*                                                                       */
1513   /* <Function>                                                            */
1514   /*    t1_builder_init                                                    */
1515   /*                                                                       */
1516   /* <Description>                                                         */
1517   /*    Initializes a given glyph builder.                                 */
1518   /*                                                                       */
1519   /* <InOut>                                                               */
1520   /*    builder :: A pointer to the glyph builder to initialize.           */
1521   /*                                                                       */
1522   /* <Input>                                                               */
1523   /*    face    :: The current face object.                                */
1524   /*                                                                       */
1525   /*    size    :: The current size object.                                */
1526   /*                                                                       */
1527   /*    glyph   :: The current glyph object.                               */
1528   /*                                                                       */
1529   /*    hinting :: Whether hinting should be applied.                      */
1530   /*                                                                       */
1531   FT_LOCAL_DEF( void )
1532   t1_builder_init( T1_Builder    builder,
1533                    FT_Face       face,
1534                    FT_Size       size,
1535                    FT_GlyphSlot  glyph,
1536                    FT_Bool       hinting )
1537   {
1538     builder->parse_state = T1_Parse_Start;
1539     builder->load_points = 1;
1540
1541     builder->face   = face;
1542     builder->glyph  = glyph;
1543     builder->memory = face->memory;
1544
1545     if ( glyph )
1546     {
1547       FT_GlyphLoader  loader = glyph->internal->loader;
1548
1549
1550       builder->loader  = loader;
1551       builder->base    = &loader->base.outline;
1552       builder->current = &loader->current.outline;
1553       FT_GlyphLoader_Rewind( loader );
1554
1555       builder->hints_globals = size->internal;
1556       builder->hints_funcs   = 0;
1557
1558       if ( hinting )
1559         builder->hints_funcs = glyph->internal->glyph_hints;
1560     }
1561
1562     builder->pos_x = 0;
1563     builder->pos_y = 0;
1564
1565     builder->left_bearing.x = 0;
1566     builder->left_bearing.y = 0;
1567     builder->advance.x      = 0;
1568     builder->advance.y      = 0;
1569
1570     builder->funcs = t1_builder_funcs;
1571   }
1572
1573
1574   /*************************************************************************/
1575   /*                                                                       */
1576   /* <Function>                                                            */
1577   /*    t1_builder_done                                                    */
1578   /*                                                                       */
1579   /* <Description>                                                         */
1580   /*    Finalizes a given glyph builder.  Its contents can still be used   */
1581   /*    after the call, but the function saves important information       */
1582   /*    within the corresponding glyph slot.                               */
1583   /*                                                                       */
1584   /* <Input>                                                               */
1585   /*    builder :: A pointer to the glyph builder to finalize.             */
1586   /*                                                                       */
1587   FT_LOCAL_DEF( void )
1588   t1_builder_done( T1_Builder  builder )
1589   {
1590     FT_GlyphSlot  glyph = builder->glyph;
1591
1592
1593     if ( glyph )
1594       glyph->outline = *builder->base;
1595   }
1596
1597
1598   /* check that there is enough space for `count' more points */
1599   FT_LOCAL_DEF( FT_Error )
1600   t1_builder_check_points( T1_Builder  builder,
1601                            FT_Int      count )
1602   {
1603     return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
1604   }
1605
1606
1607   /* add a new point, do not check space */
1608   FT_LOCAL_DEF( void )
1609   t1_builder_add_point( T1_Builder  builder,
1610                         FT_Pos      x,
1611                         FT_Pos      y,
1612                         FT_Byte     flag )
1613   {
1614     FT_Outline*  outline = builder->current;
1615
1616
1617     if ( builder->load_points )
1618     {
1619       FT_Vector*  point   = outline->points + outline->n_points;
1620       FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points;
1621
1622
1623       point->x = FIXED_TO_INT( x );
1624       point->y = FIXED_TO_INT( y );
1625       *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
1626     }
1627     outline->n_points++;
1628   }
1629
1630
1631   /* check space for a new on-curve point, then add it */
1632   FT_LOCAL_DEF( FT_Error )
1633   t1_builder_add_point1( T1_Builder  builder,
1634                          FT_Pos      x,
1635                          FT_Pos      y )
1636   {
1637     FT_Error  error;
1638
1639
1640     error = t1_builder_check_points( builder, 1 );
1641     if ( !error )
1642       t1_builder_add_point( builder, x, y, 1 );
1643
1644     return error;
1645   }
1646
1647
1648   /* check space for a new contour, then add it */
1649   FT_LOCAL_DEF( FT_Error )
1650   t1_builder_add_contour( T1_Builder  builder )
1651   {
1652     FT_Outline*  outline = builder->current;
1653     FT_Error     error;
1654
1655
1656     /* this might happen in invalid fonts */
1657     if ( !outline )
1658     {
1659       FT_ERROR(( "t1_builder_add_contour: no outline to add points to\n" ));
1660       return FT_THROW( Invalid_File_Format );
1661     }
1662
1663     if ( !builder->load_points )
1664     {
1665       outline->n_contours++;
1666       return FT_Err_Ok;
1667     }
1668
1669     error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
1670     if ( !error )
1671     {
1672       if ( outline->n_contours > 0 )
1673         outline->contours[outline->n_contours - 1] =
1674           (short)( outline->n_points - 1 );
1675
1676       outline->n_contours++;
1677     }
1678
1679     return error;
1680   }
1681
1682
1683   /* if a path was begun, add its first on-curve point */
1684   FT_LOCAL_DEF( FT_Error )
1685   t1_builder_start_point( T1_Builder  builder,
1686                           FT_Pos      x,
1687                           FT_Pos      y )
1688   {
1689     FT_Error  error = FT_ERR( Invalid_File_Format );
1690
1691
1692     /* test whether we are building a new contour */
1693
1694     if ( builder->parse_state == T1_Parse_Have_Path )
1695       error = FT_Err_Ok;
1696     else
1697     {
1698       builder->parse_state = T1_Parse_Have_Path;
1699       error = t1_builder_add_contour( builder );
1700       if ( !error )
1701         error = t1_builder_add_point1( builder, x, y );
1702     }
1703
1704     return error;
1705   }
1706
1707
1708   /* close the current contour */
1709   FT_LOCAL_DEF( void )
1710   t1_builder_close_contour( T1_Builder  builder )
1711   {
1712     FT_Outline*  outline = builder->current;
1713     FT_Int       first;
1714
1715
1716     if ( !outline )
1717       return;
1718
1719     first = outline->n_contours <= 1
1720             ? 0 : outline->contours[outline->n_contours - 2] + 1;
1721
1722     /* We must not include the last point in the path if it */
1723     /* is located on the first point.                       */
1724     if ( outline->n_points > 1 )
1725     {
1726       FT_Vector*  p1      = outline->points + first;
1727       FT_Vector*  p2      = outline->points + outline->n_points - 1;
1728       FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points - 1;
1729
1730
1731       /* `delete' last point only if it coincides with the first */
1732       /* point and it is not a control point (which can happen). */
1733       if ( p1->x == p2->x && p1->y == p2->y )
1734         if ( *control == FT_CURVE_TAG_ON )
1735           outline->n_points--;
1736     }
1737
1738     if ( outline->n_contours > 0 )
1739     {
1740       /* Don't add contours only consisting of one point, i.e.,  */
1741       /* check whether the first and the last point is the same. */
1742       if ( first == outline->n_points - 1 )
1743       {
1744         outline->n_contours--;
1745         outline->n_points--;
1746       }
1747       else
1748         outline->contours[outline->n_contours - 1] =
1749           (short)( outline->n_points - 1 );
1750     }
1751   }
1752
1753
1754   /*************************************************************************/
1755   /*************************************************************************/
1756   /*****                                                               *****/
1757   /*****                            OTHER                              *****/
1758   /*****                                                               *****/
1759   /*************************************************************************/
1760   /*************************************************************************/
1761
1762   FT_LOCAL_DEF( void )
1763   t1_decrypt( FT_Byte*   buffer,
1764               FT_Offset  length,
1765               FT_UShort  seed )
1766   {
1767     PS_Conv_EexecDecode( &buffer,
1768                          buffer + length,
1769                          buffer,
1770                          length,
1771                          &seed );
1772   }
1773
1774
1775 /* END */