]> git.saurik.com Git - wxWidgets.git/blame - src/freetype/type1/t1load.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fixes to client area origin handling
[wxWidgets.git] / src / freetype / type1 / t1load.c
CommitLineData
cabec872
RR		 1/***************************************************************************/
2/* */
3/* t1load.c */
4/* */
5/* Type 1 font loader (body). */
6/* */
7/* Copyright 1996-2000 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/config/ftconfig.h>
20#include <freetype/internal/ftdebug.h>
21#include <freetype/internal/t1types.h>
22
23
24#ifdef FT_FLAT_COMPILE
25
26#include "t1tokens.h"
27#include "t1parse.h"
28
29#else
30
31#include <type1/t1tokens.h>
32#include <type1/t1parse.h>
33
34#endif
35
36
37#include <stdio.h>
38
39#include <string.h> /* for strncpy(), strncmp(), strlen() */
40
41
42 /*************************************************************************/
43 /* */
44 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
45 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
46 /* messages during execution. */
47 /* */
48#undef FT_COMPONENT
49#define FT_COMPONENT trace_t1load
50
51
52 typedef FT_Error (*T1_Parse_Func)( T1_Parser* parser );
53
54
55 /*************************************************************************/
56 /* */
57 /* <Function> */
58 /* Init_T1_Parser */
59 /* */
60 /* <Description> */
61 /* Initializes a given parser object to build a given T1_Face. */
62 /* */
63 /* <InOut> */
64 /* parser :: A handle to the newly built parser object. */
65 /* */
66 /* <Input> */
67 /* face :: A handle to the target Type 1 face object. */
68 /* */
69 /* tokenizer :: A handle to the target Type 1 token manager. */
70 /* */
71 LOCAL_FUNC
72 void Init_T1_Parser( T1_Parser* parser,
73 T1_Face face,
74 T1_Tokenizer tokenizer )
75 {
76 parser->error = 0;
77 parser->face = face;
78 parser->tokenizer = tokenizer;
79 parser->top = parser->stack;
80 parser->limit = parser->stack + T1_MAX_STACK_DEPTH;
81
82 parser->state_index = 0;
83 parser->state_stack[0] = dict_none;
84
85 parser->encoding_type = t1_encoding_none;
86 parser->encoding_names = 0;
87 parser->encoding_offsets = 0;
88 parser->encoding_lengths = 0;
89
90 parser->dump_tokens = 0;
91 face->type1.private_dict.lenIV = 4; /* XXX : is it sure? */
92 }
93
94
95 /*************************************************************************/
96 /* */
97 /* <Function> */
98 /* Next_T1_Token */
99 /* */
100 /* <Description> */
101 /* Grabs the next significant token from a parser's input stream. */
102 /* This function ignores a number of tokens, and translates */
103 /* alternate forms into their common ones. */
104 /* */
105 /* <Input> */
106 /* parser :: A handle to the source parser. */
107 /* */
108 /* <Output> */
109 /* token :: The extracted token descriptor. */
110 /* */
111 /* <Return> */
112 /* FreeTyoe error code. 0 means success. */
113 /* */
114 LOCAL_FUNC
115 FT_Error Next_T1_Token( T1_Parser* parser,
116 T1_Token* token )
117 {
118 FT_Error error;
119 T1_Tokenizer tokzer = parser->tokenizer;
120
121
122 L1:
123 error = Read_Token( tokzer );
124 if ( error )
125 return error;
126
127 /* we now must ignore a number of tokens like `dup', `executeonly', */
128 /* `readonly', etc. */
129 *token = tokzer->token;
130 if ( token->kind == tok_keyword )
131 switch( token->kind2 )
132 {
133 case key_dup:
134 case key_execonly:
135 case key_readonly:
136 case key_noaccess:
137 case key_userdict:
138 /* do nothing - loop */
139 goto L1;
140
141 /* we also translate some other keywords from their alternative */
142 /* to their `normal' form */
143
144 case key_NP_alternate:
145 token->kind2 = key_NP;
146 break;
147
148 case key_RD_alternate:
149 token->kind2 = key_RD;
150 break;
151
152 case key_ND_alternate:
153 token->kind2 = key_ND;
154 break;
155
156 default:
157 ;
158 }
159
160#if defined( FT_DEBUG_LEVEL_ERROR ) || defined( FT_DEBUG_LEVEL_TRACE )
161
162 /* Dump the token when requested. This feature is only available */
163 /* in the `error' and `trace' debug levels. */
164 if ( parser->dump_tokens )
165 {
166 FT_String temp_string[128];
167 FT_Int len;
168
169
170 len = token->len;
171 if ( len > 127 )
172 len = 127;
173 strncpy( temp_string,
174 (FT_String*)tokzer->base + token->start,
175 len );
176 temp_string[len] = '\0';
177 FT_ERROR(( "%s\n", temp_string ));
178 }
179
180#endif /* FT_DEBUG_LEVEL_ERROR or FT_DEBUG_LEVEL_TRACE */
181
182 return T1_Err_Ok;
183 }
184
185
186 static
187 FT_Error Expect_Keyword( T1_Parser* parser,
188 T1_TokenType keyword )
189 {
190 T1_Token token;
191 FT_Error error;
192
193
194 error = Next_T1_Token( parser, &token );
195 if ( error )
196 goto Exit;
197
198 if ( token.kind != tok_keyword ||
199 token.kind2 != keyword )
200 {
201 error = T1_Err_Syntax_Error;
202 FT_ERROR(( "Expect_Keyword: keyword `%s' expected.\n",
203 t1_keywords[keyword - key_first_] ));
204 }
205
206 Exit:
207 return error;
208 }
209
210
211 static
212 FT_Error Expect_Keyword2( T1_Parser* parser,
213 T1_TokenType keyword1,
214 T1_TokenType keyword2 )
215 {
216 T1_Token token;
217 FT_Error error;
218
219
220 error = Next_T1_Token( parser, &token );
221 if ( error )
222 goto Exit;
223
224 if ( token.kind != tok_keyword ||
225 ( token.kind2 != keyword1 &&
226 token.kind2 != keyword2 ) )
227 {
228 error = T1_Err_Syntax_Error;
229 FT_ERROR(( "Expect_Keyword2: keyword `%s' or `%s' expected.\n",
230 t1_keywords[keyword1 - key_first_],
231 t1_keywords[keyword2 - key_first_] ));
232 }
233
234 Exit:
235 return error;
236 }
237
238
239 static
240 void Parse_Encoding( T1_Parser* parser )
241 {
242 T1_Token* token = parser->top+1;
243 FT_Memory memory = parser->face->root.memory;
244 T1_Encoding* encode = &parser->face->type1.encoding;
245 FT_Error error = 0;
246
247
248 if ( token->kind == tok_keyword &&
249 ( token->kind2 == key_StandardEncoding ||
250 token->kind2 == key_ExpertEncoding ) )
251 {
252 encode->num_chars = 256;
253 encode->code_first = 32;
254 encode->code_last = 255;
255
256 if ( ALLOC_ARRAY( encode->char_index, 256, FT_Short ) )
257 goto Exit;
258
259 encode->char_name = 0; /* no need to store glyph names */
260
261 /* Now copy the encoding */
262 switch ( token->kind2 )
263 {
264 case key_ExpertEncoding:
265 parser->encoding_type = t1_encoding_expert;
266 break;
267
268 default:
269 parser->encoding_type = t1_encoding_standard;
270 break;
271 }
272 }
273 else
274 {
275 FT_ERROR(( "Parse_Encoding: invalid encoding type\n" ));
276 error = T1_Err_Syntax_Error;
277 }
278
279 Exit:
280 parser->error = error;
281 }
282
283
284 /*************************************************************************/
285 /* */
286 /* */
287 /* IMPLEMENTATION OF THE `DEF' KEYWORD DEPENDING ON */
288 /* CURRENT DICTIONARY STATE */
289 /* */
290 /* */
291 /*************************************************************************/
292
293
294 /*************************************************************************/
295 /* */
296 /* <Function> */
297 /* Do_Def_Font */
298 /* */
299 /* <Description> */
300 /* This function performs a `def' if in the Font dictionary. Its */
301 /* purpose is to build the T1_Face attributes directly from the */
302 /* stream. */
303 /* */
304 /* <InOut> */
305 /* parser :: A handle to the current parser. */
306 /* */
307 /* <Return> */
308 /* FreeType error code. 0 means success. */
309 /* */
310 static
311 FT_Error Do_Def_Font( T1_Parser* parser )
312 {
313 T1_Token* top = parser->top;
314 T1_Face face = parser->face;
315 T1_Font* type1 = &face->type1;
316
317
318 switch ( top[0].kind2 )
319 {
320 case imm_FontName:
321 /* in some cases, the /FontName is an immediate like */
322 /* /TimesNewRoman. In this case, we simply copy the */
323 /* token string (without the /). */
324 if ( top[1].kind == tok_immediate )
325 {
326 FT_Memory memory = parser->tokenizer->memory;
327 FT_Error error;
328 FT_Int len = top[1].len;
329
330
331 if ( ALLOC( type1->font_name, len + 1 ) )
332 {
333 parser->error = error;
334 return error;
335 }
336
337 MEM_Copy( type1->font_name,
338 parser->tokenizer->base + top[1].start,
339 len );
340 type1->font_name[len] = '\0';
341 }
342 else
343 type1->font_name = CopyString( parser );
344 break;
345
346 case imm_Encoding:
347 Parse_Encoding( parser );
348 break;
349
350 case imm_PaintType:
351 type1->paint_type = (FT_Byte)CopyInteger( parser );
352 break;
353
354 case imm_FontType:
355 type1->font_type = (FT_Byte)CopyInteger( parser );
356 break;
357
358 case imm_FontMatrix:
359 CopyMatrix( parser, &type1->font_matrix );
360 break;
361
362 case imm_FontBBox:
363 CopyBBox( parser, &type1->font_bbox );
364 break;
365
366 case imm_UniqueID:
367 type1->private_dict.unique_id = CopyInteger( parser );
368 break;
369
370 case imm_StrokeWidth:
371 type1->stroke_width = CopyInteger( parser );
372 break;
373
374 case imm_FontID:
375 type1->font_id = CopyInteger( parser );
376 break;
377
378 default:
379 /* ignore all other things */
380 parser->error = T1_Err_Ok;
381 }
382
383 return parser->error;
384 }
385
386
387 /*************************************************************************/
388 /* */
389 /* <Function> */
390 /* Do_Def_FontInfo */
391 /* */
392 /* <Description> */
393 /* This function performs a `def' if in the FontInfo dictionary. Its */
394 /* purpose is to build the T1_FontInfo structure directly from the */
395 /* stream. */
396 /* */
397 /* <InOut> */
398 /* parser :: A handle to the current parser. */
399 /* */
400 /* <Return> */
401 /* FreeTyoe error code. 0 means success. */
402 /* */
403 static
404 FT_Error Do_Def_FontInfo( T1_Parser* parser )
405 {
406 T1_Token* top = parser->top;
407 T1_FontInfo* info = &parser->face->type1.font_info;
408
409
410 switch ( top[0].kind2 )
411 {
412 case imm_version:
413 info->version = CopyString( parser );
414 break;
415
416 case imm_Notice:
417 info->notice = CopyString( parser );
418 break;
419
420 case imm_FullName:
421 info->full_name = CopyString( parser );
422 break;
423
424 case imm_FamilyName:
425 info->family_name = CopyString( parser );
426 break;
427
428 case imm_Weight:
429 info->weight = CopyString( parser );
430 break;
431
432 case imm_ItalicAngle:
433 info->italic_angle = CopyInteger( parser );
434 break;
435
436 case imm_isFixedPitch:
437 info->is_fixed_pitch = CopyBoolean( parser );
438 break;
439
440 case imm_UnderlinePosition:
441 info->underline_position = (FT_Short)CopyInteger( parser );
442 break;
443
444 case imm_UnderlineThickness:
445 info->underline_thickness = (FT_Short)CopyInteger( parser );
446 break;
447
448 default:
449 /* ignore all other things */
450 parser->error = T1_Err_Ok;
451 }
452
453 return parser->error;
454 }
455
456
457 /*************************************************************************/
458 /* */
459 /* <Function> */
460 /* Do_Def_Private */
461 /* */
462 /* <Description> */
463 /* This function performs a `def' if in the Private dictionary. Its */
464 /* purpose is to build the T1_Private structure directly from the */
465 /* stream. */
466 /* */
467 /* <InOut> */
468 /* parser :: A handle to the current parser. */
469 /* */
470 /* <Return> */
471 /* FreeTyoe error code. 0 means success. */
472 /* */
473 static
474 FT_Error Do_Def_Private( T1_Parser* parser )
475 {
476 T1_Token* top = parser->top;
477 T1_Private* priv = &parser->face->type1.private_dict;
478
479
480 switch ( top[0].kind2 )
481 {
482 /* Ignore the definitions of RD, NP, ND, and their alternate forms */
483 case imm_RD:
484 case imm_RD_alternate:
485 case imm_ND:
486 case imm_ND_alternate:
487 case imm_NP:
488 case imm_NP_alternate:
489 parser->error = T1_Err_Ok;
490 break;
491
492 case imm_BlueValues:
493 CopyArray( parser, &priv->num_blue_values,
494 priv->blue_values, 14 );
495 break;
496
497 case imm_OtherBlues:
498 CopyArray( parser, &priv->num_other_blues,
499 priv->other_blues, 10 );
500 break;
501
502 case imm_FamilyBlues:
503 CopyArray( parser, &priv->num_family_blues,
504 priv->family_blues, 14 );
505 break;
506
507 case imm_FamilyOtherBlues:
508 CopyArray( parser, &priv->num_family_other_blues,
509 priv->family_other_blues, 10 );
510 break;
511
512 case imm_BlueScale:
513 priv->blue_scale = CopyFloat( parser, 0x10000L );
514 break;
515
516 case imm_BlueShift:
517 priv->blue_shift = CopyInteger( parser );
518 break;
519
520 case imm_BlueFuzz:
521 priv->blue_fuzz = CopyInteger( parser );
522 break;
523
524 case imm_StdHW:
525 CopyArray( parser, 0, (FT_Short*)&priv->standard_width, 1 );
526 break;
527
528 case imm_StdVW:
529 CopyArray( parser, 0, (FT_Short*)&priv->standard_height, 1 );
530 break;
531
532 case imm_StemSnapH:
533 CopyArray( parser, &priv->num_snap_widths,
534 priv->snap_widths, 12 );
535 break;
536
537 case imm_StemSnapV:
538 CopyArray( parser, &priv->num_snap_heights,
539 priv->snap_heights, 12 );
540 break;
541
542 case imm_ForceBold:
543 priv->force_bold = CopyBoolean( parser );
544 break;
545
546 case imm_LanguageGroup:
547 priv->language_group = CopyInteger( parser );
548 break;
549
550 case imm_password:
551 priv->password = CopyInteger( parser );
552 break;
553
554 case imm_UniqueID:
555 priv->unique_id = CopyInteger( parser );
556 break;
557
558 case imm_lenIV:
559 priv->lenIV = CopyInteger( parser );
560 break;
561
562 case imm_MinFeature:
563 CopyArray( parser, 0, priv->min_feature, 2 );
564 break;
565
566 default:
567 /* ignore all other things */
568 parser->error = T1_Err_Ok;
569 }
570
571 return parser->error;
572 }
573
574
575 /*************************************************************************/
576 /* */
577 /* <Function> */
578 /* Do_Def_Error */
579 /* */
580 /* <Description> */
581 /* This function returns a simple syntax error when invoked. It is */
582 /* used for the `def' keyword if in the `encoding', `subrs', */
583 /* `othersubrs', and `charstrings' dictionary states. */
584 /* */
585 /* <InOut> */
586 /* parser :: A handle to the current parser. */
587 /* */
588 /* <Return> */
589 /* FreeType error code. 0 means success. */
590 /* */
591 static
592 FT_Error Do_Def_Error( T1_Parser* parser )
593 {
594 FT_ERROR(( "Do_Def_Error:" ));
595 FT_ERROR(( " `def' keyword encountered in bad dictionary/array\n" ));
596
597 parser->error = T1_Err_Syntax_Error;
598
599 return parser->error;
600 }
601
602
603 static
604 FT_Error Do_Def_Ignore( T1_Parser* parser )
605 {
606 FT_UNUSED( parser );
607 return T1_Err_Ok;
608 }
609
610
611 static
612 T1_Parse_Func def_funcs[dict_max] =
613 {
614 Do_Def_Error,
615 Do_Def_Font,
616 Do_Def_FontInfo,
617 Do_Def_Ignore,
618 Do_Def_Private,
619 Do_Def_Ignore,
620 Do_Def_Ignore,
621 Do_Def_Ignore,
622 Do_Def_Ignore,
623 Do_Def_Ignore,
624 Do_Def_Ignore,
625 };
626
627
628 /*************************************************************************/
629 /* */
630 /* */
631 /* IMPLEMENTATION OF THE `PUT' KEYWORD DEPENDING ON */
632 /* CURRENT DICTIONARY STATE */
633 /* */
634 /* */
635 /*************************************************************************/
636
637
638 /*************************************************************************/
639 /* */
640 /* <Function> */
641 /* Do_Put_Encoding */
642 /* */
643 /* <Description> */
644 /* This function performs a `put' if in the Encoding array. The */
645 /* glyph name is copied into the T1 recorder, and the charcode and */
646 /* glyph name pointer are written into the face object encoding. */
647 /* */
648 /* <InOut> */
649 /* parser :: A handle to the current parser. */
650 /* */
651 /* <Return> */
652 /* FreeType error code. 0 means success. */
653 /* */
654 static
655 FT_Error Do_Put_Encoding( T1_Parser* parser )
656 {
657 FT_Error error = T1_Err_Ok;
658 T1_Face face = parser->face;
659 T1_Token* top = parser->top;
660 T1_Encoding* encode = &face->type1.encoding;
661 FT_Int index;
662
663
664 /* record and check the character code */
665 if ( top[0].kind != tok_number )
666 {
667 FT_TRACE4(( "Do_Put_Encoding: number expected\n" ));
668 goto Syntax_Error;
669 }
670 index = (FT_Int)CopyInteger( parser );
671 if ( parser->error )
672 return parser->error;
673
674 if ( index < 0 || index >= encode->num_chars )
675 {
676 FT_TRACE4(( "Do_Put_Encoding: invalid character code\n" ));
677 goto Syntax_Error;
678 }
679
680 /* record the immediate name */
681 if ( top[1].kind != tok_immediate )
682 {
683 FT_TRACE4(( "Do_Put_Encoding: immediate name expected\n" ));
684 goto Syntax_Error;
685 }
686
687 /* if the glyph name is `.notdef', store a NULL char name; */
688 /* otherwise, record the glyph name */
689 if ( top[1].kind == imm_notdef )
690 {
691 parser->table.elements[index] = 0;
692 parser->table.lengths [index] = 0;
693 }
694 else
695 {
696 FT_String temp_name[128];
697 T1_Token* token = top + 1;
698 FT_Int len = token->len - 1;
699
700
701 /* copy immediate name */
702 if ( len > 127 )
703 len = 127;
704 MEM_Copy( temp_name, parser->tokenizer->base + token->start + 1, len );
705 temp_name[len] = '\0';
706
707 error = T1_Add_Table( &parser->table, index,
708 (FT_Byte*)temp_name, len + 1 );
709
710 /* adjust code_first and code_last */
711 if ( index < encode->code_first ) encode->code_first = index;
712 if ( index > encode->code_last ) encode->code_last = index;
713 }
714 return error;
715
716 Syntax_Error:
717 /* ignore the error, and simply clear the stack */
718 FT_TRACE4(( "Do_Put_Encoding: invalid syntax encountered\n" ));
719 parser->top = parser->stack;
720
721 return T1_Err_Ok;
722 }
723
724
725 /*************************************************************************/
726 /* */
727 /* */
728 /* IMPLEMENTATION OF THE "RD" KEYWORD DEPENDING ON */
729 /* CURRENT DICTIONARY STATE */
730 /* */
731 /* */
732 /*************************************************************************/
733
734
735 /*************************************************************************/
736 /* */
737 /* <Function> */
738 /* Do_RD_Subrs */
739 /* */
740 /* <Description> */
741 /* This function performs an `RD' if in the Subrs dictionary. It */
742 /* simply records the array of bytecodes/charstrings corresponding to */
743 /* the sub-routine. */
744 /* */
745 /* <InOut> */
746 /* parser :: A handle to the current parser. */
747 /* */
748 /* <Return> */
749 /* FreeType error code. 0 means success. */
750 /* */
751 static
752 FT_Error Do_RD_Subrs( T1_Parser* parser )
753 {
754 FT_Error error = T1_Err_Ok;
755 T1_Face face = parser->face;
756 T1_Token* top = parser->top;
757 T1_Tokenizer tokzer = parser->tokenizer;
758 FT_Int index, count;
759
760
761 /* record and check the character code */
762 if ( top[0].kind != tok_number ||
763 top[1].kind != tok_number )
764 {
765 FT_ERROR(( "Do_RD_Subrs: number expected\n" ));
766 goto Syntax_Error;
767 }
768 index = (FT_Int)CopyInteger( parser );
769 error = parser->error;
770 if ( error )
771 goto Exit;
772
773 count = (FT_Int)CopyInteger( parser );
774 error = parser->error;
775 if ( error )
776 goto Exit;
777
778 if ( index < 0 || index >= face->type1.num_subrs )
779 {
780 FT_ERROR(( "Do_RD_Subrs: invalid character code\n" ));
781 goto Syntax_Error;
782 }
783
784 /* decrypt charstring and skip it */
785 {
786 FT_Byte* base = tokzer->base + tokzer->cursor;
787
788
789 tokzer->cursor += count;
790
791 /* some fonts use a value of -1 for lenIV to indicate that */
792 /* the charstrings are unencoded. */
793 /* */
794 /* Thanks to Tom Kacvinsky for pointing this out. */
795 /* */
796 if ( face->type1.private_dict.lenIV >= 0 )
797 {
798 t1_decrypt( base, count, 4330 );
799
800 base += face->type1.private_dict.lenIV;
801 count -= face->type1.private_dict.lenIV;
802 }
803
804 error = T1_Add_Table( &parser->table, index, base, count );
805 }
806
807 /* consume the closing NP or `put' */
808 error = Expect_Keyword2( parser, key_NP, key_put );
809
810 Exit:
811 return error;
812
813 Syntax_Error:
814 return T1_Err_Syntax_Error;
815 }
816
817
818 /*************************************************************************/
819 /* */
820 /* <Function> */
821 /* Do_RD_CharStrings */
822 /* */
823 /* <Description> */
824 /* This function performs an `RD' if in the CharStrings dictionary. */
825 /* It simply records the array of bytecodes/charstrings corresponding */
826 /* to the glyph program string. */
827 /* */
828 /* <InOut> */
829 /* parser :: A handle to the current parser. */
830 /* */
831 /* <Return> */
832 /* FreeType error code. 0 means success. */
833 /* */
834 static
835 FT_Error Do_RD_Charstrings( T1_Parser* parser )
836 {
837 FT_Error error = T1_Err_Ok;
838 T1_Face face = parser->face;
839 T1_Token* top = parser->top;
840 T1_Tokenizer tokzer = parser->tokenizer;
841 FT_Int index, count;
842
843
844 /* check the character name argument */
845 if ( top[0].kind != tok_immediate )
846 {
847 FT_ERROR(( "Do_RD_Charstrings: immediate character name expected\n" ));
848 goto Syntax_Error;
849 }
850
851 /* check the count argument */
852 if ( top[1].kind != tok_number )
853 {
854 FT_ERROR(( "Do_RD_Charstrings: number expected\n" ));
855 goto Syntax_Error;
856 }
857
858 parser->args++;
859 count = (FT_Int)CopyInteger( parser );
860 error = parser->error;
861 if ( error )
862 goto Exit;
863
864 /* record the glyph name and get the corresponding glyph index */
865 if ( top[0].kind2 == imm_notdef )
866 index = 0;
867 else
868 {
869 FT_String temp_name[128];
870 T1_Token* token = top;
871 FT_Int len = token->len - 1;
872
873
874 /* copy immediate name */
875 if ( len > 127 )
876 len = 127;
877 MEM_Copy( temp_name, parser->tokenizer->base + token->start + 1, len );
878 temp_name[len] = '\0';
879
880 index = parser->cur_name++;
881 error = T1_Add_Table( &parser->table, index * 2,
882 (FT_Byte*)temp_name, len + 1 );
883 if ( error )
884 goto Exit;
885 }
886
887 /* decrypt and record charstring, then skip them */
888 {
889 FT_Byte* base = tokzer->base + tokzer->cursor;
890
891
892 tokzer->cursor += count; /* skip */
893
894 if ( face->type1.private_dict.lenIV >= 0 )
895 {
896 t1_decrypt( base, count, 4330 );
897
898 base += face->type1.private_dict.lenIV;
899 count -= face->type1.private_dict.lenIV;
900 }
901
902 error = T1_Add_Table( &parser->table, index * 2 + 1, base, count );
903 }
904
905 /* consume the closing `ND' */
906 if ( !error )
907 error = Expect_Keyword( parser, key_ND );
908
909 Exit:
910 return error;
911
912 Syntax_Error:
913 return T1_Err_Syntax_Error;
914 }
915
916
917 static
918 FT_Error Expect_Dict_Arguments( T1_Parser* parser,
919 FT_Int num_args,
920 T1_TokenType immediate,
921 T1_DictState new_state,
922 FT_Int* count )
923 {
924 /* check that we have enough arguments in the stack, including */
925 /* the `dict' keyword */
926 if ( parser->top - parser->stack < num_args )
927 {
928 FT_ERROR(( "Expect_Dict_Arguments: expecting at least %d arguments",
929 num_args ));
930 goto Syntax_Error;
931 }
932
933 /* check that we have the correct immediate, if needed */
934 if ( num_args == 2 )
935 {
936 if ( parser->top[-2].kind != tok_immediate ||
937 parser->top[-2].kind2 != immediate )
938 {
939 FT_ERROR(( "Expect_Dict_Arguments: expecting `/%s' dictionary\n",
940 t1_immediates[immediate - imm_first_] ));
941 goto Syntax_Error;
942 }
943 }
944
945 parser->args = parser->top-1;
946
947 /* check that the count argument is a number */
948 if ( parser->args->kind != tok_number )
949 {
950 FT_ERROR(( "Expect_Dict_Arguments:" ));
951 FT_ERROR(( " expecting numerical count argument for `dict'\n" ));
952 goto Syntax_Error;
953 }
954
955 if ( count )
956 {
957 *count = CopyInteger( parser );
958 if ( parser->error )
959 return parser->error;
960 }
961
962 /* save the dictionary state */
963 parser->state_stack[++parser->state_index] = new_state;
964
965 /* consume the `begin' keyword and clear the stack */
966 parser->top -= num_args;
967 return Expect_Keyword( parser, key_begin );
968
969 Syntax_Error:
970 return T1_Err_Syntax_Error;
971 }
972
973
974 static
975 FT_Error Expect_Array_Arguments( T1_Parser* parser )
976 {
977 T1_Token* top = parser->top;
978 FT_Error error = T1_Err_Ok;
979 T1_DictState new_state;
980 FT_Int count;
981 T1_Face face = parser->face;
982 FT_Memory memory = face->root.memory;
983
984
985 /* Check arguments format */
986 if ( top - parser->stack < 2 )
987 {
988 FT_ERROR(( "Expect_Array_Arguments: two arguments expected\n" ));
989 error = T1_Err_Stack_Underflow;
990 goto Exit;
991 }
992
993 parser->top -= 2;
994 top -= 2;
995 parser->args = top + 1;
996
997 if ( top[0].kind != tok_immediate )
998 {
999 FT_ERROR(( "Expect_Array_Arguments:" ));
1000 FT_ERROR(( " first argument must be an immediate name\n" ));
1001 goto Syntax_Error;
1002 }
1003
1004 if ( top[1].kind != tok_number )
1005 {
1006 FT_ERROR(( "Expect_Array_Arguments:" ));
1007 FT_ERROR(( " second argument must be a number\n" ));
1008 goto Syntax_Error;
1009 }
1010
1011 count = (FT_Int)CopyInteger( parser );
1012
1013 /* Is this an array we know about? */
1014 switch ( top[0].kind2 )
1015 {
1016 case imm_Encoding:
1017 {
1018 T1_Encoding* encode = &face->type1.encoding;
1019
1020
1021 new_state = dict_encoding;
1022
1023 encode->code_first = count;
1024 encode->code_last = 0;
1025 encode->num_chars = count;
1026
1027 /* Allocate the table of character indices. The table of */
1028 /* character names is allocated through init_t1_recorder(). */
1029 if ( ALLOC_ARRAY( encode->char_index, count, FT_Short ) )
1030 return error;
1031
1032 error = T1_New_Table( &parser->table, count, memory );
1033 if ( error )
1034 goto Exit;
1035
1036 parser->encoding_type = t1_encoding_array;
1037 }
1038 break;
1039
1040 case imm_Subrs:
1041 new_state = dict_subrs;
1042 face->type1.num_subrs = count;
1043
1044 error = T1_New_Table( &parser->table, count, memory );
1045 if ( error )
1046 goto Exit;
1047 break;
1048
1049 case imm_CharStrings:
1050 new_state = dict_charstrings;
1051 break;
1052
1053 default:
1054 new_state = dict_unknown_array;
1055 }
1056
1057 parser->state_stack[++parser->state_index] = new_state;
1058
1059 Exit:
1060 return error;
1061
1062 Syntax_Error:
1063 return T1_Err_Syntax_Error;
1064 }
1065
1066
1067 static
1068 FT_Error Finalize_Parsing( T1_Parser* parser )
1069 {
1070 T1_Face face = parser->face;
1071 T1_Font* type1 = &face->type1;
1072 FT_Memory memory = face->root.memory;
1073 T1_Table* strings = &parser->table;
1074 PSNames_Interface* psnames = (PSNames_Interface*)face->psnames;
1075
1076 FT_Int num_glyphs;
1077 FT_Int n;
1078 FT_Error error;
1079
1080
1081 num_glyphs = type1->num_glyphs = parser->cur_name;
1082
1083 /* allocate glyph names and charstrings arrays */
1084 if ( ALLOC_ARRAY( type1->glyph_names, num_glyphs, FT_String* ) ||
1085 ALLOC_ARRAY( type1->charstrings, num_glyphs, FT_Byte* ) ||
1086 ALLOC_ARRAY( type1->charstrings_len, num_glyphs, FT_Int* ) )
1087 return error;
1088
1089 /* copy glyph names and charstrings offsets and lengths */
1090 type1->charstrings_block = strings->block;
1091 for ( n = 0; n < num_glyphs; n++ )
1092 {
1093 type1->glyph_names[n] = (FT_String*)strings->elements[2 * n];
1094 type1->charstrings[n] = strings->elements[2 * n + 1];
1095 type1->charstrings_len[n] = strings->lengths [2 * n + 1];
1096 }
1097
1098 /* now free the old tables */
1099 FREE( strings->elements );
1100 FREE( strings->lengths );
1101
1102 if ( !psnames )
1103 {
1104 FT_ERROR(( "Finalize_Parsing: `PSNames' module missing!\n" ));
1105 return T1_Err_Unimplemented_Feature;
1106 }
1107
1108 /* compute encoding if required */
1109 if ( parser->encoding_type == t1_encoding_none )
1110 {
1111 FT_ERROR(( "Finalize_Parsing: no encoding specified in font file\n" ));
1112 return T1_Err_Syntax_Error;
1113 }
1114
1115 {
1116 FT_Int n;
1117 T1_Encoding* encode = &type1->encoding;
1118
1119
1120 encode->code_first = encode->num_chars - 1;
1121 encode->code_last = 0;
1122
1123 for ( n = 0; n < encode->num_chars; n++ )
1124 {
1125 FT_String** names;
1126 FT_Int index;
1127 FT_Int m;
1128
1129
1130 switch ( parser->encoding_type )
1131 {
1132 case t1_encoding_standard:
1133 index = psnames->adobe_std_encoding[n];
1134 names = 0;
1135 break;
1136
1137 case t1_encoding_expert:
1138 index = psnames->adobe_expert_encoding[n];
1139 names = 0;
1140 break;
1141
1142 default:
1143 index = n;
1144 names = (FT_String**)parser->encoding_offsets;
1145 }
1146
1147 encode->char_index[n] = 0;
1148
1149 if ( index )
1150 {
1151 FT_String* name;
1152
1153
1154 if ( names )
1155 name = names[index];
1156 else
1157 name = (FT_String*)psnames->adobe_std_strings(index);
1158
1159 if ( name )
1160 {
1161 FT_Int len = strlen( name );
1162
1163
1164 /* lookup glyph index from name */
1165 for ( m = 0; m < num_glyphs; m++ )
1166 {
1167 if ( strncmp( type1->glyph_names[m], name, len ) == 0 )
1168 {
1169 encode->char_index[n] = m;
1170 break;
1171 }
1172 }
1173
1174 if ( n < encode->code_first ) encode->code_first = n;
1175 if ( n > encode->code_last ) encode->code_last = n;
1176 }
1177 }
1178 }
1179
1180 parser->encoding_type = t1_encoding_none;
1181
1182 FREE( parser->encoding_names );
1183 FREE( parser->encoding_lengths );
1184 FREE( parser->encoding_offsets );
1185 }
1186
1187 return T1_Err_Ok;
1188 }
1189
1190
1191 /*************************************************************************/
1192 /* */
1193 /* <Function> */
1194 /* Parse_T1_FontProgram */
1195 /* */
1196 /* <Description> */
1197 /* Parses a given Type 1 font file and builds its face object. */
1198 /* */
1199 /* <InOut> */
1200 /* parser :: A handle to the target parser object. */
1201 /* */
1202 /* <Return> */
1203 /* FreeType error code. 0 means success. */
1204 /* */
1205 /* <Note> */
1206 /* The parser contains a handle to the target face object. */
1207 /* */
1208 LOCAL_FUNC
1209 FT_Error Parse_T1_FontProgram( T1_Parser* parser )
1210 {
1211 FT_Error error;
1212 T1_Font* type1 = &parser->face->type1;
1213
1214
1215 for (;;)
1216 {
1217 T1_Token token;
1218 T1_Token* top;
1219 T1_DictState dict_state;
1220 FT_Int dict_index;
1221
1222
1223 error = Next_T1_Token( parser, &token );
1224 top = parser->top;
1225 dict_index = parser->state_index;
1226 dict_state = parser->state_stack[dict_index];
1227
1228 switch ( token.kind )
1229 {
1230 /* a keyword has been detected */
1231 case tok_keyword:
1232 switch ( token.kind2 )
1233 {
1234 case key_dict:
1235 switch ( dict_state )
1236 {
1237 case dict_none:
1238 /* All right, we are beginning the font dictionary. */
1239 /* Check that we only have one number argument, then */
1240 /* consume the `begin' and change to `dict_font' */
1241 /* state. */
1242 error = Expect_Dict_Arguments( parser, 1, tok_error,
1243 dict_font, 0 );
1244 if ( error )
1245 goto Exit;
1246
1247 /* clear stack from all the previous content. This */
1248 /* could be some stupid Postscript code. */
1249 parser->top = parser->stack;
1250 break;
1251
1252 case dict_font:
1253 /* This must be the /FontInfo dictionary, so check */
1254 /* that we have at least two arguments, that they */
1255 /* are `/FontInfo' and a number, then change the */
1256 /* dictionary state. */
1257 error = Expect_Dict_Arguments( parser, 2, imm_FontInfo,
1258 dict_fontinfo, 0 );
1259 if ( error )
1260 goto Exit;
1261 break;
1262
1263 case dict_none2:
1264 error = Expect_Dict_Arguments( parser, 2, imm_Private,
1265 dict_private, 0 );
1266 if ( error )
1267 goto Exit;
1268 break;
1269
1270 case dict_private:
1271 {
1272 T1_Face face = parser->face;
1273 FT_Int count;
1274
1275
1276 error = Expect_Dict_Arguments( parser, 2, imm_CharStrings,
1277 dict_charstrings, &count );
1278 if ( error )
1279 goto Exit;
1280
1281 type1->num_glyphs = count;
1282 error = T1_New_Table( &parser->table, count * 2,
1283 face->root.memory );
1284 if ( error )
1285 goto Exit;
1286
1287 /* record `.notdef' as the first glyph in the font */
1288 error = T1_Add_Table( &parser->table, 0,
1289 (FT_Byte*)".notdef", 8 );
1290 parser->cur_name = 1;
1291 /* XXX: DO SOMETHING HERE */
1292 }
1293 break;
1294
1295 default:
1296 /* All other uses are invalid */
1297 FT_ERROR(( "Parse_T1_FontProgram:" ));
1298 FT_ERROR(( " invalid use of `dict' keyword\n" ));
1299 goto Syntax_Error;
1300 }
1301 break;
1302
1303 case key_array:
1304 /* Are we in an array yet? If so, raise an error */
1305 switch ( dict_state )
1306 {
1307 case dict_encoding:
1308 case dict_subrs:
1309 case dict_othersubrs:
1310 case dict_charstrings:
1311 case dict_unknown_array:
1312 FT_ERROR(( "Parse_T1_FontProgram: nested array definitions\n" ));
1313 goto Syntax_Error;
1314
1315 default:
1316 ;
1317 }
1318 error = Expect_Array_Arguments( parser );
1319 if ( error )
1320 goto Exit;
1321 break;
1322
1323 case key_ND:
1324 case key_NP:
1325 case key_def:
1326 /* Are we in an array? If so, finalize it. */
1327 switch ( dict_state )
1328 {
1329 case dict_encoding: /* finish encoding array */
1330 /* copy table names to the face object */
1331 T1_Done_Table( &parser->table );
1332
1333 parser->encoding_names = parser->table.block;
1334 parser->encoding_lengths = parser->table.lengths;
1335 parser->encoding_offsets = parser->table.elements;
1336
1337 parser->state_index--;
1338 break;
1339
1340 case dict_subrs:
1341 /* copy recorder sub-routines */
1342 T1_Done_Table( &parser->table );
1343
1344 parser->subrs = parser->table.block;
1345 type1->subrs = parser->table.elements;
1346 type1->subrs_len = parser->table.lengths;
1347 type1->subrs_block = parser->table.block;
1348
1349 parser->state_index--;
1350 break;
1351
1352 case dict_charstrings:
1353 case dict_othersubrs:
1354 case dict_unknown_array:
1355 FT_ERROR(( "Parse_T1_FontProgram: unsupported array\n" ));
1356 goto Syntax_Error;
1357 break;
1358
1359 default: /* normal `def' processing */
1360 /* Check that we have sufficient operands in the stack */
1361 if ( top >= parser->stack + 2 )
1362 {
1363 /* Now check that the first operand is an immediate. */
1364 /* If so, call the appropriate `def' routine based */
1365 /* on the current parser state. */
1366 if ( top[-2].kind == tok_immediate )
1367 {
1368 parser->top -= 2;
1369 parser->args = parser->top + 1;
1370 error = def_funcs[dict_state](parser);
1371 }
1372 else
1373 {
1374 /* This is an error, but some fonts contain */
1375 /* stupid Postscript code. We simply ignore */
1376 /* an invalid `def' by clearing the stack. */
1377#if 0
1378 FT_ERROR(( "Parse_T1_FontProgram: immediate expected\n" ));
1379 goto Syntax_Error;
1380#else
1381 parser->top = parser->stack;
1382#endif
1383 }
1384 }
1385 else
1386 {
1387 FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
1388 goto Stack_Underflow;
1389 }
1390 }
1391 break;
1392
1393 case key_index:
1394 if ( top <= parser->stack )
1395 {
1396 FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
1397 goto Stack_Underflow;
1398 }
1399
1400 /* simply ignore? */
1401 parser->top --;
1402 break;
1403
1404 case key_put:
1405 /* Check that we have sufficient operands in stack */
1406 if ( top < parser->stack + 2 )
1407 {
1408 FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
1409 goto Stack_Underflow;
1410 }
1411
1412 parser->top -= 2;
1413 parser->args = parser->top;
1414
1415 switch ( dict_state )
1416 {
1417 case dict_encoding:
1418 error = Do_Put_Encoding( parser );
1419 if ( error )
1420 goto Exit;
1421 break;
1422
1423 case dict_unknown_array: /* ignore the `put' */
1424 break;
1425
1426 default:
1427#if 0
1428 FT_ERROR(( "Parse_T1_FontProgram: invalid context\n" ));
1429 goto Syntax_Error;
1430#else
1431 /* invalid context; simply ignore the `put' and */
1432 /* clear the stack (stupid Postscript code) */
1433 FT_TRACE4(( "Parse_T1_FontProgram: invalid context ignored.\n" ));
1434 parser->top = parser->stack;
1435#endif
1436 }
1437 break;
1438
1439 case key_RD:
1440 /* Check that we have sufficient operands in stack */
1441 if ( top < parser->stack + 2 )
1442 {
1443 FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
1444 goto Stack_Underflow;
1445 }
1446
1447 parser->top -= 2;
1448 parser->args = parser->top;
1449 switch ( dict_state )
1450 {
1451 case dict_subrs:
1452 error = Do_RD_Subrs( parser );
1453 if ( error )
1454 goto Exit;
1455 break;
1456
1457 case dict_charstrings:
1458 error = Do_RD_Charstrings( parser );
1459 if ( error )
1460 goto Exit;
1461 break;
1462
1463 default:
1464 FT_ERROR(( "Parse_T1_FontProgram: invalid context\n" ));
1465 goto Syntax_Error;
1466 }
1467 break;
1468
1469 case key_end:
1470 /* Were we in a dictionary or in an array? */
1471 if ( dict_index <= 0 )
1472 {
1473 FT_ERROR(( "Parse_T1_FontProgram: no dictionary defined\n" ));
1474 goto Syntax_Error;
1475 }
1476
1477 switch ( dict_state )
1478 {
1479 /* jump to the private dictionary if we are closing the */
1480 /* `/Font' dictionary */
1481 case dict_font:
1482 goto Open_Private;
1483
1484 /* exit the parser when closing the CharStrings dictionary */
1485 case dict_charstrings:
1486 return Finalize_Parsing( parser );
1487
1488 default:
1489 /* Pop the current dictionary state and return to previous */
1490 /* one. Consume the `def'. */
1491
1492 /* Because some buggy fonts (BitStream) have incorrect */
1493 /* syntax, we never escape from the private dictionary */
1494 if ( dict_state != dict_private )
1495 parser->state_index--;
1496
1497 /* many fonts use `NP' instead of `def' or `put', so */
1498 /* we simply ignore the next token */
1499#if 0
1500 error = Expect_Keyword2( parser, key_def, key_put );
1501 if ( error )
1502 goto Exit;
1503#else
1504 (void)Expect_Keyword2( parser, key_def, key_put );
1505#endif
1506 }
1507 break;
1508
1509 case key_for:
1510 /* check that we have four arguments and simply */
1511 /* ignore them */
1512 if ( top - parser->stack < 4 )
1513 {
1514 FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
1515 goto Stack_Underflow;
1516 }
1517
1518 parser->top -= 4;
1519 break;
1520
1521 case key_currentdict:
1522 Open_Private:
1523 parser->state_index = 0;
1524 parser->state_stack[0] = dict_none2;
1525 error = Open_PrivateDict( parser->tokenizer );
1526 if ( error )
1527 goto Exit;
1528 break;
1529
1530 case key_true:
1531 case key_false:
1532 case key_StandardEncoding:
1533 case key_ExpertEncoding:
1534 goto Push_Element;
1535
1536 default:
1537 FT_ERROR(( "Parse_T1_FontProgram:" ));
1538 FT_ERROR(( " invalid keyword in context\n" ));
1539 error = T1_Err_Syntax_Error;
1540 }
1541 break;
1542
1543 /* check for the presence of `/BlendAxisTypes' -- we cannot deal */
1544 /* with multiple master fonts, so we must return a correct error */
1545 /* code to allow another driver to load them */
1546 case tok_immediate:
1547 if ( token.kind2 == imm_BlendAxisTypes )
1548 {
1549 error = FT_Err_Unknown_File_Format;
1550 goto Exit;
1551 }
1552 /* fallthrough */
1553
1554 /* A number was detected */
1555 case tok_string:
1556 case tok_program:
1557 case tok_array:
1558 case tok_hexarray:
1559 case tok_any:
1560 case tok_number: /* push number on stack */
1561
1562 Push_Element:
1563 if ( top >= parser->limit )
1564 {
1565 error = T1_Err_Stack_Overflow;
1566 goto Exit;
1567 }
1568 else
1569 *parser->top++ = token;
1570 break;
1571
1572 /* anything else is an error per se the spec, but we */
1573 /* frequently encounter stupid postscript code in fonts, */
1574 /* so just ignore them */
1575 default:
1576 error = T1_Err_Ok; /* ignore token */
1577 }
1578
1579 if ( error )
1580 return error;
1581 }
1582
1583 Exit:
1584 return error;
1585
1586 Syntax_Error:
1587 return T1_Err_Syntax_Error;
1588
1589 Stack_Underflow:
1590 return T1_Err_Stack_Underflow;
1591 }
1592
1593
1594/* END */
wxWidgets (Impactor)