zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
cffgload.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* cffgload.c */
4 /* */
5 /* OpenType Glyph Loader (body). */
6 /* */
7 /* Copyright 1996-2012 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 FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_STREAM_H
22 #include FT_INTERNAL_SFNT_H
23 #include FT_OUTLINE_H
24 
25 #include "cffobjs.h"
26 #include "cffload.h"
27 #include "cffgload.h"
28 
29 #include "cfferrs.h"
30 
31 
32  /*************************************************************************/
33  /* */
34  /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
35  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
36  /* messages during execution. */
37  /* */
38 #undef FT_COMPONENT
39 #define FT_COMPONENT trace_cffgload
40 
41 
42  typedef enum CFF_Operator_
43  {
44  cff_op_unknown = 0,
45 
46  cff_op_rmoveto,
47  cff_op_hmoveto,
48  cff_op_vmoveto,
49 
50  cff_op_rlineto,
51  cff_op_hlineto,
52  cff_op_vlineto,
53 
54  cff_op_rrcurveto,
55  cff_op_hhcurveto,
56  cff_op_hvcurveto,
57  cff_op_rcurveline,
58  cff_op_rlinecurve,
59  cff_op_vhcurveto,
60  cff_op_vvcurveto,
61 
62  cff_op_flex,
63  cff_op_hflex,
64  cff_op_hflex1,
65  cff_op_flex1,
66 
67  cff_op_endchar,
68 
69  cff_op_hstem,
70  cff_op_vstem,
71  cff_op_hstemhm,
72  cff_op_vstemhm,
73 
74  cff_op_hintmask,
75  cff_op_cntrmask,
76  cff_op_dotsection, /* deprecated, acts as no-op */
77 
78  cff_op_abs,
79  cff_op_add,
80  cff_op_sub,
81  cff_op_div,
82  cff_op_neg,
83  cff_op_random,
84  cff_op_mul,
85  cff_op_sqrt,
86 
87  cff_op_blend,
88 
89  cff_op_drop,
90  cff_op_exch,
91  cff_op_index,
92  cff_op_roll,
93  cff_op_dup,
94 
95  cff_op_put,
96  cff_op_get,
97  cff_op_store,
98  cff_op_load,
99 
100  cff_op_and,
101  cff_op_or,
102  cff_op_not,
103  cff_op_eq,
104  cff_op_ifelse,
105 
106  cff_op_callsubr,
107  cff_op_callgsubr,
108  cff_op_return,
109 
110  /* Type 1 opcodes: invalid but seen in real life */
111  cff_op_hsbw,
112  cff_op_closepath,
113  cff_op_callothersubr,
114  cff_op_pop,
115  cff_op_seac,
116  cff_op_sbw,
117  cff_op_setcurrentpoint,
118 
119  /* do not remove */
120  cff_op_max
121 
122  } CFF_Operator;
123 
124 
125 #define CFF_COUNT_CHECK_WIDTH 0x80
126 #define CFF_COUNT_EXACT 0x40
127 #define CFF_COUNT_CLEAR_STACK 0x20
128 
129  /* count values which have the `CFF_COUNT_CHECK_WIDTH' flag set are */
130  /* used for checking the width and requested numbers of arguments */
131  /* only; they are set to zero afterwards */
132 
133  /* the other two flags are informative only and unused currently */
134 
135  static const FT_Byte cff_argument_counts[] =
136  {
137  0, /* unknown */
138 
139  2 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT, /* rmoveto */
140  1 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT,
141  1 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT,
142 
143  0 | CFF_COUNT_CLEAR_STACK, /* rlineto */
144  0 | CFF_COUNT_CLEAR_STACK,
145  0 | CFF_COUNT_CLEAR_STACK,
146 
147  0 | CFF_COUNT_CLEAR_STACK, /* rrcurveto */
148  0 | CFF_COUNT_CLEAR_STACK,
149  0 | CFF_COUNT_CLEAR_STACK,
150  0 | CFF_COUNT_CLEAR_STACK,
151  0 | CFF_COUNT_CLEAR_STACK,
152  0 | CFF_COUNT_CLEAR_STACK,
153  0 | CFF_COUNT_CLEAR_STACK,
154 
155  13, /* flex */
156  7,
157  9,
158  11,
159 
160  0 | CFF_COUNT_CHECK_WIDTH, /* endchar */
161 
162  2 | CFF_COUNT_CHECK_WIDTH, /* hstem */
163  2 | CFF_COUNT_CHECK_WIDTH,
164  2 | CFF_COUNT_CHECK_WIDTH,
165  2 | CFF_COUNT_CHECK_WIDTH,
166 
167  0 | CFF_COUNT_CHECK_WIDTH, /* hintmask */
168  0 | CFF_COUNT_CHECK_WIDTH, /* cntrmask */
169  0, /* dotsection */
170 
171  1, /* abs */
172  2,
173  2,
174  2,
175  1,
176  0,
177  2,
178  1,
179 
180  1, /* blend */
181 
182  1, /* drop */
183  2,
184  1,
185  2,
186  1,
187 
188  2, /* put */
189  1,
190  4,
191  3,
192 
193  2, /* and */
194  2,
195  1,
196  2,
197  4,
198 
199  1, /* callsubr */
200  1,
201  0,
202 
203  2, /* hsbw */
204  0,
205  0,
206  0,
207  5, /* seac */
208  4, /* sbw */
209  2 /* setcurrentpoint */
210  };
211 
212 
213  /*************************************************************************/
214  /*************************************************************************/
215  /*************************************************************************/
216  /********** *********/
217  /********** *********/
218  /********** GENERIC CHARSTRING PARSING *********/
219  /********** *********/
220  /********** *********/
221  /*************************************************************************/
222  /*************************************************************************/
223  /*************************************************************************/
224 
225 
226  /*************************************************************************/
227  /* */
228  /* <Function> */
229  /* cff_builder_init */
230  /* */
231  /* <Description> */
232  /* Initializes a given glyph builder. */
233  /* */
234  /* <InOut> */
235  /* builder :: A pointer to the glyph builder to initialize. */
236  /* */
237  /* <Input> */
238  /* face :: The current face object. */
239  /* */
240  /* size :: The current size object. */
241  /* */
242  /* glyph :: The current glyph object. */
243  /* */
244  /* hinting :: Whether hinting is active. */
245  /* */
246  static void
247  cff_builder_init( CFF_Builder* builder,
248  TT_Face face,
249  CFF_Size size,
250  CFF_GlyphSlot glyph,
251  FT_Bool hinting )
252  {
253  builder->path_begun = 0;
254  builder->load_points = 1;
255 
256  builder->face = face;
257  builder->glyph = glyph;
258  builder->memory = face->root.memory;
259 
260  if ( glyph )
261  {
262  FT_GlyphLoader loader = glyph->root.internal->loader;
263 
264 
265  builder->loader = loader;
266  builder->base = &loader->base.outline;
267  builder->current = &loader->current.outline;
268  FT_GlyphLoader_Rewind( loader );
269 
270  builder->hints_globals = 0;
271  builder->hints_funcs = 0;
272 
273  if ( hinting && size )
274  {
275  CFF_Internal internal = (CFF_Internal)size->root.internal;
276 
277 
278  builder->hints_globals = (void *)internal->topfont;
279  builder->hints_funcs = glyph->root.internal->glyph_hints;
280  }
281  }
282 
283  builder->pos_x = 0;
284  builder->pos_y = 0;
285 
286  builder->left_bearing.x = 0;
287  builder->left_bearing.y = 0;
288  builder->advance.x = 0;
289  builder->advance.y = 0;
290  }
291 
292 
293  /*************************************************************************/
294  /* */
295  /* <Function> */
296  /* cff_builder_done */
297  /* */
298  /* <Description> */
299  /* Finalizes a given glyph builder. Its contents can still be used */
300  /* after the call, but the function saves important information */
301  /* within the corresponding glyph slot. */
302  /* */
303  /* <Input> */
304  /* builder :: A pointer to the glyph builder to finalize. */
305  /* */
306  static void
307  cff_builder_done( CFF_Builder* builder )
308  {
309  CFF_GlyphSlot glyph = builder->glyph;
310 
311 
312  if ( glyph )
313  glyph->root.outline = *builder->base;
314  }
315 
316 
317  /*************************************************************************/
318  /* */
319  /* <Function> */
320  /* cff_compute_bias */
321  /* */
322  /* <Description> */
323  /* Computes the bias value in dependence of the number of glyph */
324  /* subroutines. */
325  /* */
326  /* <Input> */
327  /* in_charstring_type :: The `CharstringType' value of the top DICT */
328  /* dictionary. */
329  /* */
330  /* num_subrs :: The number of glyph subroutines. */
331  /* */
332  /* <Return> */
333  /* The bias value. */
334  static FT_Int
335  cff_compute_bias( FT_Int in_charstring_type,
336  FT_UInt num_subrs )
337  {
338  FT_Int result;
339 
340 
341  if ( in_charstring_type == 1 )
342  result = 0;
343  else if ( num_subrs < 1240 )
344  result = 107;
345  else if ( num_subrs < 33900U )
346  result = 1131;
347  else
348  result = 32768U;
349 
350  return result;
351  }
352 
353 
354  /*************************************************************************/
355  /* */
356  /* <Function> */
357  /* cff_decoder_init */
358  /* */
359  /* <Description> */
360  /* Initializes a given glyph decoder. */
361  /* */
362  /* <InOut> */
363  /* decoder :: A pointer to the glyph builder to initialize. */
364  /* */
365  /* <Input> */
366  /* face :: The current face object. */
367  /* */
368  /* size :: The current size object. */
369  /* */
370  /* slot :: The current glyph object. */
371  /* */
372  /* hinting :: Whether hinting is active. */
373  /* */
374  /* hint_mode :: The hinting mode. */
375  /* */
376  FT_LOCAL_DEF( void )
377  cff_decoder_init( CFF_Decoder* decoder,
378  TT_Face face,
379  CFF_Size size,
380  CFF_GlyphSlot slot,
381  FT_Bool hinting,
382  FT_Render_Mode hint_mode )
383  {
384  CFF_Font cff = (CFF_Font)face->extra.data;
385 
386 
387  /* clear everything */
388  FT_MEM_ZERO( decoder, sizeof ( *decoder ) );
389 
390  /* initialize builder */
391  cff_builder_init( &decoder->builder, face, size, slot, hinting );
392 
393  /* initialize Type2 decoder */
394  decoder->cff = cff;
395  decoder->num_globals = cff->global_subrs_index.count;
396  decoder->globals = cff->global_subrs;
397  decoder->globals_bias = cff_compute_bias(
398  cff->top_font.font_dict.charstring_type,
399  decoder->num_globals );
400 
401  decoder->hint_mode = hint_mode;
402  }
403 
404 
405  /* this function is used to select the subfont */
406  /* and the locals subrs array */
407  FT_LOCAL_DEF( FT_Error )
408  cff_decoder_prepare( CFF_Decoder* decoder,
409  CFF_Size size,
410  FT_UInt glyph_index )
411  {
412  CFF_Builder *builder = &decoder->builder;
413  CFF_Font cff = (CFF_Font)builder->face->extra.data;
414  CFF_SubFont sub = &cff->top_font;
415  FT_Error error = CFF_Err_Ok;
416 
417 
418  /* manage CID fonts */
419  if ( cff->num_subfonts )
420  {
421  FT_Byte fd_index = cff_fd_select_get( &cff->fd_select, glyph_index );
422 
423 
424  if ( fd_index >= cff->num_subfonts )
425  {
426  FT_TRACE4(( "cff_decoder_prepare: invalid CID subfont index\n" ));
427  error = CFF_Err_Invalid_File_Format;
428  goto Exit;
429  }
430 
431  FT_TRACE3(( "glyph index %d (subfont %d):\n", glyph_index, fd_index ));
432 
433  sub = cff->subfonts[fd_index];
434 
435  if ( builder->hints_funcs && size )
436  {
437  CFF_Internal internal = (CFF_Internal)size->root.internal;
438 
439 
440  /* for CFFs without subfonts, this value has already been set */
441  builder->hints_globals = (void *)internal->subfonts[fd_index];
442  }
443  }
444 #ifdef FT_DEBUG_LEVEL_TRACE
445  else
446  FT_TRACE3(( "glyph index %d:\n", glyph_index ));
447 #endif
448 
449  decoder->num_locals = sub->local_subrs_index.count;
450  decoder->locals = sub->local_subrs;
451  decoder->locals_bias = cff_compute_bias(
452  decoder->cff->top_font.font_dict.charstring_type,
453  decoder->num_locals );
454 
455  decoder->glyph_width = sub->private_dict.default_width;
456  decoder->nominal_width = sub->private_dict.nominal_width;
457 
458  Exit:
459  return error;
460  }
461 
462 
463  /* check that there is enough space for `count' more points */
464  static FT_Error
465  check_points( CFF_Builder* builder,
466  FT_Int count )
467  {
468  return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
469  }
470 
471 
472  /* add a new point, do not check space */
473  static void
474  cff_builder_add_point( CFF_Builder* builder,
475  FT_Pos x,
476  FT_Pos y,
477  FT_Byte flag )
478  {
479  FT_Outline* outline = builder->current;
480 
481 
482  if ( builder->load_points )
483  {
484  FT_Vector* point = outline->points + outline->n_points;
485  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
486 
487 
488  point->x = x >> 16;
489  point->y = y >> 16;
490  *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
491  }
492 
493  outline->n_points++;
494  }
495 
496 
497  /* check space for a new on-curve point, then add it */
498  static FT_Error
499  cff_builder_add_point1( CFF_Builder* builder,
500  FT_Pos x,
501  FT_Pos y )
502  {
503  FT_Error error;
504 
505 
506  error = check_points( builder, 1 );
507  if ( !error )
508  cff_builder_add_point( builder, x, y, 1 );
509 
510  return error;
511  }
512 
513 
514  /* check space for a new contour, then add it */
515  static FT_Error
516  cff_builder_add_contour( CFF_Builder* builder )
517  {
518  FT_Outline* outline = builder->current;
519  FT_Error error;
520 
521 
522  if ( !builder->load_points )
523  {
524  outline->n_contours++;
525  return CFF_Err_Ok;
526  }
527 
528  error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
529  if ( !error )
530  {
531  if ( outline->n_contours > 0 )
532  outline->contours[outline->n_contours - 1] =
533  (short)( outline->n_points - 1 );
534 
535  outline->n_contours++;
536  }
537 
538  return error;
539  }
540 
541 
542  /* if a path was begun, add its first on-curve point */
543  static FT_Error
544  cff_builder_start_point( CFF_Builder* builder,
545  FT_Pos x,
546  FT_Pos y )
547  {
548  FT_Error error = CFF_Err_Ok;
549 
550 
551  /* test whether we are building a new contour */
552  if ( !builder->path_begun )
553  {
554  builder->path_begun = 1;
555  error = cff_builder_add_contour( builder );
556  if ( !error )
557  error = cff_builder_add_point1( builder, x, y );
558  }
559 
560  return error;
561  }
562 
563 
564  /* close the current contour */
565  static void
566  cff_builder_close_contour( CFF_Builder* builder )
567  {
568  FT_Outline* outline = builder->current;
569  FT_Int first;
570 
571 
572  if ( !outline )
573  return;
574 
575  first = outline->n_contours <= 1
576  ? 0 : outline->contours[outline->n_contours - 2] + 1;
577 
578  /* We must not include the last point in the path if it */
579  /* is located on the first point. */
580  if ( outline->n_points > 1 )
581  {
582  FT_Vector* p1 = outline->points + first;
583  FT_Vector* p2 = outline->points + outline->n_points - 1;
584  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
585 
586 
587  /* `delete' last point only if it coincides with the first */
588  /* point and if it is not a control point (which can happen). */
589  if ( p1->x == p2->x && p1->y == p2->y )
590  if ( *control == FT_CURVE_TAG_ON )
591  outline->n_points--;
592  }
593 
594  if ( outline->n_contours > 0 )
595  {
596  /* Don't add contours only consisting of one point, i.e., */
597  /* check whether begin point and last point are the same. */
598  if ( first == outline->n_points - 1 )
599  {
600  outline->n_contours--;
601  outline->n_points--;
602  }
603  else
604  outline->contours[outline->n_contours - 1] =
605  (short)( outline->n_points - 1 );
606  }
607  }
608 
609 
610  static FT_Int
611  cff_lookup_glyph_by_stdcharcode( CFF_Font cff,
612  FT_Int charcode )
613  {
614  FT_UInt n;
615  FT_UShort glyph_sid;
616 
617 
618  /* CID-keyed fonts don't have glyph names */
619  if ( !cff->charset.sids )
620  return -1;
621 
622  /* check range of standard char code */
623  if ( charcode < 0 || charcode > 255 )
624  return -1;
625 
626  /* Get code to SID mapping from `cff_standard_encoding'. */
627  glyph_sid = cff_get_standard_encoding( (FT_UInt)charcode );
628 
629  for ( n = 0; n < cff->num_glyphs; n++ )
630  {
631  if ( cff->charset.sids[n] == glyph_sid )
632  return n;
633  }
634 
635  return -1;
636  }
637 
638 
639  static FT_Error
640  cff_get_glyph_data( TT_Face face,
641  FT_UInt glyph_index,
642  FT_Byte** pointer,
643  FT_ULong* length )
644  {
645 #ifdef FT_CONFIG_OPTION_INCREMENTAL
646  /* For incremental fonts get the character data using the */
647  /* callback function. */
648  if ( face->root.internal->incremental_interface )
649  {
650  FT_Data data;
651  FT_Error error =
652  face->root.internal->incremental_interface->funcs->get_glyph_data(
653  face->root.internal->incremental_interface->object,
654  glyph_index, &data );
655 
656 
657  *pointer = (FT_Byte*)data.pointer;
658  *length = data.length;
659 
660  return error;
661  }
662  else
663 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
664 
665  {
666  CFF_Font cff = (CFF_Font)(face->extra.data);
667 
668 
669  return cff_index_access_element( &cff->charstrings_index, glyph_index,
670  pointer, length );
671  }
672  }
673 
674 
675  static void
676  cff_free_glyph_data( TT_Face face,
677  FT_Byte** pointer,
678  FT_ULong length )
679  {
680 #ifndef FT_CONFIG_OPTION_INCREMENTAL
681  FT_UNUSED( length );
682 #endif
683 
684 #ifdef FT_CONFIG_OPTION_INCREMENTAL
685  /* For incremental fonts get the character data using the */
686  /* callback function. */
687  if ( face->root.internal->incremental_interface )
688  {
689  FT_Data data;
690 
691 
692  data.pointer = *pointer;
693  data.length = length;
694 
695  face->root.internal->incremental_interface->funcs->free_glyph_data(
696  face->root.internal->incremental_interface->object, &data );
697  }
698  else
699 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
700 
701  {
702  CFF_Font cff = (CFF_Font)(face->extra.data);
703 
704 
705  cff_index_forget_element( &cff->charstrings_index, pointer );
706  }
707  }
708 
709 
710  static FT_Error
711  cff_operator_seac( CFF_Decoder* decoder,
712  FT_Pos asb,
713  FT_Pos adx,
714  FT_Pos ady,
715  FT_Int bchar,
716  FT_Int achar )
717  {
718  FT_Error error;
719  CFF_Builder* builder = &decoder->builder;
720  FT_Int bchar_index, achar_index;
721  TT_Face face = decoder->builder.face;
722  FT_Vector left_bearing, advance;
723  FT_Byte* charstring;
724  FT_ULong charstring_len;
725  FT_Pos glyph_width;
726 
727 
728  if ( decoder->seac )
729  {
730  FT_ERROR(( "cff_operator_seac: invalid nested seac\n" ));
731  return CFF_Err_Syntax_Error;
732  }
733 
734  adx += decoder->builder.left_bearing.x;
735  ady += decoder->builder.left_bearing.y;
736 
737 #ifdef FT_CONFIG_OPTION_INCREMENTAL
738  /* Incremental fonts don't necessarily have valid charsets. */
739  /* They use the character code, not the glyph index, in this case. */
740  if ( face->root.internal->incremental_interface )
741  {
742  bchar_index = bchar;
743  achar_index = achar;
744  }
745  else
746 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
747  {
748  CFF_Font cff = (CFF_Font)(face->extra.data);
749 
750 
751  bchar_index = cff_lookup_glyph_by_stdcharcode( cff, bchar );
752  achar_index = cff_lookup_glyph_by_stdcharcode( cff, achar );
753  }
754 
755  if ( bchar_index < 0 || achar_index < 0 )
756  {
757  FT_ERROR(( "cff_operator_seac:"
758  " invalid seac character code arguments\n" ));
759  return CFF_Err_Syntax_Error;
760  }
761 
762  /* If we are trying to load a composite glyph, do not load the */
763  /* accent character and return the array of subglyphs. */
764  if ( builder->no_recurse )
765  {
766  FT_GlyphSlot glyph = (FT_GlyphSlot)builder->glyph;
767  FT_GlyphLoader loader = glyph->internal->loader;
768  FT_SubGlyph subg;
769 
770 
771  /* reallocate subglyph array if necessary */
772  error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
773  if ( error )
774  goto Exit;
775 
776  subg = loader->current.subglyphs;
777 
778  /* subglyph 0 = base character */
779  subg->index = bchar_index;
780  subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
781  FT_SUBGLYPH_FLAG_USE_MY_METRICS;
782  subg->arg1 = 0;
783  subg->arg2 = 0;
784  subg++;
785 
786  /* subglyph 1 = accent character */
787  subg->index = achar_index;
788  subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
789  subg->arg1 = (FT_Int)( adx >> 16 );
790  subg->arg2 = (FT_Int)( ady >> 16 );
791 
792  /* set up remaining glyph fields */
793  glyph->num_subglyphs = 2;
794  glyph->subglyphs = loader->base.subglyphs;
795  glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
796 
797  loader->current.num_subglyphs = 2;
798  }
799 
800  FT_GlyphLoader_Prepare( builder->loader );
801 
802  /* First load `bchar' in builder */
803  error = cff_get_glyph_data( face, bchar_index,
804  &charstring, &charstring_len );
805  if ( !error )
806  {
807  /* the seac operator must not be nested */
808  decoder->seac = TRUE;
809  error = cff_decoder_parse_charstrings( decoder, charstring,
810  charstring_len );
811  decoder->seac = FALSE;
812 
813  cff_free_glyph_data( face, &charstring, charstring_len );
814 
815  if ( error )
816  goto Exit;
817  }
818 
819  /* Save the left bearing, advance and glyph width of the base */
820  /* character as they will be erased by the next load. */
821 
822  left_bearing = builder->left_bearing;
823  advance = builder->advance;
824  glyph_width = decoder->glyph_width;
825 
826  builder->left_bearing.x = 0;
827  builder->left_bearing.y = 0;
828 
829  builder->pos_x = adx - asb;
830  builder->pos_y = ady;
831 
832  /* Now load `achar' on top of the base outline. */
833  error = cff_get_glyph_data( face, achar_index,
834  &charstring, &charstring_len );
835  if ( !error )
836  {
837  /* the seac operator must not be nested */
838  decoder->seac = TRUE;
839  error = cff_decoder_parse_charstrings( decoder, charstring,
840  charstring_len );
841  decoder->seac = FALSE;
842 
843  cff_free_glyph_data( face, &charstring, charstring_len );
844 
845  if ( error )
846  goto Exit;
847  }
848 
849  /* Restore the left side bearing, advance and glyph width */
850  /* of the base character. */
851  builder->left_bearing = left_bearing;
852  builder->advance = advance;
853  decoder->glyph_width = glyph_width;
854 
855  builder->pos_x = 0;
856  builder->pos_y = 0;
857 
858  Exit:
859  return error;
860  }
861 
862 
863  /*************************************************************************/
864  /* */
865  /* <Function> */
866  /* cff_decoder_parse_charstrings */
867  /* */
868  /* <Description> */
869  /* Parses a given Type 2 charstrings program. */
870  /* */
871  /* <InOut> */
872  /* decoder :: The current Type 1 decoder. */
873  /* */
874  /* <Input> */
875  /* charstring_base :: The base of the charstring stream. */
876  /* */
877  /* charstring_len :: The length in bytes of the charstring stream. */
878  /* */
879  /* <Return> */
880  /* FreeType error code. 0 means success. */
881  /* */
882  FT_LOCAL_DEF( FT_Error )
883  cff_decoder_parse_charstrings( CFF_Decoder* decoder,
884  FT_Byte* charstring_base,
885  FT_ULong charstring_len )
886  {
887  FT_Error error;
888  CFF_Decoder_Zone* zone;
889  FT_Byte* ip;
890  FT_Byte* limit;
891  CFF_Builder* builder = &decoder->builder;
892  FT_Pos x, y;
893  FT_Fixed seed;
894  FT_Fixed* stack;
895  FT_Int charstring_type =
896  decoder->cff->top_font.font_dict.charstring_type;
897 
898  T2_Hints_Funcs hinter;
899 
900 
901  /* set default width */
902  decoder->num_hints = 0;
903  decoder->read_width = 1;
904 
905  /* compute random seed from stack address of parameter */
906  seed = (FT_Fixed)( ( (FT_PtrDist)(char*)&seed ^
907  (FT_PtrDist)(char*)&decoder ^
908  (FT_PtrDist)(char*)&charstring_base ) &
909  FT_ULONG_MAX ) ;
910  seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
911  if ( seed == 0 )
912  seed = 0x7384;
913 
914  /* initialize the decoder */
915  decoder->top = decoder->stack;
916  decoder->zone = decoder->zones;
917  zone = decoder->zones;
918  stack = decoder->top;
919 
920  hinter = (T2_Hints_Funcs)builder->hints_funcs;
921 
922  builder->path_begun = 0;
923 
924  zone->base = charstring_base;
925  limit = zone->limit = charstring_base + charstring_len;
926  ip = zone->cursor = zone->base;
927 
928  error = CFF_Err_Ok;
929 
930  x = builder->pos_x;
931  y = builder->pos_y;
932 
933  /* begin hints recording session, if any */
934  if ( hinter )
935  hinter->open( hinter->hints );
936 
937  /* now execute loop */
938  while ( ip < limit )
939  {
940  CFF_Operator op;
941  FT_Byte v;
942 
943 
944  /********************************************************************/
945  /* */
946  /* Decode operator or operand */
947  /* */
948  v = *ip++;
949  if ( v >= 32 || v == 28 )
950  {
951  FT_Int shift = 16;
952  FT_Int32 val;
953 
954 
955  /* this is an operand, push it on the stack */
956  if ( v == 28 )
957  {
958  if ( ip + 1 >= limit )
959  goto Syntax_Error;
960  val = (FT_Short)( ( (FT_Short)ip[0] << 8 ) | ip[1] );
961  ip += 2;
962  }
963  else if ( v < 247 )
964  val = (FT_Int32)v - 139;
965  else if ( v < 251 )
966  {
967  if ( ip >= limit )
968  goto Syntax_Error;
969  val = ( (FT_Int32)v - 247 ) * 256 + *ip++ + 108;
970  }
971  else if ( v < 255 )
972  {
973  if ( ip >= limit )
974  goto Syntax_Error;
975  val = -( (FT_Int32)v - 251 ) * 256 - *ip++ - 108;
976  }
977  else
978  {
979  if ( ip + 3 >= limit )
980  goto Syntax_Error;
981  val = ( (FT_Int32)ip[0] << 24 ) |
982  ( (FT_Int32)ip[1] << 16 ) |
983  ( (FT_Int32)ip[2] << 8 ) |
984  ip[3];
985  ip += 4;
986  if ( charstring_type == 2 )
987  shift = 0;
988  }
989  if ( decoder->top - stack >= CFF_MAX_OPERANDS )
990  goto Stack_Overflow;
991 
992  val <<= shift;
993  *decoder->top++ = val;
994 
995 #ifdef FT_DEBUG_LEVEL_TRACE
996  if ( !( val & 0xFFFFL ) )
997  FT_TRACE4(( " %ld", (FT_Int32)( val >> 16 ) ));
998  else
999  FT_TRACE4(( " %.2f", val / 65536.0 ));
1000 #endif
1001 
1002  }
1003  else
1004  {
1005  /* The specification says that normally arguments are to be taken */
1006  /* from the bottom of the stack. However, this seems not to be */
1007  /* correct, at least for Acroread 7.0.8 on GNU/Linux: It pops the */
1008  /* arguments similar to a PS interpreter. */
1009 
1010  FT_Fixed* args = decoder->top;
1011  FT_Int num_args = (FT_Int)( args - decoder->stack );
1012  FT_Int req_args;
1013 
1014 
1015  /* find operator */
1016  op = cff_op_unknown;
1017 
1018  switch ( v )
1019  {
1020  case 1:
1021  op = cff_op_hstem;
1022  break;
1023  case 3:
1024  op = cff_op_vstem;
1025  break;
1026  case 4:
1027  op = cff_op_vmoveto;
1028  break;
1029  case 5:
1030  op = cff_op_rlineto;
1031  break;
1032  case 6:
1033  op = cff_op_hlineto;
1034  break;
1035  case 7:
1036  op = cff_op_vlineto;
1037  break;
1038  case 8:
1039  op = cff_op_rrcurveto;
1040  break;
1041  case 9:
1042  op = cff_op_closepath;
1043  break;
1044  case 10:
1045  op = cff_op_callsubr;
1046  break;
1047  case 11:
1048  op = cff_op_return;
1049  break;
1050  case 12:
1051  {
1052  if ( ip >= limit )
1053  goto Syntax_Error;
1054  v = *ip++;
1055 
1056  switch ( v )
1057  {
1058  case 0:
1059  op = cff_op_dotsection;
1060  break;
1061  case 1: /* this is actually the Type1 vstem3 operator */
1062  op = cff_op_vstem;
1063  break;
1064  case 2: /* this is actually the Type1 hstem3 operator */
1065  op = cff_op_hstem;
1066  break;
1067  case 3:
1068  op = cff_op_and;
1069  break;
1070  case 4:
1071  op = cff_op_or;
1072  break;
1073  case 5:
1074  op = cff_op_not;
1075  break;
1076  case 6:
1077  op = cff_op_seac;
1078  break;
1079  case 7:
1080  op = cff_op_sbw;
1081  break;
1082  case 8:
1083  op = cff_op_store;
1084  break;
1085  case 9:
1086  op = cff_op_abs;
1087  break;
1088  case 10:
1089  op = cff_op_add;
1090  break;
1091  case 11:
1092  op = cff_op_sub;
1093  break;
1094  case 12:
1095  op = cff_op_div;
1096  break;
1097  case 13:
1098  op = cff_op_load;
1099  break;
1100  case 14:
1101  op = cff_op_neg;
1102  break;
1103  case 15:
1104  op = cff_op_eq;
1105  break;
1106  case 16:
1107  op = cff_op_callothersubr;
1108  break;
1109  case 17:
1110  op = cff_op_pop;
1111  break;
1112  case 18:
1113  op = cff_op_drop;
1114  break;
1115  case 20:
1116  op = cff_op_put;
1117  break;
1118  case 21:
1119  op = cff_op_get;
1120  break;
1121  case 22:
1122  op = cff_op_ifelse;
1123  break;
1124  case 23:
1125  op = cff_op_random;
1126  break;
1127  case 24:
1128  op = cff_op_mul;
1129  break;
1130  case 26:
1131  op = cff_op_sqrt;
1132  break;
1133  case 27:
1134  op = cff_op_dup;
1135  break;
1136  case 28:
1137  op = cff_op_exch;
1138  break;
1139  case 29:
1140  op = cff_op_index;
1141  break;
1142  case 30:
1143  op = cff_op_roll;
1144  break;
1145  case 33:
1146  op = cff_op_setcurrentpoint;
1147  break;
1148  case 34:
1149  op = cff_op_hflex;
1150  break;
1151  case 35:
1152  op = cff_op_flex;
1153  break;
1154  case 36:
1155  op = cff_op_hflex1;
1156  break;
1157  case 37:
1158  op = cff_op_flex1;
1159  break;
1160  default:
1161  FT_TRACE4(( " unknown op (12, %d)\n", v ));
1162  break;
1163  }
1164  }
1165  break;
1166  case 13:
1167  op = cff_op_hsbw;
1168  break;
1169  case 14:
1170  op = cff_op_endchar;
1171  break;
1172  case 16:
1173  op = cff_op_blend;
1174  break;
1175  case 18:
1176  op = cff_op_hstemhm;
1177  break;
1178  case 19:
1179  op = cff_op_hintmask;
1180  break;
1181  case 20:
1182  op = cff_op_cntrmask;
1183  break;
1184  case 21:
1185  op = cff_op_rmoveto;
1186  break;
1187  case 22:
1188  op = cff_op_hmoveto;
1189  break;
1190  case 23:
1191  op = cff_op_vstemhm;
1192  break;
1193  case 24:
1194  op = cff_op_rcurveline;
1195  break;
1196  case 25:
1197  op = cff_op_rlinecurve;
1198  break;
1199  case 26:
1200  op = cff_op_vvcurveto;
1201  break;
1202  case 27:
1203  op = cff_op_hhcurveto;
1204  break;
1205  case 29:
1206  op = cff_op_callgsubr;
1207  break;
1208  case 30:
1209  op = cff_op_vhcurveto;
1210  break;
1211  case 31:
1212  op = cff_op_hvcurveto;
1213  break;
1214  default:
1215  FT_TRACE4(( " unknown op (%d)\n", v ));
1216  break;
1217  }
1218 
1219  if ( op == cff_op_unknown )
1220  continue;
1221 
1222  /* check arguments */
1223  req_args = cff_argument_counts[op];
1224  if ( req_args & CFF_COUNT_CHECK_WIDTH )
1225  {
1226  if ( num_args > 0 && decoder->read_width )
1227  {
1228  /* If `nominal_width' is non-zero, the number is really a */
1229  /* difference against `nominal_width'. Else, the number here */
1230  /* is truly a width, not a difference against `nominal_width'. */
1231  /* If the font does not set `nominal_width', then */
1232  /* `nominal_width' defaults to zero, and so we can set */
1233  /* `glyph_width' to `nominal_width' plus number on the stack */
1234  /* -- for either case. */
1235 
1236  FT_Int set_width_ok;
1237 
1238 
1239  switch ( op )
1240  {
1241  case cff_op_hmoveto:
1242  case cff_op_vmoveto:
1243  set_width_ok = num_args & 2;
1244  break;
1245 
1246  case cff_op_hstem:
1247  case cff_op_vstem:
1248  case cff_op_hstemhm:
1249  case cff_op_vstemhm:
1250  case cff_op_rmoveto:
1251  case cff_op_hintmask:
1252  case cff_op_cntrmask:
1253  set_width_ok = num_args & 1;
1254  break;
1255 
1256  case cff_op_endchar:
1257  /* If there is a width specified for endchar, we either have */
1258  /* 1 argument or 5 arguments. We like to argue. */
1259  set_width_ok = ( num_args == 5 ) || ( num_args == 1 );
1260  break;
1261 
1262  default:
1263  set_width_ok = 0;
1264  break;
1265  }
1266 
1267  if ( set_width_ok )
1268  {
1269  decoder->glyph_width = decoder->nominal_width +
1270  ( stack[0] >> 16 );
1271 
1272  if ( decoder->width_only )
1273  {
1274  /* we only want the advance width; stop here */
1275  break;
1276  }
1277 
1278  /* Consumed an argument. */
1279  num_args--;
1280  }
1281  }
1282 
1283  decoder->read_width = 0;
1284  req_args = 0;
1285  }
1286 
1287  req_args &= 0x000F;
1288  if ( num_args < req_args )
1289  goto Stack_Underflow;
1290  args -= req_args;
1291  num_args -= req_args;
1292 
1293  /* At this point, `args' points to the first argument of the */
1294  /* operand in case `req_args' isn't zero. Otherwise, we have */
1295  /* to adjust `args' manually. */
1296 
1297  /* Note that we only pop arguments from the stack which we */
1298  /* really need and can digest so that we can continue in case */
1299  /* of superfluous stack elements. */
1300 
1301  switch ( op )
1302  {
1303  case cff_op_hstem:
1304  case cff_op_vstem:
1305  case cff_op_hstemhm:
1306  case cff_op_vstemhm:
1307  /* the number of arguments is always even here */
1308  FT_TRACE4((
1309  op == cff_op_hstem ? " hstem\n" :
1310  ( op == cff_op_vstem ? " vstem\n" :
1311  ( op == cff_op_hstemhm ? " hstemhm\n" : " vstemhm\n" ) ) ));
1312 
1313  if ( hinter )
1314  hinter->stems( hinter->hints,
1315  ( op == cff_op_hstem || op == cff_op_hstemhm ),
1316  num_args / 2,
1317  args - ( num_args & ~1 ) );
1318 
1319  decoder->num_hints += num_args / 2;
1320  args = stack;
1321  break;
1322 
1323  case cff_op_hintmask:
1324  case cff_op_cntrmask:
1325  FT_TRACE4(( op == cff_op_hintmask ? " hintmask" : " cntrmask" ));
1326 
1327  /* implement vstem when needed -- */
1328  /* the specification doesn't say it, but this also works */
1329  /* with the 'cntrmask' operator */
1330  /* */
1331  if ( num_args > 0 )
1332  {
1333  if ( hinter )
1334  hinter->stems( hinter->hints,
1335  0,
1336  num_args / 2,
1337  args - ( num_args & ~1 ) );
1338 
1339  decoder->num_hints += num_args / 2;
1340  }
1341 
1342  /* In a valid charstring there must be at least one byte */
1343  /* after `hintmask' or `cntrmask' (e.g., for a `return' */
1344  /* instruction). Additionally, there must be space for */
1345  /* `num_hints' bits. */
1346 
1347  if ( ( ip + ( ( decoder->num_hints + 7 ) >> 3 ) ) >= limit )
1348  goto Syntax_Error;
1349 
1350  if ( hinter )
1351  {
1352  if ( op == cff_op_hintmask )
1353  hinter->hintmask( hinter->hints,
1354  builder->current->n_points,
1355  decoder->num_hints,
1356  ip );
1357  else
1358  hinter->counter( hinter->hints,
1359  decoder->num_hints,
1360  ip );
1361  }
1362 
1363 #ifdef FT_DEBUG_LEVEL_TRACE
1364  {
1365  FT_UInt maskbyte;
1366 
1367 
1368  FT_TRACE4(( " (maskbytes:" ));
1369 
1370  for ( maskbyte = 0;
1371  maskbyte < (FT_UInt)( ( decoder->num_hints + 7 ) >> 3 );
1372  maskbyte++, ip++ )
1373  FT_TRACE4(( " 0x%02X", *ip ));
1374 
1375  FT_TRACE4(( ")\n" ));
1376  }
1377 #else
1378  ip += ( decoder->num_hints + 7 ) >> 3;
1379 #endif
1380  args = stack;
1381  break;
1382 
1383  case cff_op_rmoveto:
1384  FT_TRACE4(( " rmoveto\n" ));
1385 
1386  cff_builder_close_contour( builder );
1387  builder->path_begun = 0;
1388  x += args[-2];
1389  y += args[-1];
1390  args = stack;
1391  break;
1392 
1393  case cff_op_vmoveto:
1394  FT_TRACE4(( " vmoveto\n" ));
1395 
1396  cff_builder_close_contour( builder );
1397  builder->path_begun = 0;
1398  y += args[-1];
1399  args = stack;
1400  break;
1401 
1402  case cff_op_hmoveto:
1403  FT_TRACE4(( " hmoveto\n" ));
1404 
1405  cff_builder_close_contour( builder );
1406  builder->path_begun = 0;
1407  x += args[-1];
1408  args = stack;
1409  break;
1410 
1411  case cff_op_rlineto:
1412  FT_TRACE4(( " rlineto\n" ));
1413 
1414  if ( cff_builder_start_point ( builder, x, y ) ||
1415  check_points( builder, num_args / 2 ) )
1416  goto Fail;
1417 
1418  if ( num_args < 2 )
1419  goto Stack_Underflow;
1420 
1421  args -= num_args & ~1;
1422  while ( args < decoder->top )
1423  {
1424  x += args[0];
1425  y += args[1];
1426  cff_builder_add_point( builder, x, y, 1 );
1427  args += 2;
1428  }
1429  args = stack;
1430  break;
1431 
1432  case cff_op_hlineto:
1433  case cff_op_vlineto:
1434  {
1435  FT_Int phase = ( op == cff_op_hlineto );
1436 
1437 
1438  FT_TRACE4(( op == cff_op_hlineto ? " hlineto\n"
1439  : " vlineto\n" ));
1440 
1441  if ( num_args < 0 )
1442  goto Stack_Underflow;
1443 
1444  /* there exist subsetted fonts (found in PDFs) */
1445  /* which call `hlineto' without arguments */
1446  if ( num_args == 0 )
1447  break;
1448 
1449  if ( cff_builder_start_point ( builder, x, y ) ||
1450  check_points( builder, num_args ) )
1451  goto Fail;
1452 
1453  args = stack;
1454  while ( args < decoder->top )
1455  {
1456  if ( phase )
1457  x += args[0];
1458  else
1459  y += args[0];
1460 
1461  if ( cff_builder_add_point1( builder, x, y ) )
1462  goto Fail;
1463 
1464  args++;
1465  phase ^= 1;
1466  }
1467  args = stack;
1468  }
1469  break;
1470 
1471  case cff_op_rrcurveto:
1472  {
1473  FT_Int nargs;
1474 
1475 
1476  FT_TRACE4(( " rrcurveto\n" ));
1477 
1478  if ( num_args < 6 )
1479  goto Stack_Underflow;
1480 
1481  nargs = num_args - num_args % 6;
1482 
1483  if ( cff_builder_start_point ( builder, x, y ) ||
1484  check_points( builder, nargs / 2 ) )
1485  goto Fail;
1486 
1487  args -= nargs;
1488  while ( args < decoder->top )
1489  {
1490  x += args[0];
1491  y += args[1];
1492  cff_builder_add_point( builder, x, y, 0 );
1493  x += args[2];
1494  y += args[3];
1495  cff_builder_add_point( builder, x, y, 0 );
1496  x += args[4];
1497  y += args[5];
1498  cff_builder_add_point( builder, x, y, 1 );
1499  args += 6;
1500  }
1501  args = stack;
1502  }
1503  break;
1504 
1505  case cff_op_vvcurveto:
1506  {
1507  FT_Int nargs;
1508 
1509 
1510  FT_TRACE4(( " vvcurveto\n" ));
1511 
1512  if ( num_args < 4 )
1513  goto Stack_Underflow;
1514 
1515  /* if num_args isn't of the form 4n or 4n+1, */
1516  /* we enforce it by clearing the second bit */
1517 
1518  nargs = num_args & ~2;
1519 
1520  if ( cff_builder_start_point( builder, x, y ) )
1521  goto Fail;
1522 
1523  args -= nargs;
1524 
1525  if ( nargs & 1 )
1526  {
1527  x += args[0];
1528  args++;
1529  nargs--;
1530  }
1531 
1532  if ( check_points( builder, 3 * ( nargs / 4 ) ) )
1533  goto Fail;
1534 
1535  while ( args < decoder->top )
1536  {
1537  y += args[0];
1538  cff_builder_add_point( builder, x, y, 0 );
1539  x += args[1];
1540  y += args[2];
1541  cff_builder_add_point( builder, x, y, 0 );
1542  y += args[3];
1543  cff_builder_add_point( builder, x, y, 1 );
1544  args += 4;
1545  }
1546  args = stack;
1547  }
1548  break;
1549 
1550  case cff_op_hhcurveto:
1551  {
1552  FT_Int nargs;
1553 
1554 
1555  FT_TRACE4(( " hhcurveto\n" ));
1556 
1557  if ( num_args < 4 )
1558  goto Stack_Underflow;
1559 
1560  /* if num_args isn't of the form 4n or 4n+1, */
1561  /* we enforce it by clearing the second bit */
1562 
1563  nargs = num_args & ~2;
1564 
1565  if ( cff_builder_start_point( builder, x, y ) )
1566  goto Fail;
1567 
1568  args -= nargs;
1569  if ( nargs & 1 )
1570  {
1571  y += args[0];
1572  args++;
1573  nargs--;
1574  }
1575 
1576  if ( check_points( builder, 3 * ( nargs / 4 ) ) )
1577  goto Fail;
1578 
1579  while ( args < decoder->top )
1580  {
1581  x += args[0];
1582  cff_builder_add_point( builder, x, y, 0 );
1583  x += args[1];
1584  y += args[2];
1585  cff_builder_add_point( builder, x, y, 0 );
1586  x += args[3];
1587  cff_builder_add_point( builder, x, y, 1 );
1588  args += 4;
1589  }
1590  args = stack;
1591  }
1592  break;
1593 
1594  case cff_op_vhcurveto:
1595  case cff_op_hvcurveto:
1596  {
1597  FT_Int phase;
1598  FT_Int nargs;
1599 
1600 
1601  FT_TRACE4(( op == cff_op_vhcurveto ? " vhcurveto\n"
1602  : " hvcurveto\n" ));
1603 
1604  if ( cff_builder_start_point( builder, x, y ) )
1605  goto Fail;
1606 
1607  if ( num_args < 4 )
1608  goto Stack_Underflow;
1609 
1610  /* if num_args isn't of the form 8n, 8n+1, 8n+4, or 8n+5, */
1611  /* we enforce it by clearing the second bit */
1612 
1613  nargs = num_args & ~2;
1614 
1615  args -= nargs;
1616  if ( check_points( builder, ( nargs / 4 ) * 3 ) )
1617  goto Stack_Underflow;
1618 
1619  phase = ( op == cff_op_hvcurveto );
1620 
1621  while ( nargs >= 4 )
1622  {
1623  nargs -= 4;
1624  if ( phase )
1625  {
1626  x += args[0];
1627  cff_builder_add_point( builder, x, y, 0 );
1628  x += args[1];
1629  y += args[2];
1630  cff_builder_add_point( builder, x, y, 0 );
1631  y += args[3];
1632  if ( nargs == 1 )
1633  x += args[4];
1634  cff_builder_add_point( builder, x, y, 1 );
1635  }
1636  else
1637  {
1638  y += args[0];
1639  cff_builder_add_point( builder, x, y, 0 );
1640  x += args[1];
1641  y += args[2];
1642  cff_builder_add_point( builder, x, y, 0 );
1643  x += args[3];
1644  if ( nargs == 1 )
1645  y += args[4];
1646  cff_builder_add_point( builder, x, y, 1 );
1647  }
1648  args += 4;
1649  phase ^= 1;
1650  }
1651  args = stack;
1652  }
1653  break;
1654 
1655  case cff_op_rlinecurve:
1656  {
1657  FT_Int num_lines;
1658  FT_Int nargs;
1659 
1660 
1661  FT_TRACE4(( " rlinecurve\n" ));
1662 
1663  if ( num_args < 8 )
1664  goto Stack_Underflow;
1665 
1666  nargs = num_args & ~1;
1667  num_lines = ( nargs - 6 ) / 2;
1668 
1669  if ( cff_builder_start_point( builder, x, y ) ||
1670  check_points( builder, num_lines + 3 ) )
1671  goto Fail;
1672 
1673  args -= nargs;
1674 
1675  /* first, add the line segments */
1676  while ( num_lines > 0 )
1677  {
1678  x += args[0];
1679  y += args[1];
1680  cff_builder_add_point( builder, x, y, 1 );
1681  args += 2;
1682  num_lines--;
1683  }
1684 
1685  /* then the curve */
1686  x += args[0];
1687  y += args[1];
1688  cff_builder_add_point( builder, x, y, 0 );
1689  x += args[2];
1690  y += args[3];
1691  cff_builder_add_point( builder, x, y, 0 );
1692  x += args[4];
1693  y += args[5];
1694  cff_builder_add_point( builder, x, y, 1 );
1695  args = stack;
1696  }
1697  break;
1698 
1699  case cff_op_rcurveline:
1700  {
1701  FT_Int num_curves;
1702  FT_Int nargs;
1703 
1704 
1705  FT_TRACE4(( " rcurveline\n" ));
1706 
1707  if ( num_args < 8 )
1708  goto Stack_Underflow;
1709 
1710  nargs = num_args - 2;
1711  nargs = nargs - nargs % 6 + 2;
1712  num_curves = ( nargs - 2 ) / 6;
1713 
1714  if ( cff_builder_start_point ( builder, x, y ) ||
1715  check_points( builder, num_curves * 3 + 2 ) )
1716  goto Fail;
1717 
1718  args -= nargs;
1719 
1720  /* first, add the curves */
1721  while ( num_curves > 0 )
1722  {
1723  x += args[0];
1724  y += args[1];
1725  cff_builder_add_point( builder, x, y, 0 );
1726  x += args[2];
1727  y += args[3];
1728  cff_builder_add_point( builder, x, y, 0 );
1729  x += args[4];
1730  y += args[5];
1731  cff_builder_add_point( builder, x, y, 1 );
1732  args += 6;
1733  num_curves--;
1734  }
1735 
1736  /* then the final line */
1737  x += args[0];
1738  y += args[1];
1739  cff_builder_add_point( builder, x, y, 1 );
1740  args = stack;
1741  }
1742  break;
1743 
1744  case cff_op_hflex1:
1745  {
1746  FT_Pos start_y;
1747 
1748 
1749  FT_TRACE4(( " hflex1\n" ));
1750 
1751  /* adding five more points: 4 control points, 1 on-curve point */
1752  /* -- make sure we have enough space for the start point if it */
1753  /* needs to be added */
1754  if ( cff_builder_start_point( builder, x, y ) ||
1755  check_points( builder, 6 ) )
1756  goto Fail;
1757 
1758  /* record the starting point's y position for later use */
1759  start_y = y;
1760 
1761  /* first control point */
1762  x += args[0];
1763  y += args[1];
1764  cff_builder_add_point( builder, x, y, 0 );
1765 
1766  /* second control point */
1767  x += args[2];
1768  y += args[3];
1769  cff_builder_add_point( builder, x, y, 0 );
1770 
1771  /* join point; on curve, with y-value the same as the last */
1772  /* control point's y-value */
1773  x += args[4];
1774  cff_builder_add_point( builder, x, y, 1 );
1775 
1776  /* third control point, with y-value the same as the join */
1777  /* point's y-value */
1778  x += args[5];
1779  cff_builder_add_point( builder, x, y, 0 );
1780 
1781  /* fourth control point */
1782  x += args[6];
1783  y += args[7];
1784  cff_builder_add_point( builder, x, y, 0 );
1785 
1786  /* ending point, with y-value the same as the start */
1787  x += args[8];
1788  y = start_y;
1789  cff_builder_add_point( builder, x, y, 1 );
1790 
1791  args = stack;
1792  break;
1793  }
1794 
1795  case cff_op_hflex:
1796  {
1797  FT_Pos start_y;
1798 
1799 
1800  FT_TRACE4(( " hflex\n" ));
1801 
1802  /* adding six more points; 4 control points, 2 on-curve points */
1803  if ( cff_builder_start_point( builder, x, y ) ||
1804  check_points( builder, 6 ) )
1805  goto Fail;
1806 
1807  /* record the starting point's y-position for later use */
1808  start_y = y;
1809 
1810  /* first control point */
1811  x += args[0];
1812  cff_builder_add_point( builder, x, y, 0 );
1813 
1814  /* second control point */
1815  x += args[1];
1816  y += args[2];
1817  cff_builder_add_point( builder, x, y, 0 );
1818 
1819  /* join point; on curve, with y-value the same as the last */
1820  /* control point's y-value */
1821  x += args[3];
1822  cff_builder_add_point( builder, x, y, 1 );
1823 
1824  /* third control point, with y-value the same as the join */
1825  /* point's y-value */
1826  x += args[4];
1827  cff_builder_add_point( builder, x, y, 0 );
1828 
1829  /* fourth control point */
1830  x += args[5];
1831  y = start_y;
1832  cff_builder_add_point( builder, x, y, 0 );
1833 
1834  /* ending point, with y-value the same as the start point's */
1835  /* y-value -- we don't add this point, though */
1836  x += args[6];
1837  cff_builder_add_point( builder, x, y, 1 );
1838 
1839  args = stack;
1840  break;
1841  }
1842 
1843  case cff_op_flex1:
1844  {
1845  FT_Pos start_x, start_y; /* record start x, y values for */
1846  /* alter use */
1847  FT_Fixed dx = 0, dy = 0; /* used in horizontal/vertical */
1848  /* algorithm below */
1849  FT_Int horizontal, count;
1850  FT_Fixed* temp;
1851 
1852 
1853  FT_TRACE4(( " flex1\n" ));
1854 
1855  /* adding six more points; 4 control points, 2 on-curve points */
1856  if ( cff_builder_start_point( builder, x, y ) ||
1857  check_points( builder, 6 ) )
1858  goto Fail;
1859 
1860  /* record the starting point's x, y position for later use */
1861  start_x = x;
1862  start_y = y;
1863 
1864  /* XXX: figure out whether this is supposed to be a horizontal */
1865  /* or vertical flex; the Type 2 specification is vague... */
1866 
1867  temp = args;
1868 
1869  /* grab up to the last argument */
1870  for ( count = 5; count > 0; count-- )
1871  {
1872  dx += temp[0];
1873  dy += temp[1];
1874  temp += 2;
1875  }
1876 
1877  if ( dx < 0 )
1878  dx = -dx;
1879  if ( dy < 0 )
1880  dy = -dy;
1881 
1882  /* strange test, but here it is... */
1883  horizontal = ( dx > dy );
1884 
1885  for ( count = 5; count > 0; count-- )
1886  {
1887  x += args[0];
1888  y += args[1];
1889  cff_builder_add_point( builder, x, y,
1890  (FT_Bool)( count == 3 ) );
1891  args += 2;
1892  }
1893 
1894  /* is last operand an x- or y-delta? */
1895  if ( horizontal )
1896  {
1897  x += args[0];
1898  y = start_y;
1899  }
1900  else
1901  {
1902  x = start_x;
1903  y += args[0];
1904  }
1905 
1906  cff_builder_add_point( builder, x, y, 1 );
1907 
1908  args = stack;
1909  break;
1910  }
1911 
1912  case cff_op_flex:
1913  {
1914  FT_UInt count;
1915 
1916 
1917  FT_TRACE4(( " flex\n" ));
1918 
1919  if ( cff_builder_start_point( builder, x, y ) ||
1920  check_points( builder, 6 ) )
1921  goto Fail;
1922 
1923  for ( count = 6; count > 0; count-- )
1924  {
1925  x += args[0];
1926  y += args[1];
1927  cff_builder_add_point( builder, x, y,
1928  (FT_Bool)( count == 4 || count == 1 ) );
1929  args += 2;
1930  }
1931 
1932  args = stack;
1933  }
1934  break;
1935 
1936  case cff_op_seac:
1937  FT_TRACE4(( " seac\n" ));
1938 
1939  error = cff_operator_seac( decoder,
1940  args[0], args[1], args[2],
1941  (FT_Int)( args[3] >> 16 ),
1942  (FT_Int)( args[4] >> 16 ) );
1943 
1944  /* add current outline to the glyph slot */
1945  FT_GlyphLoader_Add( builder->loader );
1946 
1947  /* return now! */
1948  FT_TRACE4(( "\n" ));
1949  return error;
1950 
1951  case cff_op_endchar:
1952  FT_TRACE4(( " endchar\n" ));
1953 
1954  /* We are going to emulate the seac operator. */
1955  if ( num_args >= 4 )
1956  {
1957  /* Save glyph width so that the subglyphs don't overwrite it. */
1958  FT_Pos glyph_width = decoder->glyph_width;
1959 
1960 
1961  error = cff_operator_seac( decoder,
1962  0L, args[-4], args[-3],
1963  (FT_Int)( args[-2] >> 16 ),
1964  (FT_Int)( args[-1] >> 16 ) );
1965 
1966  decoder->glyph_width = glyph_width;
1967  }
1968  else
1969  {
1970  if ( !error )
1971  error = CFF_Err_Ok;
1972 
1973  cff_builder_close_contour( builder );
1974 
1975  /* close hints recording session */
1976  if ( hinter )
1977  {
1978  if ( hinter->close( hinter->hints,
1979  builder->current->n_points ) )
1980  goto Syntax_Error;
1981 
1982  /* apply hints to the loaded glyph outline now */
1983  hinter->apply( hinter->hints,
1984  builder->current,
1985  (PSH_Globals)builder->hints_globals,
1986  decoder->hint_mode );
1987  }
1988 
1989  /* add current outline to the glyph slot */
1990  FT_GlyphLoader_Add( builder->loader );
1991  }
1992 
1993  /* return now! */
1994  FT_TRACE4(( "\n" ));
1995  return error;
1996 
1997  case cff_op_abs:
1998  FT_TRACE4(( " abs\n" ));
1999 
2000  if ( args[0] < 0 )
2001  args[0] = -args[0];
2002  args++;
2003  break;
2004 
2005  case cff_op_add:
2006  FT_TRACE4(( " add\n" ));
2007 
2008  args[0] += args[1];
2009  args++;
2010  break;
2011 
2012  case cff_op_sub:
2013  FT_TRACE4(( " sub\n" ));
2014 
2015  args[0] -= args[1];
2016  args++;
2017  break;
2018 
2019  case cff_op_div:
2020  FT_TRACE4(( " div\n" ));
2021 
2022  args[0] = FT_DivFix( args[0], args[1] );
2023  args++;
2024  break;
2025 
2026  case cff_op_neg:
2027  FT_TRACE4(( " neg\n" ));
2028 
2029  args[0] = -args[0];
2030  args++;
2031  break;
2032 
2033  case cff_op_random:
2034  {
2035  FT_Fixed Rand;
2036 
2037 
2038  FT_TRACE4(( " rand\n" ));
2039 
2040  Rand = seed;
2041  if ( Rand >= 0x8000L )
2042  Rand++;
2043 
2044  args[0] = Rand;
2045  seed = FT_MulFix( seed, 0x10000L - seed );
2046  if ( seed == 0 )
2047  seed += 0x2873;
2048  args++;
2049  }
2050  break;
2051 
2052  case cff_op_mul:
2053  FT_TRACE4(( " mul\n" ));
2054 
2055  args[0] = FT_MulFix( args[0], args[1] );
2056  args++;
2057  break;
2058 
2059  case cff_op_sqrt:
2060  FT_TRACE4(( " sqrt\n" ));
2061 
2062  if ( args[0] > 0 )
2063  {
2064  FT_Int count = 9;
2065  FT_Fixed root = args[0];
2066  FT_Fixed new_root;
2067 
2068 
2069  for (;;)
2070  {
2071  new_root = ( root + FT_DivFix( args[0], root ) + 1 ) >> 1;
2072  if ( new_root == root || count <= 0 )
2073  break;
2074  root = new_root;
2075  }
2076  args[0] = new_root;
2077  }
2078  else
2079  args[0] = 0;
2080  args++;
2081  break;
2082 
2083  case cff_op_drop:
2084  /* nothing */
2085  FT_TRACE4(( " drop\n" ));
2086 
2087  break;
2088 
2089  case cff_op_exch:
2090  {
2091  FT_Fixed tmp;
2092 
2093 
2094  FT_TRACE4(( " exch\n" ));
2095 
2096  tmp = args[0];
2097  args[0] = args[1];
2098  args[1] = tmp;
2099  args += 2;
2100  }
2101  break;
2102 
2103  case cff_op_index:
2104  {
2105  FT_Int idx = (FT_Int)( args[0] >> 16 );
2106 
2107 
2108  FT_TRACE4(( " index\n" ));
2109 
2110  if ( idx < 0 )
2111  idx = 0;
2112  else if ( idx > num_args - 2 )
2113  idx = num_args - 2;
2114  args[0] = args[-( idx + 1 )];
2115  args++;
2116  }
2117  break;
2118 
2119  case cff_op_roll:
2120  {
2121  FT_Int count = (FT_Int)( args[0] >> 16 );
2122  FT_Int idx = (FT_Int)( args[1] >> 16 );
2123 
2124 
2125  FT_TRACE4(( " roll\n" ));
2126 
2127  if ( count <= 0 )
2128  count = 1;
2129 
2130  args -= count;
2131  if ( args < stack )
2132  goto Stack_Underflow;
2133 
2134  if ( idx >= 0 )
2135  {
2136  while ( idx > 0 )
2137  {
2138  FT_Fixed tmp = args[count - 1];
2139  FT_Int i;
2140 
2141 
2142  for ( i = count - 2; i >= 0; i-- )
2143  args[i + 1] = args[i];
2144  args[0] = tmp;
2145  idx--;
2146  }
2147  }
2148  else
2149  {
2150  while ( idx < 0 )
2151  {
2152  FT_Fixed tmp = args[0];
2153  FT_Int i;
2154 
2155 
2156  for ( i = 0; i < count - 1; i++ )
2157  args[i] = args[i + 1];
2158  args[count - 1] = tmp;
2159  idx++;
2160  }
2161  }
2162  args += count;
2163  }
2164  break;
2165 
2166  case cff_op_dup:
2167  FT_TRACE4(( " dup\n" ));
2168 
2169  args[1] = args[0];
2170  args += 2;
2171  break;
2172 
2173  case cff_op_put:
2174  {
2175  FT_Fixed val = args[0];
2176  FT_Int idx = (FT_Int)( args[1] >> 16 );
2177 
2178 
2179  FT_TRACE4(( " put\n" ));
2180 
2181  if ( idx >= 0 && idx < CFF_MAX_TRANS_ELEMENTS )
2182  decoder->buildchar[idx] = val;
2183  }
2184  break;
2185 
2186  case cff_op_get:
2187  {
2188  FT_Int idx = (FT_Int)( args[0] >> 16 );
2189  FT_Fixed val = 0;
2190 
2191 
2192  FT_TRACE4(( " get\n" ));
2193 
2194  if ( idx >= 0 && idx < CFF_MAX_TRANS_ELEMENTS )
2195  val = decoder->buildchar[idx];
2196 
2197  args[0] = val;
2198  args++;
2199  }
2200  break;
2201 
2202  case cff_op_store:
2203  FT_TRACE4(( " store\n"));
2204 
2205  goto Unimplemented;
2206 
2207  case cff_op_load:
2208  FT_TRACE4(( " load\n" ));
2209 
2210  goto Unimplemented;
2211 
2212  case cff_op_dotsection:
2213  /* this operator is deprecated and ignored by the parser */
2214  FT_TRACE4(( " dotsection\n" ));
2215  break;
2216 
2217  case cff_op_closepath:
2218  /* this is an invalid Type 2 operator; however, there */
2219  /* exist fonts which are incorrectly converted from probably */
2220  /* Type 1 to CFF, and some parsers seem to accept it */
2221 
2222  FT_TRACE4(( " closepath (invalid op)\n" ));
2223 
2224  args = stack;
2225  break;
2226 
2227  case cff_op_hsbw:
2228  /* this is an invalid Type 2 operator; however, there */
2229  /* exist fonts which are incorrectly converted from probably */
2230  /* Type 1 to CFF, and some parsers seem to accept it */
2231 
2232  FT_TRACE4(( " hsbw (invalid op)\n" ));
2233 
2234  decoder->glyph_width = decoder->nominal_width + ( args[1] >> 16 );
2235 
2236  decoder->builder.left_bearing.x = args[0];
2237  decoder->builder.left_bearing.y = 0;
2238 
2239  x = decoder->builder.pos_x + args[0];
2240  y = decoder->builder.pos_y;
2241  args = stack;
2242  break;
2243 
2244  case cff_op_sbw:
2245  /* this is an invalid Type 2 operator; however, there */
2246  /* exist fonts which are incorrectly converted from probably */
2247  /* Type 1 to CFF, and some parsers seem to accept it */
2248 
2249  FT_TRACE4(( " sbw (invalid op)\n" ));
2250 
2251  decoder->glyph_width = decoder->nominal_width + ( args[2] >> 16 );
2252 
2253  decoder->builder.left_bearing.x = args[0];
2254  decoder->builder.left_bearing.y = args[1];
2255 
2256  x = decoder->builder.pos_x + args[0];
2257  y = decoder->builder.pos_y + args[1];
2258  args = stack;
2259  break;
2260 
2261  case cff_op_setcurrentpoint:
2262  /* this is an invalid Type 2 operator; however, there */
2263  /* exist fonts which are incorrectly converted from probably */
2264  /* Type 1 to CFF, and some parsers seem to accept it */
2265 
2266  FT_TRACE4(( " setcurrentpoint (invalid op)\n" ));
2267 
2268  x = decoder->builder.pos_x + args[0];
2269  y = decoder->builder.pos_y + args[1];
2270  args = stack;
2271  break;
2272 
2273  case cff_op_callothersubr:
2274  /* this is an invalid Type 2 operator; however, there */
2275  /* exist fonts which are incorrectly converted from probably */
2276  /* Type 1 to CFF, and some parsers seem to accept it */
2277 
2278  FT_TRACE4(( " callothersubr (invalid op)\n" ));
2279 
2280  /* subsequent `pop' operands should add the arguments, */
2281  /* this is the implementation described for `unknown' other */
2282  /* subroutines in the Type1 spec. */
2283  /* */
2284  /* XXX Fix return arguments (see discussion below). */
2285  args -= 2 + ( args[-2] >> 16 );
2286  if ( args < stack )
2287  goto Stack_Underflow;
2288  break;
2289 
2290  case cff_op_pop:
2291  /* this is an invalid Type 2 operator; however, there */
2292  /* exist fonts which are incorrectly converted from probably */
2293  /* Type 1 to CFF, and some parsers seem to accept it */
2294 
2295  FT_TRACE4(( " pop (invalid op)\n" ));
2296 
2297  /* XXX Increasing `args' is wrong: After a certain number of */
2298  /* `pop's we get a stack overflow. Reason for doing it is */
2299  /* code like this (actually found in a CFF font): */
2300  /* */
2301  /* 17 1 3 callothersubr */
2302  /* pop */
2303  /* callsubr */
2304  /* */
2305  /* Since we handle `callothersubr' as a no-op, and */
2306  /* `callsubr' needs at least one argument, `pop' can't be a */
2307  /* no-op too as it basically should be. */
2308  /* */
2309  /* The right solution would be to provide real support for */
2310  /* `callothersubr' as done in `t1decode.c', however, given */
2311  /* the fact that CFF fonts with `pop' are invalid, it is */
2312  /* questionable whether it is worth the time. */
2313  args++;
2314  break;
2315 
2316  case cff_op_and:
2317  {
2318  FT_Fixed cond = args[0] && args[1];
2319 
2320 
2321  FT_TRACE4(( " and\n" ));
2322 
2323  args[0] = cond ? 0x10000L : 0;
2324  args++;
2325  }
2326  break;
2327 
2328  case cff_op_or:
2329  {
2330  FT_Fixed cond = args[0] || args[1];
2331 
2332 
2333  FT_TRACE4(( " or\n" ));
2334 
2335  args[0] = cond ? 0x10000L : 0;
2336  args++;
2337  }
2338  break;
2339 
2340  case cff_op_eq:
2341  {
2342  FT_Fixed cond = !args[0];
2343 
2344 
2345  FT_TRACE4(( " eq\n" ));
2346 
2347  args[0] = cond ? 0x10000L : 0;
2348  args++;
2349  }
2350  break;
2351 
2352  case cff_op_ifelse:
2353  {
2354  FT_Fixed cond = ( args[2] <= args[3] );
2355 
2356 
2357  FT_TRACE4(( " ifelse\n" ));
2358 
2359  if ( !cond )
2360  args[0] = args[1];
2361  args++;
2362  }
2363  break;
2364 
2365  case cff_op_callsubr:
2366  {
2367  FT_UInt idx = (FT_UInt)( ( args[0] >> 16 ) +
2368  decoder->locals_bias );
2369 
2370 
2371  FT_TRACE4(( " callsubr(%d)\n", idx ));
2372 
2373  if ( idx >= decoder->num_locals )
2374  {
2375  FT_ERROR(( "cff_decoder_parse_charstrings:"
2376  " invalid local subr index\n" ));
2377  goto Syntax_Error;
2378  }
2379 
2380  if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
2381  {
2382  FT_ERROR(( "cff_decoder_parse_charstrings:"
2383  " too many nested subrs\n" ));
2384  goto Syntax_Error;
2385  }
2386 
2387  zone->cursor = ip; /* save current instruction pointer */
2388 
2389  zone++;
2390  zone->base = decoder->locals[idx];
2391  zone->limit = decoder->locals[idx + 1];
2392  zone->cursor = zone->base;
2393 
2394  if ( !zone->base || zone->limit == zone->base )
2395  {
2396  FT_ERROR(( "cff_decoder_parse_charstrings:"
2397  " invoking empty subrs\n" ));
2398  goto Syntax_Error;
2399  }
2400 
2401  decoder->zone = zone;
2402  ip = zone->base;
2403  limit = zone->limit;
2404  }
2405  break;
2406 
2407  case cff_op_callgsubr:
2408  {
2409  FT_UInt idx = (FT_UInt)( ( args[0] >> 16 ) +
2410  decoder->globals_bias );
2411 
2412 
2413  FT_TRACE4(( " callgsubr(%d)\n", idx ));
2414 
2415  if ( idx >= decoder->num_globals )
2416  {
2417  FT_ERROR(( "cff_decoder_parse_charstrings:"
2418  " invalid global subr index\n" ));
2419  goto Syntax_Error;
2420  }
2421 
2422  if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
2423  {
2424  FT_ERROR(( "cff_decoder_parse_charstrings:"
2425  " too many nested subrs\n" ));
2426  goto Syntax_Error;
2427  }
2428 
2429  zone->cursor = ip; /* save current instruction pointer */
2430 
2431  zone++;
2432  zone->base = decoder->globals[idx];
2433  zone->limit = decoder->globals[idx + 1];
2434  zone->cursor = zone->base;
2435 
2436  if ( !zone->base || zone->limit == zone->base )
2437  {
2438  FT_ERROR(( "cff_decoder_parse_charstrings:"
2439  " invoking empty subrs\n" ));
2440  goto Syntax_Error;
2441  }
2442 
2443  decoder->zone = zone;
2444  ip = zone->base;
2445  limit = zone->limit;
2446  }
2447  break;
2448 
2449  case cff_op_return:
2450  FT_TRACE4(( " return\n" ));
2451 
2452  if ( decoder->zone <= decoder->zones )
2453  {
2454  FT_ERROR(( "cff_decoder_parse_charstrings:"
2455  " unexpected return\n" ));
2456  goto Syntax_Error;
2457  }
2458 
2459  decoder->zone--;
2460  zone = decoder->zone;
2461  ip = zone->cursor;
2462  limit = zone->limit;
2463  break;
2464 
2465  default:
2466  Unimplemented:
2467  FT_ERROR(( "Unimplemented opcode: %d", ip[-1] ));
2468 
2469  if ( ip[-1] == 12 )
2470  FT_ERROR(( " %d", ip[0] ));
2471  FT_ERROR(( "\n" ));
2472 
2473  return CFF_Err_Unimplemented_Feature;
2474  }
2475 
2476  decoder->top = args;
2477 
2478  if ( decoder->top - stack >= CFF_MAX_OPERANDS )
2479  goto Stack_Overflow;
2480 
2481  } /* general operator processing */
2482 
2483  } /* while ip < limit */
2484 
2485  FT_TRACE4(( "..end..\n\n" ));
2486 
2487  Fail:
2488  return error;
2489 
2490  Syntax_Error:
2491  FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error\n" ));
2492  return CFF_Err_Invalid_File_Format;
2493 
2494  Stack_Underflow:
2495  FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow\n" ));
2496  return CFF_Err_Too_Few_Arguments;
2497 
2498  Stack_Overflow:
2499  FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow\n" ));
2500  return CFF_Err_Stack_Overflow;
2501  }
2502 
2503 
2504  /*************************************************************************/
2505  /*************************************************************************/
2506  /*************************************************************************/
2507  /********** *********/
2508  /********** *********/
2509  /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
2510  /********** *********/
2511  /********** The following code is in charge of computing *********/
2512  /********** the maximum advance width of the font. It *********/
2513  /********** quickly processes each glyph charstring to *********/
2514  /********** extract the value from either a `sbw' or `seac' *********/
2515  /********** operator. *********/
2516  /********** *********/
2517  /*************************************************************************/
2518  /*************************************************************************/
2519  /*************************************************************************/
2520 
2521 
2522 #if 0 /* unused until we support pure CFF fonts */
2523 
2524 
2525  FT_LOCAL_DEF( FT_Error )
2526  cff_compute_max_advance( TT_Face face,
2527  FT_Int* max_advance )
2528  {
2529  FT_Error error = CFF_Err_Ok;
2530  CFF_Decoder decoder;
2531  FT_Int glyph_index;
2532  CFF_Font cff = (CFF_Font)face->other;
2533 
2534 
2535  *max_advance = 0;
2536 
2537  /* Initialize load decoder */
2538  cff_decoder_init( &decoder, face, 0, 0, 0, 0 );
2539 
2540  decoder.builder.metrics_only = 1;
2541  decoder.builder.load_points = 0;
2542 
2543  /* For each glyph, parse the glyph charstring and extract */
2544  /* the advance width. */
2545  for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
2546  glyph_index++ )
2547  {
2548  FT_Byte* charstring;
2549  FT_ULong charstring_len;
2550 
2551 
2552  /* now get load the unscaled outline */
2553  error = cff_get_glyph_data( face, glyph_index,
2554  &charstring, &charstring_len );
2555  if ( !error )
2556  {
2557  error = cff_decoder_prepare( &decoder, size, glyph_index );
2558  if ( !error )
2559  error = cff_decoder_parse_charstrings( &decoder,
2560  charstring,
2561  charstring_len );
2562 
2563  cff_free_glyph_data( face, &charstring, &charstring_len );
2564  }
2565 
2566  /* ignore the error if one has occurred -- skip to next glyph */
2567  error = CFF_Err_Ok;
2568  }
2569 
2570  *max_advance = decoder.builder.advance.x;
2571 
2572  return CFF_Err_Ok;
2573  }
2574 
2575 
2576 #endif /* 0 */
2577 
2578 
2579  FT_LOCAL_DEF( FT_Error )
2580  cff_slot_load( CFF_GlyphSlot glyph,
2581  CFF_Size size,
2582  FT_UInt glyph_index,
2583  FT_Int32 load_flags )
2584  {
2585  FT_Error error;
2586  CFF_Decoder decoder;
2587  TT_Face face = (TT_Face)glyph->root.face;
2588  FT_Bool hinting, force_scaling;
2589  CFF_Font cff = (CFF_Font)face->extra.data;
2590 
2591  FT_Matrix font_matrix;
2592  FT_Vector font_offset;
2593 
2594 
2595  force_scaling = FALSE;
2596 
2597  /* in a CID-keyed font, consider `glyph_index' as a CID and map */
2598  /* it immediately to the real glyph_index -- if it isn't a */
2599  /* subsetted font, glyph_indices and CIDs are identical, though */
2600  if ( cff->top_font.font_dict.cid_registry != 0xFFFFU &&
2601  cff->charset.cids )
2602  {
2603  /* don't handle CID 0 (.notdef) which is directly mapped to GID 0 */
2604  if ( glyph_index != 0 )
2605  {
2606  glyph_index = cff_charset_cid_to_gindex( &cff->charset,
2607  glyph_index );
2608  if ( glyph_index == 0 )
2609  return CFF_Err_Invalid_Argument;
2610  }
2611  }
2612  else if ( glyph_index >= cff->num_glyphs )
2613  return CFF_Err_Invalid_Argument;
2614 
2615  if ( load_flags & FT_LOAD_NO_RECURSE )
2616  load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
2617 
2618  glyph->x_scale = 0x10000L;
2619  glyph->y_scale = 0x10000L;
2620  if ( size )
2621  {
2622  glyph->x_scale = size->root.metrics.x_scale;
2623  glyph->y_scale = size->root.metrics.y_scale;
2624  }
2625 
2626 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
2627 
2628  /* try to load embedded bitmap if any */
2629  /* */
2630  /* XXX: The convention should be emphasized in */
2631  /* the documents because it can be confusing. */
2632  if ( size )
2633  {
2634  CFF_Face cff_face = (CFF_Face)size->root.face;
2635  SFNT_Service sfnt = (SFNT_Service)cff_face->sfnt;
2636  FT_Stream stream = cff_face->root.stream;
2637 
2638 
2639  if ( size->strike_index != 0xFFFFFFFFUL &&
2640  sfnt->load_eblc &&
2641  ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
2642  {
2643  TT_SBit_MetricsRec metrics;
2644 
2645 
2646  error = sfnt->load_sbit_image( face,
2647  size->strike_index,
2648  glyph_index,
2649  (FT_Int)load_flags,
2650  stream,
2651  &glyph->root.bitmap,
2652  &metrics );
2653 
2654  if ( !error )
2655  {
2656  glyph->root.outline.n_points = 0;
2657  glyph->root.outline.n_contours = 0;
2658 
2659  glyph->root.metrics.width = (FT_Pos)metrics.width << 6;
2660  glyph->root.metrics.height = (FT_Pos)metrics.height << 6;
2661 
2662  glyph->root.metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
2663  glyph->root.metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
2664  glyph->root.metrics.horiAdvance = (FT_Pos)metrics.horiAdvance << 6;
2665 
2666  glyph->root.metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
2667  glyph->root.metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
2668  glyph->root.metrics.vertAdvance = (FT_Pos)metrics.vertAdvance << 6;
2669 
2670  glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
2671 
2672  if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2673  {
2674  glyph->root.bitmap_left = metrics.vertBearingX;
2675  glyph->root.bitmap_top = metrics.vertBearingY;
2676  }
2677  else
2678  {
2679  glyph->root.bitmap_left = metrics.horiBearingX;
2680  glyph->root.bitmap_top = metrics.horiBearingY;
2681  }
2682  return error;
2683  }
2684  }
2685  }
2686 
2687 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
2688 
2689  /* return immediately if we only want the embedded bitmaps */
2690  if ( load_flags & FT_LOAD_SBITS_ONLY )
2691  return CFF_Err_Invalid_Argument;
2692 
2693  /* if we have a CID subfont, use its matrix (which has already */
2694  /* been multiplied with the root matrix) */
2695 
2696  /* this scaling is only relevant if the PS hinter isn't active */
2697  if ( cff->num_subfonts )
2698  {
2699  FT_ULong top_upm, sub_upm;
2700  FT_Byte fd_index = cff_fd_select_get( &cff->fd_select,
2701  glyph_index );
2702 
2703  if ( fd_index >= cff->num_subfonts )
2704  fd_index = (FT_Byte)( cff->num_subfonts - 1 );
2705 
2706  top_upm = cff->top_font.font_dict.units_per_em;
2707  sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
2708 
2709 
2710  font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
2711  font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
2712 
2713  if ( top_upm != sub_upm )
2714  {
2715  glyph->x_scale = FT_MulDiv( glyph->x_scale, top_upm, sub_upm );
2716  glyph->y_scale = FT_MulDiv( glyph->y_scale, top_upm, sub_upm );
2717 
2718  force_scaling = TRUE;
2719  }
2720  }
2721  else
2722  {
2723  font_matrix = cff->top_font.font_dict.font_matrix;
2724  font_offset = cff->top_font.font_dict.font_offset;
2725  }
2726 
2727  glyph->root.outline.n_points = 0;
2728  glyph->root.outline.n_contours = 0;
2729 
2730  hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
2731  ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
2732 
2733  glyph->root.format = FT_GLYPH_FORMAT_OUTLINE; /* by default */
2734 
2735  {
2736  FT_Byte* charstring;
2737  FT_ULong charstring_len;
2738 
2739 
2740  cff_decoder_init( &decoder, face, size, glyph, hinting,
2741  FT_LOAD_TARGET_MODE( load_flags ) );
2742 
2743  if ( load_flags & FT_LOAD_ADVANCE_ONLY )
2744  decoder.width_only = TRUE;
2745 
2746  decoder.builder.no_recurse =
2747  (FT_Bool)( load_flags & FT_LOAD_NO_RECURSE );
2748 
2749  /* now load the unscaled outline */
2750  error = cff_get_glyph_data( face, glyph_index,
2751  &charstring, &charstring_len );
2752  if ( error )
2753  goto Glyph_Build_Finished;
2754 
2755  error = cff_decoder_prepare( &decoder, size, glyph_index );
2756  if ( error )
2757  goto Glyph_Build_Finished;
2758 
2759  error = cff_decoder_parse_charstrings( &decoder,
2760  charstring,
2761  charstring_len );
2762 
2763  cff_free_glyph_data( face, &charstring, charstring_len );
2764 
2765  if ( error )
2766  goto Glyph_Build_Finished;
2767 
2768 #ifdef FT_CONFIG_OPTION_INCREMENTAL
2769  /* Control data and length may not be available for incremental */
2770  /* fonts. */
2771  if ( face->root.internal->incremental_interface )
2772  {
2773  glyph->root.control_data = 0;
2774  glyph->root.control_len = 0;
2775  }
2776  else
2777 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
2778 
2779  /* We set control_data and control_len if charstrings is loaded. */
2780  /* See how charstring loads at cff_index_access_element() in */
2781  /* cffload.c. */
2782  {
2783  CFF_Index csindex = &cff->charstrings_index;
2784 
2785 
2786  if ( csindex->offsets )
2787  {
2788  glyph->root.control_data = csindex->bytes +
2789  csindex->offsets[glyph_index] - 1;
2790  glyph->root.control_len = charstring_len;
2791  }
2792  }
2793 
2794  Glyph_Build_Finished:
2795  /* save new glyph tables, if no error */
2796  if ( !error )
2797  cff_builder_done( &decoder.builder );
2798  /* XXX: anything to do for broken glyph entry? */
2799  }
2800 
2801 #ifdef FT_CONFIG_OPTION_INCREMENTAL
2802 
2803  /* Incremental fonts can optionally override the metrics. */
2804  if ( !error &&
2805  face->root.internal->incremental_interface &&
2806  face->root.internal->incremental_interface->funcs->get_glyph_metrics )
2807  {
2808  FT_Incremental_MetricsRec metrics;
2809 
2810 
2811  metrics.bearing_x = decoder.builder.left_bearing.x;
2812  metrics.bearing_y = 0;
2813  metrics.advance = decoder.builder.advance.x;
2814  metrics.advance_v = decoder.builder.advance.y;
2815 
2816  error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
2817  face->root.internal->incremental_interface->object,
2818  glyph_index, FALSE, &metrics );
2819 
2820  decoder.builder.left_bearing.x = metrics.bearing_x;
2821  decoder.builder.advance.x = metrics.advance;
2822  decoder.builder.advance.y = metrics.advance_v;
2823  }
2824 
2825 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
2826 
2827  if ( !error )
2828  {
2829  /* Now, set the metrics -- this is rather simple, as */
2830  /* the left side bearing is the xMin, and the top side */
2831  /* bearing the yMax. */
2832 
2833  /* For composite glyphs, return only left side bearing and */
2834  /* advance width. */
2835  if ( load_flags & FT_LOAD_NO_RECURSE )
2836  {
2837  FT_Slot_Internal internal = glyph->root.internal;
2838 
2839 
2840  glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
2841  glyph->root.metrics.horiAdvance = decoder.glyph_width;
2842  internal->glyph_matrix = font_matrix;
2843  internal->glyph_delta = font_offset;
2844  internal->glyph_transformed = 1;
2845  }
2846  else
2847  {
2848  FT_BBox cbox;
2849  FT_Glyph_Metrics* metrics = &glyph->root.metrics;
2850  FT_Vector advance;
2851  FT_Bool has_vertical_info;
2852 
2853 
2854  /* copy the _unscaled_ advance width */
2855  metrics->horiAdvance = decoder.glyph_width;
2856  glyph->root.linearHoriAdvance = decoder.glyph_width;
2857  glyph->root.internal->glyph_transformed = 0;
2858 
2859 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
2860  has_vertical_info = FT_BOOL( face->vertical_info &&
2861  face->vertical.number_Of_VMetrics > 0 &&
2862  face->vertical.long_metrics );
2863 #else
2864  has_vertical_info = FT_BOOL( face->vertical_info &&
2865  face->vertical.number_Of_VMetrics > 0 );
2866 #endif
2867 
2868  /* get the vertical metrics from the vtmx table if we have one */
2869  if ( has_vertical_info )
2870  {
2871  FT_Short vertBearingY = 0;
2872  FT_UShort vertAdvance = 0;
2873 
2874 
2875  ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
2876  glyph_index,
2877  &vertBearingY,
2878  &vertAdvance );
2879  metrics->vertBearingY = vertBearingY;
2880  metrics->vertAdvance = vertAdvance;
2881  }
2882  else
2883  {
2884  /* make up vertical ones */
2885  if ( face->os2.version != 0xFFFFU )
2886  metrics->vertAdvance = (FT_Pos)( face->os2.sTypoAscender -
2887  face->os2.sTypoDescender );
2888  else
2889  metrics->vertAdvance = (FT_Pos)( face->horizontal.Ascender -
2890  face->horizontal.Descender );
2891  }
2892 
2893  glyph->root.linearVertAdvance = metrics->vertAdvance;
2894 
2895  glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
2896 
2897  glyph->root.outline.flags = 0;
2898  if ( size && size->root.metrics.y_ppem < 24 )
2899  glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;
2900 
2901  glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
2902 
2903  if ( !( font_matrix.xx == 0x10000L &&
2904  font_matrix.yy == 0x10000L &&
2905  font_matrix.xy == 0 &&
2906  font_matrix.yx == 0 ) )
2907  FT_Outline_Transform( &glyph->root.outline, &font_matrix );
2908 
2909  if ( !( font_offset.x == 0 &&
2910  font_offset.y == 0 ) )
2911  FT_Outline_Translate( &glyph->root.outline,
2912  font_offset.x, font_offset.y );
2913 
2914  advance.x = metrics->horiAdvance;
2915  advance.y = 0;
2916  FT_Vector_Transform( &advance, &font_matrix );
2917  metrics->horiAdvance = advance.x + font_offset.x;
2918 
2919  advance.x = 0;
2920  advance.y = metrics->vertAdvance;
2921  FT_Vector_Transform( &advance, &font_matrix );
2922  metrics->vertAdvance = advance.y + font_offset.y;
2923 
2924  if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )
2925  {
2926  /* scale the outline and the metrics */
2927  FT_Int n;
2928  FT_Outline* cur = &glyph->root.outline;
2929  FT_Vector* vec = cur->points;
2930  FT_Fixed x_scale = glyph->x_scale;
2931  FT_Fixed y_scale = glyph->y_scale;
2932 
2933 
2934  /* First of all, scale the points */
2935  if ( !hinting || !decoder.builder.hints_funcs )
2936  for ( n = cur->n_points; n > 0; n--, vec++ )
2937  {
2938  vec->x = FT_MulFix( vec->x, x_scale );
2939  vec->y = FT_MulFix( vec->y, y_scale );
2940  }
2941 
2942  /* Then scale the metrics */
2943  metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
2944  metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
2945  }
2946 
2947  /* compute the other metrics */
2948  FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
2949 
2950  metrics->width = cbox.xMax - cbox.xMin;
2951  metrics->height = cbox.yMax - cbox.yMin;
2952 
2953  metrics->horiBearingX = cbox.xMin;
2954  metrics->horiBearingY = cbox.yMax;
2955 
2956  if ( has_vertical_info )
2957  metrics->vertBearingX = metrics->horiBearingX -
2958  metrics->horiAdvance / 2;
2959  else
2960  {
2961  if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2962  ft_synthesize_vertical_metrics( metrics,
2963  metrics->vertAdvance );
2964  }
2965  }
2966  }
2967 
2968  return error;
2969  }
2970 
2971 
2972 /* END */
PSH_Globals
typedefFT_BEGIN_HEADER struct PSH_GlobalsRec_ * PSH_Globals
Definition: pshints.h:41
FT_Error
int FT_Error
Definition: fttypes.h:296
FT_Incremental_MetricsRec_::bearing_y
FT_Long bearing_y
Definition: ftincrem.h:118
cff_get_standard_encoding
cff_get_standard_encoding(FT_UInt charcode)
Definition: cffload.c:183
CFF_Builder_::base
FT_Outline * base
Definition: cffgload.h:87
CFF_Builder_::metrics_only
FT_Bool metrics_only
Definition: cffgload.h:101
FT_LOAD_VERTICAL_LAYOUT
#define FT_LOAD_VERTICAL_LAYOUT
Definition: freetype.h:2516
FT_DivFix
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:536
CFF_Builder_::loader
FT_GlyphLoader loader
Definition: cffgload.h:86
TT_FaceRec_::sfnt
void * sfnt
Definition: tttypes.h:1298
FT_PtrDist
ft_ptrdiff_t FT_PtrDist
Definition: fttypes.h:333
val
GLuint const GLfloat * val
Definition: glew.h:2715
CFF_Decoder_
Definition: cffgload.h:120
SFNT_Service
SFNT_Interface * SFNT_Service
Definition: sfnt.h:754
TT_FaceRec_::os2
TT_OS2 os2
Definition: tttypes.h:1282
cff_builder_close_contour
static void cff_builder_close_contour(CFF_Builder *builder)
Definition: cffgload.c:566
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:249
FT_LOAD_SBITS_ONLY
#define FT_LOAD_SBITS_ONLY
Definition: freetype.h:2531
FT_Pos
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:59
CFF_MAX_TRANS_ELEMENTS
#define CFF_MAX_TRANS_ELEMENTS
Definition: cffgload.h:33
FT_GlyphSlotRec_
Definition: freetype.h:1605
ft_synthesize_vertical_metrics
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2530
TT_OS2_::version
FT_UShort version
Definition: tttables.h:352
FT_SubGlyphRec_
Definition: ftgloadr.h:57
FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES
#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES
Definition: freetype.h:3218
TT_SBit_MetricsRec_::horiBearingY
FT_Char horiBearingY
Definition: tttypes.h:441
FT_MEM_ZERO
#define FT_MEM_ZERO(dest, count)
Definition: ftmemory.h:208
CFF_Builder_
Definition: cffgload.h:81
FT_SUBGLYPH_FLAG_USE_MY_METRICS
#define FT_SUBGLYPH_FLAG_USE_MY_METRICS
Definition: freetype.h:3223
CFF_Decoder_::builder
CFF_Builder builder
Definition: cffgload.h:122
CFF_MAX_SUBRS_CALLS
#define CFF_MAX_SUBRS_CALLS
Definition: cffgload.h:32
FT_CURVE_TAG_CUBIC
#define FT_CURVE_TAG_CUBIC
Definition: ftimage.h:518
TT_OS2_::sTypoDescender
FT_Short sTypoDescender
Definition: tttables.h:382
FT_Matrix_::xy
FT_Fixed xy
Definition: fttypes.h:383
cff_builder_init
static void cff_builder_init(CFF_Builder *builder, TT_Face face, CFF_Size size, CFF_GlyphSlot glyph, FT_Bool hinting)
Definition: cffgload.c:247
FT_Int
signed int FT_Int
Definition: fttypes.h:216
FT_Outline_::n_contours
short n_contours
Definition: ftimage.h:385
FT_Data_::pointer
const FT_Byte * pointer
Definition: fttypes.h:404
T2_Hints_FuncsRec_::hints
T2_Hints hints
Definition: pshints.h:658
FT_ULONG_MAX
#define FT_ULONG_MAX
Definition: ftstdlib.h:67
FT_Render_Mode
enum FT_Render_Mode_ FT_Render_Mode
TT_SBit_MetricsRec_::horiAdvance
FT_Byte horiAdvance
Definition: tttypes.h:442
FT_Data_::length
FT_Int length
Definition: fttypes.h:405
FT_Matrix_
Definition: fttypes.h:381
stream
GLuint GLuint stream
Definition: glew.h:6573
n
GLclampd n
Definition: glew.h:7287
FT_LOAD_NO_HINTING
#define FT_LOAD_NO_HINTING
Definition: freetype.h:2513
FT_Outline_::contours
short * contours
Definition: ftimage.h:390
CFF_Face
TT_Face CFF_Face
Definition: cffobjs.h:44
x
EGLSurface EGLint x
Definition: eglext.h:293
FT_Outline_::tags
char * tags
Definition: ftimage.h:389
metrics
GLuint GLsizei GLsizei GLfloat * metrics
Definition: glew.h:12394
CFF_FontRecDictRec_::charstring_type
FT_Int charstring_type
Definition: cfftypes.h:118
CFF_Font
struct CFF_FontRec_ * CFF_Font
cff_operator_seac
static FT_Error cff_operator_seac(CFF_Decoder *decoder, FT_Pos asb, FT_Pos adx, FT_Pos ady, FT_Int bchar, FT_Int achar)
Definition: cffgload.c:711
FT_LOAD_NO_RECURSE
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:2521
CFF_FontRec_::subfonts
CFF_SubFont subfonts[CFF_MAX_CID_FONTS]
Definition: cfftypes.h:256
FT_Outline_
Definition: ftimage.h:383
CFF_FontRec_::global_subrs_index
CFF_IndexRec global_subrs_index
Definition: cfftypes.h:234
T2_Hints_FuncsRec_::stems
T2_Hints_StemsFunc stems
Definition: pshints.h:661
cff_builder_start_point
static FT_Error cff_builder_start_point(CFF_Builder *builder, FT_Pos x, FT_Pos y)
Definition: cffgload.c:544
FT_LOAD_ADVANCE_ONLY
#define FT_LOAD_ADVANCE_ONLY
Definition: freetype.h:2530
cff_decoder_parse_charstrings
cff_decoder_parse_charstrings(CFF_Decoder *decoder, FT_Byte *charstring_base, FT_ULong charstring_len)
Definition: cffgload.c:883
CFF_GlyphSlotRec_::root
FT_GlyphSlotRec root
Definition: cffobjs.h:73
CFF_Decoder_Zone_::limit
FT_Byte * limit
Definition: cffgload.h:114
if
if(!yyg->yy_init)
Definition: glslang_lex.cpp:1037
FT_Bool
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
FT_LOAD_NO_SCALE
#define FT_LOAD_NO_SCALE
Definition: freetype.h:2512
FT_FaceRec_::internal
FT_Face_Internal internal
Definition: freetype.h:964
CFF_FontRecDictRec_::font_offset
FT_Vector font_offset
Definition: cfftypes.h:122
cff_builder_add_contour
static FT_Error cff_builder_add_contour(CFF_Builder *builder)
Definition: cffgload.c:516
CFF_Decoder_::glyph_width
FT_Pos glyph_width
Definition: cffgload.h:135
CFF_Decoder_Zone_::base
FT_Byte * base
Definition: cffgload.h:113
FT_GlyphSlotRec_::outline
FT_Outline outline
Definition: freetype.h:1624
pointer
GLsizei const GLvoid * pointer
Definition: glew.h:1509
cff_argument_counts
static const FT_Byte cff_argument_counts[]
Definition: cffgload.c:135
FT_GlyphLoader
typedefFT_BEGIN_HEADER struct FT_GlyphLoaderRec_ * FT_GlyphLoader
Definition: ftgloadr.h:43
CFF_FontRec_
Definition: cfftypes.h:219
FT_ERROR
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
CFF_GlyphSlotRec_
Definition: cffobjs.h:71
cff_fd_select_get
cff_fd_select_get(CFF_FDSelect fdselect, FT_UInt glyph_index)
Definition: cffload.c:708
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:150
CFF_Operator_
CFF_Operator_
Definition: cffgload.c:42
cff_index_access_element
cff_index_access_element(CFF_Index idx, FT_UInt element, FT_Byte **pbytes, FT_ULong *pbyte_len)
Definition: cffload.c:469
CFF_Internal
struct CFF_InternalRec_ * CFF_Internal
FT_SizeRec_::internal
FT_Size_Internal internal
Definition: freetype.h:1400
FT_TRACE4
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
CFF_Builder_::no_recurse
FT_Bool no_recurse
Definition: cffgload.h:99
TT_HoriHeader_::Descender
FT_Short Descender
Definition: tttables.h:184
FT_Outline_Get_CBox
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:460
FT_GlyphLoader_Add
FT_GlyphLoader_Add(FT_GlyphLoader loader)
Definition: ftgloadr.c:323
CFF_Builder_::left_bearing
FT_Vector left_bearing
Definition: cffgload.h:93
CFF_FontRec_::num_subfonts
FT_UInt num_subfonts
Definition: cfftypes.h:255
CFF_FontRec_::global_subrs
FT_Byte ** global_subrs
Definition: cfftypes.h:247
CFF_Builder_::current
FT_Outline * current
Definition: cffgload.h:88
CFF_SubFontRec_::font_dict
CFF_FontRecDictRec font_dict
Definition: cfftypes.h:207
TT_SBit_MetricsRec_::horiBearingX
FT_Char horiBearingX
Definition: tttypes.h:440
cff_decoder_prepare
cff_decoder_prepare(CFF_Decoder *decoder, CFF_Size size, FT_UInt glyph_index)
Definition: cffgload.c:408
cff
CFF_Font cff
Definition: cffdrivr.c:448
FT_Outline_Transform
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:695
TT_HoriHeader_::Ascender
FT_Short Ascender
Definition: tttables.h:183
first
GLint first
Definition: gl2ext.h:1011
result
GLuint64EXT * result
Definition: glew.h:12708
FT_BBox_::yMax
FT_Pos yMax
Definition: ftimage.h:119
FT_LOCAL_DEF
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:467
FT_BBox_::xMin
FT_Pos xMin
Definition: ftimage.h:118
cff_decoder_init
cff_decoder_init(CFF_Decoder *decoder, TT_Face face, CFF_Size size, CFF_GlyphSlot slot, FT_Bool hinting, FT_Render_Mode hint_mode)
Definition: cffgload.c:377
TT_Face
struct TT_FaceRec_ * TT_Face
Definition: tttypes.h:951
v
const GLdouble * v
Definition: glew.h:1377
CFF_COUNT_CHECK_WIDTH
#define CFF_COUNT_CHECK_WIDTH
Definition: cffgload.c:125
T2_Hints_FuncsRec_::counter
T2_Hints_CounterFunc counter
Definition: pshints.h:663
TT_SBit_MetricsRec_::height
FT_Byte height
Definition: tttypes.h:437
CFF_FontRec_::fd_select
CFF_FDSelectRec fd_select
Definition: cfftypes.h:258
FT_GlyphLoader_CheckSubGlyphs
FT_GlyphLoader_CheckSubGlyphs(FT_GlyphLoader loader, FT_UInt n_subs)
Definition: ftgloadr.c:276
idx
FT_UInt idx
Definition: cffcmap.c:125
CFF_SizeRec_::root
FT_SizeRec root
Definition: cffobjs.h:57
length
GLsizei GLsizei * length
Definition: gl2ext.h:792
FT_MulDiv
FT_MulDiv(FT_Long a, FT_Long b, FT_Long c)
Definition: ftcalc.c:358
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl2ext.h:848
T2_Hints_FuncsRec_
Definition: pshints.h:656
error
FT_Error error
Definition: cffdrivr.c:407
TT_SBit_MetricsRec_::vertBearingX
FT_Char vertBearingX
Definition: tttypes.h:444
FT_GlyphSlotRec_::num_subglyphs
FT_UInt num_subglyphs
Definition: freetype.h:1626
FT_Vector_::x
FT_Pos x
Definition: ftimage.h:77
CFF_InternalRec_
Definition: cffobjs.h:92
T2_Hints_FuncsRec_::apply
T2_Hints_ApplyFunc apply
Definition: pshints.h:664
TT_VertHeader_::number_Of_VMetrics
FT_UShort number_Of_VMetrics
Definition: tttables.h:325
FT_OUTLINE_HIGH_PRECISION
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:482
count
GLint GLsizei count
Definition: gl2ext.h:1011
face
GLenum face
Definition: gl2ext.h:1490
FT_Vector_::y
FT_Pos y
Definition: ftimage.h:78
TT_FaceRec_::vertical_info
FT_Bool vertical_info
Definition: tttypes.h:1276
CFF_FontRec_::top_font
CFF_SubFontRec top_font
Definition: cfftypes.h:254
TT_SBit_MetricsRec_::vertBearingY
FT_Char vertBearingY
Definition: tttypes.h:445
check_points
static FT_Error check_points(CFF_Builder *builder, FT_Int count)
Definition: cffgload.c:465
CFF_MAX_OPERANDS
#define CFF_MAX_OPERANDS
Definition: cffgload.h:31
limit
GLint limit
Definition: glew.h:11829
FT_Slot_InternalRec_::loader
FT_GlyphLoader loader
Definition: ftobjs.h:380
CFF_Builder_::memory
FT_Memory memory
Definition: cffgload.h:83
FT_Vector_
Definition: ftimage.h:75
TT_FaceRec_::vertical
TT_VertHeader vertical
Definition: tttypes.h:1277
TT_SBit_MetricsRec_::width
FT_Byte width
Definition: tttypes.h:438
CFF_CharsetRec_::cids
FT_UShort * cids
Definition: cfftypes.h:97
FT_Incremental_MetricsRec_::bearing_x
FT_Long bearing_x
Definition: ftincrem.h:117
vec
FT_Vector * vec
Definition: ftbbox.c:579
FT_Incremental_MetricsRec_::advance
FT_Long advance
Definition: ftincrem.h:119
FT_GlyphSlotRec_::subglyphs
FT_SubGlyph subglyphs
Definition: freetype.h:1627
FT_Slot_InternalRec_::glyph_hints
void * glyph_hints
Definition: ftobjs.h:385
top
GLfloat GLfloat GLfloat top
Definition: glew.h:13816
CFF_Decoder_::width_only
FT_Bool width_only
Definition: cffgload.h:139
CFF_COUNT_CLEAR_STACK
#define CFF_COUNT_CLEAR_STACK
Definition: cffgload.c:127
FALSE
#define FALSE
Definition: ftobjs.h:57
FT_BBox_::xMax
FT_Pos xMax
Definition: ftimage.h:119
cff_slot_load
cff_slot_load(CFF_GlyphSlot glyph, CFF_Size size, FT_UInt glyph_index, FT_Int32 load_flags)
Definition: cffgload.c:2580
CFF_Builder_::path_begun
FT_Bool path_begun
Definition: cffgload.h:97
FT_Outline_::n_points
short n_points
Definition: ftimage.h:386
CFF_Builder_::hints_globals
void * hints_globals
Definition: cffgload.h:104
T2_Hints_FuncsRec_::open
T2_Hints_OpenFunc open
Definition: pshints.h:659
CFF_Builder_::glyph
CFF_GlyphSlot glyph
Definition: cffgload.h:85
FT_Short
signed short FT_Short
Definition: fttypes.h:194
cff_get_glyph_data
static FT_Error cff_get_glyph_data(TT_Face face, FT_UInt glyph_index, FT_Byte **pointer, FT_ULong *length)
Definition: cffgload.c:640
FT_Matrix_::xx
FT_Fixed xx
Definition: fttypes.h:383
FT_BOOL
#define FT_BOOL(x)
Definition: fttypes.h:581
CFF_Builder_::pos_x
FT_Pos pos_x
Definition: cffgload.h:90
cff_free_glyph_data
static void cff_free_glyph_data(TT_Face face, FT_Byte **pointer, FT_ULong length)
Definition: cffgload.c:676
TT_FaceRec_::root
FT_FaceRec root
Definition: tttypes.h:1260
TT_FaceRec_::horizontal
TT_HoriHeader horizontal
Definition: tttypes.h:1269
y
EGLSurface EGLint EGLint y
Definition: eglext.h:293
cff_builder_done
static void cff_builder_done(CFF_Builder *builder)
Definition: cffgload.c:307
FT_MulFix
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:435
FT_Generic_::data
void * data
Definition: fttypes.h:457
cff_builder_add_point1
static FT_Error cff_builder_add_point1(CFF_Builder *builder, FT_Pos x, FT_Pos y)
Definition: cffgload.c:499
FT_TRACE3
#define FT_TRACE3(varformat)
Definition: ftdebug.h:160
TT_FaceRec_::extra
FT_Generic extra
Definition: tttypes.h:1382
TT_SBit_MetricsRec_
Definition: tttypes.h:435
CFF_Decoder_Zone_
Definition: cffgload.h:111
FT_Matrix_::yx
FT_Fixed yx
Definition: fttypes.h:384
FT_Vector_Transform
FT_Vector_Transform(FT_Vector *vec, const FT_Matrix *matrix)
Definition: ftoutln.c:672
FT_Fixed
signed long FT_Fixed
Definition: fttypes.h:284
FT_Glyph_Metrics
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
FT_GlyphSlotRec_::format
FT_Glyph_Format format
Definition: freetype.h:1618
T2_Hints_Funcs
struct T2_Hints_FuncsRec_ * T2_Hints_Funcs
Definition: pshints.h:404
CFF_Decoder_::seac
FT_Bool seac
Definition: cffgload.h:157
cff_compute_bias
static FT_Int cff_compute_bias(FT_Int in_charstring_type, FT_UInt num_subrs)
Definition: cffgload.c:335
cff_builder_add_point
static void cff_builder_add_point(CFF_Builder *builder, FT_Pos x, FT_Pos y, FT_Byte flag)
Definition: cffgload.c:474
CFF_Decoder_Zone_::cursor
FT_Byte * cursor
Definition: cffgload.h:115
TT_OS2_::sTypoAscender
FT_Short sTypoAscender
Definition: tttables.h:381
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:227
FT_GlyphSlot
struct FT_GlyphSlotRec_ * FT_GlyphSlot
Definition: freetype.h:450
CFF_FontRecDictRec_::units_per_em
FT_ULong units_per_em
Definition: cfftypes.h:121
CFF_FontRecDictRec_::font_matrix
FT_Matrix font_matrix
Definition: cfftypes.h:119
FT_GlyphLoader_Rewind
FT_GlyphLoader_Rewind(FT_GlyphLoader loader)
Definition: ftgloadr.c:87
FT_Data_
Definition: fttypes.h:402
cff_lookup_glyph_by_stdcharcode
static FT_Int cff_lookup_glyph_by_stdcharcode(CFF_Font cff, FT_Int charcode)
Definition: cffgload.c:611
FT_GlyphSlotRec_::internal
FT_Slot_Internal internal
Definition: freetype.h:1637
CFF_SubFontRec_
Definition: cfftypes.h:205
FT_Incremental_MetricsRec_::advance_v
FT_Long advance_v
Definition: ftincrem.h:120
cff_charset_cid_to_gindex
cff_charset_cid_to_gindex(CFF_Charset charset, FT_UInt cid)
Definition: cffload.c:816
FT_Slot_InternalRec_
Definition: ftobjs.h:378
CFF_Builder_::face
TT_Face face
Definition: cffgload.h:84
FT_Outline_Translate
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:510
FT_GlyphLoader_Prepare
FT_GlyphLoader_Prepare(FT_GlyphLoader loader)
Definition: ftgloadr.c:307
FT_CURVE_TAG_ON
#define FT_CURVE_TAG_ON
Definition: ftimage.h:516
CFF_FontRec_::charstrings_index
CFF_IndexRec charstrings_index
Definition: cfftypes.h:239
FT_Matrix_::yy
FT_Fixed yy
Definition: fttypes.h:384
i
int i
Definition: pngrutil.c:1377
CFF_Builder_::advance
FT_Vector advance
Definition: cffgload.h:94
CFF_FontRec_::num_glyphs
FT_UInt num_glyphs
Definition: cfftypes.h:224
FT_LOAD_NO_BITMAP
#define FT_LOAD_NO_BITMAP
Definition: freetype.h:2515
CFF_CharsetRec_::sids
FT_UShort * sids
Definition: cfftypes.h:96
FT_UShort
unsigned short FT_UShort
Definition: fttypes.h:205
FT_GLYPHLOADER_CHECK_POINTS
#define FT_GLYPHLOADER_CHECK_POINTS(_loader, _points, _contours)
Definition: ftgloadr.h:134
FT_StreamRec_
Definition: ftsystem.h:321
FT_BBox_::yMin
FT_Pos yMin
Definition: ftimage.h:118
CFF_Operator
enum CFF_Operator_ CFF_Operator
FT_FaceRec_::stream
FT_Stream stream
Definition: freetype.h:957
FT_BBox_
Definition: ftimage.h:116
TT_FaceRec_
Definition: tttypes.h:1258
CFF_Builder_::load_points
FT_Bool load_points
Definition: cffgload.h:98
CFF_COUNT_EXACT
#define CFF_COUNT_EXACT
Definition: cffgload.c:126
FT_UNUSED
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
TRUE
#define TRUE
Definition: ftobjs.h:53
T2_Hints_FuncsRec_::close
T2_Hints_CloseFunc close
Definition: pshints.h:660
FT_Outline_::points
FT_Vector * points
Definition: ftimage.h:388
SFNT_Interface_
Definition: sfnt.h:649
CFF_FontRecDictRec_::cid_registry
FT_UInt cid_registry
Definition: cfftypes.h:135
CFF_FontRec_::charset
CFF_CharsetRec charset
Definition: cfftypes.h:237
FT_GLYPH_FORMAT_OUTLINE
FT_Module_Constructor FT_GLYPH_FORMAT_OUTLINE
Definition: ftrend1.c:283
CFF_Builder_::pos_y
FT_Pos pos_y
Definition: cffgload.h:91
TT_SBit_MetricsRec_::vertAdvance
FT_Byte vertAdvance
Definition: tttypes.h:446
cff_index_forget_element
cff_index_forget_element(CFF_Index idx, FT_Byte **pbytes)
Definition: cffload.c:567
FT_FaceRec_::memory
FT_Memory memory
Definition: freetype.h:956
T2_Hints_FuncsRec_::hintmask
T2_Hints_MaskFunc hintmask
Definition: pshints.h:662
CFF_SizeRec_
Definition: cffobjs.h:55
TT_VertHeader_::long_metrics
void * long_metrics
Definition: tttables.h:331
FT_Incremental_MetricsRec_
Definition: ftincrem.h:115
CFF_Builder_::hints_funcs
void * hints_funcs
Definition: cffgload.h:103
FT_OUTLINE_REVERSE_FILL
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:477
CFF_Index
FT_BEGIN_HEADER struct CFF_IndexRec_ * CFF_Index
FT_LOAD_TARGET_MODE
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:2617
size
GLsizei size
Definition: gl2ext.h:1467