source: trunk/poppler/freetype2/src/cff/cffgload.c @ 182

Last change on this file since 182 was 182, checked in by Eugene Romanenko, 15 years ago

freetype update to version 2.3.0

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