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