XFA: merge patch from CL 815103002
[pdfium.git] / third_party / 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 */