projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync with trunk r63343.
[reactos.git] / lib / 3rdparty / freetype / src / cff / cffparse.c
1 /***************************************************************************/
2 /* */
3 /* cffparse.c */
4 /* */
5 /* CFF token stream parser (body) */
6 /* */
7 /* Copyright 1996-2004, 2007-2014 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
9 /* */
10 /* This file is part of the FreeType project, and may only be used, */
11 /* modified, and distributed under the terms of the FreeType project */
12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13 /* this file you indicate that you have read the license and */
14 /* understand and accept it fully. */
15 /* */
16 /***************************************************************************/
17
18
19 #include <ft2build.h>
20 #include "cffparse.h"
21 #include FT_INTERNAL_STREAM_H
22 #include FT_INTERNAL_DEBUG_H
23
24 #include "cfferrs.h"
25 #include "cffpic.h"
26
27
28 /*************************************************************************/
29 /* */
30 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
31 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
32 /* messages during execution. */
33 /* */
34 #undef FT_COMPONENT
35 #define FT_COMPONENT trace_cffparse
36
37
38 FT_LOCAL_DEF( void )
39 cff_parser_init( CFF_Parser parser,
40 FT_UInt code,
41 void* object,
42 FT_Library library)
43 {
44 FT_MEM_ZERO( parser, sizeof ( *parser ) );
45
46 parser->top = parser->stack;
47 parser->object_code = code;
48 parser->object = object;
49 parser->library = library;
50 }
51
52
53 /* read an integer */
54 static FT_Long
55 cff_parse_integer( FT_Byte* start,
56 FT_Byte* limit )
57 {
58 FT_Byte* p = start;
59 FT_Int v = *p++;
60 FT_Long val = 0;
61
62
63 if ( v == 28 )
64 {
65 if ( p + 2 > limit )
66 goto Bad;
67
68 val = (FT_Short)( ( (FT_UShort)p[0] << 8 ) | p[1] );
69 }
70 else if ( v == 29 )
71 {
72 if ( p + 4 > limit )
73 goto Bad;
74
75 val = (FT_Long)( ( (FT_ULong)p[0] << 24 ) |
76 ( (FT_ULong)p[1] << 16 ) |
77 ( (FT_ULong)p[2] << 8 ) |
78 (FT_ULong)p[3] );
79 }
80 else if ( v < 247 )
81 {
82 val = v - 139;
83 }
84 else if ( v < 251 )
85 {
86 if ( p + 1 > limit )
87 goto Bad;
88
89 val = ( v - 247 ) * 256 + p[0] + 108;
90 }
91 else
92 {
93 if ( p + 1 > limit )
94 goto Bad;
95
96 val = -( v - 251 ) * 256 - p[0] - 108;
97 }
98
99 Exit:
100 return val;
101
102 Bad:
103 val = 0;
104 FT_TRACE4(( "!!!END OF DATA:!!!" ));
105 goto Exit;
106 }
107
108
109 static const FT_Long power_tens[] =
110 {
111 1L,
112 10L,
113 100L,
114 1000L,
115 10000L,
116 100000L,
117 1000000L,
118 10000000L,
119 100000000L,
120 1000000000L
121 };
122
123
124 /* read a real */
125 static FT_Fixed
126 cff_parse_real( FT_Byte* start,
127 FT_Byte* limit,
128 FT_Long power_ten,
129 FT_Long* scaling )
130 {
131 FT_Byte* p = start;
132 FT_UInt nib;
133 FT_UInt phase;
134
135 FT_Long result, number, exponent;
136 FT_Int sign = 0, exponent_sign = 0, have_overflow = 0;
137 FT_Long exponent_add, integer_length, fraction_length;
138
139
140 if ( scaling )
141 *scaling = 0;
142
143 result = 0;
144
145 number = 0;
146 exponent = 0;
147
148 exponent_add = 0;
149 integer_length = 0;
150 fraction_length = 0;
151
152 /* First of all, read the integer part. */
153 phase = 4;
154
155 for (;;)
156 {
157 /* If we entered this iteration with phase == 4, we need to */
158 /* read a new byte. This also skips past the initial 0x1E. */
159 if ( phase )
160 {
161 p++;
162
163 /* Make sure we don't read past the end. */
164 if ( p >= limit )
165 goto Bad;
166 }
167
168 /* Get the nibble. */
169 nib = ( p[0] >> phase ) & 0xF;
170 phase = 4 - phase;
171
172 if ( nib == 0xE )
173 sign = 1;
174 else if ( nib > 9 )
175 break;
176 else
177 {
178 /* Increase exponent if we can't add the digit. */
179 if ( number >= 0xCCCCCCCL )
180 exponent_add++;
181 /* Skip leading zeros. */
182 else if ( nib || number )
183 {
184 integer_length++;
185 number = number * 10 + nib;
186 }
187 }
188 }
189
190 /* Read fraction part, if any. */
191 if ( nib == 0xa )
192 for (;;)
193 {
194 /* If we entered this iteration with phase == 4, we need */
195 /* to read a new byte. */
196 if ( phase )
197 {
198 p++;
199
200 /* Make sure we don't read past the end. */
201 if ( p >= limit )
202 goto Bad;
203 }
204
205 /* Get the nibble. */
206 nib = ( p[0] >> phase ) & 0xF;
207 phase = 4 - phase;
208 if ( nib >= 10 )
209 break;
210
211 /* Skip leading zeros if possible. */
212 if ( !nib && !number )
213 exponent_add--;
214 /* Only add digit if we don't overflow. */
215 else if ( number < 0xCCCCCCCL && fraction_length < 9 )
216 {
217 fraction_length++;
218 number = number * 10 + nib;
219 }
220 }
221
222 /* Read exponent, if any. */
223 if ( nib == 12 )
224 {
225 exponent_sign = 1;
226 nib = 11;
227 }
228
229 if ( nib == 11 )
230 {
231 for (;;)
232 {
233 /* If we entered this iteration with phase == 4, */
234 /* we need to read a new byte. */
235 if ( phase )
236 {
237 p++;
238
239 /* Make sure we don't read past the end. */
240 if ( p >= limit )
241 goto Bad;
242 }
243
244 /* Get the nibble. */
245 nib = ( p[0] >> phase ) & 0xF;
246 phase = 4 - phase;
247 if ( nib >= 10 )
248 break;
249
250 /* Arbitrarily limit exponent. */
251 if ( exponent > 1000 )
252 have_overflow = 1;
253 else
254 exponent = exponent * 10 + nib;
255 }
256
257 if ( exponent_sign )
258 exponent = -exponent;
259 }
260
261 if ( !number )
262 goto Exit;
263
264 if ( have_overflow )
265 {
266 if ( exponent_sign )
267 goto Underflow;
268 else
269 goto Overflow;
270 }
271
272 /* We don't check `power_ten' and `exponent_add'. */
273 exponent += power_ten + exponent_add;
274
275 if ( scaling )
276 {
277 /* Only use `fraction_length'. */
278 fraction_length += integer_length;
279 exponent += integer_length;
280
281 if ( fraction_length <= 5 )
282 {
283 if ( number > 0x7FFFL )
284 {
285 result = FT_DivFix( number, 10 );
286 *scaling = exponent - fraction_length + 1;
287 }
288 else
289 {
290 if ( exponent > 0 )
291 {
292 FT_Long new_fraction_length, shift;
293
294
295 /* Make `scaling' as small as possible. */
296 new_fraction_length = FT_MIN( exponent, 5 );
297 shift = new_fraction_length - fraction_length;
298
299 if ( shift > 0 )
300 {
301 exponent -= new_fraction_length;
302 number *= power_tens[shift];
303 if ( number > 0x7FFFL )
304 {
305 number /= 10;
306 exponent += 1;
307 }
308 }
309 else
310 exponent -= fraction_length;
311 }
312 else
313 exponent -= fraction_length;
314
315 result = (FT_Long)( (FT_ULong)number << 16 );
316 *scaling = exponent;
317 }
318 }
319 else
320 {
321 if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
322 {
323 result = FT_DivFix( number, power_tens[fraction_length - 4] );
324 *scaling = exponent - 4;
325 }
326 else
327 {
328 result = FT_DivFix( number, power_tens[fraction_length - 5] );
329 *scaling = exponent - 5;
330 }
331 }
332 }
333 else
334 {
335 integer_length += exponent;
336 fraction_length -= exponent;
337
338 if ( integer_length > 5 )
339 goto Overflow;
340 if ( integer_length < -5 )
341 goto Underflow;
342
343 /* Remove non-significant digits. */
344 if ( integer_length < 0 )
345 {
346 number /= power_tens[-integer_length];
347 fraction_length += integer_length;
348 }
349
350 /* this can only happen if exponent was non-zero */
351 if ( fraction_length == 10 )
352 {
353 number /= 10;
354 fraction_length -= 1;
355 }
356
357 /* Convert into 16.16 format. */
358 if ( fraction_length > 0 )
359 {
360 if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
361 goto Exit;
362
363 result = FT_DivFix( number, power_tens[fraction_length] );
364 }
365 else
366 {
367 number *= power_tens[-fraction_length];
368
369 if ( number > 0x7FFFL )
370 goto Overflow;
371
372 result = (FT_Long)( (FT_ULong)number << 16 );
373 }
374 }
375
376 Exit:
377 if ( sign )
378 result = -result;
379
380 return result;
381
382 Overflow:
383 result = 0x7FFFFFFFL;
384 FT_TRACE4(( "!!!OVERFLOW:!!!" ));
385 goto Exit;
386
387 Underflow:
388 result = 0;
389 FT_TRACE4(( "!!!UNDERFLOW:!!!" ));
390 goto Exit;
391
392 Bad:
393 result = 0;
394 FT_TRACE4(( "!!!END OF DATA:!!!" ));
395 goto Exit;
396 }
397
398
399 /* read a number, either integer or real */
400 static FT_Long
401 cff_parse_num( FT_Byte** d )
402 {
403 return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 )
404 : cff_parse_integer( d[0], d[1] );
405 }
406
407
408 /* read a floating point number, either integer or real */
409 static FT_Fixed
410 do_fixed( FT_Byte** d,
411 FT_Long scaling )
412 {
413 if ( **d == 30 )
414 return cff_parse_real( d[0], d[1], scaling, NULL );
415 else
416 {
417 FT_Long val = cff_parse_integer( d[0], d[1] );
418
419
420 if ( scaling )
421 val *= power_tens[scaling];
422
423 if ( val > 0x7FFF )
424 {
425 val = 0x7FFFFFFFL;
426 goto Overflow;
427 }
428 else if ( val < -0x7FFF )
429 {
430 val = -0x7FFFFFFFL;
431 goto Overflow;
432 }
433
434 return (FT_Long)( (FT_ULong)val << 16 );
435
436 Overflow:
437 FT_TRACE4(( "!!!OVERFLOW:!!!" ));
438 return val;
439 }
440 }
441
442
443 /* read a floating point number, either integer or real */
444 static FT_Fixed
445 cff_parse_fixed( FT_Byte** d )
446 {
447 return do_fixed( d, 0 );
448 }
449
450
451 /* read a floating point number, either integer or real, */
452 /* but return `10^scaling' times the number read in */
453 static FT_Fixed
454 cff_parse_fixed_scaled( FT_Byte** d,
455 FT_Long scaling )
456 {
457 return do_fixed( d, scaling );
458 }
459
460
461 /* read a floating point number, either integer or real, */
462 /* and return it as precise as possible -- `scaling' returns */
463 /* the scaling factor (as a power of 10) */
464 static FT_Fixed
465 cff_parse_fixed_dynamic( FT_Byte** d,
466 FT_Long* scaling )
467 {
468 FT_ASSERT( scaling );
469
470 if ( **d == 30 )
471 return cff_parse_real( d[0], d[1], 0, scaling );
472 else
473 {
474 FT_Long number;
475 FT_Int integer_length;
476
477
478 number = cff_parse_integer( d[0], d[1] );
479
480 if ( number > 0x7FFFL )
481 {
482 for ( integer_length = 5; integer_length < 10; integer_length++ )
483 if ( number < power_tens[integer_length] )
484 break;
485
486 if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL )
487 {
488 *scaling = integer_length - 4;
489 return FT_DivFix( number, power_tens[integer_length - 4] );
490 }
491 else
492 {
493 *scaling = integer_length - 5;
494 return FT_DivFix( number, power_tens[integer_length - 5] );
495 }
496 }
497 else
498 {
499 *scaling = 0;
500 return (FT_Long)( (FT_ULong)number << 16 );
501 }
502 }
503 }
504
505
506 static FT_Error
507 cff_parse_font_matrix( CFF_Parser parser )
508 {
509 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
510 FT_Matrix* matrix = &dict->font_matrix;
511 FT_Vector* offset = &dict->font_offset;
512 FT_ULong* upm = &dict->units_per_em;
513 FT_Byte** data = parser->stack;
514 FT_Error error = FT_ERR( Stack_Underflow );
515
516
517 if ( parser->top >= parser->stack + 6 )
518 {
519 FT_Long scaling;
520
521
522 error = FT_Err_Ok;
523
524 dict->has_font_matrix = TRUE;
525
526 /* We expect a well-formed font matrix, this is, the matrix elements */
527 /* `xx' and `yy' are of approximately the same magnitude. To avoid */
528 /* loss of precision, we use the magnitude of element `xx' to scale */
529 /* all other elements. The scaling factor is then contained in the */
530 /* `units_per_em' value. */
531
532 matrix->xx = cff_parse_fixed_dynamic( data++, &scaling );
533
534 scaling = -scaling;
535
536 if ( scaling < 0 || scaling > 9 )
537 {
538 /* Return default matrix in case of unlikely values. */
539
540 FT_TRACE1(( "cff_parse_font_matrix:"
541 " strange scaling value for xx element (%d),\n"
542 " "
543 " using default matrix\n", scaling ));
544
545 matrix->xx = 0x10000L;
546 matrix->yx = 0;
547 matrix->xy = 0;
548 matrix->yy = 0x10000L;
549 offset->x = 0;
550 offset->y = 0;
551 *upm = 1;
552
553 goto Exit;
554 }
555
556 matrix->yx = cff_parse_fixed_scaled( data++, scaling );
557 matrix->xy = cff_parse_fixed_scaled( data++, scaling );
558 matrix->yy = cff_parse_fixed_scaled( data++, scaling );
559 offset->x = cff_parse_fixed_scaled( data++, scaling );
560 offset->y = cff_parse_fixed_scaled( data, scaling );
561
562 *upm = power_tens[scaling];
563
564 FT_TRACE4(( " [%f %f %f %f %f %f]\n",
565 (double)matrix->xx / *upm / 65536,
566 (double)matrix->xy / *upm / 65536,
567 (double)matrix->yx / *upm / 65536,
568 (double)matrix->yy / *upm / 65536,
569 (double)offset->x / *upm / 65536,
570 (double)offset->y / *upm / 65536 ));
571 }
572
573 Exit:
574 return error;
575 }
576
577
578 static FT_Error
579 cff_parse_font_bbox( CFF_Parser parser )
580 {
581 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
582 FT_BBox* bbox = &dict->font_bbox;
583 FT_Byte** data = parser->stack;
584 FT_Error error;
585
586
587 error = FT_ERR( Stack_Underflow );
588
589 if ( parser->top >= parser->stack + 4 )
590 {
591 bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) );
592 bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) );
593 bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) );
594 bbox->yMax = FT_RoundFix( cff_parse_fixed( data ) );
595 error = FT_Err_Ok;
596
597 FT_TRACE4(( " [%d %d %d %d]\n",
598 bbox->xMin / 65536,
599 bbox->yMin / 65536,
600 bbox->xMax / 65536,
601 bbox->yMax / 65536 ));
602 }
603
604 return error;
605 }
606
607
608 static FT_Error
609 cff_parse_private_dict( CFF_Parser parser )
610 {
611 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
612 FT_Byte** data = parser->stack;
613 FT_Error error;
614
615
616 error = FT_ERR( Stack_Underflow );
617
618 if ( parser->top >= parser->stack + 2 )
619 {
620 dict->private_size = cff_parse_num( data++ );
621 dict->private_offset = cff_parse_num( data );
622 FT_TRACE4(( " %lu %lu\n",
623 dict->private_size, dict->private_offset ));
624
625 error = FT_Err_Ok;
626 }
627
628 return error;
629 }
630
631
632 static FT_Error
633 cff_parse_cid_ros( CFF_Parser parser )
634 {
635 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
636 FT_Byte** data = parser->stack;
637 FT_Error error;
638
639
640 error = FT_ERR( Stack_Underflow );
641
642 if ( parser->top >= parser->stack + 3 )
643 {
644 dict->cid_registry = (FT_UInt)cff_parse_num( data++ );
645 dict->cid_ordering = (FT_UInt)cff_parse_num( data++ );
646 if ( **data == 30 )
647 FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
648 dict->cid_supplement = cff_parse_num( data );
649 if ( dict->cid_supplement < 0 )
650 FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n",
651 dict->cid_supplement ));
652 error = FT_Err_Ok;
653
654 FT_TRACE4(( " %d %d %d\n",
655 dict->cid_registry,
656 dict->cid_ordering,
657 dict->cid_supplement ));
658 }
659
660 return error;
661 }
662
663
664 #define CFF_FIELD_NUM( code, name, id ) \
665 CFF_FIELD( code, name, id, cff_kind_num )
666 #define CFF_FIELD_FIXED( code, name, id ) \
667 CFF_FIELD( code, name, id, cff_kind_fixed )
668 #define CFF_FIELD_FIXED_1000( code, name, id ) \
669 CFF_FIELD( code, name, id, cff_kind_fixed_thousand )
670 #define CFF_FIELD_STRING( code, name, id ) \
671 CFF_FIELD( code, name, id, cff_kind_string )
672 #define CFF_FIELD_BOOL( code, name, id ) \
673 CFF_FIELD( code, name, id, cff_kind_bool )
674
675 #define CFFCODE_TOPDICT 0x1000
676 #define CFFCODE_PRIVATE 0x2000
677
678
679 #ifndef FT_CONFIG_OPTION_PIC
680
681
682 #undef CFF_FIELD
683 #undef CFF_FIELD_DELTA
684
685
686 #ifndef FT_DEBUG_LEVEL_TRACE
687
688
689 #define CFF_FIELD_CALLBACK( code, name, id ) \
690 { \
691 cff_kind_callback, \
692 code | CFFCODE, \
693 0, 0, \
694 cff_parse_ ## name, \
695 0, 0 \
696 },
697
698 #define CFF_FIELD( code, name, id, kind ) \
699 { \
700 kind, \
701 code | CFFCODE, \
702 FT_FIELD_OFFSET( name ), \
703 FT_FIELD_SIZE( name ), \
704 0, 0, 0 \
705 },
706
707 #define CFF_FIELD_DELTA( code, name, max, id ) \
708 { \
709 cff_kind_delta, \
710 code | CFFCODE, \
711 FT_FIELD_OFFSET( name ), \
712 FT_FIELD_SIZE_DELTA( name ), \
713 0, \
714 max, \
715 FT_FIELD_OFFSET( num_ ## name ) \
716 },
717
718 static const CFF_Field_Handler cff_field_handlers[] =
719 {
720
721 #include "cfftoken.h"
722
723 { 0, 0, 0, 0, 0, 0, 0 }
724 };
725
726
727 #else /* FT_DEBUG_LEVEL_TRACE */
728
729
730
731 #define CFF_FIELD_CALLBACK( code, name, id ) \
732 { \
733 cff_kind_callback, \
734 code | CFFCODE, \
735 0, 0, \
736 cff_parse_ ## name, \
737 0, 0, \
738 id \
739 },
740
741 #define CFF_FIELD( code, name, id, kind ) \
742 { \
743 kind, \
744 code | CFFCODE, \
745 FT_FIELD_OFFSET( name ), \
746 FT_FIELD_SIZE( name ), \
747 0, 0, 0, \
748 id \
749 },
750
751 #define CFF_FIELD_DELTA( code, name, max, id ) \
752 { \
753 cff_kind_delta, \
754 code | CFFCODE, \
755 FT_FIELD_OFFSET( name ), \
756 FT_FIELD_SIZE_DELTA( name ), \
757 0, \
758 max, \
759 FT_FIELD_OFFSET( num_ ## name ), \
760 id \
761 },
762
763 static const CFF_Field_Handler cff_field_handlers[] =
764 {
765
766 #include "cfftoken.h"
767
768 { 0, 0, 0, 0, 0, 0, 0, 0 }
769 };
770
771
772 #endif /* FT_DEBUG_LEVEL_TRACE */
773
774
775 #else /* FT_CONFIG_OPTION_PIC */
776
777
778 void
779 FT_Destroy_Class_cff_field_handlers( FT_Library library,
780 CFF_Field_Handler* clazz )
781 {
782 FT_Memory memory = library->memory;
783
784
785 if ( clazz )
786 FT_FREE( clazz );
787 }
788
789
790 FT_Error
791 FT_Create_Class_cff_field_handlers( FT_Library library,
792 CFF_Field_Handler** output_class )
793 {
794 CFF_Field_Handler* clazz = NULL;
795 FT_Error error;
796 FT_Memory memory = library->memory;
797
798 int i = 0;
799
800
801 #undef CFF_FIELD
802 #define CFF_FIELD( code, name, id, kind ) i++;
803 #undef CFF_FIELD_DELTA
804 #define CFF_FIELD_DELTA( code, name, max, id ) i++;
805 #undef CFF_FIELD_CALLBACK
806 #define CFF_FIELD_CALLBACK( code, name, id ) i++;
807
808 #include "cfftoken.h"
809
810 i++; /* { 0, 0, 0, 0, 0, 0, 0 } */
811
812 if ( FT_ALLOC( clazz, sizeof ( CFF_Field_Handler ) * i ) )
813 return error;
814
815 i = 0;
816
817
818 #ifndef FT_DEBUG_LEVEL_TRACE
819
820
821 #undef CFF_FIELD_CALLBACK
822 #define CFF_FIELD_CALLBACK( code_, name_, id_ ) \
823 clazz[i].kind = cff_kind_callback; \
824 clazz[i].code = code_ | CFFCODE; \
825 clazz[i].offset = 0; \
826 clazz[i].size = 0; \
827 clazz[i].reader = cff_parse_ ## name_; \
828 clazz[i].array_max = 0; \
829 clazz[i].count_offset = 0; \
830 i++;
831
832 #undef CFF_FIELD
833 #define CFF_FIELD( code_, name_, id_, kind_ ) \
834 clazz[i].kind = kind_; \
835 clazz[i].code = code_ | CFFCODE; \
836 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \
837 clazz[i].size = FT_FIELD_SIZE( name_ ); \
838 clazz[i].reader = 0; \
839 clazz[i].array_max = 0; \
840 clazz[i].count_offset = 0; \
841 i++; \
842
843 #undef CFF_FIELD_DELTA
844 #define CFF_FIELD_DELTA( code_, name_, max_, id_ ) \
845 clazz[i].kind = cff_kind_delta; \
846 clazz[i].code = code_ | CFFCODE; \
847 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \
848 clazz[i].size = FT_FIELD_SIZE_DELTA( name_ ); \
849 clazz[i].reader = 0; \
850 clazz[i].array_max = max_; \
851 clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
852 i++;
853
854 #include "cfftoken.h"
855
856 clazz[i].kind = 0;
857 clazz[i].code = 0;
858 clazz[i].offset = 0;
859 clazz[i].size = 0;
860 clazz[i].reader = 0;
861 clazz[i].array_max = 0;
862 clazz[i].count_offset = 0;
863
864
865 #else /* FT_DEBUG_LEVEL_TRACE */
866
867
868 #undef CFF_FIELD_CALLBACK
869 #define CFF_FIELD_CALLBACK( code_, name_, id_ ) \
870 clazz[i].kind = cff_kind_callback; \
871 clazz[i].code = code_ | CFFCODE; \
872 clazz[i].offset = 0; \
873 clazz[i].size = 0; \
874 clazz[i].reader = cff_parse_ ## name_; \
875 clazz[i].array_max = 0; \
876 clazz[i].count_offset = 0; \
877 clazz[i].id = id_; \
878 i++;
879
880 #undef CFF_FIELD
881 #define CFF_FIELD( code_, name_, id_, kind_ ) \
882 clazz[i].kind = kind_; \
883 clazz[i].code = code_ | CFFCODE; \
884 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \
885 clazz[i].size = FT_FIELD_SIZE( name_ ); \
886 clazz[i].reader = 0; \
887 clazz[i].array_max = 0; \
888 clazz[i].count_offset = 0; \
889 clazz[i].id = id_; \
890 i++; \
891
892 #undef CFF_FIELD_DELTA
893 #define CFF_FIELD_DELTA( code_, name_, max_, id_ ) \
894 clazz[i].kind = cff_kind_delta; \
895 clazz[i].code = code_ | CFFCODE; \
896 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \
897 clazz[i].size = FT_FIELD_SIZE_DELTA( name_ ); \
898 clazz[i].reader = 0; \
899 clazz[i].array_max = max_; \
900 clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
901 clazz[i].id = id_; \
902 i++;
903
904 #include "cfftoken.h"
905
906 clazz[i].kind = 0;
907 clazz[i].code = 0;
908 clazz[i].offset = 0;
909 clazz[i].size = 0;
910 clazz[i].reader = 0;
911 clazz[i].array_max = 0;
912 clazz[i].count_offset = 0;
913 clazz[i].id = 0;
914
915
916 #endif /* FT_DEBUG_LEVEL_TRACE */
917
918
919 *output_class = clazz;
920
921 return FT_Err_Ok;
922 }
923
924
925 #endif /* FT_CONFIG_OPTION_PIC */
926
927
928 FT_LOCAL_DEF( FT_Error )
929 cff_parser_run( CFF_Parser parser,
930 FT_Byte* start,
931 FT_Byte* limit )
932 {
933 FT_Byte* p = start;
934 FT_Error error = FT_Err_Ok;
935 FT_Library library = parser->library;
936 FT_UNUSED( library );
937
938
939 parser->top = parser->stack;
940 parser->start = start;
941 parser->limit = limit;
942 parser->cursor = start;
943
944 while ( p < limit )
945 {
946 FT_UInt v = *p;
947
948
949 if ( v >= 27 && v != 31 )
950 {
951 /* it's a number; we will push its position on the stack */
952 if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH )
953 goto Stack_Overflow;
954
955 *parser->top ++ = p;
956
957 /* now, skip it */
958 if ( v == 30 )
959 {
960 /* skip real number */
961 p++;
962 for (;;)
963 {
964 /* An unterminated floating point number at the */
965 /* end of a dictionary is invalid but harmless. */
966 if ( p >= limit )
967 goto Exit;
968 v = p[0] >> 4;
969 if ( v == 15 )
970 break;
971 v = p[0] & 0xF;
972 if ( v == 15 )
973 break;
974 p++;
975 }
976 }
977 else if ( v == 28 )
978 p += 2;
979 else if ( v == 29 )
980 p += 4;
981 else if ( v > 246 )
982 p += 1;
983 }
984 else
985 {
986 /* This is not a number, hence it's an operator. Compute its code */
987 /* and look for it in our current list. */
988
989 FT_UInt code;
990 FT_UInt num_args = (FT_UInt)
991 ( parser->top - parser->stack );
992 const CFF_Field_Handler* field;
993
994
995 *parser->top = p;
996 code = v;
997 if ( v == 12 )
998 {
999 /* two byte operator */
1000 p++;
1001 if ( p >= limit )
1002 goto Syntax_Error;
1003
1004 code = 0x100 | p[0];
1005 }
1006 code = code | parser->object_code;
1007
1008 for ( field = CFF_FIELD_HANDLERS_GET; field->kind; field++ )
1009 {
1010 if ( field->code == (FT_Int)code )
1011 {
1012 /* we found our field's handler; read it */
1013 FT_Long val;
1014 FT_Byte* q = (FT_Byte*)parser->object + field->offset;
1015
1016
1017 #ifdef FT_DEBUG_LEVEL_TRACE
1018 FT_TRACE4(( " %s", field->id ));
1019 #endif
1020
1021 /* check that we have enough arguments -- except for */
1022 /* delta encoded arrays, which can be empty */
1023 if ( field->kind != cff_kind_delta && num_args < 1 )
1024 goto Stack_Underflow;
1025
1026 switch ( field->kind )
1027 {
1028 case cff_kind_bool:
1029 case cff_kind_string:
1030 case cff_kind_num:
1031 val = cff_parse_num( parser->stack );
1032 goto Store_Number;
1033
1034 case cff_kind_fixed:
1035 val = cff_parse_fixed( parser->stack );
1036 goto Store_Number;
1037
1038 case cff_kind_fixed_thousand:
1039 val = cff_parse_fixed_scaled( parser->stack, 3 );
1040
1041 Store_Number:
1042 switch ( field->size )
1043 {
1044 case (8 / FT_CHAR_BIT):
1045 *(FT_Byte*)q = (FT_Byte)val;
1046 break;
1047
1048 case (16 / FT_CHAR_BIT):
1049 *(FT_Short*)q = (FT_Short)val;
1050 break;
1051
1052 case (32 / FT_CHAR_BIT):
1053 *(FT_Int32*)q = (FT_Int)val;
1054 break;
1055
1056 default: /* for 64-bit systems */
1057 *(FT_Long*)q = val;
1058 }
1059
1060 #ifdef FT_DEBUG_LEVEL_TRACE
1061 switch ( field->kind )
1062 {
1063 case cff_kind_bool:
1064 FT_TRACE4(( " %s\n", val ? "true" : "false" ));
1065 break;
1066
1067 case cff_kind_string:
1068 FT_TRACE4(( " %ld (SID)\n", val ));
1069 break;
1070
1071 case cff_kind_num:
1072 FT_TRACE4(( " %ld\n", val ));
1073 break;
1074
1075 case cff_kind_fixed:
1076 FT_TRACE4(( " %f\n", (double)val / 65536 ));
1077 break;
1078
1079 case cff_kind_fixed_thousand:
1080 FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
1081
1082 default:
1083 ; /* never reached */
1084 }
1085 #endif
1086
1087 break;
1088
1089 case cff_kind_delta:
1090 {
1091 FT_Byte* qcount = (FT_Byte*)parser->object +
1092 field->count_offset;
1093
1094 FT_Byte** data = parser->stack;
1095
1096
1097 if ( num_args > field->array_max )
1098 num_args = field->array_max;
1099
1100 FT_TRACE4(( " [" ));
1101
1102 /* store count */
1103 *qcount = (FT_Byte)num_args;
1104
1105 val = 0;
1106 while ( num_args > 0 )
1107 {
1108 val += cff_parse_num( data++ );
1109 switch ( field->size )
1110 {
1111 case (8 / FT_CHAR_BIT):
1112 *(FT_Byte*)q = (FT_Byte)val;
1113 break;
1114
1115 case (16 / FT_CHAR_BIT):
1116 *(FT_Short*)q = (FT_Short)val;
1117 break;
1118
1119 case (32 / FT_CHAR_BIT):
1120 *(FT_Int32*)q = (FT_Int)val;
1121 break;
1122
1123 default: /* for 64-bit systems */
1124 *(FT_Long*)q = val;
1125 }
1126
1127 FT_TRACE4(( " %ld", val ));
1128
1129 q += field->size;
1130 num_args--;
1131 }
1132
1133 FT_TRACE4(( "]\n" ));
1134 }
1135 break;
1136
1137 default: /* callback */
1138 error = field->reader( parser );
1139 if ( error )
1140 goto Exit;
1141 }
1142 goto Found;
1143 }
1144 }
1145
1146 /* this is an unknown operator, or it is unsupported; */
1147 /* we will ignore it for now. */
1148
1149 Found:
1150 /* clear stack */
1151 parser->top = parser->stack;
1152 }
1153 p++;
1154 }
1155
1156 Exit:
1157 return error;
1158
1159 Stack_Overflow:
1160 error = FT_THROW( Invalid_Argument );
1161 goto Exit;
1162
1163 Stack_Underflow:
1164 error = FT_THROW( Invalid_Argument );
1165 goto Exit;
1166
1167 Syntax_Error:
1168 error = FT_THROW( Invalid_Argument );
1169 goto Exit;
1170 }
1171
1172
1173 /* END */
A free Windows-compatible Operating System