1 /****************************************************************************
2 *
3 * psobjs.c
4 *
5 * Auxiliary functions for PostScript fonts (body).
6 *
7 * Copyright (C) 1996-2023 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 <freetype/internal/psaux.h>
20 #include <freetype/internal/ftdebug.h>
21 #include <freetype/internal/ftcalc.h>
22 #include <freetype/ftdriver.h>
23
24 #include "psobjs.h"
25 #include "psconv.h"
26
27 #include "psauxerr.h"
28 #include "psauxmod.h"
29
30
31 /**************************************************************************
32 *
33 * The macro FT_COMPONENT is used in trace mode. It is an implicit
34 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
35 * messages during execution.
36 */
37 #undef FT_COMPONENT
38 #define FT_COMPONENT psobjs
39
40
41 /*************************************************************************/
42 /*************************************************************************/
43 /***** *****/
44 /***** PS_TABLE *****/
45 /***** *****/
46 /*************************************************************************/
47 /*************************************************************************/
48
49 /**************************************************************************
50 *
51 * @Function:
52 * ps_table_new
53 *
54 * @Description:
55 * Initializes a PS_Table.
56 *
57 * @InOut:
58 * table ::
59 * The address of the target table.
60 *
61 * @Input:
62 * count ::
63 * The table size = the maximum number of elements.
64 *
65 * memory ::
66 * The memory object to use for all subsequent
67 * reallocations.
68 *
69 * @Return:
70 * FreeType error code. 0 means success.
71 */
72 FT_LOCAL_DEF( FT_Error )
73 ps_table_new( PS_Table table,
74 FT_Int count,
75 FT_Memory memory )
76 {
77 FT_Error error;
78
79
80 table->memory = memory;
81 if ( FT_NEW_ARRAY( table->elements, count ) ||
82 FT_NEW_ARRAY( table->lengths, count ) )
83 goto Exit;
84
85 table->max_elems = count;
86 table->init = 0xDEADBEEFUL;
87 table->block = NULL;
88 table->capacity = 0;
89 table->cursor = 0;
90
91 *(PS_Table_FuncsRec*)&table->funcs = ps_table_funcs;
92
93 Exit:
94 if ( error )
95 FT_FREE( table->elements );
96
97 return error;
98 }
99
100
101 static FT_Error
102 ps_table_realloc( PS_Table table,
103 FT_Offset new_size )
104 {
105 FT_Memory memory = table->memory;
106 FT_Byte* old_base = table->block;
107 FT_Error error;
108
109
110 /* (re)allocate the base block */
111 if ( FT_REALLOC( table->block, table->capacity, new_size ) )
112 return error;
113
114 /* rebase offsets if necessary */
115 if ( old_base && table->block != old_base )
116 {
117 FT_Byte** offset = table->elements;
118 FT_Byte** limit = offset + table->max_elems;
119
120
121 for ( ; offset < limit; offset++ )
122 {
123 if ( *offset )
124 *offset = table->block + ( *offset - old_base );
125 }
126 }
127
128 table->capacity = new_size;
129
130 return FT_Err_Ok;
131 }
132
133
134 /**************************************************************************
135 *
136 * @Function:
137 * ps_table_add
138 *
139 * @Description:
140 * Adds an object to a PS_Table, possibly growing its memory block.
141 *
142 * @InOut:
143 * table ::
144 * The target table.
145 *
146 * @Input:
147 * idx ::
148 * The index of the object in the table.
149 *
150 * object ::
151 * The address of the object to copy in memory.
152 *
153 * length ::
154 * The length in bytes of the source object.
155 *
156 * @Return:
157 * FreeType error code. 0 means success. An error is returned if a
158 * reallocation fails.
159 */
160 FT_LOCAL_DEF( FT_Error )
161 ps_table_add( PS_Table table,
162 FT_Int idx,
163 const void* object,
164 FT_UInt length )
165 {
166 if ( idx < 0 || idx >= table->max_elems )
167 {
168 FT_ERROR(( "ps_table_add: invalid index\n" ));
169 return FT_THROW( Invalid_Argument );
170 }
171
172 /* grow the base block if needed */
173 if ( table->cursor + length > table->capacity )
174 {
175 FT_Error error;
176 FT_Offset new_size = table->capacity;
177 FT_PtrDist in_offset;
178
179
180 in_offset = (FT_Byte*)object - table->block;
181 if ( in_offset < 0 || (FT_Offset)in_offset >= table->capacity )
182 in_offset = -1;
183
184 while ( new_size < table->cursor + length )
185 {
186 /* increase size by 25% and round up to the nearest multiple
187 of 1024 */
188 new_size += ( new_size >> 2 ) + 1;
189 new_size = FT_PAD_CEIL( new_size, 1024 );
190 }
191
192 error = ps_table_realloc( table, new_size );
193 if ( error )
194 return error;
195
196 if ( in_offset >= 0 )
197 object = table->block + in_offset;
198 }
199
200 /* add the object to the base block and adjust offset */
201 table->elements[idx] = FT_OFFSET( table->block, table->cursor );
202 table->lengths [idx] = length;
203 FT_MEM_COPY( table->block + table->cursor, object, length );
204
205 table->cursor += length;
206 return FT_Err_Ok;
207 }
208
209
210 /**************************************************************************
211 *
212 * @Function:
213 * ps_table_done
214 *
215 * @Description:
216 * Finalizes a PS_TableRec (i.e., reallocate it to its current
217 * cursor).
218 *
219 * @InOut:
220 * table ::
221 * The target table.
222 */
223 FT_LOCAL_DEF( void )
224 ps_table_done( PS_Table table )
225 {
226 /* no problem if shrinking fails */
227 ps_table_realloc( table, table->cursor );
228 }
229
230
231 FT_LOCAL_DEF( void )
232 ps_table_release( PS_Table table )
233 {
234 FT_Memory memory = table->memory;
235
236
237 if ( table->init == 0xDEADBEEFUL )
238 {
239 FT_FREE( table->block );
240 FT_FREE( table->elements );
241 FT_FREE( table->lengths );
242 table->init = 0;
243 }
244 }
245
246
247 /*************************************************************************/
248 /*************************************************************************/
249 /***** *****/
250 /***** T1 PARSER *****/
251 /***** *****/
252 /*************************************************************************/
253 /*************************************************************************/
254
255
256 /* first character must be already part of the comment */
257
258 static void
259 skip_comment( FT_Byte* *acur,
260 FT_Byte* limit )
261 {
262 FT_Byte* cur = *acur;
263
264
265 while ( cur < limit )
266 {
267 if ( IS_PS_NEWLINE( *cur ) )
268 break;
269 cur++;
270 }
271
272 *acur = cur;
273 }
274
275
276 static void
277 skip_spaces( FT_Byte* *acur,
278 FT_Byte* limit )
279 {
280 FT_Byte* cur = *acur;
281
282
283 while ( cur < limit )
284 {
285 if ( !IS_PS_SPACE( *cur ) )
286 {
287 if ( *cur == '%' )
288 /* According to the PLRM, a comment is equal to a space. */
289 skip_comment( &cur, limit );
290 else
291 break;
292 }
293 cur++;
294 }
295
296 *acur = cur;
297 }
298
299
300 #define IS_OCTAL_DIGIT( c ) ( '0' <= (c) && (c) <= '7' )
301
302
303 /* first character must be `('; */
304 /* *acur is positioned at the character after the closing `)' */
305
306 static FT_Error
307 skip_literal_string( FT_Byte* *acur,
308 FT_Byte* limit )
309 {
310 FT_Byte* cur = *acur;
311 FT_Int embed = 0;
312 FT_Error error = FT_ERR( Invalid_File_Format );
313 unsigned int i;
314
315
316 while ( cur < limit )
317 {
318 FT_Byte c = *cur;
319
320
321 cur++;
322
323 if ( c == '\\' )
324 {
325 /* Red Book 3rd ed., section `Literal Text Strings', p. 29: */
326 /* A backslash can introduce three different types */
327 /* of escape sequences: */
328 /* - a special escaped char like \r, \n, etc. */
329 /* - a one-, two-, or three-digit octal number */
330 /* - none of the above in which case the backslash is ignored */
331
332 if ( cur == limit )
333 /* error (or to be ignored?) */
334 break;
335
336 switch ( *cur )
337 {
338 /* skip `special' escape */
339 case 'n':
340 case 'r':
341 case 't':
342 case 'b':
343 case 'f':
344 case '\\':
345 case '(':
346 case ')':
347 cur++;
348 break;
349
350 default:
351 /* skip octal escape or ignore backslash */
352 for ( i = 0; i < 3 && cur < limit; i++ )
353 {
354 if ( !IS_OCTAL_DIGIT( *cur ) )
355 break;
356
357 cur++;
358 }
359 }
360 }
361 else if ( c == '(' )
362 embed++;
363 else if ( c == ')' )
364 {
365 embed--;
366 if ( embed == 0 )
367 {
368 error = FT_Err_Ok;
369 break;
370 }
371 }
372 }
373
374 *acur = cur;
375
376 return error;
377 }
378
379
380 /* first character must be `<' */
381
382 static FT_Error
383 skip_string( FT_Byte* *acur,
384 FT_Byte* limit )
385 {
386 FT_Byte* cur = *acur;
387 FT_Error err = FT_Err_Ok;
388
389
390 while ( ++cur < limit )
391 {
392 /* All whitespace characters are ignored. */
393 skip_spaces( &cur, limit );
394 if ( cur >= limit )
395 break;
396
397 if ( !IS_PS_XDIGIT( *cur ) )
398 break;
399 }
400
401 if ( cur < limit && *cur != '>' )
402 {
403 FT_ERROR(( "skip_string: missing closing delimiter `>'\n" ));
404 err = FT_THROW( Invalid_File_Format );
405 }
406 else
407 cur++;
408
409 *acur = cur;
410 return err;
411 }
412
413
414 /* first character must be the opening brace that */
415 /* starts the procedure */
416
417 /* NB: [ and ] need not match: */
418 /* `/foo {[} def' is a valid PostScript fragment, */
419 /* even within a Type1 font */
420
421 static FT_Error
422 skip_procedure( FT_Byte* *acur,
423 FT_Byte* limit )
424 {
425 FT_Byte* cur;
426 FT_Int embed = 0;
427 FT_Error error = FT_Err_Ok;
428
429
430 FT_ASSERT( **acur == '{' );
431
432 for ( cur = *acur; cur < limit && error == FT_Err_Ok; cur++ )
433 {
434 switch ( *cur )
435 {
436 case '{':
437 embed++;
438 break;
439
440 case '}':
441 embed--;
442 if ( embed == 0 )
443 {
444 cur++;
445 goto end;
446 }
447 break;
448
449 case '(':
450 error = skip_literal_string( &cur, limit );
451 break;
452
453 case '<':
454 error = skip_string( &cur, limit );
455 break;
456
457 case '%':
458 skip_comment( &cur, limit );
459 break;
460 }
461 }
462
463 end:
464 if ( embed != 0 )
465 error = FT_THROW( Invalid_File_Format );
466
467 *acur = cur;
468
469 return error;
470 }
471
472
473 /************************************************************************
474 *
475 * All exported parsing routines handle leading whitespace and stop at
476 * the first character which isn't part of the just handled token.
477 *
478 */
479
480
481 FT_LOCAL_DEF( void )
482 ps_parser_skip_PS_token( PS_Parser parser )
483 {
484 /* Note: PostScript allows any non-delimiting, non-whitespace */
485 /* character in a name (PS Ref Manual, 3rd ed, p31). */
486 /* PostScript delimiters are (, ), <, >, [, ], {, }, /, and %. */
487
488 FT_Byte* cur = parser->cursor;
489 FT_Byte* limit = parser->limit;
490 FT_Error error = FT_Err_Ok;
491
492
493 skip_spaces( &cur, limit ); /* this also skips comments */
494 if ( cur >= limit )
495 goto Exit;
496
497 /* self-delimiting, single-character tokens */
498 if ( *cur == '[' || *cur == ']' )
499 {
500 cur++;
501 goto Exit;
502 }
503
504 /* skip balanced expressions (procedures and strings) */
505
506 if ( *cur == '{' ) /* {...} */
507 {
508 error = skip_procedure( &cur, limit );
509 goto Exit;
510 }
511
512 if ( *cur == '(' ) /* (...) */
513 {
514 error = skip_literal_string( &cur, limit );
515 goto Exit;
516 }
517
518 if ( *cur == '<' ) /* <...> */
519 {
520 if ( cur + 1 < limit && *( cur + 1 ) == '<' ) /* << */
521 {
522 cur++;
523 cur++;
524 }
525 else
526 error = skip_string( &cur, limit );
527
528 goto Exit;
529 }
530
531 if ( *cur == '>' )
532 {
533 cur++;
534 if ( cur >= limit || *cur != '>' ) /* >> */
535 {
536 FT_ERROR(( "ps_parser_skip_PS_token:"
537 " unexpected closing delimiter `>'\n" ));
538 error = FT_THROW( Invalid_File_Format );
539 goto Exit;
540 }
541 cur++;
542 goto Exit;
543 }
544
545 if ( *cur == '/' )
546 cur++;
547
548 /* anything else */
549 while ( cur < limit )
550 {
551 /* *cur might be invalid (e.g., ')' or '}'), but this */
552 /* is handled by the test `cur == parser->cursor' below */
553 if ( IS_PS_DELIM( *cur ) )
554 break;
555
556 cur++;
557 }
558
559 Exit:
560 if ( cur < limit && cur == parser->cursor )
561 {
562 FT_ERROR(( "ps_parser_skip_PS_token:"
563 " current token is `%c' which is self-delimiting\n",
564 *cur ));
565 FT_ERROR(( " "
566 " but invalid at this point\n" ));
567
568 error = FT_THROW( Invalid_File_Format );
569 }
570
571 if ( cur > limit )
572 cur = limit;
573
574 parser->error = error;
575 parser->cursor = cur;
576 }
577
578
579 FT_LOCAL_DEF( void )
580 ps_parser_skip_spaces( PS_Parser parser )
581 {
582 skip_spaces( &parser->cursor, parser->limit );
583 }
584
585
586 /* `token' here means either something between balanced delimiters */
587 /* or the next token; the delimiters are not removed. */
588
589 FT_LOCAL_DEF( void )
590 ps_parser_to_token( PS_Parser parser,
591 T1_Token token )
592 {
593 FT_Byte* cur;
594 FT_Byte* limit;
595 FT_Int embed;
596
597
598 token->type = T1_TOKEN_TYPE_NONE;
599 token->start = NULL;
600 token->limit = NULL;
601
602 /* first of all, skip leading whitespace */
603 ps_parser_skip_spaces( parser );
604
605 cur = parser->cursor;
606 limit = parser->limit;
607
608 if ( cur >= limit )
609 return;
610
611 switch ( *cur )
612 {
613 /************* check for literal string *****************/
614 case '(':
615 token->type = T1_TOKEN_TYPE_STRING;
616 token->start = cur;
617
618 if ( skip_literal_string( &cur, limit ) == FT_Err_Ok )
619 token->limit = cur;
620 break;
621
622 /************* check for programs/array *****************/
623 case '{':
624 token->type = T1_TOKEN_TYPE_ARRAY;
625 token->start = cur;
626
627 if ( skip_procedure( &cur, limit ) == FT_Err_Ok )
628 token->limit = cur;
629 break;
630
631 /************* check for table/array ********************/
632 /* XXX: in theory we should also look for "<<" */
633 /* since this is semantically equivalent to "["; */
634 /* in practice it doesn't matter (?) */
635 case '[':
636 token->type = T1_TOKEN_TYPE_ARRAY;
637 embed = 1;
638 token->start = cur++;
639
640 /* we need this to catch `[ ]' */
641 parser->cursor = cur;
642 ps_parser_skip_spaces( parser );
643 cur = parser->cursor;
644
645 while ( cur < limit && !parser->error )
646 {
647 /* XXX: this is wrong because it does not */
648 /* skip comments, procedures, and strings */
649 if ( *cur == '[' )
650 embed++;
651 else if ( *cur == ']' )
652 {
653 embed--;
654 if ( embed <= 0 )
655 {
656 token->limit = ++cur;
657 break;
658 }
659 }
660
661 parser->cursor = cur;
662 ps_parser_skip_PS_token( parser );
663 /* we need this to catch `[XXX ]' */
664 ps_parser_skip_spaces ( parser );
665 cur = parser->cursor;
666 }
667 break;
668
669 /* ************ otherwise, it is any token **************/
670 default:
671 token->start = cur;
672 token->type = ( *cur == '/' ) ? T1_TOKEN_TYPE_KEY : T1_TOKEN_TYPE_ANY;
673 ps_parser_skip_PS_token( parser );
674 cur = parser->cursor;
675 if ( !parser->error )
676 token->limit = cur;
677 }
678
679 if ( !token->limit )
680 {
681 token->start = NULL;
682 token->type = T1_TOKEN_TYPE_NONE;
683 }
684
685 parser->cursor = cur;
686 }
687
688
689 /* NB: `tokens' can be NULL if we only want to count */
690 /* the number of array elements */
691
692 FT_LOCAL_DEF( void )
693 ps_parser_to_token_array( PS_Parser parser,
694 T1_Token tokens,
695 FT_UInt max_tokens,
696 FT_Int* pnum_tokens )
697 {
698 T1_TokenRec master;
699
700
701 *pnum_tokens = -1;
702
703 /* this also handles leading whitespace */
704 ps_parser_to_token( parser, &master );
705
706 if ( master.type == T1_TOKEN_TYPE_ARRAY )
707 {
708 FT_Byte* old_cursor = parser->cursor;
709 FT_Byte* old_limit = parser->limit;
710 T1_Token cur = tokens;
711 T1_Token limit = cur + max_tokens;
712
713
714 /* don't include outermost delimiters */
715 parser->cursor = master.start + 1;
716 parser->limit = master.limit - 1;
717
718 while ( parser->cursor < parser->limit )
719 {
720 T1_TokenRec token;
721
722
723 ps_parser_to_token( parser, &token );
724 if ( !token.type )
725 break;
726
727 if ( tokens && cur < limit )
728 *cur = token;
729
730 cur++;
731 }
732
733 *pnum_tokens = (FT_Int)( cur - tokens );
734
735 parser->cursor = old_cursor;
736 parser->limit = old_limit;
737 }
738 }
739
740
741 /* first character must be a delimiter or a part of a number */
742 /* NB: `coords' can be NULL if we just want to skip the */
743 /* array; in this case we ignore `max_coords' */
744
745 static FT_Int
746 ps_tocoordarray( FT_Byte* *acur,
747 FT_Byte* limit,
748 FT_Int max_coords,
749 FT_Short* coords )
750 {
751 FT_Byte* cur = *acur;
752 FT_Int count = 0;
753 FT_Byte c, ender;
754
755
756 if ( cur >= limit )
757 goto Exit;
758
759 /* check for the beginning of an array; otherwise, only one number */
760 /* will be read */
761 c = *cur;
762 ender = 0;
763
764 if ( c == '[' )
765 ender = ']';
766 else if ( c == '{' )
767 ender = '}';
768
769 if ( ender )
770 cur++;
771
772 /* now, read the coordinates */
773 while ( cur < limit )
774 {
775 FT_Short dummy;
776 FT_Byte* old_cur;
777
778
779 /* skip whitespace in front of data */
780 skip_spaces( &cur, limit );
781 if ( cur >= limit )
782 goto Exit;
783
784 if ( *cur == ender )
785 {
786 cur++;
787 break;
788 }
789
790 old_cur = cur;
791
792 if ( coords && count >= max_coords )
793 break;
794
795 /* call PS_Conv_ToFixed() even if coords == NULL */
796 /* to properly parse number at `cur' */
797 *( coords ? &coords[count] : &dummy ) =
798 (FT_Short)( PS_Conv_ToFixed( &cur, limit, 0 ) >> 16 );
799
800 if ( old_cur == cur )
801 {
802 count = -1;
803 goto Exit;
804 }
805 else
806 count++;
807
808 if ( !ender )
809 break;
810 }
811
812 Exit:
813 *acur = cur;
814 return count;
815 }
816
817
818 /* first character must be a delimiter or a part of a number */
819 /* NB: `values' can be NULL if we just want to skip the */
820 /* array; in this case we ignore `max_values' */
821 /* */
822 /* return number of successfully parsed values */
823
824 static FT_Int
825 ps_tofixedarray( FT_Byte* *acur,
826 FT_Byte* limit,
827 FT_Int max_values,
828 FT_Fixed* values,
829 FT_Int power_ten )
830 {
831 FT_Byte* cur = *acur;
832 FT_Int count = 0;
833 FT_Byte c, ender;
834
835
836 if ( cur >= limit )
837 goto Exit;
838
839 /* Check for the beginning of an array. Otherwise, only one number */
840 /* will be read. */
841 c = *cur;
842 ender = 0;
843
844 if ( c == '[' )
845 ender = ']';
846 else if ( c == '{' )
847 ender = '}';
848
849 if ( ender )
850 cur++;
851
852 /* now, read the values */
853 while ( cur < limit )
854 {
855 FT_Fixed dummy;
856 FT_Byte* old_cur;
857
858
859 /* skip whitespace in front of data */
860 skip_spaces( &cur, limit );
861 if ( cur >= limit )
862 goto Exit;
863
864 if ( *cur == ender )
865 {
866 cur++;
867 break;
868 }
869
870 old_cur = cur;
871
872 if ( values && count >= max_values )
873 break;
874
875 /* call PS_Conv_ToFixed() even if coords == NULL */
876 /* to properly parse number at `cur' */
877 *( values ? &values[count] : &dummy ) =
878 PS_Conv_ToFixed( &cur, limit, power_ten );
879
880 if ( old_cur == cur )
881 {
882 count = -1;
883 goto Exit;
884 }
885 else
886 count++;
887
888 if ( !ender )
889 break;
890 }
891
892 Exit:
893 *acur = cur;
894 return count;
895 }
896
897
898 #if 0
899
900 static FT_String*
901 ps_tostring( FT_Byte** cursor,
902 FT_Byte* limit,
903 FT_Memory memory )
904 {
905 FT_Byte* cur = *cursor;
906 FT_UInt len = 0;
907 FT_Int count;
908 FT_String* result;
909 FT_Error error;
910
911
912 /* XXX: some stupid fonts have a `Notice' or `Copyright' string */
913 /* that simply doesn't begin with an opening parenthesis, even */
914 /* though they have a closing one! E.g. "amuncial.pfb" */
915 /* */
916 /* We must deal with these ill-fated cases there. Note that */
917 /* these fonts didn't work with the old Type 1 driver as the */
918 /* notice/copyright was not recognized as a valid string token */
919 /* and made the old token parser commit errors. */
920
921 while ( cur < limit && ( *cur == ' ' || *cur == '\t' ) )
922 cur++;
923 if ( cur + 1 >= limit )
924 return 0;
925
926 if ( *cur == '(' )
927 cur++; /* skip the opening parenthesis, if there is one */
928
929 *cursor = cur;
930 count = 0;
931
932 /* then, count its length */
933 for ( ; cur < limit; cur++ )
934 {
935 if ( *cur == '(' )
936 count++;
937
938 else if ( *cur == ')' )
939 {
940 count--;
941 if ( count < 0 )
942 break;
943 }
944 }
945
946 len = (FT_UInt)( cur - *cursor );
947 if ( cur >= limit || FT_QALLOC( result, len + 1 ) )
948 return 0;
949
950 /* now copy the string */
951 FT_MEM_COPY( result, *cursor, len );
952 result[len] = '\0';
953 *cursor = cur;
954 return result;
955 }
956
957 #endif /* 0 */
958
959
960 static int
961 ps_tobool( FT_Byte* *acur,
962 FT_Byte* limit )
963 {
964 FT_Byte* cur = *acur;
965 FT_Bool result = 0;
966
967
968 /* return 1 if we find `true', 0 otherwise */
969 if ( cur + 3 < limit &&
970 cur[0] == 't' &&
971 cur[1] == 'r' &&
972 cur[2] == 'u' &&
973 cur[3] == 'e' )
974 {
975 result = 1;
976 cur += 5;
977 }
978 else if ( cur + 4 < limit &&
979 cur[0] == 'f' &&
980 cur[1] == 'a' &&
981 cur[2] == 'l' &&
982 cur[3] == 's' &&
983 cur[4] == 'e' )
984 {
985 result = 0;
986 cur += 6;
987 }
988
989 *acur = cur;
990 return result;
991 }
992
993
994 /* load a simple field (i.e. non-table) into the current list of objects */
995
996 FT_LOCAL_DEF( FT_Error )
997 ps_parser_load_field( PS_Parser parser,
998 const T1_Field field,
999 void** objects,
1000 FT_UInt max_objects,
1001 FT_ULong* pflags )
1002 {
1003 T1_TokenRec token;
1004 FT_Byte* cur;
1005 FT_Byte* limit;
1006 FT_UInt count;
1007 FT_UInt idx;
1008 FT_Error error;
1009 T1_FieldType type;
1010
1011
1012 /* this also skips leading whitespace */
1013 ps_parser_to_token( parser, &token );
1014 if ( !token.type )
1015 goto Fail;
1016
1017 count = 1;
1018 idx = 0;
1019 cur = token.start;
1020 limit = token.limit;
1021
1022 type = field->type;
1023
1024 /* we must detect arrays in /FontBBox */
1025 if ( type == T1_FIELD_TYPE_BBOX )
1026 {
1027 T1_TokenRec token2;
1028 FT_Byte* old_cur = parser->cursor;
1029 FT_Byte* old_limit = parser->limit;
1030
1031
1032 /* don't include delimiters */
1033 parser->cursor = token.start + 1;
1034 parser->limit = token.limit - 1;
1035
1036 ps_parser_to_token( parser, &token2 );
1037 parser->cursor = old_cur;
1038 parser->limit = old_limit;
1039
1040 if ( token2.type == T1_TOKEN_TYPE_ARRAY )
1041 {
1042 type = T1_FIELD_TYPE_MM_BBOX;
1043 goto FieldArray;
1044 }
1045 }
1046 else if ( token.type == T1_TOKEN_TYPE_ARRAY )
1047 {
1048 count = max_objects;
1049
1050 FieldArray:
1051 /* if this is an array and we have no blend, an error occurs */
1052 if ( max_objects == 0 )
1053 goto Fail;
1054
1055 idx = 1;
1056
1057 /* don't include delimiters */
1058 cur++;
1059 limit--;
1060 }
1061
1062 for ( ; count > 0; count--, idx++ )
1063 {
1064 FT_Byte* q = (FT_Byte*)objects[idx] + field->offset;
1065 FT_Long val;
1066
1067
1068 skip_spaces( &cur, limit );
1069
1070 switch ( type )
1071 {
1072 case T1_FIELD_TYPE_BOOL:
1073 val = ps_tobool( &cur, limit );
1074 FT_TRACE4(( " %s", val ? "true" : "false" ));
1075 goto Store_Integer;
1076
1077 case T1_FIELD_TYPE_FIXED:
1078 val = PS_Conv_ToFixed( &cur, limit, 0 );
1079 FT_TRACE4(( " %f", (double)val / 65536 ));
1080 goto Store_Integer;
1081
1082 case T1_FIELD_TYPE_FIXED_1000:
1083 val = PS_Conv_ToFixed( &cur, limit, 3 );
1084 FT_TRACE4(( " %f", (double)val / 65536 / 1000 ));
1085 goto Store_Integer;
1086
1087 case T1_FIELD_TYPE_INTEGER:
1088 val = PS_Conv_ToInt( &cur, limit );
1089 FT_TRACE4(( " %ld", val ));
1090 /* fall through */
1091
1092 Store_Integer:
1093 switch ( field->size )
1094 {
1095 case (8 / FT_CHAR_BIT):
1096 *(FT_Byte*)q = (FT_Byte)val;
1097 break;
1098
1099 case (16 / FT_CHAR_BIT):
1100 *(FT_UShort*)q = (FT_UShort)val;
1101 break;
1102
1103 case (32 / FT_CHAR_BIT):
1104 *(FT_UInt32*)q = (FT_UInt32)val;
1105 break;
1106
1107 default: /* for 64-bit systems */
1108 *(FT_Long*)q = val;
1109 }
1110 break;
1111
1112 case T1_FIELD_TYPE_STRING:
1113 case T1_FIELD_TYPE_KEY:
1114 {
1115 FT_Memory memory = parser->memory;
1116 FT_UInt len = (FT_UInt)( limit - cur );
1117 FT_String* string = NULL;
1118
1119
1120 if ( cur >= limit )
1121 break;
1122
1123 /* we allow both a string or a name */
1124 /* for cases like /FontName (foo) def */
1125 if ( token.type == T1_TOKEN_TYPE_KEY )
1126 {
1127 /* don't include leading `/' */
1128 len--;
1129 cur++;
1130 }
1131 else if ( token.type == T1_TOKEN_TYPE_STRING )
1132 {
1133 /* don't include delimiting parentheses */
1134 /* XXX we don't handle <<...>> here */
1135 /* XXX should we convert octal escapes? */
1136 /* if so, what encoding should we use? */
1137 cur++;
1138 len -= 2;
1139 }
1140 else
1141 {
1142 FT_ERROR(( "ps_parser_load_field:"
1143 " expected a name or string\n" ));
1144 FT_ERROR(( " "
1145 " but found token of type %d instead\n",
1146 token.type ));
1147 error = FT_THROW( Invalid_File_Format );
1148 goto Exit;
1149 }
1150
1151 /* for this to work (FT_String**)q must have been */
1152 /* initialized to NULL */
1153 if ( *(FT_String**)q )
1154 {
1155 FT_TRACE0(( "ps_parser_load_field: overwriting field %s\n",
1156 field->ident ));
1157 FT_FREE( *(FT_String**)q );
1158 }
1159
1160 if ( FT_QALLOC( string, len + 1 ) )
1161 goto Exit;
1162
1163 FT_MEM_COPY( string, cur, len );
1164 string[len] = 0;
1165
1166 #ifdef FT_DEBUG_LEVEL_TRACE
1167 if ( token.type == T1_TOKEN_TYPE_STRING )
1168 FT_TRACE4(( " (%s)", string ));
1169 else
1170 FT_TRACE4(( " /%s", string ));
1171 #endif
1172
1173 *(FT_String**)q = string;
1174 }
1175 break;
1176
1177 case T1_FIELD_TYPE_BBOX:
1178 {
1179 FT_Fixed temp[4];
1180 FT_BBox* bbox = (FT_BBox*)q;
1181 FT_Int result;
1182
1183
1184 result = ps_tofixedarray( &cur, limit, 4, temp, 0 );
1185
1186 if ( result < 4 )
1187 {
1188 FT_ERROR(( "ps_parser_load_field:"
1189 " expected four integers in bounding box\n" ));
1190 error = FT_THROW( Invalid_File_Format );
1191 goto Exit;
1192 }
1193
1194 bbox->xMin = FT_RoundFix( temp[0] );
1195 bbox->yMin = FT_RoundFix( temp[1] );
1196 bbox->xMax = FT_RoundFix( temp[2] );
1197 bbox->yMax = FT_RoundFix( temp[3] );
1198
1199 FT_TRACE4(( " [%ld %ld %ld %ld]",
1200 bbox->xMin / 65536,
1201 bbox->yMin / 65536,
1202 bbox->xMax / 65536,
1203 bbox->yMax / 65536 ));
1204 }
1205 break;
1206
1207 case T1_FIELD_TYPE_MM_BBOX:
1208 {
1209 FT_Memory memory = parser->memory;
1210 FT_Fixed* temp = NULL;
1211 FT_Int result;
1212 FT_UInt i;
1213
1214
1215 if ( FT_QNEW_ARRAY( temp, max_objects * 4 ) )
1216 goto Exit;
1217
1218 for ( i = 0; i < 4; i++ )
1219 {
1220 result = ps_tofixedarray( &cur, limit, (FT_Int)max_objects,
1221 temp + i * max_objects, 0 );
1222 if ( result < 0 || (FT_UInt)result < max_objects )
1223 {
1224 FT_ERROR(( "ps_parser_load_field:"
1225 " expected %d integer%s in the %s subarray\n",
1226 max_objects, max_objects > 1 ? "s" : "",
1227 i == 0 ? "first"
1228 : ( i == 1 ? "second"
1229 : ( i == 2 ? "third"
1230 : "fourth" ) ) ));
1231 FT_ERROR(( " "
1232 " of /FontBBox in the /Blend dictionary\n" ));
1233 error = FT_THROW( Invalid_File_Format );
1234
1235 FT_FREE( temp );
1236 goto Exit;
1237 }
1238
1239 skip_spaces( &cur, limit );
1240 }
1241
1242 FT_TRACE4(( " [" ));
1243 for ( i = 0; i < max_objects; i++ )
1244 {
1245 FT_BBox* bbox = (FT_BBox*)objects[i];
1246
1247
1248 bbox->xMin = FT_RoundFix( temp[i ] );
1249 bbox->yMin = FT_RoundFix( temp[i + max_objects] );
1250 bbox->xMax = FT_RoundFix( temp[i + 2 * max_objects] );
1251 bbox->yMax = FT_RoundFix( temp[i + 3 * max_objects] );
1252
1253 FT_TRACE4(( " [%ld %ld %ld %ld]",
1254 bbox->xMin / 65536,
1255 bbox->yMin / 65536,
1256 bbox->xMax / 65536,
1257 bbox->yMax / 65536 ));
1258 }
1259 FT_TRACE4(( "]" ));
1260
1261 FT_FREE( temp );
1262 }
1263 break;
1264
1265 default:
1266 /* an error occurred */
1267 goto Fail;
1268 }
1269 }
1270
1271 #if 0 /* obsolete -- keep for reference */
1272 if ( pflags )
1273 *pflags |= 1L << field->flag_bit;
1274 #else
1275 FT_UNUSED( pflags );
1276 #endif
1277
1278 error = FT_Err_Ok;
1279
1280 Exit:
1281 return error;
1282
1283 Fail:
1284 error = FT_THROW( Invalid_File_Format );
1285 goto Exit;
1286 }
1287
1288
1289 #define T1_MAX_TABLE_ELEMENTS 32
1290
1291
1292 FT_LOCAL_DEF( FT_Error )
1293 ps_parser_load_field_table( PS_Parser parser,
1294 const T1_Field field,
1295 void** objects,
1296 FT_UInt max_objects,
1297 FT_ULong* pflags )
1298 {
1299 T1_TokenRec elements[T1_MAX_TABLE_ELEMENTS];
1300 T1_Token token;
1301 FT_Int num_elements;
1302 FT_Error error = FT_Err_Ok;
1303 FT_Byte* old_cursor;
1304 FT_Byte* old_limit;
1305 T1_FieldRec fieldrec = *(T1_Field)field;
1306
1307
1308 fieldrec.type = T1_FIELD_TYPE_INTEGER;
1309 if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY ||
1310 field->type == T1_FIELD_TYPE_BBOX )
1311 fieldrec.type = T1_FIELD_TYPE_FIXED;
1312
1313 ps_parser_to_token_array( parser, elements,
1314 T1_MAX_TABLE_ELEMENTS, &num_elements );
1315 if ( num_elements < 0 )
1316 {
1317 error = FT_ERR( Ignore );
1318 goto Exit;
1319 }
1320 if ( (FT_UInt)num_elements > field->array_max )
1321 num_elements = (FT_Int)field->array_max;
1322
1323 old_cursor = parser->cursor;
1324 old_limit = parser->limit;
1325
1326 /* we store the elements count if necessary; */
1327 /* we further assume that `count_offset' can't be zero */
1328 if ( field->type != T1_FIELD_TYPE_BBOX && field->count_offset != 0 )
1329 *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) =
1330 (FT_Byte)num_elements;
1331
1332 FT_TRACE4(( " [" ));
1333
1334 /* we now load each element, adjusting the field.offset on each one */
1335 token = elements;
1336 for ( ; num_elements > 0; num_elements--, token++ )
1337 {
1338 parser->cursor = token->start;
1339 parser->limit = token->limit;
1340
1341 error = ps_parser_load_field( parser,
1342 &fieldrec,
1343 objects,
1344 max_objects,
1345 0 );
1346 if ( error )
1347 break;
1348
1349 fieldrec.offset += fieldrec.size;
1350 }
1351
1352 FT_TRACE4(( "]" ));
1353
1354 #if 0 /* obsolete -- keep for reference */
1355 if ( pflags )
1356 *pflags |= 1L << field->flag_bit;
1357 #else
1358 FT_UNUSED( pflags );
1359 #endif
1360
1361 parser->cursor = old_cursor;
1362 parser->limit = old_limit;
1363
1364 Exit:
1365 return error;
1366 }
1367
1368
1369 FT_LOCAL_DEF( FT_Long )
1370 ps_parser_to_int( PS_Parser parser )
1371 {
1372 ps_parser_skip_spaces( parser );
1373 return PS_Conv_ToInt( &parser->cursor, parser->limit );
1374 }
1375
1376
1377 /* first character must be `<' if `delimiters' is non-zero */
1378
1379 FT_LOCAL_DEF( FT_Error )
1380 ps_parser_to_bytes( PS_Parser parser,
1381 FT_Byte* bytes,
1382 FT_Offset max_bytes,
1383 FT_ULong* pnum_bytes,
1384 FT_Bool delimiters )
1385 {
1386 FT_Error error = FT_Err_Ok;
1387 FT_Byte* cur;
1388
1389
1390 ps_parser_skip_spaces( parser );
1391 cur = parser->cursor;
1392
1393 if ( cur >= parser->limit )
1394 goto Exit;
1395
1396 if ( delimiters )
1397 {
1398 if ( *cur != '<' )
1399 {
1400 FT_ERROR(( "ps_parser_to_bytes: Missing starting delimiter `<'\n" ));
1401 error = FT_THROW( Invalid_File_Format );
1402 goto Exit;
1403 }
1404
1405 cur++;
1406 }
1407
1408 *pnum_bytes = PS_Conv_ASCIIHexDecode( &cur,
1409 parser->limit,
1410 bytes,
1411 max_bytes );
1412
1413 parser->cursor = cur;
1414
1415 if ( delimiters )
1416 {
1417 if ( cur < parser->limit && *cur != '>' )
1418 {
1419 FT_ERROR(( "ps_parser_to_bytes: Missing closing delimiter `>'\n" ));
1420 error = FT_THROW( Invalid_File_Format );
1421 goto Exit;
1422 }
1423
1424 parser->cursor++;
1425 }
1426
1427 Exit:
1428 return error;
1429 }
1430
1431
1432 FT_LOCAL_DEF( FT_Fixed )
1433 ps_parser_to_fixed( PS_Parser parser,
1434 FT_Int power_ten )
1435 {
1436 ps_parser_skip_spaces( parser );
1437 return PS_Conv_ToFixed( &parser->cursor, parser->limit, power_ten );
1438 }
1439
1440
1441 FT_LOCAL_DEF( FT_Int )
1442 ps_parser_to_coord_array( PS_Parser parser,
1443 FT_Int max_coords,
1444 FT_Short* coords )
1445 {
1446 ps_parser_skip_spaces( parser );
1447 return ps_tocoordarray( &parser->cursor, parser->limit,
1448 max_coords, coords );
1449 }
1450
1451
1452 FT_LOCAL_DEF( FT_Int )
1453 ps_parser_to_fixed_array( PS_Parser parser,
1454 FT_Int max_values,
1455 FT_Fixed* values,
1456 FT_Int power_ten )
1457 {
1458 ps_parser_skip_spaces( parser );
1459 return ps_tofixedarray( &parser->cursor, parser->limit,
1460 max_values, values, power_ten );
1461 }
1462
1463
1464 #if 0
1465
1466 FT_LOCAL_DEF( FT_String* )
1467 T1_ToString( PS_Parser parser )
1468 {
1469 return ps_tostring( &parser->cursor, parser->limit, parser->memory );
1470 }
1471
1472
1473 FT_LOCAL_DEF( FT_Bool )
1474 T1_ToBool( PS_Parser parser )
1475 {
1476 return ps_tobool( &parser->cursor, parser->limit );
1477 }
1478
1479 #endif /* 0 */
1480
1481
1482 FT_LOCAL_DEF( void )
1483 ps_parser_init( PS_Parser parser,
1484 FT_Byte* base,
1485 FT_Byte* limit,
1486 FT_Memory memory )
1487 {
1488 parser->error = FT_Err_Ok;
1489 parser->base = base;
1490 parser->limit = limit;
1491 parser->cursor = base;
1492 parser->memory = memory;
1493 parser->funcs = ps_parser_funcs;
1494 }
1495
1496
1497 FT_LOCAL_DEF( void )
1498 ps_parser_done( PS_Parser parser )
1499 {
1500 FT_UNUSED( parser );
1501 }
1502
1503
1504 /*************************************************************************/
1505 /*************************************************************************/
1506 /***** *****/
1507 /***** T1 BUILDER *****/
1508 /***** *****/
1509 /*************************************************************************/
1510 /*************************************************************************/
1511
1512 /**************************************************************************
1513 *
1514 * @Function:
1515 * t1_builder_init
1516 *
1517 * @Description:
1518 * Initializes a given glyph builder.
1519 *
1520 * @InOut:
1521 * builder ::
1522 * A pointer to the glyph builder to initialize.
1523 *
1524 * @Input:
1525 * face ::
1526 * The current face object.
1527 *
1528 * size ::
1529 * The current size object.
1530 *
1531 * glyph ::
1532 * The current glyph object.
1533 *
1534 * hinting ::
1535 * Whether hinting should be applied.
1536 */
1537 FT_LOCAL_DEF( void )
1538 t1_builder_init( T1_Builder builder,
1539 FT_Face face,
1540 FT_Size size,
1541 FT_GlyphSlot glyph,
1542 FT_Bool hinting )
1543 {
1544 builder->parse_state = T1_Parse_Start;
1545 builder->load_points = 1;
1546
1547 builder->face = face;
1548 builder->glyph = glyph;
1549 builder->memory = face->memory;
1550
1551 if ( glyph )
1552 {
1553 FT_GlyphLoader loader = glyph->internal->loader;
1554
1555
1556 builder->loader = loader;
1557 builder->base = &loader->base.outline;
1558 builder->current = &loader->current.outline;
1559 FT_GlyphLoader_Rewind( loader );
1560
1561 builder->hints_globals = size->internal->module_data;
1562 builder->hints_funcs = NULL;
1563
1564 if ( hinting )
1565 builder->hints_funcs = glyph->internal->glyph_hints;
1566 }
1567
1568 builder->pos_x = 0;
1569 builder->pos_y = 0;
1570
1571 builder->left_bearing.x = 0;
1572 builder->left_bearing.y = 0;
1573 builder->advance.x = 0;
1574 builder->advance.y = 0;
1575
1576 builder->funcs = t1_builder_funcs;
1577 }
1578
1579
1580 /**************************************************************************
1581 *
1582 * @Function:
1583 * t1_builder_done
1584 *
1585 * @Description:
1586 * Finalizes a given glyph builder. Its contents can still be used
1587 * after the call, but the function saves important information
1588 * within the corresponding glyph slot.
1589 *
1590 * @Input:
1591 * builder ::
1592 * A pointer to the glyph builder to finalize.
1593 */
1594 FT_LOCAL_DEF( void )
1595 t1_builder_done( T1_Builder builder )
1596 {
1597 FT_GlyphSlot glyph = builder->glyph;
1598
1599
1600 if ( glyph )
1601 glyph->outline = *builder->base;
1602 }
1603
1604
1605 /* check that there is enough space for `count' more points */
1606 FT_LOCAL_DEF( FT_Error )
1607 t1_builder_check_points( T1_Builder builder,
1608 FT_Int count )
1609 {
1610 return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
1611 }
1612
1613
1614 /* add a new point, do not check space */
1615 FT_LOCAL_DEF( void )
1616 t1_builder_add_point( T1_Builder builder,
1617 FT_Pos x,
1618 FT_Pos y,
1619 FT_Byte flag )
1620 {
1621 FT_Outline* outline = builder->current;
1622
1623
1624 if ( builder->load_points )
1625 {
1626 FT_Vector* point = outline->points + outline->n_points;
1627 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
1628
1629
1630 point->x = FIXED_TO_INT( x );
1631 point->y = FIXED_TO_INT( y );
1632 *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
1633 }
1634 outline->n_points++;
1635 }
1636
1637
1638 /* check space for a new on-curve point, then add it */
1639 FT_LOCAL_DEF( FT_Error )
1640 t1_builder_add_point1( T1_Builder builder,
1641 FT_Pos x,
1642 FT_Pos y )
1643 {
1644 FT_Error error;
1645
1646
1647 error = t1_builder_check_points( builder, 1 );
1648 if ( !error )
1649 t1_builder_add_point( builder, x, y, 1 );
1650
1651 return error;
1652 }
1653
1654
1655 /* check space for a new contour, then add it */
1656 FT_LOCAL_DEF( FT_Error )
1657 t1_builder_add_contour( T1_Builder builder )
1658 {
1659 FT_Outline* outline = builder->current;
1660 FT_Error error;
1661
1662
1663 /* this might happen in invalid fonts */
1664 if ( !outline )
1665 {
1666 FT_ERROR(( "t1_builder_add_contour: no outline to add points to\n" ));
1667 return FT_THROW( Invalid_File_Format );
1668 }
1669
1670 if ( !builder->load_points )
1671 {
1672 outline->n_contours++;
1673 return FT_Err_Ok;
1674 }
1675
1676 error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
1677 if ( !error )
1678 {
1679 if ( outline->n_contours > 0 )
1680 outline->contours[outline->n_contours - 1] =
1681 (short)( outline->n_points - 1 );
1682
1683 outline->n_contours++;
1684 }
1685
1686 return error;
1687 }
1688
1689
1690 /* if a path was begun, add its first on-curve point */
1691 FT_LOCAL_DEF( FT_Error )
1692 t1_builder_start_point( T1_Builder builder,
1693 FT_Pos x,
1694 FT_Pos y )
1695 {
1696 FT_Error error = FT_ERR( Invalid_File_Format );
1697
1698
1699 /* test whether we are building a new contour */
1700
1701 if ( builder->parse_state == T1_Parse_Have_Path )
1702 error = FT_Err_Ok;
1703 else
1704 {
1705 builder->parse_state = T1_Parse_Have_Path;
1706 error = t1_builder_add_contour( builder );
1707 if ( !error )
1708 error = t1_builder_add_point1( builder, x, y );
1709 }
1710
1711 return error;
1712 }
1713
1714
1715 /* close the current contour */
1716 FT_LOCAL_DEF( void )
1717 t1_builder_close_contour( T1_Builder builder )
1718 {
1719 FT_Outline* outline = builder->current;
1720 FT_Int first;
1721
1722
1723 if ( !outline )
1724 return;
1725
1726 first = outline->n_contours <= 1
1727 ? 0 : outline->contours[outline->n_contours - 2] + 1;
1728
1729 /* in malformed fonts it can happen that a contour was started */
1730 /* but no points were added */
1731 if ( outline->n_contours && first == outline->n_points )
1732 {
1733 outline->n_contours--;
1734 return;
1735 }
1736
1737 /* We must not include the last point in the path if it */
1738 /* is located on the first point. */
1739 if ( outline->n_points > 1 )
1740 {
1741 FT_Vector* p1 = outline->points + first;
1742 FT_Vector* p2 = outline->points + outline->n_points - 1;
1743 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
1744
1745
1746 /* `delete' last point only if it coincides with the first */
1747 /* point and it is not a control point (which can happen). */
1748 if ( p1->x == p2->x && p1->y == p2->y )
1749 if ( *control == FT_CURVE_TAG_ON )
1750 outline->n_points--;
1751 }
1752
1753 if ( outline->n_contours > 0 )
1754 {
1755 /* Don't add contours only consisting of one point, i.e., */
1756 /* check whether the first and the last point is the same. */
1757 if ( first == outline->n_points - 1 )
1758 {
1759 outline->n_contours--;
1760 outline->n_points--;
1761 }
1762 else
1763 outline->contours[outline->n_contours - 1] =
1764 (short)( outline->n_points - 1 );
1765 }
1766 }
1767
1768
1769 /*************************************************************************/
1770 /*************************************************************************/
1771 /***** *****/
1772 /***** CFF BUILDER *****/
1773 /***** *****/
1774 /*************************************************************************/
1775 /*************************************************************************/
1776
1777
1778 /**************************************************************************
1779 *
1780 * @Function:
1781 * cff_builder_init
1782 *
1783 * @Description:
1784 * Initializes a given glyph builder.
1785 *
1786 * @InOut:
1787 * builder ::
1788 * A pointer to the glyph builder to initialize.
1789 *
1790 * @Input:
1791 * face ::
1792 * The current face object.
1793 *
1794 * size ::
1795 * The current size object.
1796 *
1797 * glyph ::
1798 * The current glyph object.
1799 *
1800 * hinting ::
1801 * Whether hinting is active.
1802 */
1803 FT_LOCAL_DEF( void )
1804 cff_builder_init( CFF_Builder* builder,
1805 TT_Face face,
1806 CFF_Size size,
1807 CFF_GlyphSlot glyph,
1808 FT_Bool hinting )
1809 {
1810 builder->path_begun = 0;
1811 builder->load_points = 1;
1812
1813 builder->face = face;
1814 builder->glyph = glyph;
1815 builder->memory = face->root.memory;
1816
1817 if ( glyph )
1818 {
1819 FT_GlyphLoader loader = glyph->root.internal->loader;
1820
1821
1822 builder->loader = loader;
1823 builder->base = &loader->base.outline;
1824 builder->current = &loader->current.outline;
1825 FT_GlyphLoader_Rewind( loader );
1826
1827 builder->hints_globals = NULL;
1828 builder->hints_funcs = NULL;
1829
1830 if ( hinting && size )
1831 {
1832 FT_Size ftsize = FT_SIZE( size );
1833 CFF_Internal internal = (CFF_Internal)ftsize->internal->module_data;
1834
1835 if ( internal )
1836 {
1837 builder->hints_globals = (void *)internal->topfont;
1838 builder->hints_funcs = glyph->root.internal->glyph_hints;
1839 }
1840 }
1841 }
1842
1843 builder->pos_x = 0;
1844 builder->pos_y = 0;
1845
1846 builder->left_bearing.x = 0;
1847 builder->left_bearing.y = 0;
1848 builder->advance.x = 0;
1849 builder->advance.y = 0;
1850
1851 builder->funcs = cff_builder_funcs;
1852 }
1853
1854
1855 /**************************************************************************
1856 *
1857 * @Function:
1858 * cff_builder_done
1859 *
1860 * @Description:
1861 * Finalizes a given glyph builder. Its contents can still be used
1862 * after the call, but the function saves important information
1863 * within the corresponding glyph slot.
1864 *
1865 * @Input:
1866 * builder ::
1867 * A pointer to the glyph builder to finalize.
1868 */
1869 FT_LOCAL_DEF( void )
1870 cff_builder_done( CFF_Builder* builder )
1871 {
1872 CFF_GlyphSlot glyph = builder->glyph;
1873
1874
1875 if ( glyph )
1876 glyph->root.outline = *builder->base;
1877 }
1878
1879
1880 /* check that there is enough space for `count' more points */
1881 FT_LOCAL_DEF( FT_Error )
1882 cff_check_points( CFF_Builder* builder,
1883 FT_Int count )
1884 {
1885 return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
1886 }
1887
1888
1889 /* add a new point, do not check space */
1890 FT_LOCAL_DEF( void )
1891 cff_builder_add_point( CFF_Builder* builder,
1892 FT_Pos x,
1893 FT_Pos y,
1894 FT_Byte flag )
1895 {
1896 FT_Outline* outline = builder->current;
1897
1898
1899 if ( builder->load_points )
1900 {
1901 FT_Vector* point = outline->points + outline->n_points;
1902 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
1903
1904 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1905 PS_Driver driver = (PS_Driver)FT_FACE_DRIVER( builder->face );
1906
1907
1908 if ( driver->hinting_engine == FT_HINTING_FREETYPE )
1909 {
1910 point->x = x >> 16;
1911 point->y = y >> 16;
1912 }
1913 else
1914 #endif
1915 {
1916 /* cf2_decoder_parse_charstrings uses 16.16 coordinates */
1917 point->x = x >> 10;
1918 point->y = y >> 10;
1919 }
1920 *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
1921 }
1922
1923 outline->n_points++;
1924 }
1925
1926
1927 /* check space for a new on-curve point, then add it */
1928 FT_LOCAL_DEF( FT_Error )
1929 cff_builder_add_point1( CFF_Builder* builder,
1930 FT_Pos x,
1931 FT_Pos y )
1932 {
1933 FT_Error error;
1934
1935
1936 error = cff_check_points( builder, 1 );
1937 if ( !error )
1938 cff_builder_add_point( builder, x, y, 1 );
1939
1940 return error;
1941 }
1942
1943
1944 /* check space for a new contour, then add it */
1945 FT_LOCAL_DEF( FT_Error )
1946 cff_builder_add_contour( CFF_Builder* builder )
1947 {
1948 FT_Outline* outline = builder->current;
1949 FT_Error error;
1950
1951
1952 if ( !builder->load_points )
1953 {
1954 outline->n_contours++;
1955 return FT_Err_Ok;
1956 }
1957
1958 error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
1959 if ( !error )
1960 {
1961 if ( outline->n_contours > 0 )
1962 outline->contours[outline->n_contours - 1] =
1963 (short)( outline->n_points - 1 );
1964
1965 outline->n_contours++;
1966 }
1967
1968 return error;
1969 }
1970
1971
1972 /* if a path was begun, add its first on-curve point */
1973 FT_LOCAL_DEF( FT_Error )
1974 cff_builder_start_point( CFF_Builder* builder,
1975 FT_Pos x,
1976 FT_Pos y )
1977 {
1978 FT_Error error = FT_Err_Ok;
1979
1980
1981 /* test whether we are building a new contour */
1982 if ( !builder->path_begun )
1983 {
1984 builder->path_begun = 1;
1985 error = cff_builder_add_contour( builder );
1986 if ( !error )
1987 error = cff_builder_add_point1( builder, x, y );
1988 }
1989
1990 return error;
1991 }
1992
1993
1994 /* close the current contour */
1995 FT_LOCAL_DEF( void )
1996 cff_builder_close_contour( CFF_Builder* builder )
1997 {
1998 FT_Outline* outline = builder->current;
1999 FT_Int first;
2000
2001
2002 if ( !outline )
2003 return;
2004
2005 first = outline->n_contours <= 1
2006 ? 0 : outline->contours[outline->n_contours - 2] + 1;
2007
2008 /* in malformed fonts it can happen that a contour was started */
2009 /* but no points were added */
2010 if ( outline->n_contours && first == outline->n_points )
2011 {
2012 outline->n_contours--;
2013 return;
2014 }
2015
2016 /* We must not include the last point in the path if it */
2017 /* is located on the first point. */
2018 if ( outline->n_points > 1 )
2019 {
2020 FT_Vector* p1 = outline->points + first;
2021 FT_Vector* p2 = outline->points + outline->n_points - 1;
2022 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
2023
2024
2025 /* `delete' last point only if it coincides with the first */
2026 /* point and if it is not a control point (which can happen). */
2027 if ( p1->x == p2->x && p1->y == p2->y )
2028 if ( *control == FT_CURVE_TAG_ON )
2029 outline->n_points--;
2030 }
2031
2032 if ( outline->n_contours > 0 )
2033 {
2034 /* Don't add contours only consisting of one point, i.e., */
2035 /* check whether begin point and last point are the same. */
2036 if ( first == outline->n_points - 1 )
2037 {
2038 outline->n_contours--;
2039 outline->n_points--;
2040 }
2041 else
2042 outline->contours[outline->n_contours - 1] =
2043 (short)( outline->n_points - 1 );
2044 }
2045 }
2046
2047
2048 /*************************************************************************/
2049 /*************************************************************************/
2050 /***** *****/
2051 /***** PS BUILDER *****/
2052 /***** *****/
2053 /*************************************************************************/
2054 /*************************************************************************/
2055
2056 /**************************************************************************
2057 *
2058 * @Function:
2059 * ps_builder_init
2060 *
2061 * @Description:
2062 * Initializes a given glyph builder.
2063 *
2064 * @InOut:
2065 * builder ::
2066 * A pointer to the glyph builder to initialize.
2067 *
2068 * @Input:
2069 * face ::
2070 * The current face object.
2071 *
2072 * size ::
2073 * The current size object.
2074 *
2075 * glyph ::
2076 * The current glyph object.
2077 *
2078 * hinting ::
2079 * Whether hinting should be applied.
2080 */
2081 FT_LOCAL_DEF( void )
2082 ps_builder_init( PS_Builder* ps_builder,
2083 void* builder,
2084 FT_Bool is_t1 )
2085 {
2086 FT_ZERO( ps_builder );
2087
2088 if ( is_t1 )
2089 {
2090 T1_Builder t1builder = (T1_Builder)builder;
2091
2092
2093 ps_builder->memory = t1builder->memory;
2094 ps_builder->face = (FT_Face)t1builder->face;
2095 ps_builder->glyph = (CFF_GlyphSlot)t1builder->glyph;
2096 ps_builder->loader = t1builder->loader;
2097 ps_builder->base = t1builder->base;
2098 ps_builder->current = t1builder->current;
2099
2100 ps_builder->pos_x = &t1builder->pos_x;
2101 ps_builder->pos_y = &t1builder->pos_y;
2102
2103 ps_builder->left_bearing = &t1builder->left_bearing;
2104 ps_builder->advance = &t1builder->advance;
2105
2106 ps_builder->bbox = &t1builder->bbox;
2107 ps_builder->path_begun = 0;
2108 ps_builder->load_points = t1builder->load_points;
2109 ps_builder->no_recurse = t1builder->no_recurse;
2110
2111 ps_builder->metrics_only = t1builder->metrics_only;
2112 }
2113 else
2114 {
2115 CFF_Builder* cffbuilder = (CFF_Builder*)builder;
2116
2117
2118 ps_builder->memory = cffbuilder->memory;
2119 ps_builder->face = (FT_Face)cffbuilder->face;
2120 ps_builder->glyph = cffbuilder->glyph;
2121 ps_builder->loader = cffbuilder->loader;
2122 ps_builder->base = cffbuilder->base;
2123 ps_builder->current = cffbuilder->current;
2124
2125 ps_builder->pos_x = &cffbuilder->pos_x;
2126 ps_builder->pos_y = &cffbuilder->pos_y;
2127
2128 ps_builder->left_bearing = &cffbuilder->left_bearing;
2129 ps_builder->advance = &cffbuilder->advance;
2130
2131 ps_builder->bbox = &cffbuilder->bbox;
2132 ps_builder->path_begun = cffbuilder->path_begun;
2133 ps_builder->load_points = cffbuilder->load_points;
2134 ps_builder->no_recurse = cffbuilder->no_recurse;
2135
2136 ps_builder->metrics_only = cffbuilder->metrics_only;
2137 }
2138
2139 ps_builder->is_t1 = is_t1;
2140 ps_builder->funcs = ps_builder_funcs;
2141 }
2142
2143
2144 /**************************************************************************
2145 *
2146 * @Function:
2147 * ps_builder_done
2148 *
2149 * @Description:
2150 * Finalizes a given glyph builder. Its contents can still be used
2151 * after the call, but the function saves important information
2152 * within the corresponding glyph slot.
2153 *
2154 * @Input:
2155 * builder ::
2156 * A pointer to the glyph builder to finalize.
2157 */
2158 FT_LOCAL_DEF( void )
2159 ps_builder_done( PS_Builder* builder )
2160 {
2161 CFF_GlyphSlot glyph = builder->glyph;
2162
2163
2164 if ( glyph )
2165 glyph->root.outline = *builder->base;
2166 }
2167
2168
2169 /* check that there is enough space for `count' more points */
2170 FT_LOCAL_DEF( FT_Error )
2171 ps_builder_check_points( PS_Builder* builder,
2172 FT_Int count )
2173 {
2174 return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
2175 }
2176
2177
2178 /* add a new point, do not check space */
2179 FT_LOCAL_DEF( void )
2180 ps_builder_add_point( PS_Builder* builder,
2181 FT_Pos x,
2182 FT_Pos y,
2183 FT_Byte flag )
2184 {
2185 FT_Outline* outline = builder->current;
2186
2187
2188 if ( builder->load_points )
2189 {
2190 FT_Vector* point = outline->points + outline->n_points;
2191 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
2192
2193 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
2194 PS_Driver driver = (PS_Driver)FT_FACE_DRIVER( builder->face );
2195
2196
2197 if ( !builder->is_t1 &&
2198 driver->hinting_engine == FT_HINTING_FREETYPE )
2199 {
2200 point->x = x >> 16;
2201 point->y = y >> 16;
2202 }
2203 else
2204 #endif
2205 #ifdef T1_CONFIG_OPTION_OLD_ENGINE
2206 #ifndef CFF_CONFIG_OPTION_OLD_ENGINE
2207 PS_Driver driver = (PS_Driver)FT_FACE_DRIVER( builder->face );
2208 #endif
2209 if ( builder->is_t1 &&
2210 driver->hinting_engine == FT_HINTING_FREETYPE )
2211 {
2212 point->x = FIXED_TO_INT( x );
2213 point->y = FIXED_TO_INT( y );
2214 }
2215 else
2216 #endif
2217 {
2218 /* cf2_decoder_parse_charstrings uses 16.16 coordinates */
2219 point->x = x >> 10;
2220 point->y = y >> 10;
2221 }
2222 *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
2223 }
2224 outline->n_points++;
2225 }
2226
2227
2228 /* check space for a new on-curve point, then add it */
2229 FT_LOCAL_DEF( FT_Error )
2230 ps_builder_add_point1( PS_Builder* builder,
2231 FT_Pos x,
2232 FT_Pos y )
2233 {
2234 FT_Error error;
2235
2236
2237 error = ps_builder_check_points( builder, 1 );
2238 if ( !error )
2239 ps_builder_add_point( builder, x, y, 1 );
2240
2241 return error;
2242 }
2243
2244
2245 /* check space for a new contour, then add it */
2246 FT_LOCAL_DEF( FT_Error )
2247 ps_builder_add_contour( PS_Builder* builder )
2248 {
2249 FT_Outline* outline = builder->current;
2250 FT_Error error;
2251
2252
2253 /* this might happen in invalid fonts */
2254 if ( !outline )
2255 {
2256 FT_ERROR(( "ps_builder_add_contour: no outline to add points to\n" ));
2257 return FT_THROW( Invalid_File_Format );
2258 }
2259
2260 if ( !builder->load_points )
2261 {
2262 outline->n_contours++;
2263 return FT_Err_Ok;
2264 }
2265
2266 error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
2267 if ( !error )
2268 {
2269 if ( outline->n_contours > 0 )
2270 outline->contours[outline->n_contours - 1] =
2271 (short)( outline->n_points - 1 );
2272
2273 outline->n_contours++;
2274 }
2275
2276 return error;
2277 }
2278
2279
2280 /* if a path was begun, add its first on-curve point */
2281 FT_LOCAL_DEF( FT_Error )
2282 ps_builder_start_point( PS_Builder* builder,
2283 FT_Pos x,
2284 FT_Pos y )
2285 {
2286 FT_Error error = FT_Err_Ok;
2287
2288
2289 /* test whether we are building a new contour */
2290 if ( !builder->path_begun )
2291 {
2292 builder->path_begun = 1;
2293 error = ps_builder_add_contour( builder );
2294 if ( !error )
2295 error = ps_builder_add_point1( builder, x, y );
2296 }
2297
2298 return error;
2299 }
2300
2301
2302 /* close the current contour */
2303 FT_LOCAL_DEF( void )
2304 ps_builder_close_contour( PS_Builder* builder )
2305 {
2306 FT_Outline* outline = builder->current;
2307 FT_Int first;
2308
2309
2310 if ( !outline )
2311 return;
2312
2313 first = outline->n_contours <= 1
2314 ? 0 : outline->contours[outline->n_contours - 2] + 1;
2315
2316 /* in malformed fonts it can happen that a contour was started */
2317 /* but no points were added */
2318 if ( outline->n_contours && first == outline->n_points )
2319 {
2320 outline->n_contours--;
2321 return;
2322 }
2323
2324 /* We must not include the last point in the path if it */
2325 /* is located on the first point. */
2326 if ( outline->n_points > 1 )
2327 {
2328 FT_Vector* p1 = outline->points + first;
2329 FT_Vector* p2 = outline->points + outline->n_points - 1;
2330 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
2331
2332
2333 /* `delete' last point only if it coincides with the first */
2334 /* point and it is not a control point (which can happen). */
2335 if ( p1->x == p2->x && p1->y == p2->y )
2336 if ( *control == FT_CURVE_TAG_ON )
2337 outline->n_points--;
2338 }
2339
2340 if ( outline->n_contours > 0 )
2341 {
2342 /* Don't add contours only consisting of one point, i.e., */
2343 /* check whether the first and the last point is the same. */
2344 if ( first == outline->n_points - 1 )
2345 {
2346 outline->n_contours--;
2347 outline->n_points--;
2348 }
2349 else
2350 outline->contours[outline->n_contours - 1] =
2351 (short)( outline->n_points - 1 );
2352 }
2353 }
2354
2355
2356 /*************************************************************************/
2357 /*************************************************************************/
2358 /***** *****/
2359 /***** OTHER *****/
2360 /***** *****/
2361 /*************************************************************************/
2362 /*************************************************************************/
2363
2364
2365 /**************************************************************************
2366 *
2367 * @Function:
2368 * ps_decoder_init
2369 *
2370 * @Description:
2371 * Creates a wrapper decoder for use in the combined
2372 * Type 1 / CFF interpreter.
2373 *
2374 * @InOut:
2375 * ps_decoder ::
2376 * A pointer to the decoder to initialize.
2377 *
2378 * @Input:
2379 * decoder ::
2380 * A pointer to the original decoder.
2381 *
2382 * is_t1 ::
2383 * Flag indicating Type 1 or CFF
2384 */
2385 FT_LOCAL_DEF( void )
2386 ps_decoder_init( PS_Decoder* ps_decoder,
2387 void* decoder,
2388 FT_Bool is_t1 )
2389 {
2390 FT_ZERO( ps_decoder );
2391
2392 if ( is_t1 )
2393 {
2394 T1_Decoder t1_decoder = (T1_Decoder)decoder;
2395
2396
2397 ps_builder_init( &ps_decoder->builder,
2398 &t1_decoder->builder,
2399 is_t1 );
2400
2401 ps_decoder->cf2_instance = &t1_decoder->cf2_instance;
2402 ps_decoder->psnames = t1_decoder->psnames;
2403
2404 ps_decoder->num_glyphs = t1_decoder->num_glyphs;
2405 ps_decoder->glyph_names = t1_decoder->glyph_names;
2406 ps_decoder->hint_mode = t1_decoder->hint_mode;
2407 ps_decoder->blend = t1_decoder->blend;
2408
2409 ps_decoder->num_locals = (FT_UInt)t1_decoder->num_subrs;
2410 ps_decoder->locals = t1_decoder->subrs;
2411 ps_decoder->locals_len = t1_decoder->subrs_len;
2412 ps_decoder->locals_hash = t1_decoder->subrs_hash;
2413
2414 ps_decoder->buildchar = t1_decoder->buildchar;
2415 ps_decoder->len_buildchar = t1_decoder->len_buildchar;
2416
2417 ps_decoder->lenIV = t1_decoder->lenIV;
2418 }
2419 else
2420 {
2421 CFF_Decoder* cff_decoder = (CFF_Decoder*)decoder;
2422
2423
2424 ps_builder_init( &ps_decoder->builder,
2425 &cff_decoder->builder,
2426 is_t1 );
2427
2428 ps_decoder->cff = cff_decoder->cff;
2429 ps_decoder->cf2_instance = &cff_decoder->cff->cf2_instance;
2430 ps_decoder->current_subfont = cff_decoder->current_subfont;
2431
2432 ps_decoder->num_globals = cff_decoder->num_globals;
2433 ps_decoder->globals = cff_decoder->globals;
2434 ps_decoder->globals_bias = cff_decoder->globals_bias;
2435 ps_decoder->num_locals = cff_decoder->num_locals;
2436 ps_decoder->locals = cff_decoder->locals;
2437 ps_decoder->locals_bias = cff_decoder->locals_bias;
2438
2439 ps_decoder->glyph_width = &cff_decoder->glyph_width;
2440 ps_decoder->width_only = cff_decoder->width_only;
2441
2442 ps_decoder->hint_mode = cff_decoder->hint_mode;
2443
2444 ps_decoder->get_glyph_callback = cff_decoder->get_glyph_callback;
2445 ps_decoder->free_glyph_callback = cff_decoder->free_glyph_callback;
2446 }
2447 }
2448
2449
2450 /* Synthesize a SubFont object for Type 1 fonts, for use in the */
2451 /* new interpreter to access Private dict data. */
2452 FT_LOCAL_DEF( void )
2453 t1_make_subfont( FT_Face face,
2454 PS_Private priv,
2455 CFF_SubFont subfont )
2456 {
2457 CFF_Private cpriv = &subfont->private_dict;
2458 FT_UInt n, count;
2459
2460
2461 FT_ZERO( subfont );
2462 FT_ZERO( cpriv );
2463
2464 count = cpriv->num_blue_values = priv->num_blue_values;
2465 for ( n = 0; n < count; n++ )
2466 cpriv->blue_values[n] = (FT_Pos)priv->blue_values[n];
2467
2468 count = cpriv->num_other_blues = priv->num_other_blues;
2469 for ( n = 0; n < count; n++ )
2470 cpriv->other_blues[n] = (FT_Pos)priv->other_blues[n];
2471
2472 count = cpriv->num_family_blues = priv->num_family_blues;
2473 for ( n = 0; n < count; n++ )
2474 cpriv->family_blues[n] = (FT_Pos)priv->family_blues[n];
2475
2476 count = cpriv->num_family_other_blues = priv->num_family_other_blues;
2477 for ( n = 0; n < count; n++ )
2478 cpriv->family_other_blues[n] = (FT_Pos)priv->family_other_blues[n];
2479
2480 cpriv->blue_scale = priv->blue_scale;
2481 cpriv->blue_shift = (FT_Pos)priv->blue_shift;
2482 cpriv->blue_fuzz = (FT_Pos)priv->blue_fuzz;
2483
2484 cpriv->standard_width = (FT_Pos)priv->standard_width[0];
2485 cpriv->standard_height = (FT_Pos)priv->standard_height[0];
2486
2487 count = cpriv->num_snap_widths = priv->num_snap_widths;
2488 for ( n = 0; n < count; n++ )
2489 cpriv->snap_widths[n] = (FT_Pos)priv->snap_widths[n];
2490
2491 count = cpriv->num_snap_heights = priv->num_snap_heights;
2492 for ( n = 0; n < count; n++ )
2493 cpriv->snap_heights[n] = (FT_Pos)priv->snap_heights[n];
2494
2495 cpriv->force_bold = priv->force_bold;
2496 cpriv->lenIV = priv->lenIV;
2497 cpriv->language_group = priv->language_group;
2498 cpriv->expansion_factor = priv->expansion_factor;
2499
2500 cpriv->subfont = subfont;
2501
2502
2503 /* Initialize the random number generator. */
2504 if ( face->internal->random_seed != -1 )
2505 {
2506 /* If we have a face-specific seed, use it. */
2507 /* If non-zero, update it to a positive value. */
2508 subfont->random = (FT_UInt32)face->internal->random_seed;
2509 if ( face->internal->random_seed )
2510 {
2511 do
2512 {
2513 face->internal->random_seed = (FT_Int32)cff_random(
2514 (FT_UInt32)face->internal->random_seed );
2515
2516 } while ( face->internal->random_seed < 0 );
2517 }
2518 }
2519 if ( !subfont->random )
2520 {
2521 FT_UInt32 seed;
2522
2523
2524 /* compute random seed from some memory addresses */
2525 seed = (FT_UInt32)( (FT_Offset)(char*)&seed ^
2526 (FT_Offset)(char*)&face ^
2527 (FT_Offset)(char*)&subfont );
2528 seed = seed ^ ( seed >> 10 ) ^ ( seed >> 20 );
2529 if ( seed == 0 )
2530 seed = 0x7384;
2531
2532 subfont->random = seed;
2533 }
2534 }
2535
2536
2537 FT_LOCAL_DEF( void )
2538 t1_decrypt( FT_Byte* buffer,
2539 FT_Offset length,
2540 FT_UShort seed )
2541 {
2542 PS_Conv_EexecDecode( &buffer,
2543 FT_OFFSET( buffer, length ),
2544 buffer,
2545 length,
2546 &seed );
2547 }
2548
2549
2550 FT_LOCAL_DEF( FT_UInt32 )
2551 cff_random( FT_UInt32 r )
2552 {
2553 /* a 32bit version of the `xorshift' algorithm */
2554 r ^= r << 13;
2555 r ^= r >> 17;
2556 r ^= r << 5;
2557
2558 return r;
2559 }
2560
2561
2562 /* END */