w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

cffparse.c
Go to the documentation of this file.
1 /****************************************************************************
2  *
3  * cffparse.c
4  *
5  * CFF token stream parser (body)
6  *
7  * Copyright (C) 1996-2020 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 "cffparse.h"
20 #include <freetype/internal/ftstream.h>
21 #include <freetype/internal/ftdebug.h>
22 #include <freetype/internal/ftcalc.h>
23 #include <freetype/internal/psaux.h>
24 #include <freetype/ftlist.h>
25 
26 #include "cfferrs.h"
27 #include "cffload.h"
28 
29 
30  /**************************************************************************
31  *
32  * The macro FT_COMPONENT is used in trace mode. It is an implicit
33  * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
34  * messages during execution.
35  */
36 #undef FT_COMPONENT
37 #define FT_COMPONENT cffparse
38 
39 
42  FT_UInt code,
43  void* object,
45  FT_UInt stackSize,
46  FT_UShort num_designs,
47  FT_UShort num_axes )
48  {
49  FT_Memory memory = library->memory; /* for FT_NEW_ARRAY */
50  FT_Error error; /* for FT_NEW_ARRAY */
51 
52 
53  FT_ZERO( parser );
54 
55 #if 0
56  parser->top = parser->stack;
57 #endif
58  parser->object_code = code;
59  parser->object = object;
60  parser->library = library;
61  parser->num_designs = num_designs;
62  parser->num_axes = num_axes;
63 
64  /* allocate the stack buffer */
65  if ( FT_NEW_ARRAY( parser->stack, stackSize ) )
66  {
67  FT_FREE( parser->stack );
68  goto Exit;
69  }
70 
71  parser->stackSize = stackSize;
72  parser->top = parser->stack; /* empty stack */
73 
74  Exit:
75  return error;
76  }
77 
78 
79 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
80  static void
81  finalize_t2_strings( FT_Memory memory,
82  void* data,
83  void* user )
84  {
85  CFF_T2_String t2 = (CFF_T2_String)data;
86 
87 
88  FT_UNUSED( user );
89 
90  memory->free( memory, t2->start );
91  memory->free( memory, data );
92  }
93 #endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
94 
95 
96  FT_LOCAL_DEF( void )
98  {
99  FT_Memory memory = parser->library->memory; /* for FT_FREE */
100 
101 
102  FT_FREE( parser->stack );
103 
104 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
105  FT_List_Finalize( &parser->t2_strings,
106  finalize_t2_strings,
107  memory,
108  NULL );
109 #endif
110  }
111 
112 
113  /* Assuming `first >= last'. */
114 
115  static FT_Error
117  FT_Byte* first,
118  FT_Byte* last )
119  {
120 #ifndef CFF_CONFIG_OPTION_OLD_ENGINE
121 
122  /* Fast path for regular FreeType builds with the "new" engine; */
123  /* `first >= parser->start' can be assumed. */
124 
125  FT_UNUSED( first );
126 
127  return last < parser->limit ? FT_Err_Ok : FT_THROW( Invalid_Argument );
128 
129 #else /* CFF_CONFIG_OPTION_OLD_ENGINE */
130 
132 
133 
134  if ( first >= parser->start &&
135  last < parser->limit )
136  return FT_Err_Ok;
137 
138  node = parser->t2_strings.head;
139 
140  while ( node )
141  {
142  CFF_T2_String t2 = (CFF_T2_String)node->data;
143 
144 
145  if ( first >= t2->start &&
146  last < t2->limit )
147  return FT_Err_Ok;
148 
149  node = node->next;
150  }
151 
152  return FT_THROW( Invalid_Argument );
153 
154 #endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
155  }
156 
157 
158  /* read an integer */
159  static FT_Long
161  FT_Byte* start )
162  {
163  FT_Byte* p = start;
164  FT_Int v = *p++;
165  FT_Long val = 0;
166 
167 
168  if ( v == 28 )
169  {
170  if ( cff_parser_within_limits( parser, p, p + 1 ) )
171  goto Bad;
172 
173  val = (FT_Short)( ( (FT_UShort)p[0] << 8 ) | p[1] );
174  }
175  else if ( v == 29 )
176  {
177  if ( cff_parser_within_limits( parser, p, p + 3 ) )
178  goto Bad;
179 
180  val = (FT_Long)( ( (FT_ULong)p[0] << 24 ) |
181  ( (FT_ULong)p[1] << 16 ) |
182  ( (FT_ULong)p[2] << 8 ) |
183  (FT_ULong)p[3] );
184  }
185  else if ( v < 247 )
186  {
187  val = v - 139;
188  }
189  else if ( v < 251 )
190  {
191  if ( cff_parser_within_limits( parser, p, p ) )
192  goto Bad;
193 
194  val = ( v - 247 ) * 256 + p[0] + 108;
195  }
196  else
197  {
198  if ( cff_parser_within_limits( parser, p, p ) )
199  goto Bad;
200 
201  val = -( v - 251 ) * 256 - p[0] - 108;
202  }
203 
204  Exit:
205  return val;
206 
207  Bad:
208  val = 0;
209  FT_TRACE4(( "!!!END OF DATA:!!!" ));
210  goto Exit;
211  }
212 
213 
214  static const FT_Long power_tens[] =
215  {
216  1L,
217  10L,
218  100L,
219  1000L,
220  10000L,
221  100000L,
222  1000000L,
223  10000000L,
224  100000000L,
225  1000000000L
226  };
227 
228  /* maximum values allowed for multiplying */
229  /* with the corresponding `power_tens' element */
230  static const FT_Long power_ten_limits[] =
231  {
232  FT_LONG_MAX / 1L,
233  FT_LONG_MAX / 10L,
234  FT_LONG_MAX / 100L,
235  FT_LONG_MAX / 1000L,
236  FT_LONG_MAX / 10000L,
237  FT_LONG_MAX / 100000L,
238  FT_LONG_MAX / 1000000L,
239  FT_LONG_MAX / 10000000L,
240  FT_LONG_MAX / 100000000L,
241  FT_LONG_MAX / 1000000000L,
242  };
243 
244 
245  /* read a real */
246  static FT_Fixed
248  FT_Byte* start,
249  FT_Long power_ten,
250  FT_Long* scaling )
251  {
252  FT_Byte* p = start;
253  FT_Int nib;
254  FT_UInt phase;
255 
256  FT_Long result, number, exponent;
257  FT_Int sign = 0, exponent_sign = 0, have_overflow = 0;
258  FT_Long exponent_add, integer_length, fraction_length;
259 
260 
261  if ( scaling )
262  *scaling = 0;
263 
264  result = 0;
265 
266  number = 0;
267  exponent = 0;
268 
269  exponent_add = 0;
270  integer_length = 0;
271  fraction_length = 0;
272 
273  /* First of all, read the integer part. */
274  phase = 4;
275 
276  for (;;)
277  {
278  /* If we entered this iteration with phase == 4, we need to */
279  /* read a new byte. This also skips past the initial 0x1E. */
280  if ( phase )
281  {
282  p++;
283 
284  /* Make sure we don't read past the end. */
285  if ( cff_parser_within_limits( parser, p, p ) )
286  goto Bad;
287  }
288 
289  /* Get the nibble. */
290  nib = (FT_Int)( p[0] >> phase ) & 0xF;
291  phase = 4 - phase;
292 
293  if ( nib == 0xE )
294  sign = 1;
295  else if ( nib > 9 )
296  break;
297  else
298  {
299  /* Increase exponent if we can't add the digit. */
300  if ( number >= 0xCCCCCCCL )
301  exponent_add++;
302  /* Skip leading zeros. */
303  else if ( nib || number )
304  {
305  integer_length++;
306  number = number * 10 + nib;
307  }
308  }
309  }
310 
311  /* Read fraction part, if any. */
312  if ( nib == 0xA )
313  for (;;)
314  {
315  /* If we entered this iteration with phase == 4, we need */
316  /* to read a new byte. */
317  if ( phase )
318  {
319  p++;
320 
321  /* Make sure we don't read past the end. */
322  if ( cff_parser_within_limits( parser, p, p ) )
323  goto Bad;
324  }
325 
326  /* Get the nibble. */
327  nib = ( p[0] >> phase ) & 0xF;
328  phase = 4 - phase;
329  if ( nib >= 10 )
330  break;
331 
332  /* Skip leading zeros if possible. */
333  if ( !nib && !number )
334  exponent_add--;
335  /* Only add digit if we don't overflow. */
336  else if ( number < 0xCCCCCCCL && fraction_length < 9 )
337  {
338  fraction_length++;
339  number = number * 10 + nib;
340  }
341  }
342 
343  /* Read exponent, if any. */
344  if ( nib == 12 )
345  {
346  exponent_sign = 1;
347  nib = 11;
348  }
349 
350  if ( nib == 11 )
351  {
352  for (;;)
353  {
354  /* If we entered this iteration with phase == 4, */
355  /* we need to read a new byte. */
356  if ( phase )
357  {
358  p++;
359 
360  /* Make sure we don't read past the end. */
361  if ( cff_parser_within_limits( parser, p, p ) )
362  goto Bad;
363  }
364 
365  /* Get the nibble. */
366  nib = ( p[0] >> phase ) & 0xF;
367  phase = 4 - phase;
368  if ( nib >= 10 )
369  break;
370 
371  /* Arbitrarily limit exponent. */
372  if ( exponent > 1000 )
373  have_overflow = 1;
374  else
375  exponent = exponent * 10 + nib;
376  }
377 
378  if ( exponent_sign )
379  exponent = -exponent;
380  }
381 
382  if ( !number )
383  goto Exit;
384 
385  if ( have_overflow )
386  {
387  if ( exponent_sign )
388  goto Underflow;
389  else
390  goto Overflow;
391  }
392 
393  /* We don't check `power_ten' and `exponent_add'. */
394  exponent += power_ten + exponent_add;
395 
396  if ( scaling )
397  {
398  /* Only use `fraction_length'. */
399  fraction_length += integer_length;
400  exponent += integer_length;
401 
402  if ( fraction_length <= 5 )
403  {
404  if ( number > 0x7FFFL )
405  {
406  result = FT_DivFix( number, 10 );
407  *scaling = exponent - fraction_length + 1;
408  }
409  else
410  {
411  if ( exponent > 0 )
412  {
413  FT_Long new_fraction_length, shift;
414 
415 
416  /* Make `scaling' as small as possible. */
417  new_fraction_length = FT_MIN( exponent, 5 );
418  shift = new_fraction_length - fraction_length;
419 
420  if ( shift > 0 )
421  {
422  exponent -= new_fraction_length;
423  number *= power_tens[shift];
424  if ( number > 0x7FFFL )
425  {
426  number /= 10;
427  exponent += 1;
428  }
429  }
430  else
431  exponent -= fraction_length;
432  }
433  else
434  exponent -= fraction_length;
435 
436  result = (FT_Long)( (FT_ULong)number << 16 );
437  *scaling = exponent;
438  }
439  }
440  else
441  {
442  if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
443  {
444  result = FT_DivFix( number, power_tens[fraction_length - 4] );
445  *scaling = exponent - 4;
446  }
447  else
448  {
449  result = FT_DivFix( number, power_tens[fraction_length - 5] );
450  *scaling = exponent - 5;
451  }
452  }
453  }
454  else
455  {
456  integer_length += exponent;
457  fraction_length -= exponent;
458 
459  if ( integer_length > 5 )
460  goto Overflow;
461  if ( integer_length < -5 )
462  goto Underflow;
463 
464  /* Remove non-significant digits. */
465  if ( integer_length < 0 )
466  {
467  number /= power_tens[-integer_length];
468  fraction_length += integer_length;
469  }
470 
471  /* this can only happen if exponent was non-zero */
472  if ( fraction_length == 10 )
473  {
474  number /= 10;
475  fraction_length -= 1;
476  }
477 
478  /* Convert into 16.16 format. */
479  if ( fraction_length > 0 )
480  {
481  if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
482  goto Exit;
483 
484  result = FT_DivFix( number, power_tens[fraction_length] );
485  }
486  else
487  {
488  number *= power_tens[-fraction_length];
489 
490  if ( number > 0x7FFFL )
491  goto Overflow;
492 
493  result = (FT_Long)( (FT_ULong)number << 16 );
494  }
495  }
496 
497  Exit:
498  if ( sign )
499  result = -result;
500 
501  return result;
502 
503  Overflow:
504  result = 0x7FFFFFFFL;
505  FT_TRACE4(( "!!!OVERFLOW:!!!" ));
506  goto Exit;
507 
508  Underflow:
509  result = 0;
510  FT_TRACE4(( "!!!UNDERFLOW:!!!" ));
511  goto Exit;
512 
513  Bad:
514  result = 0;
515  FT_TRACE4(( "!!!END OF DATA:!!!" ));
516  goto Exit;
517  }
518 
519 
520  /* read a number, either integer or real */
523  FT_Byte** d )
524  {
525  if ( **d == 30 )
526  {
527  /* binary-coded decimal is truncated to integer */
528  return cff_parse_real( parser, *d, 0, NULL ) >> 16;
529  }
530 
531  else if ( **d == 255 )
532  {
533  /* 16.16 fixed point is used internally for CFF2 blend results. */
534  /* Since these are trusted values, a limit check is not needed. */
535 
536  /* After the 255, 4 bytes give the number. */
537  /* The blend value is converted to integer, with rounding; */
538  /* due to the right-shift we don't need the lowest byte. */
539 #if 0
540  return (FT_Short)(
541  ( ( ( (FT_UInt32)*( d[0] + 1 ) << 24 ) |
542  ( (FT_UInt32)*( d[0] + 2 ) << 16 ) |
543  ( (FT_UInt32)*( d[0] + 3 ) << 8 ) |
544  (FT_UInt32)*( d[0] + 4 ) ) + 0x8000U ) >> 16 );
545 #else
546  return (FT_Short)(
547  ( ( ( (FT_UInt32)*( d[0] + 1 ) << 16 ) |
548  ( (FT_UInt32)*( d[0] + 2 ) << 8 ) |
549  (FT_UInt32)*( d[0] + 3 ) ) + 0x80U ) >> 8 );
550 #endif
551  }
552 
553  else
554  return cff_parse_integer( parser, *d );
555  }
556 
557 
558  /* read a floating point number, either integer or real */
559  static FT_Fixed
561  FT_Byte** d,
562  FT_Long scaling )
563  {
564  if ( **d == 30 )
565  return cff_parse_real( parser, *d, scaling, NULL );
566  else
567  {
569 
570 
571  if ( scaling )
572  {
573  if ( FT_ABS( val ) > power_ten_limits[scaling] )
574  {
575  val = val > 0 ? 0x7FFFFFFFL : -0x7FFFFFFFL;
576  goto Overflow;
577  }
578 
579  val *= power_tens[scaling];
580  }
581 
582  if ( val > 0x7FFF )
583  {
584  val = 0x7FFFFFFFL;
585  goto Overflow;
586  }
587  else if ( val < -0x7FFF )
588  {
589  val = -0x7FFFFFFFL;
590  goto Overflow;
591  }
592 
593  return (FT_Long)( (FT_ULong)val << 16 );
594 
595  Overflow:
596  FT_TRACE4(( "!!!OVERFLOW:!!!" ));
597  return val;
598  }
599  }
600 
601 
602  /* read a floating point number, either integer or real */
603  static FT_Fixed
605  FT_Byte** d )
606  {
607  return do_fixed( parser, d, 0 );
608  }
609 
610 
611  /* read a floating point number, either integer or real, */
612  /* but return `10^scaling' times the number read in */
613  static FT_Fixed
615  FT_Byte** d,
616  FT_Long scaling )
617  {
618  return do_fixed( parser, d, scaling );
619  }
620 
621 
622  /* read a floating point number, either integer or real, */
623  /* and return it as precise as possible -- `scaling' returns */
624  /* the scaling factor (as a power of 10) */
625  static FT_Fixed
627  FT_Byte** d,
628  FT_Long* scaling )
629  {
630  FT_ASSERT( scaling );
631 
632  if ( **d == 30 )
633  return cff_parse_real( parser, *d, 0, scaling );
634  else
635  {
636  FT_Long number;
637  FT_Int integer_length;
638 
639 
640  number = cff_parse_integer( parser, d[0] );
641 
642  if ( number > 0x7FFFL )
643  {
644  for ( integer_length = 5; integer_length < 10; integer_length++ )
645  if ( number < power_tens[integer_length] )
646  break;
647 
648  if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL )
649  {
650  *scaling = integer_length - 4;
651  return FT_DivFix( number, power_tens[integer_length - 4] );
652  }
653  else
654  {
655  *scaling = integer_length - 5;
656  return FT_DivFix( number, power_tens[integer_length - 5] );
657  }
658  }
659  else
660  {
661  *scaling = 0;
662  return (FT_Long)( (FT_ULong)number << 16 );
663  }
664  }
665  }
666 
667 
668  static FT_Error
670  {
671  CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
672  FT_Matrix* matrix = &dict->font_matrix;
673  FT_Vector* offset = &dict->font_offset;
674  FT_ULong* upm = &dict->units_per_em;
675  FT_Byte** data = parser->stack;
676 
677 
678  if ( parser->top >= parser->stack + 6 )
679  {
680  FT_Fixed values[6];
681  FT_Long scalings[6];
682 
683  FT_Long min_scaling, max_scaling;
684  int i;
685 
686 
687  dict->has_font_matrix = TRUE;
688 
689  /* We expect a well-formed font matrix, this is, the matrix elements */
690  /* `xx' and `yy' are of approximately the same magnitude. To avoid */
691  /* loss of precision, we use the magnitude of the largest matrix */
692  /* element to scale all other elements. The scaling factor is then */
693  /* contained in the `units_per_em' value. */
694 
695  max_scaling = FT_LONG_MIN;
696  min_scaling = FT_LONG_MAX;
697 
698  for ( i = 0; i < 6; i++ )
699  {
700  values[i] = cff_parse_fixed_dynamic( parser, data++, &scalings[i] );
701  if ( values[i] )
702  {
703  if ( scalings[i] > max_scaling )
704  max_scaling = scalings[i];
705  if ( scalings[i] < min_scaling )
706  min_scaling = scalings[i];
707  }
708  }
709 
710  if ( max_scaling < -9 ||
711  max_scaling > 0 ||
712  ( max_scaling - min_scaling ) < 0 ||
713  ( max_scaling - min_scaling ) > 9 )
714  {
715  FT_TRACE1(( "cff_parse_font_matrix:"
716  " strange scaling values (minimum %ld, maximum %ld),\n"
717  " "
718  " using default matrix\n", min_scaling, max_scaling ));
719  goto Unlikely;
720  }
721 
722  for ( i = 0; i < 6; i++ )
723  {
724  FT_Fixed value = values[i];
725  FT_Long divisor, half_divisor;
726 
727 
728  if ( !value )
729  continue;
730 
731  divisor = power_tens[max_scaling - scalings[i]];
732  half_divisor = divisor >> 1;
733 
734  if ( value < 0 )
735  {
736  if ( FT_LONG_MIN + half_divisor < value )
737  values[i] = ( value - half_divisor ) / divisor;
738  else
739  values[i] = FT_LONG_MIN / divisor;
740  }
741  else
742  {
743  if ( FT_LONG_MAX - half_divisor > value )
744  values[i] = ( value + half_divisor ) / divisor;
745  else
746  values[i] = FT_LONG_MAX / divisor;
747  }
748  }
749 
750  matrix->xx = values[0];
751  matrix->yx = values[1];
752  matrix->xy = values[2];
753  matrix->yy = values[3];
754  offset->x = values[4];
755  offset->y = values[5];
756 
757  *upm = (FT_ULong)power_tens[-max_scaling];
758 
759  FT_TRACE4(( " [%f %f %f %f %f %f]\n",
760  (double)matrix->xx / *upm / 65536,
761  (double)matrix->xy / *upm / 65536,
762  (double)matrix->yx / *upm / 65536,
763  (double)matrix->yy / *upm / 65536,
764  (double)offset->x / *upm / 65536,
765  (double)offset->y / *upm / 65536 ));
766 
767  if ( !FT_Matrix_Check( matrix ) )
768  {
769  FT_TRACE1(( "cff_parse_font_matrix:"
770  " degenerate values, using default matrix\n" ));
771  goto Unlikely;
772  }
773 
774  return FT_Err_Ok;
775  }
776  else
777  return FT_THROW( Stack_Underflow );
778 
779  Unlikely:
780  /* Return default matrix in case of unlikely values. */
781 
782  matrix->xx = 0x10000L;
783  matrix->yx = 0;
784  matrix->xy = 0;
785  matrix->yy = 0x10000L;
786  offset->x = 0;
787  offset->y = 0;
788  *upm = 1;
789 
790  return FT_Err_Ok;
791  }
792 
793 
794  static FT_Error
796  {
797  CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
798  FT_BBox* bbox = &dict->font_bbox;
799  FT_Byte** data = parser->stack;
800  FT_Error error;
801 
802 
803  error = FT_ERR( Stack_Underflow );
804 
805  if ( parser->top >= parser->stack + 4 )
806  {
807  bbox->xMin = FT_RoundFix( cff_parse_fixed( parser, data++ ) );
808  bbox->yMin = FT_RoundFix( cff_parse_fixed( parser, data++ ) );
809  bbox->xMax = FT_RoundFix( cff_parse_fixed( parser, data++ ) );
810  bbox->yMax = FT_RoundFix( cff_parse_fixed( parser, data ) );
811  error = FT_Err_Ok;
812 
813  FT_TRACE4(( " [%ld %ld %ld %ld]\n",
814  bbox->xMin / 65536,
815  bbox->yMin / 65536,
816  bbox->xMax / 65536,
817  bbox->yMax / 65536 ));
818  }
819 
820  return error;
821  }
822 
823 
824  static FT_Error
826  {
827  CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
828  FT_Byte** data = parser->stack;
829  FT_Error error;
830 
831 
832  error = FT_ERR( Stack_Underflow );
833 
834  if ( parser->top >= parser->stack + 2 )
835  {
836  FT_Long tmp;
837 
838 
839  tmp = cff_parse_num( parser, data++ );
840  if ( tmp < 0 )
841  {
842  FT_ERROR(( "cff_parse_private_dict: Invalid dictionary size\n" ));
843  error = FT_THROW( Invalid_File_Format );
844  goto Fail;
845  }
846  dict->private_size = (FT_ULong)tmp;
847 
848  tmp = cff_parse_num( parser, data );
849  if ( tmp < 0 )
850  {
851  FT_ERROR(( "cff_parse_private_dict: Invalid dictionary offset\n" ));
852  error = FT_THROW( Invalid_File_Format );
853  goto Fail;
854  }
855  dict->private_offset = (FT_ULong)tmp;
856 
857  FT_TRACE4(( " %lu %lu\n",
858  dict->private_size, dict->private_offset ));
859 
860  error = FT_Err_Ok;
861  }
862 
863  Fail:
864  return error;
865  }
866 
867 
868  /* The `MultipleMaster' operator comes before any */
869  /* top DICT operators that contain T2 charstrings. */
870 
871  static FT_Error
873  {
874  CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
875  FT_Error error;
876 
877 
879  /* beautify tracing message */
880  if ( ft_trace_levels[FT_TRACE_COMP( FT_COMPONENT )] < 4 )
881  FT_TRACE1(( "Multiple Master CFFs not supported yet,"
882  " handling first master design only\n" ));
883  else
884  FT_TRACE1(( " (not supported yet,"
885  " handling first master design only)\n" ));
886 #endif
887 
888  error = FT_ERR( Stack_Underflow );
889 
890  /* currently, we handle only the first argument */
891  if ( parser->top >= parser->stack + 5 )
892  {
893  FT_Long num_designs = cff_parse_num( parser, parser->stack );
894 
895 
896  if ( num_designs > 16 || num_designs < 2 )
897  {
898  FT_ERROR(( "cff_parse_multiple_master:"
899  " Invalid number of designs\n" ));
900  error = FT_THROW( Invalid_File_Format );
901  }
902  else
903  {
904  dict->num_designs = (FT_UShort)num_designs;
905  dict->num_axes = (FT_UShort)( parser->top - parser->stack - 4 );
906 
907  parser->num_designs = dict->num_designs;
908  parser->num_axes = dict->num_axes;
909 
910  error = FT_Err_Ok;
911  }
912  }
913 
914  return error;
915  }
916 
917 
918  static FT_Error
920  {
921  CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
922  FT_Byte** data = parser->stack;
923  FT_Error error;
924 
925 
926  error = FT_ERR( Stack_Underflow );
927 
928  if ( parser->top >= parser->stack + 3 )
929  {
932  if ( **data == 30 )
933  FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
935  if ( dict->cid_supplement < 0 )
936  FT_TRACE1(( "cff_parse_cid_ros: negative supplement %ld is found\n",
937  dict->cid_supplement ));
938  error = FT_Err_Ok;
939 
940  FT_TRACE4(( " %d %d %ld\n",
941  dict->cid_registry,
942  dict->cid_ordering,
943  dict->cid_supplement ));
944  }
945 
946  return error;
947  }
948 
949 
950  static FT_Error
952  {
953  /* vsindex operator can only be used in a Private DICT */
954  CFF_Private priv = (CFF_Private)parser->object;
955  FT_Byte** data = parser->stack;
957  FT_Error error;
958 
959 
960  if ( !priv || !priv->subfont )
961  {
962  error = FT_THROW( Invalid_File_Format );
963  goto Exit;
964  }
965 
966  blend = &priv->subfont->blend;
967 
968  if ( blend->usedBV )
969  {
970  FT_ERROR(( " cff_parse_vsindex: vsindex not allowed after blend\n" ));
971  error = FT_THROW( Syntax_Error );
972  goto Exit;
973  }
974 
975  priv->vsindex = (FT_UInt)cff_parse_num( parser, data++ );
976 
977  FT_TRACE4(( " %d\n", priv->vsindex ));
978 
979  error = FT_Err_Ok;
980 
981  Exit:
982  return error;
983  }
984 
985 
986  static FT_Error
988  {
989  /* blend operator can only be used in a Private DICT */
990  CFF_Private priv = (CFF_Private)parser->object;
991  CFF_SubFont subFont;
993  FT_UInt numBlends;
994  FT_Error error;
995 
996 
997  if ( !priv || !priv->subfont )
998  {
999  error = FT_THROW( Invalid_File_Format );
1000  goto Exit;
1001  }
1002 
1003  subFont = priv->subfont;
1004  blend = &subFont->blend;
1005 
1007  priv->vsindex,
1008  subFont->lenNDV,
1009  subFont->NDV ) )
1010  {
1012  priv->vsindex,
1013  subFont->lenNDV,
1014  subFont->NDV );
1015  if ( error )
1016  goto Exit;
1017  }
1018 
1019  numBlends = (FT_UInt)cff_parse_num( parser, parser->top - 1 );
1020  if ( numBlends > parser->stackSize )
1021  {
1022  FT_ERROR(( "cff_parse_blend: Invalid number of blends\n" ));
1023  error = FT_THROW( Invalid_File_Format );
1024  goto Exit;
1025  }
1026 
1027  FT_TRACE4(( " %d value%s blended\n",
1028  numBlends,
1029  numBlends == 1 ? "" : "s" ));
1030 
1031  error = cff_blend_doBlend( subFont, parser, numBlends );
1032 
1033  blend->usedBV = TRUE;
1034 
1035  Exit:
1036  return error;
1037  }
1038 
1039 
1040  /* maxstack operator increases parser and operand stacks for CFF2 */
1041  static FT_Error
1043  {
1044  /* maxstack operator can only be used in a Top DICT */
1045  CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
1046  FT_Byte** data = parser->stack;
1048 
1049 
1050  if ( !dict )
1051  {
1052  error = FT_THROW( Invalid_File_Format );
1053  goto Exit;
1054  }
1055 
1056  dict->maxstack = (FT_UInt)cff_parse_num( parser, data++ );
1057  if ( dict->maxstack > CFF2_MAX_STACK )
1058  dict->maxstack = CFF2_MAX_STACK;
1059  if ( dict->maxstack < CFF2_DEFAULT_STACK )
1060  dict->maxstack = CFF2_DEFAULT_STACK;
1061 
1062  FT_TRACE4(( " %d\n", dict->maxstack ));
1063 
1064  Exit:
1065  return error;
1066  }
1067 
1068 
1069 #define CFF_FIELD_NUM( code, name, id ) \
1070  CFF_FIELD( code, name, id, cff_kind_num )
1071 #define CFF_FIELD_FIXED( code, name, id ) \
1072  CFF_FIELD( code, name, id, cff_kind_fixed )
1073 #define CFF_FIELD_FIXED_1000( code, name, id ) \
1074  CFF_FIELD( code, name, id, cff_kind_fixed_thousand )
1075 #define CFF_FIELD_STRING( code, name, id ) \
1076  CFF_FIELD( code, name, id, cff_kind_string )
1077 #define CFF_FIELD_BOOL( code, name, id ) \
1078  CFF_FIELD( code, name, id, cff_kind_bool )
1079 
1080 
1081 #undef CFF_FIELD
1082 #undef CFF_FIELD_DELTA
1083 
1084 
1085 #ifndef FT_DEBUG_LEVEL_TRACE
1086 
1087 
1088 #define CFF_FIELD_CALLBACK( code, name, id ) \
1089  { \
1090  cff_kind_callback, \
1091  code | CFFCODE, \
1092  0, 0, \
1093  cff_parse_ ## name, \
1094  0, 0 \
1095  },
1096 
1097 #define CFF_FIELD_BLEND( code, id ) \
1098  { \
1099  cff_kind_blend, \
1100  code | CFFCODE, \
1101  0, 0, \
1102  cff_parse_blend, \
1103  0, 0 \
1104  },
1105 
1106 #define CFF_FIELD( code, name, id, kind ) \
1107  { \
1108  kind, \
1109  code | CFFCODE, \
1110  FT_FIELD_OFFSET( name ), \
1111  FT_FIELD_SIZE( name ), \
1112  0, 0, 0 \
1113  },
1114 
1115 #define CFF_FIELD_DELTA( code, name, max, id ) \
1116  { \
1117  cff_kind_delta, \
1118  code | CFFCODE, \
1119  FT_FIELD_OFFSET( name ), \
1120  FT_FIELD_SIZE_DELTA( name ), \
1121  0, \
1122  max, \
1123  FT_FIELD_OFFSET( num_ ## name ) \
1124  },
1125 
1127  {
1128 
1129 #include "cfftoken.h"
1130 
1131  { 0, 0, 0, 0, 0, 0, 0 }
1132  };
1133 
1134 
1135 #else /* FT_DEBUG_LEVEL_TRACE */
1136 
1137 
1138 
1139 #define CFF_FIELD_CALLBACK( code, name, id ) \
1140  { \
1141  cff_kind_callback, \
1142  code | CFFCODE, \
1143  0, 0, \
1144  cff_parse_ ## name, \
1145  0, 0, \
1146  id \
1147  },
1148 
1149 #define CFF_FIELD_BLEND( code, id ) \
1150  { \
1151  cff_kind_blend, \
1152  code | CFFCODE, \
1153  0, 0, \
1154  cff_parse_blend, \
1155  0, 0, \
1156  id \
1157  },
1158 
1159 #define CFF_FIELD( code, name, id, kind ) \
1160  { \
1161  kind, \
1162  code | CFFCODE, \
1163  FT_FIELD_OFFSET( name ), \
1164  FT_FIELD_SIZE( name ), \
1165  0, 0, 0, \
1166  id \
1167  },
1168 
1169 #define CFF_FIELD_DELTA( code, name, max, id ) \
1170  { \
1171  cff_kind_delta, \
1172  code | CFFCODE, \
1173  FT_FIELD_OFFSET( name ), \
1174  FT_FIELD_SIZE_DELTA( name ), \
1175  0, \
1176  max, \
1177  FT_FIELD_OFFSET( num_ ## name ), \
1178  id \
1179  },
1180 
1181  static const CFF_Field_Handler cff_field_handlers[] =
1182  {
1183 
1184 #include "cfftoken.h"
1185 
1186  { 0, 0, 0, 0, 0, 0, 0, 0 }
1187  };
1188 
1189 
1190 #endif /* FT_DEBUG_LEVEL_TRACE */
1191 
1192 
1195  FT_Byte* start,
1196  FT_Byte* limit )
1197  {
1198  FT_Byte* p = start;
1200 
1201 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1202  PSAux_Service psaux;
1203 
1204  FT_Library library = parser->library;
1205  FT_Memory memory = library->memory;
1206 #endif
1207 
1208  parser->top = parser->stack;
1209  parser->start = start;
1210  parser->limit = limit;
1211  parser->cursor = start;
1212 
1213  while ( p < limit )
1214  {
1215  FT_UInt v = *p;
1216 
1217 
1218  /* Opcode 31 is legacy MM T2 operator, not a number. */
1219  /* Opcode 255 is reserved and should not appear in fonts; */
1220  /* it is used internally for CFF2 blends. */
1221  if ( v >= 27 && v != 31 && v != 255 )
1222  {
1223  /* it's a number; we will push its position on the stack */
1224  if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1225  goto Stack_Overflow;
1226 
1227  *parser->top++ = p;
1228 
1229  /* now, skip it */
1230  if ( v == 30 )
1231  {
1232  /* skip real number */
1233  p++;
1234  for (;;)
1235  {
1236  /* An unterminated floating point number at the */
1237  /* end of a dictionary is invalid but harmless. */
1238  if ( p >= limit )
1239  goto Exit;
1240  v = p[0] >> 4;
1241  if ( v == 15 )
1242  break;
1243  v = p[0] & 0xF;
1244  if ( v == 15 )
1245  break;
1246  p++;
1247  }
1248  }
1249  else if ( v == 28 )
1250  p += 2;
1251  else if ( v == 29 )
1252  p += 4;
1253  else if ( v > 246 )
1254  p += 1;
1255  }
1256 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1257  else if ( v == 31 )
1258  {
1259  /* a Type 2 charstring */
1260 
1261  CFF_Decoder decoder;
1262  CFF_FontRec cff_rec;
1263  FT_Byte* charstring_base;
1264  FT_ULong charstring_len;
1265 
1266  FT_Fixed* stack;
1267  FT_ListNode node;
1268  CFF_T2_String t2;
1269  FT_Fixed t2_size;
1270  FT_Byte* q;
1271 
1272 
1273  charstring_base = ++p;
1274 
1275  /* search `endchar' operator */
1276  for (;;)
1277  {
1278  if ( p >= limit )
1279  goto Exit;
1280  if ( *p == 14 )
1281  break;
1282  p++;
1283  }
1284 
1285  charstring_len = (FT_ULong)( p - charstring_base ) + 1;
1286 
1287  /* construct CFF_Decoder object */
1288  FT_ZERO( &decoder );
1289  FT_ZERO( &cff_rec );
1290 
1291  cff_rec.top_font.font_dict.num_designs = parser->num_designs;
1292  cff_rec.top_font.font_dict.num_axes = parser->num_axes;
1293  decoder.cff = &cff_rec;
1294 
1295  psaux = (PSAux_Service)FT_Get_Module_Interface( library, "psaux" );
1296  if ( !psaux )
1297  {
1298  FT_ERROR(( "cff_parser_run: cannot access `psaux' module\n" ));
1299  error = FT_THROW( Missing_Module );
1300  goto Exit;
1301  }
1302 
1303  error = psaux->cff_decoder_funcs->parse_charstrings_old(
1304  &decoder, charstring_base, charstring_len, 1 );
1305  if ( error )
1306  goto Exit;
1307 
1308  /* Now copy the stack data in the temporary decoder object, */
1309  /* converting it back to charstring number representations */
1310  /* (this is ugly, I know). */
1311 
1312  node = (FT_ListNode)memory->alloc( memory,
1313  sizeof ( FT_ListNodeRec ) );
1314  if ( !node )
1315  goto Out_Of_Memory_Error;
1316 
1317  FT_List_Add( &parser->t2_strings, node );
1318 
1319  t2 = (CFF_T2_String)memory->alloc( memory,
1320  sizeof ( CFF_T2_StringRec ) );
1321  if ( !t2 )
1322  goto Out_Of_Memory_Error;
1323 
1324  node->data = t2;
1325 
1326  /* `5' is the conservative upper bound of required bytes per stack */
1327  /* element. */
1328 
1329  t2_size = 5 * ( decoder.top - decoder.stack );
1330 
1331  q = (FT_Byte*)memory->alloc( memory, t2_size );
1332  if ( !q )
1333  goto Out_Of_Memory_Error;
1334 
1335  t2->start = q;
1336  t2->limit = q + t2_size;
1337 
1338  stack = decoder.stack;
1339 
1340  while ( stack < decoder.top )
1341  {
1342  FT_ULong num;
1343  FT_Bool neg;
1344 
1345 
1346  if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1347  goto Stack_Overflow;
1348 
1349  *parser->top++ = q;
1350 
1351  if ( *stack < 0 )
1352  {
1353  num = (FT_ULong)NEG_LONG( *stack );
1354  neg = 1;
1355  }
1356  else
1357  {
1358  num = (FT_ULong)*stack;
1359  neg = 0;
1360  }
1361 
1362  if ( num & 0xFFFFU )
1363  {
1364  if ( neg )
1365  num = (FT_ULong)-num;
1366 
1367  *q++ = 255;
1368  *q++ = ( num & 0xFF000000U ) >> 24;
1369  *q++ = ( num & 0x00FF0000U ) >> 16;
1370  *q++ = ( num & 0x0000FF00U ) >> 8;
1371  *q++ = num & 0x000000FFU;
1372  }
1373  else
1374  {
1375  num >>= 16;
1376 
1377  if ( neg )
1378  {
1379  if ( num <= 107 )
1380  *q++ = (FT_Byte)( 139 - num );
1381  else if ( num <= 1131 )
1382  {
1383  *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 251 );
1384  *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
1385  }
1386  else
1387  {
1388  num = (FT_ULong)-num;
1389 
1390  *q++ = 28;
1391  *q++ = (FT_Byte)( num >> 8 );
1392  *q++ = (FT_Byte)( num & 0xFF );
1393  }
1394  }
1395  else
1396  {
1397  if ( num <= 107 )
1398  *q++ = (FT_Byte)( num + 139 );
1399  else if ( num <= 1131 )
1400  {
1401  *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 );
1402  *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
1403  }
1404  else
1405  {
1406  *q++ = 28;
1407  *q++ = (FT_Byte)( num >> 8 );
1408  *q++ = (FT_Byte)( num & 0xFF );
1409  }
1410  }
1411  }
1412 
1413  stack++;
1414  }
1415  }
1416 #endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
1417  else
1418  {
1419  /* This is not a number, hence it's an operator. Compute its code */
1420  /* and look for it in our current list. */
1421 
1422  FT_UInt code;
1423  FT_UInt num_args;
1424  const CFF_Field_Handler* field;
1425 
1426 
1427  if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1428  goto Stack_Overflow;
1429 
1430  num_args = (FT_UInt)( parser->top - parser->stack );
1431  *parser->top = p;
1432  code = v;
1433 
1434  if ( v == 12 )
1435  {
1436  /* two byte operator */
1437  p++;
1438  if ( p >= limit )
1439  goto Syntax_Error;
1440 
1441  code = 0x100 | p[0];
1442  }
1443  code = code | parser->object_code;
1444 
1445  for ( field = cff_field_handlers; field->kind; field++ )
1446  {
1447  if ( field->code == (FT_Int)code )
1448  {
1449  /* we found our field's handler; read it */
1450  FT_Long val;
1451  FT_Byte* q = (FT_Byte*)parser->object + field->offset;
1452 
1453 
1454 #ifdef FT_DEBUG_LEVEL_TRACE
1455  FT_TRACE4(( " %s", field->id ));
1456 #endif
1457 
1458  /* check that we have enough arguments -- except for */
1459  /* delta encoded arrays, which can be empty */
1460  if ( field->kind != cff_kind_delta && num_args < 1 )
1461  goto Stack_Underflow;
1462 
1463  switch ( field->kind )
1464  {
1465  case cff_kind_bool:
1466  case cff_kind_string:
1467  case cff_kind_num:
1468  val = cff_parse_num( parser, parser->stack );
1469  goto Store_Number;
1470 
1471  case cff_kind_fixed:
1472  val = cff_parse_fixed( parser, parser->stack );
1473  goto Store_Number;
1474 
1476  val = cff_parse_fixed_scaled( parser, parser->stack, 3 );
1477 
1478  Store_Number:
1479  switch ( field->size )
1480  {
1481  case (8 / FT_CHAR_BIT):
1482  *(FT_Byte*)q = (FT_Byte)val;
1483  break;
1484 
1485  case (16 / FT_CHAR_BIT):
1486  *(FT_Short*)q = (FT_Short)val;
1487  break;
1488 
1489  case (32 / FT_CHAR_BIT):
1490  *(FT_Int32*)q = (FT_Int)val;
1491  break;
1492 
1493  default: /* for 64-bit systems */
1494  *(FT_Long*)q = val;
1495  }
1496 
1497 #ifdef FT_DEBUG_LEVEL_TRACE
1498  switch ( field->kind )
1499  {
1500  case cff_kind_bool:
1501  FT_TRACE4(( " %s\n", val ? "true" : "false" ));
1502  break;
1503 
1504  case cff_kind_string:
1505  FT_TRACE4(( " %ld (SID)\n", val ));
1506  break;
1507 
1508  case cff_kind_num:
1509  FT_TRACE4(( " %ld\n", val ));
1510  break;
1511 
1512  case cff_kind_fixed:
1513  FT_TRACE4(( " %f\n", (double)val / 65536 ));
1514  break;
1515 
1517  FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
1518 
1519  default:
1520  ; /* never reached */
1521  }
1522 #endif
1523 
1524  break;
1525 
1526  case cff_kind_delta:
1527  {
1528  FT_Byte* qcount = (FT_Byte*)parser->object +
1529  field->count_offset;
1530 
1531  FT_Byte** data = parser->stack;
1532 
1533 
1534  if ( num_args > field->array_max )
1535  num_args = field->array_max;
1536 
1537  FT_TRACE4(( " [" ));
1538 
1539  /* store count */
1540  *qcount = (FT_Byte)num_args;
1541 
1542  val = 0;
1543  while ( num_args > 0 )
1544  {
1545  val = ADD_LONG( val, cff_parse_num( parser, data++ ) );
1546  switch ( field->size )
1547  {
1548  case (8 / FT_CHAR_BIT):
1549  *(FT_Byte*)q = (FT_Byte)val;
1550  break;
1551 
1552  case (16 / FT_CHAR_BIT):
1553  *(FT_Short*)q = (FT_Short)val;
1554  break;
1555 
1556  case (32 / FT_CHAR_BIT):
1557  *(FT_Int32*)q = (FT_Int)val;
1558  break;
1559 
1560  default: /* for 64-bit systems */
1561  *(FT_Long*)q = val;
1562  }
1563 
1564  FT_TRACE4(( " %ld", val ));
1565 
1566  q += field->size;
1567  num_args--;
1568  }
1569 
1570  FT_TRACE4(( "]\n" ));
1571  }
1572  break;
1573 
1574  default: /* callback or blend */
1575  error = field->reader( parser );
1576  if ( error )
1577  goto Exit;
1578  }
1579  goto Found;
1580  }
1581  }
1582 
1583  /* this is an unknown operator, or it is unsupported; */
1584  /* we will ignore it for now. */
1585 
1586  Found:
1587  /* clear stack */
1588  /* TODO: could clear blend stack here, */
1589  /* but we don't have access to subFont */
1590  if ( field->kind != cff_kind_blend )
1591  parser->top = parser->stack;
1592  }
1593  p++;
1594  } /* while ( p < limit ) */
1595 
1596  Exit:
1597  return error;
1598 
1599 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1600  Out_Of_Memory_Error:
1601  error = FT_THROW( Out_Of_Memory );
1602  goto Exit;
1603 #endif
1604 
1605  Stack_Overflow:
1606  error = FT_THROW( Invalid_Argument );
1607  goto Exit;
1608 
1609  Stack_Underflow:
1610  error = FT_THROW( Invalid_Argument );
1611  goto Exit;
1612 
1613  Syntax_Error:
1614  error = FT_THROW( Invalid_Argument );
1615  goto Exit;
1616  }
1617 
1618 
1619 /* END */
q
Definition: afm2pl.c:2287
int code
Definition: aftopl.c:52
mrb_ast_node node
Definition: codegen.c:30
@ TRUE
Definition: dd.h:102
int v
Definition: dviconv.c:10
#define error(a)
Definition: dviinfo.c:48
struct rect data
Definition: dvipdfm.c:64
void Exit(int code)
Definition: dvispc.c:374
#define shift
Definition: exp3.c:154
FcObject field
Definition: fcdefault.c:32
#define d(n)
Definition: gpos-common.c:151
void * object
Definition: jmemsys.h:48
#define FT_DEBUG_LEVEL_TRACE
Definition: ftoption.h:431
#define FT_LONG_MIN
Definition: ftstdlib.h:66
#define FT_CHAR_BIT
Definition: ftstdlib.h:61
#define FT_LONG_MAX
Definition: ftstdlib.h:67
#define FT_UNUSED(arg)
FT_RoundFix(FT_Fixed a)
Definition: ftcalc.c:87
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:607
FT_List_Finalize(FT_List list, FT_List_Destructor destroy, FT_Memory memory, void *user)
Definition: ftutil.c:412
FT_List_Add(FT_List list, FT_ListNode node)
Definition: ftutil.c:268
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:64
struct FT_ListNodeRec_ * FT_ListNode
Definition: fttypes.h:523
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
unsigned char FT_Byte
Definition: fttypes.h:154
signed long FT_Fixed
Definition: fttypes.h:287
int FT_Error
Definition: fttypes.h:299
signed long FT_Long
Definition: fttypes.h:242
#define FT_ERR(e)
Definition: fttypes.h:599
unsigned short FT_UShort
Definition: fttypes.h:209
signed short FT_Short
Definition: fttypes.h:198
unsigned int FT_UInt
Definition: fttypes.h:231
signed int FT_Int
Definition: fttypes.h:220
struct CFF_PrivateRec_ * CFF_Private
struct CFF_FontRecDictRec_ * CFF_FontRecDict
#define FT_LOCAL_DEF(x)
#define NEG_LONG(a)
Definition: ftcalc.h:478
FT_Bool FT_Matrix_Check(const FT_Matrix *matrix)
Definition: ftcalc.c:750
#define ADD_LONG(a, b)
Definition: ftcalc.h:472
#define FT_ASSERT(condition)
Definition: ftdebug.h:241
#define FT_ERROR(varformat)
Definition: ftdebug.h:211
#define FT_THROW(e)
Definition: ftdebug.h:243
#define FT_TRACE1(varformat)
Definition: ftdebug.h:188
#define FT_TRACE4(varformat)
Definition: ftdebug.h:191
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:341
#define FT_FREE(ptr)
Definition: ftmemory.h:337
#define FT_ZERO(p)
Definition: ftmemory.h:246
#define NULL
Definition: ftobjs.h:61
#define FT_ABS(a)
Definition: ftobjs.h:73
#define FT_MIN(a, b)
Definition: ftobjs.h:70
const void * FT_Get_Module_Interface(FT_Library library, const char *mod_name)
Definition: ftobjs.c:5012
struct PSAux_ServiceRec_ * PSAux_Service
small capitals from c petite p
Definition: afcover.h:72
small capitals from c petite p scientific i
Definition: afcover.h:80
sizeof(AF_ModuleRec)
return FT_Err_Ok
Definition: ftbbox.c:526
FT_Library library
Definition: cffdrivr.c:660
cff_blend_build_vector(CFF_Blend blend, FT_UInt vsindex, FT_UInt lenNDV, FT_Fixed *NDV)
Definition: cffload.c:1393
cff_blend_doBlend(CFF_SubFont subFont, CFF_Parser parser, FT_UInt numBlends)
Definition: cffload.c:1286
cff_blend_check_vector(CFF_Blend blend, FT_UInt vsindex, FT_UInt lenNDV, FT_Fixed *NDV)
Definition: cffload.c:1567
cff_parser_init(CFF_Parser parser, FT_UInt code, void *object, FT_Library library, FT_UInt stackSize, FT_UShort num_designs, FT_UShort num_axes)
Definition: cffparse.c:41
cff_parse_num(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:522
cff_parser_done(CFF_Parser parser)
Definition: cffparse.c:97
cff_parser_run(CFF_Parser parser, FT_Byte *start, FT_Byte *limit)
Definition: cffparse.c:1194
#define CFF2_DEFAULT_STACK
Definition: cffparse.h:42
@ cff_kind_bool
Definition: cffparse.h:104
@ cff_kind_fixed_thousand
Definition: cffparse.h:102
@ cff_kind_fixed
Definition: cffparse.h:101
@ cff_kind_delta
Definition: cffparse.h:105
@ cff_kind_blend
Definition: cffparse.h:107
@ cff_kind_string
Definition: cffparse.h:103
@ cff_kind_num
Definition: cffparse.h:100
#define CFF2_MAX_STACK
Definition: cffparse.h:41
int num
Definition: disdvi.c:621
static int phase
Definition: cs_type2.c:84
float ** matrix()
static void blend(struct RGBColour *src, struct RGBColour *dst)
Definition: picttoppm.c:1294
#define sign(x)
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
#define t2
integer nib[360]
Definition: pmxab.c:90
static int32_t last
Definition: ppagelist.c:29
static int32_t first
Definition: ppagelist.c:29
static int offset
Definition: ppmtogif.c:642
static FT_Fixed cff_parse_fixed(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:604
static FT_Fixed cff_parse_real(CFF_Parser parser, FT_Byte *start, FT_Long power_ten, FT_Long *scaling)
Definition: cffparse.c:247
static FT_Error cff_parse_maxstack(CFF_Parser parser)
Definition: cffparse.c:1042
static FT_Error cff_parse_font_bbox(CFF_Parser parser)
Definition: cffparse.c:795
static FT_Error cff_parse_vsindex(CFF_Parser parser)
Definition: cffparse.c:951
static FT_Fixed cff_parse_fixed_dynamic(CFF_Parser parser, FT_Byte **d, FT_Long *scaling)
Definition: cffparse.c:626
static FT_Fixed cff_parse_fixed_scaled(CFF_Parser parser, FT_Byte **d, FT_Long scaling)
Definition: cffparse.c:614
static FT_Fixed do_fixed(CFF_Parser parser, FT_Byte **d, FT_Long scaling)
Definition: cffparse.c:560
static const FT_Long power_tens[]
Definition: cffparse.c:214
static FT_Error cff_parse_font_matrix(CFF_Parser parser)
Definition: cffparse.c:669
static FT_Long cff_parse_integer(CFF_Parser parser, FT_Byte *start)
Definition: cffparse.c:160
static FT_Error cff_parse_private_dict(CFF_Parser parser)
Definition: cffparse.c:825
static const CFF_Field_Handler cff_field_handlers[]
Definition: cffparse.c:1126
static FT_Error cff_parse_multiple_master(CFF_Parser parser)
Definition: cffparse.c:872
static FT_Error cff_parse_blend(CFF_Parser parser)
Definition: cffparse.c:987
static FT_Error cff_parse_cid_ros(CFF_Parser parser)
Definition: cffparse.c:919
#define FT_COMPONENT
Definition: cffparse.c:37
static const FT_Long power_ten_limits[]
Definition: cffparse.c:230
static FT_Error cff_parser_within_limits(CFF_Parser parser, FT_Byte *first, FT_Byte *last)
Definition: cffparse.c:116
CFF_Font cff
Definition: psaux.h:1169
FT_Fixed * top
Definition: psaux.h:1172
FT_Fixed stack[48+1]
Definition: psaux.h:1171
FT_ULong private_size
Definition: cfftypes.h:209
FT_UInt cid_ordering
Definition: cfftypes.h:215
FT_UInt cid_registry
Definition: cfftypes.h:214
FT_ULong private_offset
Definition: cfftypes.h:208
FT_Bool has_font_matrix
Definition: cfftypes.h:199
FT_Vector font_offset
Definition: cfftypes.h:201
FT_UShort num_designs
Definition: cfftypes.h:230
FT_UShort num_axes
Definition: cfftypes.h:231
FT_ULong units_per_em
Definition: cfftypes.h:200
FT_Matrix font_matrix
Definition: cfftypes.h:198
FT_Long cid_supplement
Definition: cfftypes.h:216
CFF_SubFontRec top_font
Definition: cfftypes.h:377
CFF_SubFont subfont
Definition: cfftypes.h:278
FT_UInt vsindex
Definition: cfftypes.h:277
CFF_BlendRec blend
Definition: cfftypes.h:308
CFF_FontRecDictRec font_dict
Definition: cfftypes.h:304
FT_Memory memory
Definition: ftobjs.h:895
const CFF_Decoder_FuncsRec * cff_decoder_funcs
Definition: psaux.h:1375
Definition: nsfix.c:44
Definition: inftrees.h:24
Definition: ffi.h:208
Definition: spc_misc.c:56
Definition: strexpr.c:21
int number
Definition: t1part.c:207
val
Definition: tex4ht.c:3227
#define stack
Definition: stack.c:10
Definition: obx.h:51
@ start
Definition: preamble.c:52
#define limit(x)
Definition: yuvsplittoppm.c:26