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