?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mgh: fix for default HDD DMA mode, that wasn't correctly set
[open-ps2-loader.git] / thirdparty / freetype-2.3.12 / src / cff / cffparse.c
blob01266a193d2e00e4aaa204a24cd8ae9af2c9f770
1 /***************************************************************************/
2 /* */
3 /* cffparse.c */
4 /* */
5 /* CFF token stream parser (body) */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2007, 2008, 2009 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
39
40 FT_LOCAL_DEF( void )
41 cff_parser_init( CFF_Parser parser,
42 FT_UInt code,
43 void* object,
44 FT_Library library)
45 {
46 FT_MEM_ZERO( parser, sizeof ( *parser ) );
47
48 parser->top = parser->stack;
49 parser->object_code = code;
50 parser->object = object;
51 parser->library = library;
52 }
53
54
55 /* read an integer */
56 static FT_Long
57 cff_parse_integer( FT_Byte* start,
58 FT_Byte* limit )
59 {
60 FT_Byte* p = start;
61 FT_Int v = *p++;
62 FT_Long val = 0;
63
64
65 if ( v == 28 )
66 {
67 if ( p + 2 > limit )
68 goto Bad;
69
70 val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] );
71 p += 2;
72 }
73 else if ( v == 29 )
74 {
75 if ( p + 4 > limit )
76 goto Bad;
77
78 val = ( (FT_Long)p[0] << 24 ) |
79 ( (FT_Long)p[1] << 16 ) |
80 ( (FT_Long)p[2] << 8 ) |
81 p[3];
82 p += 4;
83 }
84 else if ( v < 247 )
85 {
86 val = v - 139;
87 }
88 else if ( v < 251 )
89 {
90 if ( p + 1 > limit )
91 goto Bad;
92
93 val = ( v - 247 ) * 256 + p[0] + 108;
94 p++;
95 }
96 else
97 {
98 if ( p + 1 > limit )
99 goto Bad;
100
101 val = -( v - 251 ) * 256 - p[0] - 108;
102 p++;
103 }
104
105 Exit:
106 return val;
107
108 Bad:
109 val = 0;
110 goto Exit;
111 }
112
113
114 static const FT_Long power_tens[] =
115 {
116 1L,
117 10L,
118 100L,
119 1000L,
120 10000L,
121 100000L,
122 1000000L,
123 10000000L,
124 100000000L,
125 1000000000L
126 };
127
128
129 /* read a real */
130 static FT_Fixed
131 cff_parse_real( FT_Byte* start,
132 FT_Byte* limit,
133 FT_Long power_ten,
134 FT_Long* scaling )
135 {
136 FT_Byte* p = start;
137 FT_UInt nib;
138 FT_UInt phase;
139
140 FT_Long result, number, rest, exponent;
141 FT_Int sign = 0, exponent_sign = 0;
142 FT_Long exponent_add, integer_length, fraction_length;
143
144
145 if ( scaling )
146 *scaling = 0;
147
148 result = 0;
149
150 number = 0;
151 rest = 0;
152 exponent = 0;
153
154 exponent_add = 0;
155 integer_length = 0;
156 fraction_length = 0;
157
158 FT_UNUSED( rest );
159
160 /* First of all, read the integer part. */
161 phase = 4;
162
163 for (;;)
164 {
165 /* If we entered this iteration with phase == 4, we need to */
166 /* read a new byte. This also skips past the initial 0x1E. */
167 if ( phase )
168 {
169 p++;
170
171 /* Make sure we don't read past the end. */
172 if ( p >= limit )
173 goto Exit;
174 }
175
176 /* Get the nibble. */
177 nib = ( p[0] >> phase ) & 0xF;
178 phase = 4 - phase;
179
180 if ( nib == 0xE )
181 sign = 1;
182 else if ( nib > 9 )
183 break;
184 else
185 {
186 /* Increase exponent if we can't add the digit. */
187 if ( number >= 0xCCCCCCCL )
188 exponent_add++;
189 /* Skip leading zeros. */
190 else if ( nib || number )
191 {
192 integer_length++;
193 number = number * 10 + nib;
194 }
195 }
196 }
197
198 /* Read fraction part, if any. */
199 if ( nib == 0xa )
200 for (;;)
201 {
202 /* If we entered this iteration with phase == 4, we need */
203 /* to read a new byte. */
204 if ( phase )
205 {
206 p++;
207
208 /* Make sure we don't read past the end. */
209 if ( p >= limit )
210 goto Exit;
211 }
212
213 /* Get the nibble. */
214 nib = ( p[0] >> phase ) & 0xF;
215 phase = 4 - phase;
216 if ( nib >= 10 )
217 break;
218
219 /* Skip leading zeros if possible. */
220 if ( !nib && !number )
221 exponent_add--;
222 /* Only add digit if we don't overflow. */
223 else if ( number < 0xCCCCCCCL && fraction_length < 9 )
224 {
225 fraction_length++;
226 number = number * 10 + nib;
227 }
228 }
229
230 /* Read exponent, if any. */
231 if ( nib == 12 )
232 {
233 exponent_sign = 1;
234 nib = 11;
235 }
236
237 if ( nib == 11 )
238 {
239 for (;;)
240 {
241 /* If we entered this iteration with phase == 4, */
242 /* we need to read a new byte. */
243 if ( phase )
244 {
245 p++;
246
247 /* Make sure we don't read past the end. */
248 if ( p >= limit )
249 goto Exit;
250 }
251
252 /* Get the nibble. */
253 nib = ( p[0] >> phase ) & 0xF;
254 phase = 4 - phase;
255 if ( nib >= 10 )
256 break;
257
258 exponent = exponent * 10 + nib;
259
260 /* Arbitrarily limit exponent. */
261 if ( exponent > 1000 )
262 goto Exit;
263 }
264
265 if ( exponent_sign )
266 exponent = -exponent;
267 }
268
269 /* We don't check `power_ten' and `exponent_add'. */
270 exponent += power_ten + exponent_add;
271
272 if ( scaling )
273 {
274 /* Only use `fraction_length'. */
275 fraction_length += integer_length;
276 exponent += integer_length;
277
278 if ( fraction_length <= 5 )
279 {
280 if ( number > 0x7FFFL )
281 {
282 result = FT_DivFix( number, 10 );
283 *scaling = exponent - fraction_length + 1;
284 }
285 else
286 {
287 if ( exponent > 0 )
288 {
289 FT_Long new_fraction_length, shift;
290
291
292 /* Make `scaling' as small as possible. */
293 new_fraction_length = FT_MIN( exponent, 5 );
294 exponent -= new_fraction_length;
295 shift = new_fraction_length - fraction_length;
296
297 number *= power_tens[shift];
298 if ( number > 0x7FFFL )
299 {
300 number /= 10;
301 exponent += 1;
302 }
303 }
304 else
305 exponent -= fraction_length;
306
307 result = number << 16;
308 *scaling = exponent;
309 }
310 }
311 else
312 {
313 if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
314 {
315 result = FT_DivFix( number, power_tens[fraction_length - 4] );
316 *scaling = exponent - 4;
317 }
318 else
319 {
320 result = FT_DivFix( number, power_tens[fraction_length - 5] );
321 *scaling = exponent - 5;
322 }
323 }
324 }
325 else
326 {
327 integer_length += exponent;
328 fraction_length -= exponent;
329
330 /* Check for overflow and underflow. */
331 if ( FT_ABS( integer_length ) > 5 )
332 goto Exit;
333
334 /* Remove non-significant digits. */
335 if ( integer_length < 0 ) {
336 number /= power_tens[-integer_length];
337 fraction_length += integer_length;
338 }
339
340 /* Convert into 16.16 format. */
341 if ( fraction_length > 0 )
342 {
343 if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
344 goto Exit;
345
346 result = FT_DivFix( number, power_tens[fraction_length] );
347 }
348 else
349 {
350 number *= power_tens[-fraction_length];
351
352 if ( number > 0x7FFFL )
353 goto Exit;
354
355 result = number << 16;
356 }
357 }
358
359 if ( sign )
360 result = -result;
361
362 Exit:
363 return result;
364 }
365
366
367 /* read a number, either integer or real */
368 static FT_Long
369 cff_parse_num( FT_Byte** d )
370 {
371 return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 )
372 : cff_parse_integer( d[0], d[1] );
373 }
374
375
376 /* read a floating point number, either integer or real */
377 static FT_Fixed
378 cff_parse_fixed( FT_Byte** d )
379 {
380 return **d == 30 ? cff_parse_real( d[0], d[1], 0, NULL )
381 : cff_parse_integer( d[0], d[1] ) << 16;
382 }
383
384
385 /* read a floating point number, either integer or real, */
386 /* but return `10^scaling' times the number read in */
387 static FT_Fixed
388 cff_parse_fixed_scaled( FT_Byte** d,
389 FT_Long scaling )
390 {
391 return **d == 30 ? cff_parse_real( d[0], d[1], scaling, NULL )
392 : ( cff_parse_integer( d[0], d[1] ) *
393 power_tens[scaling] ) << 16;
394 }
395
396
397 /* read a floating point number, either integer or real, */
398 /* and return it as precise as possible -- `scaling' returns */
399 /* the scaling factor (as a power of 10) */
400 static FT_Fixed
401 cff_parse_fixed_dynamic( FT_Byte** d,
402 FT_Long* scaling )
403 {
404 FT_ASSERT( scaling );
405
406 if ( **d == 30 )
407 return cff_parse_real( d[0], d[1], 0, scaling );
408 else
409 {
410 FT_Long number;
411 FT_Int integer_length;
412
413
414 number = cff_parse_integer( d[0], d[1] );
415
416 if ( number > 0x7FFFL )
417 {
418 for ( integer_length = 5; integer_length < 10; integer_length++ )
419 if ( number < power_tens[integer_length] )
420 break;
421
422 if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL )
423 {
424 *scaling = integer_length - 4;
425 return FT_DivFix( number, power_tens[integer_length - 4] );
426 }
427 else
428 {
429 *scaling = integer_length - 5;
430 return FT_DivFix( number, power_tens[integer_length - 5] );
431 }
432 }
433 else
434 {
435 *scaling = 0;
436 return number << 16;
437 }
438 }
439 }
440
441
442 static FT_Error
443 cff_parse_font_matrix( CFF_Parser parser )
444 {
445 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
446 FT_Matrix* matrix = &dict->font_matrix;
447 FT_Vector* offset = &dict->font_offset;
448 FT_ULong* upm = &dict->units_per_em;
449 FT_Byte** data = parser->stack;
450 FT_Error error = CFF_Err_Stack_Underflow;
451
452
453 if ( parser->top >= parser->stack + 6 )
454 {
455 FT_Long scaling;
456
457
458 error = CFF_Err_Ok;
459
460 /* We expect a well-formed font matrix, this is, the matrix elements */
461 /* `xx' and `yy' are of approximately the same magnitude. To avoid */
462 /* loss of precision, we use the magnitude of element `xx' to scale */
463 /* all other elements. The scaling factor is then contained in the */
464 /* `units_per_em' value. */
465
466 matrix->xx = cff_parse_fixed_dynamic( data++, &scaling );
467
468 scaling = -scaling;
469
470 if ( scaling < 0 || scaling > 9 )
471 {
472 /* Return default matrix in case of unlikely values. */
473 matrix->xx = 0x10000L;
474 matrix->yx = 0;
475 matrix->yx = 0;
476 matrix->yy = 0x10000L;
477 offset->x = 0;
478 offset->y = 0;
479 *upm = 1;
480
481 goto Exit;
482 }
483
484 matrix->yx = cff_parse_fixed_scaled( data++, scaling );
485 matrix->xy = cff_parse_fixed_scaled( data++, scaling );
486 matrix->yy = cff_parse_fixed_scaled( data++, scaling );
487 offset->x = cff_parse_fixed_scaled( data++, scaling );
488 offset->y = cff_parse_fixed_scaled( data, scaling );
489
490 *upm = power_tens[scaling];
491 }
492
493 Exit:
494 return error;
495 }
496
497
498 static FT_Error
499 cff_parse_font_bbox( CFF_Parser parser )
500 {
501 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
502 FT_BBox* bbox = &dict->font_bbox;
503 FT_Byte** data = parser->stack;
504 FT_Error error;
505
506
507 error = CFF_Err_Stack_Underflow;
508
509 if ( parser->top >= parser->stack + 4 )
510 {
511 bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) );
512 bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) );
513 bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) );
514 bbox->yMax = FT_RoundFix( cff_parse_fixed( data ) );
515 error = CFF_Err_Ok;
516 }
517
518 return error;
519 }
520
521
522 static FT_Error
523 cff_parse_private_dict( CFF_Parser parser )
524 {
525 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
526 FT_Byte** data = parser->stack;
527 FT_Error error;
528
529
530 error = CFF_Err_Stack_Underflow;
531
532 if ( parser->top >= parser->stack + 2 )
533 {
534 dict->private_size = cff_parse_num( data++ );
535 dict->private_offset = cff_parse_num( data );
536 error = CFF_Err_Ok;
537 }
538
539 return error;
540 }
541
542
543 static FT_Error
544 cff_parse_cid_ros( CFF_Parser parser )
545 {
546 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
547 FT_Byte** data = parser->stack;
548 FT_Error error;
549
550
551 error = CFF_Err_Stack_Underflow;
552
553 if ( parser->top >= parser->stack + 3 )
554 {
555 dict->cid_registry = (FT_UInt)cff_parse_num ( data++ );
556 dict->cid_ordering = (FT_UInt)cff_parse_num ( data++ );
557 if ( **data == 30 )
558 FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
559 dict->cid_supplement = cff_parse_num( data );
560 if ( dict->cid_supplement < 0 )
561 FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n",
562 dict->cid_supplement ));
563 error = CFF_Err_Ok;
564 }
565
566 return error;
567 }
568
569
570 #define CFF_FIELD_NUM( code, name ) \
571 CFF_FIELD( code, name, cff_kind_num )
572 #define CFF_FIELD_FIXED( code, name ) \
573 CFF_FIELD( code, name, cff_kind_fixed )
574 #define CFF_FIELD_FIXED_1000( code, name ) \
575 CFF_FIELD( code, name, cff_kind_fixed_thousand )
576 #define CFF_FIELD_STRING( code, name ) \
577 CFF_FIELD( code, name, cff_kind_string )
578 #define CFF_FIELD_BOOL( code, name ) \
579 CFF_FIELD( code, name, cff_kind_bool )
580 #define CFF_FIELD_DELTA( code, name, max ) \
581 CFF_FIELD( code, name, cff_kind_delta )
582
583 #define CFFCODE_TOPDICT 0x1000
584 #define CFFCODE_PRIVATE 0x2000
585
586 #ifndef FT_CONFIG_OPTION_PIC
587
588 #define CFF_FIELD_CALLBACK( code, name ) \
589 { \
590 cff_kind_callback, \
591 code | CFFCODE, \
592 0, 0, \
593 cff_parse_ ## name, \
594 0, 0 \
595 },
596
597 #undef CFF_FIELD
598 #define CFF_FIELD( code, name, kind ) \
599 { \
600 kind, \
601 code | CFFCODE, \
602 FT_FIELD_OFFSET( name ), \
603 FT_FIELD_SIZE( name ), \
604 0, 0, 0 \
605 },
606
607 #undef CFF_FIELD_DELTA
608 #define CFF_FIELD_DELTA( code, name, max ) \
609 { \
610 cff_kind_delta, \
611 code | CFFCODE, \
612 FT_FIELD_OFFSET( name ), \
613 FT_FIELD_SIZE_DELTA( name ), \
614 0, \
615 max, \
616 FT_FIELD_OFFSET( num_ ## name ) \
617 },
618
619 static const CFF_Field_Handler cff_field_handlers[] =
620 {
621
622 #include "cfftoken.h"
623
624 { 0, 0, 0, 0, 0, 0, 0 }
625 };
626
627
628 #else /* FT_CONFIG_OPTION_PIC */
629
630 void FT_Destroy_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler* clazz)
631 {
632 FT_Memory memory = library->memory;
633 if ( clazz )
634 FT_FREE( clazz );
635 }
636
637 FT_Error FT_Create_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler** output_class)
638 {
639 CFF_Field_Handler* clazz;
640 FT_Error error;
641 FT_Memory memory = library->memory;
642 int i=0;
643
644 #undef CFF_FIELD
645 #undef CFF_FIELD_DELTA
646 #undef CFF_FIELD_CALLBACK
647 #define CFF_FIELD_CALLBACK( code, name ) i++;
648 #define CFF_FIELD( code, name, kind ) i++;
649 #define CFF_FIELD_DELTA( code, name, max ) i++;
650
651 #include "cfftoken.h"
652 i++;/*{ 0, 0, 0, 0, 0, 0, 0 }*/
653
654 if ( FT_ALLOC( clazz, sizeof(CFF_Field_Handler)*i ) )
655 return error;
656
657 i=0;
658 #undef CFF_FIELD
659 #undef CFF_FIELD_DELTA
660 #undef CFF_FIELD_CALLBACK
661
662 #define CFF_FIELD_CALLBACK( code_, name_ ) \
663 clazz[i].kind = cff_kind_callback; \
664 clazz[i].code = code_ | CFFCODE; \
665 clazz[i].offset = 0; \
666 clazz[i].size = 0; \
667 clazz[i].reader = cff_parse_ ## name_; \
668 clazz[i].array_max = 0; \
669 clazz[i].count_offset = 0; \
670 i++;
671
672 #undef CFF_FIELD
673 #define CFF_FIELD( code_, name_, kind_ ) \
674 clazz[i].kind = kind_; \
675 clazz[i].code = code_ | CFFCODE; \
676 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \
677 clazz[i].size = FT_FIELD_SIZE( name_ ); \
678 clazz[i].reader = 0; \
679 clazz[i].array_max = 0; \
680 clazz[i].count_offset = 0; \
681 i++; \
682
683 #undef CFF_FIELD_DELTA
684 #define CFF_FIELD_DELTA( code_, name_, max_ ) \
685 clazz[i].kind = cff_kind_delta; \
686 clazz[i].code = code_ | CFFCODE; \
687 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \
688 clazz[i].size = FT_FIELD_SIZE_DELTA( name_ ); \
689 clazz[i].reader = 0; \
690 clazz[i].array_max = max_; \
691 clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
692 i++;
693
694 #include "cfftoken.h"
695
696 clazz[i].kind = 0;
697 clazz[i].code = 0;
698 clazz[i].offset = 0;
699 clazz[i].size = 0;
700 clazz[i].reader = 0;
701 clazz[i].array_max = 0;
702 clazz[i].count_offset = 0;
703
704 *output_class = clazz;
705 return FT_Err_Ok;
706 }
707
708
709 #endif /* FT_CONFIG_OPTION_PIC */
710
711
712 FT_LOCAL_DEF( FT_Error )
713 cff_parser_run( CFF_Parser parser,
714 FT_Byte* start,
715 FT_Byte* limit )
716 {
717 FT_Byte* p = start;
718 FT_Error error = CFF_Err_Ok;
719 FT_Library library = parser->library;
720 FT_UNUSED(library);
721
722
723 parser->top = parser->stack;
724 parser->start = start;
725 parser->limit = limit;
726 parser->cursor = start;
727
728 while ( p < limit )
729 {
730 FT_UInt v = *p;
731
732
733 if ( v >= 27 && v != 31 )
734 {
735 /* it's a number; we will push its position on the stack */
736 if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH )
737 goto Stack_Overflow;
738
739 *parser->top ++ = p;
740
741 /* now, skip it */
742 if ( v == 30 )
743 {
744 /* skip real number */
745 p++;
746 for (;;)
747 {
748 /* An unterminated floating point number at the */
749 /* end of a dictionary is invalid but harmless. */
750 if ( p >= limit )
751 goto Exit;
752 v = p[0] >> 4;
753 if ( v == 15 )
754 break;
755 v = p[0] & 0xF;
756 if ( v == 15 )
757 break;
758 p++;
759 }
760 }
761 else if ( v == 28 )
762 p += 2;
763 else if ( v == 29 )
764 p += 4;
765 else if ( v > 246 )
766 p += 1;
767 }
768 else
769 {
770 /* This is not a number, hence it's an operator. Compute its code */
771 /* and look for it in our current list. */
772
773 FT_UInt code;
774 FT_UInt num_args = (FT_UInt)
775 ( parser->top - parser->stack );
776 const CFF_Field_Handler* field;
777
778
779 *parser->top = p;
780 code = v;
781 if ( v == 12 )
782 {
783 /* two byte operator */
784 p++;
785 if ( p >= limit )
786 goto Syntax_Error;
787
788 code = 0x100 | p[0];
789 }
790 code = code | parser->object_code;
791
792 for ( field = FT_CFF_FIELD_HANDLERS_GET; field->kind; field++ )
793 {
794 if ( field->code == (FT_Int)code )
795 {
796 /* we found our field's handler; read it */
797 FT_Long val;
798 FT_Byte* q = (FT_Byte*)parser->object + field->offset;
799
800
801 /* check that we have enough arguments -- except for */
802 /* delta encoded arrays, which can be empty */
803 if ( field->kind != cff_kind_delta && num_args < 1 )
804 goto Stack_Underflow;
805
806 switch ( field->kind )
807 {
808 case cff_kind_bool:
809 case cff_kind_string:
810 case cff_kind_num:
811 val = cff_parse_num( parser->stack );
812 goto Store_Number;
813
814 case cff_kind_fixed:
815 val = cff_parse_fixed( parser->stack );
816 goto Store_Number;
817
818 case cff_kind_fixed_thousand:
819 val = cff_parse_fixed_scaled( parser->stack, 3 );
820
821 Store_Number:
822 switch ( field->size )
823 {
824 case (8 / FT_CHAR_BIT):
825 *(FT_Byte*)q = (FT_Byte)val;
826 break;
827
828 case (16 / FT_CHAR_BIT):
829 *(FT_Short*)q = (FT_Short)val;
830 break;
831
832 case (32 / FT_CHAR_BIT):
833 *(FT_Int32*)q = (FT_Int)val;
834 break;
835
836 default: /* for 64-bit systems */
837 *(FT_Long*)q = val;
838 }
839 break;
840
841 case cff_kind_delta:
842 {
843 FT_Byte* qcount = (FT_Byte*)parser->object +
844 field->count_offset;
845
846 FT_Byte** data = parser->stack;
847
848
849 if ( num_args > field->array_max )
850 num_args = field->array_max;
851
852 /* store count */
853 *qcount = (FT_Byte)num_args;
854
855 val = 0;
856 while ( num_args > 0 )
857 {
858 val += cff_parse_num( data++ );
859 switch ( field->size )
860 {
861 case (8 / FT_CHAR_BIT):
862 *(FT_Byte*)q = (FT_Byte)val;
863 break;
864
865 case (16 / FT_CHAR_BIT):
866 *(FT_Short*)q = (FT_Short)val;
867 break;
868
869 case (32 / FT_CHAR_BIT):
870 *(FT_Int32*)q = (FT_Int)val;
871 break;
872
873 default: /* for 64-bit systems */
874 *(FT_Long*)q = val;
875 }
876
877 q += field->size;
878 num_args--;
879 }
880 }
881 break;
882
883 default: /* callback */
884 error = field->reader( parser );
885 if ( error )
886 goto Exit;
887 }
888 goto Found;
889 }
890 }
891
892 /* this is an unknown operator, or it is unsupported; */
893 /* we will ignore it for now. */
894
895 Found:
896 /* clear stack */
897 parser->top = parser->stack;
898 }
899 p++;
900 }
901
902 Exit:
903 return error;
904
905 Stack_Overflow:
906 error = CFF_Err_Invalid_Argument;
907 goto Exit;
908
909 Stack_Underflow:
910 error = CFF_Err_Invalid_Argument;
911 goto Exit;
912
913 Syntax_Error:
914 error = CFF_Err_Invalid_Argument;
915 goto Exit;
916 }
917
918
919 /* END */
Open USB/SMB/HDD Game Loader for PS2/PS3