1 /***************************************************************************/
2 /* */
3 /* cffparse.c */
4 /* */
5 /* CFF token stream parser (body) */
6 /* */
7 /* Copyright 1996-2001 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 /***************************************************************************/
19 #include <ft2build.h>
20 #include "cffparse.h"
21 #include FT_INTERNAL_STREAM_H
23 #include "cfferrs.h"
26 /*************************************************************************/
27 /* */
28 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
29 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
30 /* messages during execution. */
31 /* */
32 #undef FT_COMPONENT
33 #define FT_COMPONENT trace_cffparse
36 enum
37 {
38 cff_kind_none = 0,
39 cff_kind_num,
40 cff_kind_fixed,
41 cff_kind_string,
42 cff_kind_bool,
43 cff_kind_delta,
44 cff_kind_callback,
46 cff_kind_max /* do not remove */
47 };
50 /* now generate handlers for the most simple fields */
51 typedef FT_Error (*CFF_Field_Reader)( CFF_Parser* parser );
53 typedef struct CFF_Field_Handler_
54 {
55 int kind;
56 int code;
57 FT_UInt offset;
58 FT_Byte size;
59 CFF_Field_Reader reader;
60 FT_UInt array_max;
61 FT_UInt count_offset;
63 } CFF_Field_Handler;
66 FT_LOCAL_DEF void
67 CFF_Parser_Init( CFF_Parser* parser,
68 FT_UInt code,
69 void* object )
70 {
71 MEM_Set( parser, 0, sizeof ( *parser ) );
73 parser->top = parser->stack;
74 parser->object_code = code;
75 parser->object = object;
76 }
79 /* read an integer */
80 static FT_Long
81 cff_parse_integer( FT_Byte* start,
82 FT_Byte* limit )
83 {
84 FT_Byte* p = start;
85 FT_Int v = *p++;
86 FT_Long val = 0;
89 if ( v == 28 )
90 {
91 if ( p + 2 > limit )
92 goto Bad;
94 val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] );
95 p += 2;
96 }
97 else if ( v == 29 )
98 {
99 if ( p + 4 > limit )
100 goto Bad;
102 val = ( (FT_Long)p[0] << 24 ) |
103 ( (FT_Long)p[1] << 16 ) |
104 ( (FT_Long)p[2] << 8 ) |
105 p[3];
106 p += 4;
107 }
108 else if ( v < 247 )
109 {
110 val = v - 139;
111 }
112 else if ( v < 251 )
113 {
114 if ( p + 1 > limit )
115 goto Bad;
117 val = ( v - 247 ) * 256 + p[0] + 108;
118 p++;
119 }
120 else
121 {
122 if ( p + 1 > limit )
123 goto Bad;
125 val = -( v - 251 ) * 256 - p[0] - 108;
126 p++;
127 }
129 Exit:
130 return val;
132 Bad:
133 val = 0;
134 goto Exit;
135 }
138 /* read a real */
139 static FT_Fixed
140 cff_parse_real( FT_Byte* start,
141 FT_Byte* limit,
142 FT_Int power_ten )
143 {
144 FT_Byte* p = start;
145 FT_Long num, divider, result, exp;
146 FT_Int sign = 0, exp_sign = 0;
147 FT_UInt nib;
148 FT_UInt phase;
151 result = 0;
152 num = 0;
153 divider = 1;
155 /* first of all, read the integer part */
156 phase = 4;
158 for (;;)
159 {
160 /* If we entered this iteration with phase == 4, we need to */
161 /* read a new byte. This also skips past the intial 0x1E. */
162 if ( phase )
163 {
164 p++;
166 /* Make sure we don't read past the end. */
167 if ( p >= limit )
168 goto Bad;
169 }
171 /* Get the nibble. */
172 nib = ( p[0] >> phase ) & 0xF;
173 phase = 4 - phase;
175 if ( nib == 0xE )
176 sign = 1;
177 else if ( nib > 9 )
178 break;
179 else
180 result = result * 10 + nib;
181 }
183 /* read decimal part, if any */
184 if ( nib == 0xa )
185 for (;;)
186 {
187 /* If we entered this iteration with phase == 4, we need */
188 /* to read a new byte. */
189 if ( phase )
190 {
191 p++;
193 /* Make sure we don't read past the end. */
194 if ( p >= limit )
195 goto Bad;
196 }
198 /* Get the nibble. */
199 nib = ( p[0] >> phase ) & 0xF;
200 phase = 4 - phase;
201 if ( nib >= 10 )
202 break;
204 if ( divider < 10000000L )
205 {
206 num = num * 10 + nib;
207 divider *= 10;
208 }
209 }
211 /* read exponent, if any */
212 if ( nib == 12 )
213 {
214 exp_sign = 1;
215 nib = 11;
216 }
218 if ( nib == 11 )
219 {
220 exp = 0;
222 for (;;)
223 {
224 /* If we entered this iteration with phase == 4, we need */
225 /* to read a new byte. */
226 if ( phase )
227 {
228 p++;
230 /* Make sure we don't read past the end. */
231 if ( p >= limit )
232 goto Bad;
233 }
235 /* Get the nibble. */
236 nib = ( p[0] >> phase ) & 0xF;
237 phase = 4 - phase;
238 if ( nib >= 10 )
239 break;
241 exp = exp * 10 + nib;
242 }
244 if ( exp_sign )
245 exp = -exp;
247 power_ten += exp;
248 }
250 /* raise to power of ten if needed */
251 while ( power_ten > 0 )
252 {
253 result = result * 10;
254 num = num * 10;
256 power_ten--;
257 }
259 while ( power_ten < 0 )
260 {
261 result = result / 10;
262 divider = divider * 10;
264 power_ten++;
265 }
267 /* Move the integer part into the high 16 bits. */
268 result <<= 16;
270 /* Place the decimal part into the low 16 bits. */
271 if ( num )
272 result |= FT_DivFix( num, divider );
274 if ( sign )
275 result = -result;
277 Exit:
278 return result;
280 Bad:
281 result = 0;
282 goto Exit;
283 }
286 /* read a number, either integer or real */
287 static FT_Long
288 cff_parse_num( FT_Byte** d )
289 {
290 return ( **d == 30 ? ( cff_parse_real ( d[0], d[1], 0 ) >> 16 )
291 : cff_parse_integer( d[0], d[1] ) );
292 }
295 /* read a floating point number, either integer or real */
296 static FT_Fixed
297 cff_parse_fixed( FT_Byte** d )
298 {
299 return ( **d == 30 ? cff_parse_real ( d[0], d[1], 0 )
300 : cff_parse_integer( d[0], d[1] ) << 16 );
301 }
303 /* read a floating point number, either integer or real, */
304 /* but return 1000 times the number read in. */
305 static FT_Fixed
306 cff_parse_fixed_thousand( FT_Byte** d )
307 {
308 return **d ==
309 30 ? cff_parse_real ( d[0], d[1], 3 )
310 : (FT_Fixed)FT_MulFix( cff_parse_integer( d[0], d[1] ) << 16, 1000 );
311 }
313 static FT_Error
314 cff_parse_font_matrix( CFF_Parser* parser )
315 {
316 CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
317 FT_Matrix* matrix = &dict->font_matrix;
318 FT_Vector* offset = &dict->font_offset;
319 FT_UShort* upm = &dict->units_per_em;
320 FT_Byte** data = parser->stack;
321 FT_Error error;
322 FT_Fixed temp;
325 error = CFF_Err_Stack_Underflow;
327 if ( parser->top >= parser->stack + 6 )
328 {
329 matrix->xx = cff_parse_fixed_thousand( data++ );
330 matrix->yx = cff_parse_fixed_thousand( data++ );
331 matrix->xy = cff_parse_fixed_thousand( data++ );
332 matrix->yy = cff_parse_fixed_thousand( data++ );
333 offset->x = cff_parse_fixed_thousand( data++ );
334 offset->y = cff_parse_fixed_thousand( data );
336 temp = ABS( matrix->yy );
338 *upm = (FT_UShort)FT_DivFix( 0x10000L, FT_DivFix( temp, 1000 ) );
340 if ( temp != 0x10000L )
341 {
342 matrix->xx = FT_DivFix( matrix->xx, temp );
343 matrix->yx = FT_DivFix( matrix->yx, temp );
344 matrix->xy = FT_DivFix( matrix->xy, temp );
345 matrix->yy = FT_DivFix( matrix->yy, temp );
346 offset->x = FT_DivFix( offset->x, temp );
347 offset->y = FT_DivFix( offset->y, temp );
348 }
350 /* note that the offsets must be expressed in integer font units */
351 offset->x >>= 16;
352 offset->y >>= 16;
354 error = CFF_Err_Ok;
355 }
357 return error;
358 }
361 static FT_Error
362 cff_parse_font_bbox( CFF_Parser* parser )
363 {
364 CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
365 FT_BBox* bbox = &dict->font_bbox;
366 FT_Byte** data = parser->stack;
367 FT_Error error;
370 error = CFF_Err_Stack_Underflow;
372 if ( parser->top >= parser->stack + 4 )
373 {
374 bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) );
375 bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) );
376 bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) );
377 bbox->yMax = FT_RoundFix( cff_parse_fixed( data ) );
378 error = CFF_Err_Ok;
379 }
381 return error;
382 }
385 static FT_Error
386 cff_parse_private_dict( CFF_Parser* parser )
387 {
388 CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
389 FT_Byte** data = parser->stack;
390 FT_Error error;
393 error = CFF_Err_Stack_Underflow;
395 if ( parser->top >= parser->stack + 2 )
396 {
397 dict->private_size = cff_parse_num( data++ );
398 dict->private_offset = cff_parse_num( data );
399 error = CFF_Err_Ok;
400 }
402 return error;
403 }
406 static FT_Error
407 cff_parse_cid_ros( CFF_Parser* parser )
408 {
409 CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
410 FT_Byte** data = parser->stack;
411 FT_Error error;
414 error = CFF_Err_Stack_Underflow;
416 if ( parser->top >= parser->stack + 3 )
417 {
418 dict->cid_registry = (FT_UInt)cff_parse_num ( data++ );
419 dict->cid_ordering = (FT_UInt)cff_parse_num ( data++ );
420 dict->cid_supplement = (FT_ULong)cff_parse_num( data );
421 error = CFF_Err_Ok;
422 }
424 return error;
425 }
428 #define CFF_FIELD_NUM( code, name ) \
429 CFF_FIELD( code, name, cff_kind_num )
430 #define CFF_FIELD_FIXED( code, name ) \
431 CFF_FIELD( code, name, cff_kind_fixed )
432 #define CFF_FIELD_STRING( code, name ) \
433 CFF_FIELD( code, name, cff_kind_string )
434 #define CFF_FIELD_BOOL( code, name ) \
435 CFF_FIELD( code, name, cff_kind_bool )
436 #define CFF_FIELD_DELTA( code, name, max ) \
437 CFF_FIELD( code, name, cff_kind_delta )
439 #define CFF_FIELD_CALLBACK( code, name ) \
440 { \
441 cff_kind_callback, \
442 code | CFFCODE, \
443 0, 0, \
444 cff_parse_ ## name, \
445 0, 0 \
446 },
448 #undef CFF_FIELD
449 #define CFF_FIELD( code, name, kind ) \
450 { \
451 kind, \
452 code | CFFCODE, \
453 FT_FIELD_OFFSET( name ), \
454 FT_FIELD_SIZE( name ), \
455 0, 0, 0 \
456 },
458 #undef CFF_FIELD_DELTA
459 #define CFF_FIELD_DELTA( code, name, max ) \
460 { \
461 cff_kind_delta, \
462 code | CFFCODE, \
463 FT_FIELD_OFFSET( name ), \
464 FT_FIELD_SIZE_DELTA( name ), \
465 0, \
466 max, \
467 FT_FIELD_OFFSET( num_ ## name ) \
468 },
470 #define CFFCODE_TOPDICT 0x1000
471 #define CFFCODE_PRIVATE 0x2000
473 static const CFF_Field_Handler cff_field_handlers[] =
474 {
476 #include "cfftoken.h"
478 { 0, 0, 0, 0, 0, 0, 0 }
479 };
482 FT_LOCAL_DEF FT_Error
483 CFF_Parser_Run( CFF_Parser* parser,
484 FT_Byte* start,
485 FT_Byte* limit )
486 {
487 FT_Byte* p = start;
488 FT_Error error = CFF_Err_Ok;
491 parser->top = parser->stack;
492 parser->start = start;
493 parser->limit = limit;
494 parser->cursor = start;
496 while ( p < limit )
497 {
498 FT_UInt v = *p;
501 if ( v >= 27 && v != 31 )
502 {
503 /* it's a number; we will push its position on the stack */
504 if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH )
505 goto Stack_Overflow;
507 *parser->top ++ = p;
509 /* now, skip it */
510 if ( v == 30 )
511 {
512 /* skip real number */
513 p++;
514 for (;;)
515 {
516 if ( p >= limit )
517 goto Syntax_Error;
518 v = p[0] >> 4;
519 if ( v == 15 )
520 break;
521 v = p[0] & 0xF;
522 if ( v == 15 )
523 break;
524 p++;
525 }
526 }
527 else if ( v == 28 )
528 p += 2;
529 else if ( v == 29 )
530 p += 4;
531 else if ( v > 246 )
532 p += 1;
533 }
534 else
535 {
536 /* This is not a number, hence it's an operator. Compute its code */
537 /* and look for it in our current list. */
539 FT_UInt code;
540 FT_UInt num_args = (FT_UInt)
541 ( parser->top - parser->stack );
542 const CFF_Field_Handler* field;
545 /* first of all, a trivial check */
546 if ( num_args < 1 )
547 goto Stack_Underflow;
549 *parser->top = p;
550 code = v;
551 if ( v == 12 )
552 {
553 /* two byte operator */
554 p++;
555 code = 0x100 | p[0];
556 }
557 code = code | parser->object_code;
559 for ( field = cff_field_handlers; field->kind; field++ )
560 {
561 if ( field->code == (FT_Int)code )
562 {
563 /* we found our field's handler; read it */
564 FT_Long val;
565 FT_Byte* q = (FT_Byte*)parser->object + field->offset;
568 switch ( field->kind )
569 {
570 case cff_kind_bool:
571 case cff_kind_string:
572 case cff_kind_num:
573 val = cff_parse_num( parser->stack );
574 goto Store_Number;
576 case cff_kind_fixed:
577 val = cff_parse_fixed( parser->stack );
579 Store_Number:
580 switch ( field->size )
581 {
582 case 1:
583 *(FT_Byte*)q = (FT_Byte)val;
584 break;
586 case 2:
587 *(FT_Short*)q = (FT_Short)val;
588 break;
590 case 4:
591 *(FT_Int32*)q = (FT_Int)val;
592 break;
594 default: /* for 64-bit systems where long is 8 bytes */
595 *(FT_Long*)q = val;
596 }
597 break;
599 case cff_kind_delta:
600 {
601 FT_Byte* qcount = (FT_Byte*)parser->object +
602 field->count_offset;
604 FT_Byte** data = parser->stack;
607 if ( num_args > field->array_max )
608 num_args = field->array_max;
610 /* store count */
611 *qcount = (FT_Byte)num_args;
613 val = 0;
614 while ( num_args > 0 )
615 {
616 val += cff_parse_num( data++ );
617 switch ( field->size )
618 {
619 case 1:
620 *(FT_Byte*)q = (FT_Byte)val;
621 break;
623 case 2:
624 *(FT_Short*)q = (FT_Short)val;
625 break;
627 case 4:
628 *(FT_Int32*)q = (FT_Int)val;
629 break;
631 default: /* for 64-bit systems */
632 *(FT_Long*)q = val;
633 }
635 q += field->size;
636 num_args--;
637 }
638 }
639 break;
641 default: /* callback */
642 error = field->reader( parser );
643 if ( error )
644 goto Exit;
645 }
646 goto Found;
647 }
648 }
650 /* this is an unknown operator, or it is unsupported; */
651 /* we will ignore it for now. */
653 Found:
654 /* clear stack */
655 parser->top = parser->stack;
656 }
657 p++;
658 }
660 Exit:
661 return error;
663 Stack_Overflow:
664 error = CFF_Err_Invalid_Argument;
665 goto Exit;
667 Stack_Underflow:
668 error = CFF_Err_Invalid_Argument;
669 goto Exit;
671 Syntax_Error:
672 error = CFF_Err_Invalid_Argument;
673 goto Exit;
674 }
677 /* END */