source: trunk/poppler/freetype-2.1.10/src/psaux/t1decode.c @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 16 years ago

First import

File size: 35.0 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  t1decode.c                                                             */
4/*                                                                         */
5/*    PostScript Type 1 decoding routines (body).                          */
6/*                                                                         */
7/*  Copyright 2000-2001, 2002, 2003, 2004, 2005 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_POSTSCRIPT_HINTS_H
22#include FT_OUTLINE_H
23
24#include "t1decode.h"
25#include "psobjs.h"
26
27#include "psauxerr.h"
28
29
30  /*************************************************************************/
31  /*                                                                       */
32  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
33  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
34  /* messages during execution.                                            */
35  /*                                                                       */
36#undef  FT_COMPONENT
37#define FT_COMPONENT  trace_t1decode
38
39
40  typedef enum  T1_Operator_
41  {
42    op_none = 0,
43    op_endchar,
44    op_hsbw,
45    op_seac,
46    op_sbw,
47    op_closepath,
48    op_hlineto,
49    op_hmoveto,
50    op_hvcurveto,
51    op_rlineto,
52    op_rmoveto,
53    op_rrcurveto,
54    op_vhcurveto,
55    op_vlineto,
56    op_vmoveto,
57    op_dotsection,
58    op_hstem,
59    op_hstem3,
60    op_vstem,
61    op_vstem3,
62    op_div,
63    op_callothersubr,
64    op_callsubr,
65    op_pop,
66    op_return,
67    op_setcurrentpoint,
68
69    op_max    /* never remove this one */
70
71  } T1_Operator;
72
73
74  static
75  const FT_Int  t1_args_count[op_max] =
76  {
77    0, /* none */
78    0, /* endchar */
79    2, /* hsbw */
80    5, /* seac */
81    4, /* sbw */
82    0, /* closepath */
83    1, /* hlineto */
84    1, /* hmoveto */
85    4, /* hvcurveto */
86    2, /* rlineto */
87    2, /* rmoveto */
88    6, /* rrcurveto */
89    4, /* vhcurveto */
90    1, /* vlineto */
91    1, /* vmoveto */
92    0, /* dotsection */
93    2, /* hstem */
94    6, /* hstem3 */
95    2, /* vstem */
96    6, /* vstem3 */
97    2, /* div */
98   -1, /* callothersubr */
99    1, /* callsubr */
100    0, /* pop */
101    0, /* return */
102    2  /* setcurrentpoint */
103  };
104
105
106  /*************************************************************************/
107  /*                                                                       */
108  /* <Function>                                                            */
109  /*    t1_lookup_glyph_by_stdcharcode                                     */
110  /*                                                                       */
111  /* <Description>                                                         */
112  /*    Looks up a given glyph by its StandardEncoding charcode.  Used to  */
113  /*    implement the SEAC Type 1 operator.                                */
114  /*                                                                       */
115  /* <Input>                                                               */
116  /*    face     :: The current face object.                               */
117  /*                                                                       */
118  /*    charcode :: The character code to look for.                        */
119  /*                                                                       */
120  /* <Return>                                                              */
121  /*    A glyph index in the font face.  Returns -1 if the corresponding   */
122  /*    glyph wasn't found.                                                */
123  /*                                                                       */
124  static FT_Int
125  t1_lookup_glyph_by_stdcharcode( T1_Decoder  decoder,
126                                  FT_Int      charcode )
127  {
128    FT_UInt             n;
129    const FT_String*    glyph_name;
130    FT_Service_PsCMaps  psnames = decoder->psnames;
131
132
133    /* check range of standard char code */
134    if ( charcode < 0 || charcode > 255 )
135      return -1;
136
137    glyph_name = psnames->adobe_std_strings(
138                   psnames->adobe_std_encoding[charcode]);
139
140    for ( n = 0; n < decoder->num_glyphs; n++ )
141    {
142      FT_String*  name = (FT_String*)decoder->glyph_names[n];
143
144
145      if ( name && name[0] == glyph_name[0]  &&
146           ft_strcmp( name, glyph_name ) == 0 )
147        return n;
148    }
149
150    return -1;
151  }
152
153
154  /*************************************************************************/
155  /*                                                                       */
156  /* <Function>                                                            */
157  /*    t1operator_seac                                                    */
158  /*                                                                       */
159  /* <Description>                                                         */
160  /*    Implements the `seac' Type 1 operator for a Type 1 decoder.        */
161  /*                                                                       */
162  /* <Input>                                                               */
163  /*    decoder :: The current CID decoder.                                */
164  /*                                                                       */
165  /*    asb     :: The accent's side bearing.                              */
166  /*                                                                       */
167  /*    adx     :: The horizontal offset of the accent.                    */
168  /*                                                                       */
169  /*    ady     :: The vertical offset of the accent.                      */
170  /*                                                                       */
171  /*    bchar   :: The base character's StandardEncoding charcode.         */
172  /*                                                                       */
173  /*    achar   :: The accent character's StandardEncoding charcode.       */
174  /*                                                                       */
175  /* <Return>                                                              */
176  /*    FreeType error code.  0 means success.                             */
177  /*                                                                       */
178  static FT_Error
179  t1operator_seac( T1_Decoder  decoder,
180                   FT_Pos      asb,
181                   FT_Pos      adx,
182                   FT_Pos      ady,
183                   FT_Int      bchar,
184                   FT_Int      achar )
185  {
186    FT_Error     error;
187    FT_Int       bchar_index, achar_index;
188#if 0
189    FT_Int       n_base_points;
190    FT_Outline*  base = decoder->builder.base;
191#endif
192    FT_Vector    left_bearing, advance;
193
194
195    /* seac weirdness */
196    adx += decoder->builder.left_bearing.x;
197
198    /* `glyph_names' is set to 0 for CID fonts which do not */
199    /* include an encoding.  How can we deal with these?    */
200    if ( decoder->glyph_names == 0 )
201    {
202      FT_ERROR(( "t1operator_seac:" ));
203      FT_ERROR(( " glyph names table not available in this font!\n" ));
204      return PSaux_Err_Syntax_Error;
205    }
206
207    bchar_index = t1_lookup_glyph_by_stdcharcode( decoder, bchar );
208    achar_index = t1_lookup_glyph_by_stdcharcode( decoder, achar );
209
210    if ( bchar_index < 0 || achar_index < 0 )
211    {
212      FT_ERROR(( "t1operator_seac:" ));
213      FT_ERROR(( " invalid seac character code arguments\n" ));
214      return PSaux_Err_Syntax_Error;
215    }
216
217    /* if we are trying to load a composite glyph, do not load the */
218    /* accent character and return the array of subglyphs.         */
219    if ( decoder->builder.no_recurse )
220    {
221      FT_GlyphSlot    glyph  = (FT_GlyphSlot)decoder->builder.glyph;
222      FT_GlyphLoader  loader = glyph->internal->loader;
223      FT_SubGlyph     subg;
224
225
226      /* reallocate subglyph array if necessary */
227      error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
228      if ( error )
229        goto Exit;
230
231      subg = loader->current.subglyphs;
232
233      /* subglyph 0 = base character */
234      subg->index = bchar_index;
235      subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
236                    FT_SUBGLYPH_FLAG_USE_MY_METRICS;
237      subg->arg1  = 0;
238      subg->arg2  = 0;
239      subg++;
240
241      /* subglyph 1 = accent character */
242      subg->index = achar_index;
243      subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
244      subg->arg1  = (FT_Int)( adx - asb );
245      subg->arg2  = (FT_Int)ady;
246
247      /* set up remaining glyph fields */
248      glyph->num_subglyphs = 2;
249      glyph->subglyphs     = loader->base.subglyphs;
250      glyph->format        = FT_GLYPH_FORMAT_COMPOSITE;
251
252      loader->current.num_subglyphs = 2;
253      goto Exit;
254    }
255
256    /* First load `bchar' in builder */
257    /* now load the unscaled outline */
258
259    FT_GlyphLoader_Prepare( decoder->builder.loader );  /* prepare loader */
260
261    error = t1_decoder_parse_glyph( decoder, bchar_index );
262    if ( error )
263      goto Exit;
264
265    /* save the left bearing and width of the base character */
266    /* as they will be erased by the next load.              */
267
268    left_bearing = decoder->builder.left_bearing;
269    advance      = decoder->builder.advance;
270
271    decoder->builder.left_bearing.x = 0;
272    decoder->builder.left_bearing.y = 0;
273
274    decoder->builder.pos_x = adx - asb;
275    decoder->builder.pos_y = ady;
276
277    /* Now load `achar' on top of */
278    /* the base outline           */
279    error = t1_decoder_parse_glyph( decoder, achar_index );
280    if ( error )
281      goto Exit;
282
283    /* restore the left side bearing and   */
284    /* advance width of the base character */
285
286    decoder->builder.left_bearing = left_bearing;
287    decoder->builder.advance      = advance;
288
289    decoder->builder.pos_x = 0;
290    decoder->builder.pos_y = 0;
291
292  Exit:
293    return error;
294  }
295
296
297  /*************************************************************************/
298  /*                                                                       */
299  /* <Function>                                                            */
300  /*    t1_decoder_parse_charstrings                                       */
301  /*                                                                       */
302  /* <Description>                                                         */
303  /*    Parses a given Type 1 charstrings program.                         */
304  /*                                                                       */
305  /* <Input>                                                               */
306  /*    decoder         :: The current Type 1 decoder.                     */
307  /*                                                                       */
308  /*    charstring_base :: The base address of the charstring stream.      */
309  /*                                                                       */
310  /*    charstring_len  :: The length in bytes of the charstring stream.   */
311  /*                                                                       */
312  /* <Return>                                                              */
313  /*    FreeType error code.  0 means success.                             */
314  /*                                                                       */
315  FT_LOCAL_DEF( FT_Error )
316  t1_decoder_parse_charstrings( T1_Decoder  decoder,
317                                FT_Byte*    charstring_base,
318                                FT_UInt     charstring_len )
319  {
320    FT_Error         error;
321    T1_Decoder_Zone  zone;
322    FT_Byte*         ip;
323    FT_Byte*         limit;
324    T1_Builder       builder = &decoder->builder;
325    FT_Pos           x, y, orig_x, orig_y;
326
327    T1_Hints_Funcs   hinter;
328
329
330    /* we don't want to touch the source code -- use macro trick */
331#define start_point    t1_builder_start_point
332#define check_points   t1_builder_check_points
333#define add_point      t1_builder_add_point
334#define add_point1     t1_builder_add_point1
335#define add_contour    t1_builder_add_contour
336#define close_contour  t1_builder_close_contour
337
338    /* First of all, initialize the decoder */
339    decoder->top  = decoder->stack;
340    decoder->zone = decoder->zones;
341    zone          = decoder->zones;
342
343    builder->parse_state = T1_Parse_Start;
344
345    hinter = (T1_Hints_Funcs)builder->hints_funcs;
346
347    zone->base           = charstring_base;
348    limit = zone->limit  = charstring_base + charstring_len;
349    ip    = zone->cursor = zone->base;
350
351    error = PSaux_Err_Ok;
352
353    x = orig_x = builder->pos_x;
354    y = orig_y = builder->pos_y;
355
356    /* begin hints recording session, if any */
357    if ( hinter )
358      hinter->open( hinter->hints );
359
360    /* now, execute loop */
361    while ( ip < limit )
362    {
363      FT_Long*     top   = decoder->top;
364      T1_Operator  op    = op_none;
365      FT_Long      value = 0;
366
367
368      /*********************************************************************/
369      /*                                                                   */
370      /* Decode operator or operand                                        */
371      /*                                                                   */
372      /*                                                                   */
373
374      /* first of all, decompress operator or value */
375      switch ( *ip++ )
376      {
377      case 1:
378        op = op_hstem;
379        break;
380
381      case 3:
382        op = op_vstem;
383        break;
384      case 4:
385        op = op_vmoveto;
386        break;
387      case 5:
388        op = op_rlineto;
389        break;
390      case 6:
391        op = op_hlineto;
392        break;
393      case 7:
394        op = op_vlineto;
395        break;
396      case 8:
397        op = op_rrcurveto;
398        break;
399      case 9:
400        op = op_closepath;
401        break;
402      case 10:
403        op = op_callsubr;
404        break;
405      case 11:
406        op = op_return;
407        break;
408
409      case 13:
410        op = op_hsbw;
411        break;
412      case 14:
413        op = op_endchar;
414        break;
415
416      case 15:          /* undocumented, obsolete operator */
417        op = op_none;
418        break;
419
420      case 21:
421        op = op_rmoveto;
422        break;
423      case 22:
424        op = op_hmoveto;
425        break;
426
427      case 30:
428        op = op_vhcurveto;
429        break;
430      case 31:
431        op = op_hvcurveto;
432        break;
433
434      case 12:
435        if ( ip > limit )
436        {
437          FT_ERROR(( "t1_decoder_parse_charstrings: "
438                     "invalid escape (12+EOF)\n" ));
439          goto Syntax_Error;
440        }
441
442        switch ( *ip++ )
443        {
444        case 0:
445          op = op_dotsection;
446          break;
447        case 1:
448          op = op_vstem3;
449          break;
450        case 2:
451          op = op_hstem3;
452          break;
453        case 6:
454          op = op_seac;
455          break;
456        case 7:
457          op = op_sbw;
458          break;
459        case 12:
460          op = op_div;
461          break;
462        case 16:
463          op = op_callothersubr;
464          break;
465        case 17:
466          op = op_pop;
467          break;
468        case 33:
469          op = op_setcurrentpoint;
470          break;
471
472        default:
473          FT_ERROR(( "t1_decoder_parse_charstrings: "
474                     "invalid escape (12+%d)\n",
475                     ip[-1] ));
476          goto Syntax_Error;
477        }
478        break;
479
480      case 255:    /* four bytes integer */
481        if ( ip + 4 > limit )
482        {
483          FT_ERROR(( "t1_decoder_parse_charstrings: "
484                     "unexpected EOF in integer\n" ));
485          goto Syntax_Error;
486        }
487
488        value = (FT_Int32)( ((FT_Long)ip[0] << 24) |
489                            ((FT_Long)ip[1] << 16) |
490                            ((FT_Long)ip[2] << 8 ) |
491                                      ip[3] );
492        ip += 4;
493        break;
494
495      default:
496        if ( ip[-1] >= 32 )
497        {
498          if ( ip[-1] < 247 )
499            value = (FT_Long)ip[-1] - 139;
500          else
501          {
502            if ( ++ip > limit )
503            {
504              FT_ERROR(( "t1_decoder_parse_charstrings: " ));
505              FT_ERROR(( "unexpected EOF in integer\n" ));
506              goto Syntax_Error;
507            }
508
509            if ( ip[-2] < 251 )
510              value =  ( ( (FT_Long)ip[-2] - 247 ) << 8 ) + ip[-1] + 108;
511            else
512              value = -( ( ( (FT_Long)ip[-2] - 251 ) << 8 ) + ip[-1] + 108 );
513          }
514        }
515        else
516        {
517          FT_ERROR(( "t1_decoder_parse_charstrings: "
518                     "invalid byte (%d)\n", ip[-1] ));
519          goto Syntax_Error;
520        }
521      }
522
523      /*********************************************************************/
524      /*                                                                   */
525      /*  Push value on stack, or process operator                         */
526      /*                                                                   */
527      /*                                                                   */
528      if ( op == op_none )
529      {
530        if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS )
531        {
532          FT_ERROR(( "t1_decoder_parse_charstrings: stack overflow!\n" ));
533          goto Syntax_Error;
534        }
535
536        FT_TRACE4(( " %ld", value ));
537
538        *top++       = value;
539        decoder->top = top;
540      }
541      else if ( op == op_callothersubr )  /* callothersubr */
542      {
543        FT_TRACE4(( " callothersubr" ));
544
545        if ( top - decoder->stack < 2 )
546          goto Stack_Underflow;
547
548        top -= 2;
549        switch ( (FT_Int)top[1] )
550        {
551        case 1:                     /* start flex feature */
552          if ( top[0] != 0 )
553            goto Unexpected_OtherSubr;
554
555          decoder->flex_state        = 1;
556          decoder->num_flex_vectors  = 0;
557          if ( start_point( builder, x, y ) ||
558               check_points( builder, 6 )   )
559            goto Fail;
560          break;
561
562        case 2:                     /* add flex vectors */
563          {
564            FT_Int  idx;
565
566
567            if ( top[0] != 0 )
568              goto Unexpected_OtherSubr;
569
570            /* note that we should not add a point for index 0; */
571            /* this will move our current position to the flex  */
572            /* point without adding any point to the outline    */
573            idx = decoder->num_flex_vectors++;
574            if ( idx > 0 && idx < 7 )
575              add_point( builder,
576                         x,
577                         y,
578                         (FT_Byte)( idx == 3 || idx == 6 ) );
579          }
580          break;
581
582        case 0:                     /* end flex feature */
583          if ( top[0] != 3 )
584            goto Unexpected_OtherSubr;
585
586          if ( decoder->flex_state       == 0 ||
587               decoder->num_flex_vectors != 7 )
588          {
589            FT_ERROR(( "t1_decoder_parse_charstrings: "
590                       "unexpected flex end\n" ));
591            goto Syntax_Error;
592          }
593
594          /* now consume the remaining `pop pop setcurpoint' */
595          if ( ip + 6 > limit ||
596               ip[0] != 12 || ip[1] != 17 || /* pop */
597               ip[2] != 12 || ip[3] != 17 || /* pop */
598               ip[4] != 12 || ip[5] != 33 )  /* setcurpoint */
599          {
600            FT_ERROR(( "t1_decoder_parse_charstrings: "
601                       "invalid flex charstring\n" ));
602            goto Syntax_Error;
603          }
604
605          ip += 6;
606          decoder->flex_state = 0;
607          break;
608
609        case 3:                     /* change hints */
610          if ( top[0] != 1 )
611            goto Unexpected_OtherSubr;
612
613          /* eat the following `pop' */
614          if ( ip + 2 > limit )
615          {
616            FT_ERROR(( "t1_decoder_parse_charstrings: "
617                       "invalid escape (12+%d)\n", ip[-1] ));
618            goto Syntax_Error;
619          }
620
621          if ( ip[0] != 12 || ip[1] != 17 )
622          {
623            FT_ERROR(( "t1_decoder_parse_charstrings: " ));
624            FT_ERROR(( "`pop' expected, found (%d %d)\n", ip[0], ip[1] ));
625            goto Syntax_Error;
626          }
627          ip += 2;
628
629          if ( hinter )
630            hinter->reset( hinter->hints, builder->current->n_points );
631
632          break;
633
634        case 12:
635        case 13:
636          /* counter control hints, clear stack */
637          top = decoder->stack;
638          break;
639
640        case 14:
641        case 15:
642        case 16:
643        case 17:
644        case 18:                    /* multiple masters */
645          {
646            PS_Blend  blend = decoder->blend;
647            FT_UInt   num_points, nn, mm;
648            FT_Long*  delta;
649            FT_Long*  values;
650
651
652            if ( !blend )
653            {
654              FT_ERROR(( "t1_decoder_parse_charstrings: " ));
655              FT_ERROR(( "unexpected multiple masters operator!\n" ));
656              goto Syntax_Error;
657            }
658
659            num_points = (FT_UInt)top[1] - 13 + ( top[1] == 18 );
660            if ( top[0] != (FT_Int)( num_points * blend->num_designs ) )
661            {
662              FT_ERROR(( "t1_decoder_parse_charstrings: " ));
663              FT_ERROR(( "incorrect number of mm arguments\n" ));
664              goto Syntax_Error;
665            }
666
667            top -= blend->num_designs * num_points;
668            if ( top < decoder->stack )
669              goto Stack_Underflow;
670
671            /* we want to compute:                                   */
672            /*                                                       */
673            /*  a0*w0 + a1*w1 + ... + ak*wk                          */
674            /*                                                       */
675            /* but we only have the a0, a1-a0, a2-a0, .. ak-a0       */
676            /* however, given that w0 + w1 + ... + wk == 1, we can   */
677            /* rewrite it easily as:                                 */
678            /*                                                       */
679            /*  a0 + (a1-a0)*w1 + (a2-a0)*w2 + .. + (ak-a0)*wk       */
680            /*                                                       */
681            /* where k == num_designs-1                              */
682            /*                                                       */
683            /* I guess that's why it's written in this `compact'     */
684            /* form.                                                 */
685            /*                                                       */
686            delta  = top + num_points;
687            values = top;
688            for ( nn = 0; nn < num_points; nn++ )
689            {
690              FT_Long  tmp = values[0];
691
692
693              for ( mm = 1; mm < blend->num_designs; mm++ )
694                tmp += FT_MulFix( *delta++, blend->weight_vector[mm] );
695
696              *values++ = tmp;
697            }
698            /* note that `top' will be incremented later by calls to `pop' */
699            break;
700          }
701
702        default:
703        Unexpected_OtherSubr:
704          FT_ERROR(( "t1_decoder_parse_charstrings: "
705                     "invalid othersubr [%d %d]!\n", top[0], top[1] ));
706          goto Syntax_Error;
707        }
708        decoder->top = top;
709      }
710      else  /* general operator */
711      {
712        FT_Int  num_args = t1_args_count[op];
713
714
715        if ( top - decoder->stack < num_args )
716          goto Stack_Underflow;
717
718        top -= num_args;
719
720        switch ( op )
721        {
722        case op_endchar:
723          FT_TRACE4(( " endchar" ));
724
725          close_contour( builder );
726
727          /* close hints recording session */
728          if ( hinter )
729          {
730            if (hinter->close( hinter->hints, builder->current->n_points ))
731              goto Syntax_Error;
732
733            /* apply hints to the loaded glyph outline now */
734            hinter->apply( hinter->hints,
735                           builder->current,
736                           (PSH_Globals) builder->hints_globals,
737                           decoder->hint_mode );
738          }
739
740          /* add current outline to the glyph slot */
741          FT_GlyphLoader_Add( builder->loader );
742
743          /* return now! */
744          FT_TRACE4(( "\n\n" ));
745          return PSaux_Err_Ok;
746
747        case op_hsbw:
748          FT_TRACE4(( " hsbw" ));
749
750          builder->parse_state = T1_Parse_Have_Width;
751
752          builder->left_bearing.x += top[0];
753          builder->advance.x       = top[1];
754          builder->advance.y       = 0;
755
756          orig_x = builder->last.x = x = builder->pos_x + top[0];
757          orig_y = builder->last.y = y = builder->pos_y;
758
759          FT_UNUSED( orig_y );
760
761          /* the `metrics_only' indicates that we only want to compute */
762          /* the glyph's metrics (lsb + advance width), not load the   */
763          /* rest of it; so exit immediately                           */
764          if ( builder->metrics_only )
765            return PSaux_Err_Ok;
766
767          break;
768
769        case op_seac:
770          /* return immediately after the processing */
771          return t1operator_seac( decoder, top[0], top[1], top[2],
772                                           (FT_Int)top[3], (FT_Int)top[4] );
773
774        case op_sbw:
775          FT_TRACE4(( " sbw" ));
776
777          builder->parse_state = T1_Parse_Have_Width;
778
779          builder->left_bearing.x += top[0];
780          builder->left_bearing.y += top[1];
781          builder->advance.x       = top[2];
782          builder->advance.y       = top[3];
783
784          builder->last.x = x = builder->pos_x + top[0];
785          builder->last.y = y = builder->pos_y + top[1];
786
787          /* the `metrics_only' indicates that we only want to compute */
788          /* the glyph's metrics (lsb + advance width), not load the   */
789          /* rest of it; so exit immediately                           */
790          if ( builder->metrics_only )
791            return PSaux_Err_Ok;
792
793          break;
794
795        case op_closepath:
796          FT_TRACE4(( " closepath" ));
797
798          close_contour( builder );
799          if ( !( builder->parse_state == T1_Parse_Have_Path   ||
800                  builder->parse_state == T1_Parse_Have_Moveto ) )
801            goto Syntax_Error;
802          builder->parse_state = T1_Parse_Have_Width;
803          break;
804
805        case op_hlineto:
806          FT_TRACE4(( " hlineto" ));
807
808          if ( start_point( builder, x, y ) )
809            goto Fail;
810
811          x += top[0];
812          goto Add_Line;
813
814        case op_hmoveto:
815          FT_TRACE4(( " hmoveto" ));
816
817          x += top[0];
818          if ( !decoder->flex_state )
819          {
820            if ( builder->parse_state == T1_Parse_Start )
821              goto Syntax_Error;
822            builder->parse_state = T1_Parse_Have_Moveto;
823          }
824          break;
825
826        case op_hvcurveto:
827          FT_TRACE4(( " hvcurveto" ));
828
829          if ( start_point( builder, x, y ) ||
830               check_points( builder, 3 )   )
831            goto Fail;
832
833          x += top[0];
834          add_point( builder, x, y, 0 );
835          x += top[1];
836          y += top[2];
837          add_point( builder, x, y, 0 );
838          y += top[3];
839          add_point( builder, x, y, 1 );
840          break;
841
842        case op_rlineto:
843          FT_TRACE4(( " rlineto" ));
844
845          if ( start_point( builder, x, y ) )
846            goto Fail;
847
848          x += top[0];
849          y += top[1];
850
851        Add_Line:
852          if ( add_point1( builder, x, y ) )
853            goto Fail;
854          break;
855
856        case op_rmoveto:
857          FT_TRACE4(( " rmoveto" ));
858
859          x += top[0];
860          y += top[1];
861          if ( !decoder->flex_state )
862          {
863            if ( builder->parse_state == T1_Parse_Start )
864              goto Syntax_Error;
865            builder->parse_state = T1_Parse_Have_Moveto;
866          }
867          break;
868
869        case op_rrcurveto:
870          FT_TRACE4(( " rcurveto" ));
871
872          if ( start_point( builder, x, y ) ||
873               check_points( builder, 3 )   )
874            goto Fail;
875
876          x += top[0];
877          y += top[1];
878          add_point( builder, x, y, 0 );
879
880          x += top[2];
881          y += top[3];
882          add_point( builder, x, y, 0 );
883
884          x += top[4];
885          y += top[5];
886          add_point( builder, x, y, 1 );
887          break;
888
889        case op_vhcurveto:
890          FT_TRACE4(( " vhcurveto" ));
891
892          if ( start_point( builder, x, y ) ||
893               check_points( builder, 3 )   )
894            goto Fail;
895
896          y += top[0];
897          add_point( builder, x, y, 0 );
898          x += top[1];
899          y += top[2];
900          add_point( builder, x, y, 0 );
901          x += top[3];
902          add_point( builder, x, y, 1 );
903          break;
904
905        case op_vlineto:
906          FT_TRACE4(( " vlineto" ));
907
908          if ( start_point( builder, x, y ) )
909            goto Fail;
910
911          y += top[0];
912          goto Add_Line;
913
914        case op_vmoveto:
915          FT_TRACE4(( " vmoveto" ));
916
917          y += top[0];
918          if ( !decoder->flex_state )
919          {
920            if ( builder->parse_state == T1_Parse_Start )
921              goto Syntax_Error;
922            builder->parse_state = T1_Parse_Have_Moveto;
923          }
924          break;
925
926        case op_div:
927          FT_TRACE4(( " div" ));
928
929          if ( top[1] )
930          {
931            *top = top[0] / top[1];
932            ++top;
933          }
934          else
935          {
936            FT_ERROR(( "t1_decoder_parse_charstrings: division by 0\n" ));
937            goto Syntax_Error;
938          }
939          break;
940
941        case op_callsubr:
942          {
943            FT_Int  idx;
944
945
946            FT_TRACE4(( " callsubr" ));
947
948            idx = (FT_Int)top[0];
949            if ( idx < 0 || idx >= (FT_Int)decoder->num_subrs )
950            {
951              FT_ERROR(( "t1_decoder_parse_charstrings: "
952                         "invalid subrs index\n" ));
953              goto Syntax_Error;
954            }
955
956            if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS )
957            {
958              FT_ERROR(( "t1_decoder_parse_charstrings: "
959                         "too many nested subrs\n" ));
960              goto Syntax_Error;
961            }
962
963            zone->cursor = ip;  /* save current instruction pointer */
964
965            zone++;
966
967            /* The Type 1 driver stores subroutines without the seed bytes. */
968            /* The CID driver stores subroutines with seed bytes.  This     */
969            /* case is taken care of when decoder->subrs_len == 0.          */
970            zone->base = decoder->subrs[idx];
971
972            if ( decoder->subrs_len )
973              zone->limit = zone->base + decoder->subrs_len[idx];
974            else
975            {
976              /* We are using subroutines from a CID font.  We must adjust */
977              /* for the seed bytes.                                       */
978              zone->base  += ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
979              zone->limit  = decoder->subrs[idx + 1];
980            }
981
982            zone->cursor = zone->base;
983
984            if ( !zone->base )
985            {
986              FT_ERROR(( "t1_decoder_parse_charstrings: "
987                         "invoking empty subrs!\n" ));
988              goto Syntax_Error;
989            }
990
991            decoder->zone = zone;
992            ip            = zone->base;
993            limit         = zone->limit;
994            break;
995          }
996
997        case op_pop:
998          FT_TRACE4(( " pop" ));
999
1000          /* theoretically, the arguments are already on the stack */
1001          top++;
1002          break;
1003
1004        case op_return:
1005          FT_TRACE4(( " return" ));
1006
1007          if ( zone <= decoder->zones )
1008          {
1009            FT_ERROR(( "t1_decoder_parse_charstrings: unexpected return\n" ));
1010            goto Syntax_Error;
1011          }
1012
1013          zone--;
1014          ip            = zone->cursor;
1015          limit         = zone->limit;
1016          decoder->zone = zone;
1017          break;
1018
1019        case op_dotsection:
1020          FT_TRACE4(( " dotsection" ));
1021
1022          break;
1023
1024        case op_hstem:
1025          FT_TRACE4(( " hstem" ));
1026
1027          /* record horizontal hint */
1028          if ( hinter )
1029          {
1030            /* top[0] += builder->left_bearing.y; */
1031            hinter->stem( hinter->hints, 1, top );
1032          }
1033
1034          break;
1035
1036        case op_hstem3:
1037          FT_TRACE4(( " hstem3" ));
1038
1039          /* record horizontal counter-controlled hints */
1040          if ( hinter )
1041            hinter->stem3( hinter->hints, 1, top );
1042
1043          break;
1044
1045        case op_vstem:
1046          FT_TRACE4(( " vstem" ));
1047
1048          /* record vertical  hint */
1049          if ( hinter )
1050          {
1051            top[0] += orig_x;
1052            hinter->stem( hinter->hints, 0, top );
1053          }
1054
1055          break;
1056
1057        case op_vstem3:
1058          FT_TRACE4(( " vstem3" ));
1059
1060          /* record vertical counter-controlled hints */
1061          if ( hinter )
1062          {
1063            FT_Pos  dx = orig_x;
1064
1065
1066            top[0] += dx;
1067            top[2] += dx;
1068            top[4] += dx;
1069            hinter->stem3( hinter->hints, 0, top );
1070          }
1071          break;
1072
1073        case op_setcurrentpoint:
1074          FT_TRACE4(( " setcurrentpoint" ));
1075
1076          FT_ERROR(( "t1_decoder_parse_charstrings: " ));
1077          FT_ERROR(( "unexpected `setcurrentpoint'\n" ));
1078          goto Syntax_Error;
1079
1080        default:
1081          FT_ERROR(( "t1_decoder_parse_charstrings: "
1082                     "unhandled opcode %d\n", op ));
1083          goto Syntax_Error;
1084        }
1085
1086        decoder->top = top;
1087
1088      } /* general operator processing */
1089
1090    } /* while ip < limit */
1091
1092    FT_TRACE4(( "..end..\n\n" ));
1093
1094  Fail:
1095    return error;
1096
1097  Syntax_Error:
1098    return PSaux_Err_Syntax_Error;
1099
1100  Stack_Underflow:
1101    return PSaux_Err_Stack_Underflow;
1102  }
1103
1104
1105  /* parse a single Type 1 glyph */
1106  FT_LOCAL_DEF( FT_Error )
1107  t1_decoder_parse_glyph( T1_Decoder  decoder,
1108                          FT_UInt     glyph )
1109  {
1110    return decoder->parse_callback( decoder, glyph );
1111  }
1112
1113
1114  /* initialize T1 decoder */
1115  FT_LOCAL_DEF( FT_Error )
1116  t1_decoder_init( T1_Decoder           decoder,
1117                   FT_Face              face,
1118                   FT_Size              size,
1119                   FT_GlyphSlot         slot,
1120                   FT_Byte**            glyph_names,
1121                   PS_Blend             blend,
1122                   FT_Bool              hinting,
1123                   FT_Render_Mode       hint_mode,
1124                   T1_Decoder_Callback  parse_callback )
1125  {
1126    FT_MEM_ZERO( decoder, sizeof ( *decoder ) );
1127
1128    /* retrieve PSNames interface from list of current modules */
1129    {
1130      FT_Service_PsCMaps  psnames = 0;
1131
1132
1133      FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
1134      if ( !psnames )
1135      {
1136        FT_ERROR(( "t1_decoder_init: " ));
1137        FT_ERROR(( "the `psnames' module is not available\n" ));
1138        return PSaux_Err_Unimplemented_Feature;
1139      }
1140
1141      decoder->psnames = psnames;
1142    }
1143
1144    t1_builder_init( &decoder->builder, face, size, slot, hinting );
1145
1146    decoder->num_glyphs     = (FT_UInt)face->num_glyphs;
1147    decoder->glyph_names    = glyph_names;
1148    decoder->hint_mode      = hint_mode;
1149    decoder->blend          = blend;
1150    decoder->parse_callback = parse_callback;
1151
1152    decoder->funcs          = t1_decoder_funcs;
1153
1154    return 0;
1155  }
1156
1157
1158  /* finalize T1 decoder */
1159  FT_LOCAL_DEF( void )
1160  t1_decoder_done( T1_Decoder  decoder )
1161  {
1162    t1_builder_done( &decoder->builder );
1163  }
1164
1165
1166/* END */
Note: See TracBrowser for help on using the repository browser.