src/cff/cf2intrp.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  cf2intrp.c                                                             */
   4 /*                                                                         */
   5 /*    Adobe's CFF Interpreter (body).                                      */
   6 /*                                                                         */
   7 /*  Copyright 2007-2014 Adobe Systems Incorporated.                        */
   8 /*                                                                         */
   9 /*  This software, and all works of authorship, whether in source or       */
  10 /*  object code form as indicated by the copyright notice(s) included      */
  11 /*  herein (collectively, the "Work") is made available, and may only be   */
  12 /*  used, modified, and distributed under the FreeType Project License,    */
  13 /*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
  14 /*  FreeType Project License, each contributor to the Work hereby grants   */
  15 /*  to any individual or legal entity exercising permissions granted by    */
  16 /*  the FreeType Project License and this section (hereafter, "You" or     */
  17 /*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
  18 /*  royalty-free, irrevocable (except as stated in this section) patent    */
  19 /*  license to make, have made, use, offer to sell, sell, import, and      */
  20 /*  otherwise transfer the Work, where such license applies only to those  */
  21 /*  patent claims licensable by such contributor that are necessarily      */
  22 /*  infringed by their contribution(s) alone or by combination of their    */
  23 /*  contribution(s) with the Work to which such contribution(s) was        */
  24 /*  submitted.  If You institute patent litigation against any entity      */
  25 /*  (including a cross-claim or counterclaim in a lawsuit) alleging that   */
  26 /*  the Work or a contribution incorporated within the Work constitutes    */
  27 /*  direct or contributory patent infringement, then any patent licenses   */
  28 /*  granted to You under this License for that Work shall terminate as of  */
  29 /*  the date such litigation is filed.                                     */
  30 /*                                                                         */
  31 /*  By using, modifying, or distributing the Work you indicate that you    */
  32 /*  have read and understood the terms and conditions of the               */
  33 /*  FreeType Project License as well as those provided in this section,    */
  34 /*  and you accept them fully.                                             */
  35 /*                                                                         */
  36 /***************************************************************************/
  37
  38
  39 #include "cf2ft.h"
  40 #include FT_INTERNAL_DEBUG_H
  41
  42 #include "cf2glue.h"
  43 #include "cf2font.h"
  44 #include "cf2stack.h"
  45 #include "cf2hints.h"
  46
  47 #include "cf2error.h"
  48
  49
  50   /*************************************************************************/
  51   /*                                                                       */
  52   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  53   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  54   /* messages during execution.                                            */
  55   /*                                                                       */
  56 #undef  FT_COMPONENT
  57 #define FT_COMPONENT  trace_cf2interp
  58
  59
  60   /* some operators are not implemented yet */
  61 #define CF2_FIXME  FT_TRACE4(( "cf2_interpT2CharString:"            \
  62                                " operator not implemented yet\n" ))
  63
  64
  65
  66   FT_LOCAL_DEF( void )
  67   cf2_hintmask_init( CF2_HintMask  hintmask,
  68                      FT_Error*     error )
  69   {
  70     FT_ZERO( hintmask );
  71
  72     hintmask->error = error;
  73   }
  74
  75
  76   FT_LOCAL_DEF( FT_Bool )
  77   cf2_hintmask_isValid( const CF2_HintMask  hintmask )
  78   {
  79     return hintmask->isValid;
  80   }
  81
  82
  83   FT_LOCAL_DEF( FT_Bool )
  84   cf2_hintmask_isNew( const CF2_HintMask  hintmask )
  85   {
  86     return hintmask->isNew;
  87   }
  88
  89
  90   FT_LOCAL_DEF( void )
  91   cf2_hintmask_setNew( CF2_HintMask  hintmask,
  92                        FT_Bool       val )
  93   {
  94     hintmask->isNew = val;
  95   }
  96
  97
  98   /* clients call `getMaskPtr' in order to iterate */
  99   /* through hint mask                             */
 100
 101   FT_LOCAL_DEF( FT_Byte* )
 102   cf2_hintmask_getMaskPtr( CF2_HintMask  hintmask )
 103   {
 104     return hintmask->mask;
 105   }
 106
 107
 108   static size_t
 109   cf2_hintmask_setCounts( CF2_HintMask  hintmask,
 110                           size_t        bitCount )
 111   {
 112     if ( bitCount > CF2_MAX_HINTS )
 113     {
 114       /* total of h and v stems must be <= 96 */
 115       CF2_SET_ERROR( hintmask->error, Invalid_Glyph_Format );
 116       return 0;
 117     }
 118
 119     hintmask->bitCount  = bitCount;
 120     hintmask->byteCount = ( hintmask->bitCount + 7 ) / 8;
 121
 122     hintmask->isValid = TRUE;
 123     hintmask->isNew   = TRUE;
 124
 125     return bitCount;
 126   }
 127
 128
 129   /* consume the hintmask bytes from the charstring, advancing the src */
 130   /* pointer                                                           */
 131   static void
 132   cf2_hintmask_read( CF2_HintMask  hintmask,
 133                      CF2_Buffer    charstring,
 134                      size_t        bitCount )
 135   {
 136     size_t  i;
 137
 138 #ifndef CF2_NDEBUG
 139     /* these are the bits in the final mask byte that should be zero  */
 140     /* Note: this variable is only used in an assert expression below */
 141     /* and then only if CF2_NDEBUG is not defined                     */
 142     CF2_UInt  mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;
 143 #endif
 144
 145
 146     /* initialize counts and isValid */
 147     if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )
 148       return;
 149
 150     FT_ASSERT( hintmask->byteCount > 0 );
 151
 152     FT_TRACE4(( " (maskbytes:" ));
 153
 154     /* set mask and advance interpreter's charstring pointer */
 155     for ( i = 0; i < hintmask->byteCount; i++ )
 156     {
 157       hintmask->mask[i] = (FT_Byte)cf2_buf_readByte( charstring );
 158       FT_TRACE4(( " 0x%02X", hintmask->mask[i] ));
 159     }
 160
 161     FT_TRACE4(( ")\n" ));
 162
 163     /* assert any unused bits in last byte are zero unless there's a prior */
 164     /* error                                                               */
 165     /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1      */
 166 #ifndef CF2_NDEBUG
 167     FT_ASSERT( ( hintmask->mask[hintmask->byteCount - 1] & mask ) == 0 ||
 168                *hintmask->error                                        );
 169 #endif
 170   }
 171
 172
 173   FT_LOCAL_DEF( void )
 174   cf2_hintmask_setAll( CF2_HintMask  hintmask,
 175                        size_t        bitCount )
 176   {
 177     size_t    i;
 178     CF2_UInt  mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;
 179
 180
 181     /* initialize counts and isValid */
 182     if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )
 183       return;
 184
 185     FT_ASSERT( hintmask->byteCount > 0 );
 186     FT_ASSERT( hintmask->byteCount <
 187                  sizeof ( hintmask->mask ) / sizeof ( hintmask->mask[0] ) );
 188
 189     /* set mask to all ones */
 190     for ( i = 0; i < hintmask->byteCount; i++ )
 191       hintmask->mask[i] = 0xFF;
 192
 193     /* clear unused bits                                              */
 194     /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */
 195     hintmask->mask[hintmask->byteCount - 1] &= ~mask;
 196   }
 197
 198
 199   /* Type2 charstring opcodes */
 200   enum
 201   {
 202     cf2_cmdRESERVED_0,   /* 0 */
 203     cf2_cmdHSTEM,        /* 1 */
 204     cf2_cmdRESERVED_2,   /* 2 */
 205     cf2_cmdVSTEM,        /* 3 */
 206     cf2_cmdVMOVETO,      /* 4 */
 207     cf2_cmdRLINETO,      /* 5 */
 208     cf2_cmdHLINETO,      /* 6 */
 209     cf2_cmdVLINETO,      /* 7 */
 210     cf2_cmdRRCURVETO,    /* 8 */
 211     cf2_cmdRESERVED_9,   /* 9 */
 212     cf2_cmdCALLSUBR,     /* 10 */
 213     cf2_cmdRETURN,       /* 11 */
 214     cf2_cmdESC,          /* 12 */
 215     cf2_cmdRESERVED_13,  /* 13 */
 216     cf2_cmdENDCHAR,      /* 14 */
 217     cf2_cmdRESERVED_15,  /* 15 */
 218     cf2_cmdRESERVED_16,  /* 16 */
 219     cf2_cmdRESERVED_17,  /* 17 */
 220     cf2_cmdHSTEMHM,      /* 18 */
 221     cf2_cmdHINTMASK,     /* 19 */
 222     cf2_cmdCNTRMASK,     /* 20 */
 223     cf2_cmdRMOVETO,      /* 21 */
 224     cf2_cmdHMOVETO,      /* 22 */
 225     cf2_cmdVSTEMHM,      /* 23 */
 226     cf2_cmdRCURVELINE,   /* 24 */
 227     cf2_cmdRLINECURVE,   /* 25 */
 228     cf2_cmdVVCURVETO,    /* 26 */
 229     cf2_cmdHHCURVETO,    /* 27 */
 230     cf2_cmdEXTENDEDNMBR, /* 28 */
 231     cf2_cmdCALLGSUBR,    /* 29 */
 232     cf2_cmdVHCURVETO,    /* 30 */
 233     cf2_cmdHVCURVETO     /* 31 */
 234   };
 235
 236   enum
 237   {
 238     cf2_escDOTSECTION,   /* 0 */
 239     cf2_escRESERVED_1,   /* 1 */
 240     cf2_escRESERVED_2,   /* 2 */
 241     cf2_escAND,          /* 3 */
 242     cf2_escOR,           /* 4 */
 243     cf2_escNOT,          /* 5 */
 244     cf2_escRESERVED_6,   /* 6 */
 245     cf2_escRESERVED_7,   /* 7 */
 246     cf2_escRESERVED_8,   /* 8 */
 247     cf2_escABS,          /* 9 */
 248     cf2_escADD,          /* 10     like otherADD */
 249     cf2_escSUB,          /* 11     like otherSUB */
 250     cf2_escDIV,          /* 12 */
 251     cf2_escRESERVED_13,  /* 13 */
 252     cf2_escNEG,          /* 14 */
 253     cf2_escEQ,           /* 15 */
 254     cf2_escRESERVED_16,  /* 16 */
 255     cf2_escRESERVED_17,  /* 17 */
 256     cf2_escDROP,         /* 18 */
 257     cf2_escRESERVED_19,  /* 19 */
 258     cf2_escPUT,          /* 20     like otherPUT    */
 259     cf2_escGET,          /* 21     like otherGET    */
 260     cf2_escIFELSE,       /* 22     like otherIFELSE */
 261     cf2_escRANDOM,       /* 23     like otherRANDOM */
 262     cf2_escMUL,          /* 24     like otherMUL    */
 263     cf2_escRESERVED_25,  /* 25 */
 264     cf2_escSQRT,         /* 26 */
 265     cf2_escDUP,          /* 27     like otherDUP    */
 266     cf2_escEXCH,         /* 28     like otherEXCH   */
 267     cf2_escINDEX,        /* 29 */
 268     cf2_escROLL,         /* 30 */
 269     cf2_escRESERVED_31,  /* 31 */
 270     cf2_escRESERVED_32,  /* 32 */
 271     cf2_escRESERVED_33,  /* 33 */
 272     cf2_escHFLEX,        /* 34 */
 273     cf2_escFLEX,         /* 35 */
 274     cf2_escHFLEX1,       /* 36 */
 275     cf2_escFLEX1         /* 37 */
 276   };
 277
 278
 279   /* `stemHintArray' does not change once we start drawing the outline. */
 280   static void
 281   cf2_doStems( const CF2_Font  font,
 282                CF2_Stack       opStack,
 283                CF2_ArrStack    stemHintArray,
 284                CF2_Fixed*      width,
 285                FT_Bool*        haveWidth,
 286                CF2_Fixed       hintOffset )
 287   {
 288     CF2_UInt  i;
 289     CF2_UInt  count       = cf2_stack_count( opStack );
 290     FT_Bool   hasWidthArg = (FT_Bool)( count & 1 );
 291
 292     /* variable accumulates delta values from operand stack */
 293     CF2_Fixed  position = hintOffset;
 294
 295     if ( hasWidthArg && ! *haveWidth )
 296       *width = cf2_stack_getReal( opStack, 0 ) +
 297                  cf2_getNominalWidthX( font->decoder );
 298
 299     if ( font->decoder->width_only )
 300       goto exit;
 301
 302     for ( i = hasWidthArg ? 1 : 0; i < count; i += 2 )
 303     {
 304       /* construct a CF2_StemHint and push it onto the list */
 305       CF2_StemHintRec  stemhint;
 306
 307
 308       stemhint.min  =
 309         position   += cf2_stack_getReal( opStack, i );
 310       stemhint.max  =
 311         position   += cf2_stack_getReal( opStack, i + 1 );
 312
 313       stemhint.used  = FALSE;
 314       stemhint.maxDS =
 315       stemhint.minDS = 0;
 316
 317       cf2_arrstack_push( stemHintArray, &stemhint ); /* defer error check */
 318     }
 319
 320     cf2_stack_clear( opStack );
 321
 322   exit:
 323     /* cf2_doStems must define a width (may be default) */
 324     *haveWidth = TRUE;
 325   }
 326
 327
 328   static void
 329   cf2_doFlex( CF2_Stack       opStack,
 330               CF2_Fixed*      curX,
 331               CF2_Fixed*      curY,
 332               CF2_GlyphPath   glyphPath,
 333               const FT_Bool*  readFromStack,
 334               FT_Bool         doConditionalLastRead )
 335   {
 336     CF2_Fixed  vals[14];
 337     CF2_UInt   index;
 338     FT_Bool    isHFlex;
 339     CF2_Int    top, i, j;
 340
 341
 342     vals[0] = *curX;
 343     vals[1] = *curY;
 344     index   = 0;
 345     isHFlex = readFromStack[9] == FALSE;
 346     top     = isHFlex ? 9 : 10;
 347
 348     for ( i = 0; i < top; i++ )
 349     {
 350       vals[i + 2] = vals[i];
 351       if ( readFromStack[i] )
 352         vals[i + 2] += cf2_stack_getReal( opStack, index++ );
 353     }
 354
 355     if ( isHFlex )
 356       vals[9 + 2] = *curY;
 357
 358     if ( doConditionalLastRead )
 359     {
 360       FT_Bool    lastIsX = (FT_Bool)( cf2_fixedAbs( vals[10] - *curX ) >
 361                                         cf2_fixedAbs( vals[11] - *curY ) );
 362       CF2_Fixed  lastVal = cf2_stack_getReal( opStack, index );
 363
 364
 365       if ( lastIsX )
 366       {
 367         vals[12] = vals[10] + lastVal;
 368         vals[13] = *curY;
 369       }
 370       else
 371       {
 372         vals[12] = *curX;
 373         vals[13] = vals[11] + lastVal;
 374       }
 375     }
 376     else
 377     {
 378       if ( readFromStack[10] )
 379         vals[12] = vals[10] + cf2_stack_getReal( opStack, index++ );
 380       else
 381         vals[12] = *curX;
 382
 383       if ( readFromStack[11] )
 384         vals[13] = vals[11] + cf2_stack_getReal( opStack, index );
 385       else
 386         vals[13] = *curY;
 387     }
 388
 389     for ( j = 0; j < 2; j++ )
 390       cf2_glyphpath_curveTo( glyphPath, vals[j * 6 + 2],
 391                                         vals[j * 6 + 3],
 392                                         vals[j * 6 + 4],
 393                                         vals[j * 6 + 5],
 394                                         vals[j * 6 + 6],
 395                                         vals[j * 6 + 7] );
 396
 397     cf2_stack_clear( opStack );
 398
 399     *curX = vals[12];
 400     *curY = vals[13];
 401   }
 402
 403
 404   /*
 405    * `error' is a shared error code used by many objects in this
 406    * routine.  Before the code continues from an error, it must check and
 407    * record the error in `*error'.  The idea is that this shared
 408    * error code will record the first error encountered.  If testing
 409    * for an error anyway, the cost of `goto exit' is small, so we do it,
 410    * even if continuing would be safe.  In this case, `lastError' is
 411    * set, so the testing and storing can be done in one place, at `exit'.
 412    *
 413    * Continuing after an error is intended for objects which do their own
 414    * testing of `*error', e.g., array stack functions.  This allows us to
 415    * avoid an extra test after the call.
 416    *
 417    * Unimplemented opcodes are ignored.
 418    *
 419    */
 420   FT_LOCAL_DEF( void )
 421   cf2_interpT2CharString( CF2_Font              font,
 422                           CF2_Buffer            buf,
 423                           CF2_OutlineCallbacks  callbacks,
 424                           const FT_Vector*      translation,
 425                           FT_Bool               doingSeac,
 426                           CF2_Fixed             curX,
 427                           CF2_Fixed             curY,
 428                           CF2_Fixed*            width )
 429   {
 430     /* lastError is used for errors that are immediately tested */
 431     FT_Error  lastError = FT_Err_Ok;
 432
 433     /* pointer to parsed font object */
 434     CFF_Decoder*  decoder = font->decoder;
 435
 436     FT_Error*  error  = &font->error;
 437     FT_Memory  memory = font->memory;
 438
 439     CF2_Fixed  scaleY        = font->innerTransform.d;
 440     CF2_Fixed  nominalWidthX = cf2_getNominalWidthX( decoder );
 441
 442     /* save this for hinting seac accents */
 443     CF2_Fixed  hintOriginY = curY;
 444
 445     CF2_Stack  opStack = NULL;
 446     FT_Byte    op1;                       /* first opcode byte */
 447
 448     /* instruction limit; 20,000,000 matches Avalon */
 449     FT_UInt32  instructionLimit = 20000000UL;
 450
 451     CF2_ArrStackRec  subrStack;
 452
 453     FT_Bool     haveWidth;
 454     CF2_Buffer  charstring = NULL;
 455
 456     CF2_Int  charstringIndex = -1;       /* initialize to empty */
 457
 458     /* TODO: placeholders for hint structures */
 459
 460     /* objects used for hinting */
 461     CF2_ArrStackRec  hStemHintArray;
 462     CF2_ArrStackRec  vStemHintArray;
 463
 464     CF2_HintMaskRec   hintMask;
 465     CF2_GlyphPathRec  glyphPath;
 466
 467
 468     /* initialize the remaining objects */
 469     cf2_arrstack_init( &subrStack,
 470                        memory,
 471                        error,
 472                        sizeof ( CF2_BufferRec ) );
 473     cf2_arrstack_init( &hStemHintArray,
 474                        memory,
 475                        error,
 476                        sizeof ( CF2_StemHintRec ) );
 477     cf2_arrstack_init( &vStemHintArray,
 478                        memory,
 479                        error,
 480                        sizeof ( CF2_StemHintRec ) );
 481
 482     /* initialize CF2_StemHint arrays */
 483     cf2_hintmask_init( &hintMask, error );
 484
 485     /* initialize path map to manage drawing operations */
 486
 487     /* Note: last 4 params are used to handle `MoveToPermissive', which */
 488     /*       may need to call `hintMap.Build'                           */
 489     /* TODO: MoveToPermissive is gone; are these still needed?          */
 490     cf2_glyphpath_init( &glyphPath,
 491                         font,
 492                         callbacks,
 493                         scaleY,
 494                         /* hShift, */
 495                         &hStemHintArray,
 496                         &vStemHintArray,
 497                         &hintMask,
 498                         hintOriginY,
 499                         &font->blues,
 500                         translation );
 501
 502     /*
 503      * Initialize state for width parsing.  From the CFF Spec:
 504      *
 505      *   The first stack-clearing operator, which must be one of hstem,
 506      *   hstemhm, vstem, vstemhm, cntrmask, hintmask, hmoveto, vmoveto,
 507      *   rmoveto, or endchar, takes an additional argument - the width (as
 508      *   described earlier), which may be expressed as zero or one numeric
 509      *   argument.
 510      *
 511      * What we implement here uses the first validly specified width, but
 512      * does not detect errors for specifying more than one width.
 513      *
 514      * If one of the above operators occurs without explicitly specifying
 515      * a width, we assume the default width.
 516      *
 517      */
 518     haveWidth = FALSE;
 519     *width    = cf2_getDefaultWidthX( decoder );
 520
 521     /*
 522      * Note: at this point, all pointers to resources must be NULL
 523      * and all local objects must be initialized.
 524      * There must be no branches to exit: above this point.
 525      *
 526      */
 527
 528     /* allocate an operand stack */
 529     opStack = cf2_stack_init( memory, error );
 530     if ( !opStack )
 531     {
 532       lastError = FT_THROW( Out_Of_Memory );
 533       goto exit;
 534     }
 535
 536     /* initialize subroutine stack by placing top level charstring as */
 537     /* first element (max depth plus one for the charstring)          */
 538     /* Note: Caller owns and must finalize the first charstring.      */
 539     /*       Our copy of it does not change that requirement.         */
 540     cf2_arrstack_setCount( &subrStack, CF2_MAX_SUBR + 1 );
 541
 542     charstring  = (CF2_Buffer)cf2_arrstack_getBuffer( &subrStack );
 543     *charstring = *buf;    /* structure copy */
 544
 545     charstringIndex = 0;       /* entry is valid now */
 546
 547     /* catch errors so far */
 548     if ( *error )
 549       goto exit;
 550
 551     /* main interpreter loop */
 552     while ( 1 )
 553     {
 554       if ( cf2_buf_isEnd( charstring ) )
 555       {
 556         /* If we've reached the end of the charstring, simulate a */
 557         /* cf2_cmdRETURN or cf2_cmdENDCHAR.                       */
 558         if ( charstringIndex )
 559           op1 = cf2_cmdRETURN;  /* end of buffer for subroutine */
 560         else
 561           op1 = cf2_cmdENDCHAR; /* end of buffer for top level charstring */
 562       }
 563       else
 564         op1 = (FT_Byte)cf2_buf_readByte( charstring );
 565
 566       /* check for errors once per loop */
 567       if ( *error )
 568         goto exit;
 569
 570       instructionLimit--;
 571       if ( instructionLimit == 0 )
 572       {
 573         lastError = FT_THROW( Invalid_Glyph_Format );
 574         goto exit;
 575       }
 576
 577       switch( op1 )
 578       {
 579       case cf2_cmdRESERVED_0:
 580       case cf2_cmdRESERVED_2:
 581       case cf2_cmdRESERVED_9:
 582       case cf2_cmdRESERVED_13:
 583       case cf2_cmdRESERVED_15:
 584       case cf2_cmdRESERVED_16:
 585       case cf2_cmdRESERVED_17:
 586         /* we may get here if we have a prior error */
 587         FT_TRACE4(( " unknown op (%d)\n", op1 ));
 588         break;
 589
 590       case cf2_cmdHSTEMHM:
 591       case cf2_cmdHSTEM:
 592         FT_TRACE4(( op1 == cf2_cmdHSTEMHM ? " hstemhm\n" : " hstem\n" ));
 593
 594         /* never add hints after the mask is computed */
 595         if ( cf2_hintmask_isValid( &hintMask ) )
 596         {
 597           FT_TRACE4(( "cf2_interpT2CharString:"
 598                       " invalid horizontal hint mask\n" ));
 599           break;
 600         }
 601
 602         cf2_doStems( font,
 603                      opStack,
 604                      &hStemHintArray,
 605                      width,
 606                      &haveWidth,
 607                      0 );
 608
 609         if ( font->decoder->width_only )
 610             goto exit;
 611
 612         break;
 613
 614       case cf2_cmdVSTEMHM:
 615       case cf2_cmdVSTEM:
 616         FT_TRACE4(( op1 == cf2_cmdVSTEMHM ? " vstemhm\n" : " vstem\n" ));
 617
 618         /* never add hints after the mask is computed */
 619         if ( cf2_hintmask_isValid( &hintMask ) )
 620         {
 621           FT_TRACE4(( "cf2_interpT2CharString:"
 622                       " invalid vertical hint mask\n" ));
 623           break;
 624         }
 625
 626         cf2_doStems( font,
 627                      opStack,
 628                      &vStemHintArray,
 629                      width,
 630                      &haveWidth,
 631                      0 );
 632
 633         if ( font->decoder->width_only )
 634             goto exit;
 635
 636         break;
 637
 638       case cf2_cmdVMOVETO:
 639         FT_TRACE4(( " vmoveto\n" ));
 640
 641         if ( cf2_stack_count( opStack ) > 1 && !haveWidth )
 642           *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;
 643
 644         /* width is defined or default after this */
 645         haveWidth = TRUE;
 646
 647         if ( font->decoder->width_only )
 648             goto exit;
 649
 650         curY += cf2_stack_popFixed( opStack );
 651
 652         cf2_glyphpath_moveTo( &glyphPath, curX, curY );
 653
 654         break;
 655
 656       case cf2_cmdRLINETO:
 657         {
 658           CF2_UInt  index;
 659           CF2_UInt  count = cf2_stack_count( opStack );
 660
 661
 662           FT_TRACE4(( " rlineto\n" ));
 663
 664           for ( index = 0; index < count; index += 2 )
 665           {
 666             curX += cf2_stack_getReal( opStack, index + 0 );
 667             curY += cf2_stack_getReal( opStack, index + 1 );
 668
 669             cf2_glyphpath_lineTo( &glyphPath, curX, curY );
 670           }
 671
 672           cf2_stack_clear( opStack );
 673         }
 674         continue; /* no need to clear stack again */
 675
 676       case cf2_cmdHLINETO:
 677       case cf2_cmdVLINETO:
 678         {
 679           CF2_UInt  index;
 680           CF2_UInt  count = cf2_stack_count( opStack );
 681
 682           FT_Bool  isX = op1 == cf2_cmdHLINETO;
 683
 684
 685           FT_TRACE4(( isX ? " hlineto\n" : " vlineto\n" ));
 686
 687           for ( index = 0; index < count; index++ )
 688           {
 689             CF2_Fixed  v = cf2_stack_getReal( opStack, index );
 690
 691
 692             if ( isX )
 693               curX += v;
 694             else
 695               curY += v;
 696
 697             isX = !isX;
 698
 699             cf2_glyphpath_lineTo( &glyphPath, curX, curY );
 700           }
 701
 702           cf2_stack_clear( opStack );
 703         }
 704         continue;
 705
 706       case cf2_cmdRCURVELINE:
 707       case cf2_cmdRRCURVETO:
 708         {
 709           CF2_UInt  count = cf2_stack_count( opStack );
 710           CF2_UInt  index = 0;
 711
 712
 713           FT_TRACE4(( op1 == cf2_cmdRCURVELINE ? " rcurveline\n"
 714                                                : " rrcurveto\n" ));
 715
 716           while ( index + 6 <= count )
 717           {
 718             CF2_Fixed  x1 = cf2_stack_getReal( opStack, index + 0 ) + curX;
 719             CF2_Fixed  y1 = cf2_stack_getReal( opStack, index + 1 ) + curY;
 720             CF2_Fixed  x2 = cf2_stack_getReal( opStack, index + 2 ) + x1;
 721             CF2_Fixed  y2 = cf2_stack_getReal( opStack, index + 3 ) + y1;
 722             CF2_Fixed  x3 = cf2_stack_getReal( opStack, index + 4 ) + x2;
 723             CF2_Fixed  y3 = cf2_stack_getReal( opStack, index + 5 ) + y2;
 724
 725
 726             cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 );
 727
 728             curX   = x3;
 729             curY   = y3;
 730             index += 6;
 731           }
 732
 733           if ( op1 == cf2_cmdRCURVELINE )
 734           {
 735             curX += cf2_stack_getReal( opStack, index + 0 );
 736             curY += cf2_stack_getReal( opStack, index + 1 );
 737
 738             cf2_glyphpath_lineTo( &glyphPath, curX, curY );
 739           }
 740
 741           cf2_stack_clear( opStack );
 742         }
 743         continue; /* no need to clear stack again */
 744
 745       case cf2_cmdCALLGSUBR:
 746       case cf2_cmdCALLSUBR:
 747         {
 748           CF2_UInt  subrIndex;
 749
 750
 751           FT_TRACE4(( op1 == cf2_cmdCALLGSUBR ? " callgsubr"
 752                                               : " callsubr" ));
 753
 754           if ( charstringIndex > CF2_MAX_SUBR )
 755           {
 756             /* max subr plus one for charstring */
 757             lastError = FT_THROW( Invalid_Glyph_Format );
 758             goto exit;                      /* overflow of stack */
 759           }
 760
 761           /* push our current CFF charstring region on subrStack */
 762           charstring = (CF2_Buffer)
 763                          cf2_arrstack_getPointer( &subrStack,
 764                                                   charstringIndex + 1 );
 765
 766           /* set up the new CFF region and pointer */
 767           subrIndex = cf2_stack_popInt( opStack );
 768
 769           switch ( op1 )
 770           {
 771           case cf2_cmdCALLGSUBR:
 772             FT_TRACE4(( "(%d)\n", subrIndex + decoder->globals_bias ));
 773
 774             if ( cf2_initGlobalRegionBuffer( decoder,
 775                                              subrIndex,
 776                                              charstring ) )
 777             {
 778               lastError = FT_THROW( Invalid_Glyph_Format );
 779               goto exit;  /* subroutine lookup or stream error */
 780             }
 781             break;
 782
 783           default:
 784             /* cf2_cmdCALLSUBR */
 785             FT_TRACE4(( "(%d)\n", subrIndex + decoder->locals_bias ));
 786
 787             if ( cf2_initLocalRegionBuffer( decoder,
 788                                             subrIndex,
 789                                             charstring ) )
 790             {
 791               lastError = FT_THROW( Invalid_Glyph_Format );
 792               goto exit;  /* subroutine lookup or stream error */
 793             }
 794           }
 795
 796           charstringIndex += 1;       /* entry is valid now */
 797         }
 798         continue; /* do not clear the stack */
 799
 800       case cf2_cmdRETURN:
 801         FT_TRACE4(( " return\n" ));
 802
 803         if ( charstringIndex < 1 )
 804         {
 805           /* Note: cannot return from top charstring */
 806           lastError = FT_THROW( Invalid_Glyph_Format );
 807           goto exit;                      /* underflow of stack */
 808         }
 809
 810         /* restore position in previous charstring */
 811         charstring = (CF2_Buffer)
 812                        cf2_arrstack_getPointer( &subrStack,
 813                                                 --charstringIndex );
 814         continue;     /* do not clear the stack */
 815
 816       case cf2_cmdESC:
 817         {
 818           FT_Byte  op2 = (FT_Byte)cf2_buf_readByte( charstring );
 819
 820
 821           switch ( op2 )
 822           {
 823           case cf2_escDOTSECTION:
 824             /* something about `flip type of locking' -- ignore it */
 825             FT_TRACE4(( " dotsection\n" ));
 826
 827             break;
 828
 829           /* TODO: should these operators be supported? */
 830           case cf2_escAND: /* in spec */
 831             FT_TRACE4(( " and\n" ));
 832
 833             CF2_FIXME;
 834             break;
 835
 836           case cf2_escOR: /* in spec */
 837             FT_TRACE4(( " or\n" ));
 838
 839             CF2_FIXME;
 840             break;
 841
 842           case cf2_escNOT: /* in spec */
 843             FT_TRACE4(( " not\n" ));
 844
 845             CF2_FIXME;
 846             break;
 847
 848           case cf2_escABS: /* in spec */
 849             FT_TRACE4(( " abs\n" ));
 850
 851             CF2_FIXME;
 852             break;
 853
 854           case cf2_escADD: /* in spec */
 855             FT_TRACE4(( " add\n" ));
 856
 857             CF2_FIXME;
 858             break;
 859
 860           case cf2_escSUB: /* in spec */
 861             FT_TRACE4(( " sub\n" ));
 862
 863             CF2_FIXME;
 864             break;
 865
 866           case cf2_escDIV: /* in spec */
 867             FT_TRACE4(( " div\n" ));
 868
 869             CF2_FIXME;
 870             break;
 871
 872           case cf2_escNEG: /* in spec */
 873             FT_TRACE4(( " neg\n" ));
 874
 875             CF2_FIXME;
 876             break;
 877
 878           case cf2_escEQ: /* in spec */
 879             FT_TRACE4(( " eq\n" ));
 880
 881             CF2_FIXME;
 882             break;
 883
 884           case cf2_escDROP: /* in spec */
 885             FT_TRACE4(( " drop\n" ));
 886
 887             CF2_FIXME;
 888             break;
 889
 890           case cf2_escPUT: /* in spec */
 891             FT_TRACE4(( " put\n" ));
 892
 893             CF2_FIXME;
 894             break;
 895
 896           case cf2_escGET: /* in spec */
 897             FT_TRACE4(( " get\n" ));
 898
 899             CF2_FIXME;
 900             break;
 901
 902           case cf2_escIFELSE: /* in spec */
 903             FT_TRACE4(( " ifelse\n" ));
 904
 905             CF2_FIXME;
 906             break;
 907
 908           case cf2_escRANDOM: /* in spec */
 909             FT_TRACE4(( " random\n" ));
 910
 911             CF2_FIXME;
 912             break;
 913
 914           case cf2_escMUL: /* in spec */
 915             FT_TRACE4(( " mul\n" ));
 916
 917             CF2_FIXME;
 918             break;
 919
 920           case cf2_escSQRT: /* in spec */
 921             FT_TRACE4(( " sqrt\n" ));
 922
 923             CF2_FIXME;
 924             break;
 925
 926           case cf2_escDUP: /* in spec */
 927             FT_TRACE4(( " dup\n" ));
 928
 929             CF2_FIXME;
 930             break;
 931
 932           case cf2_escEXCH: /* in spec */
 933             FT_TRACE4(( " exch\n" ));
 934
 935             CF2_FIXME;
 936             break;
 937
 938           case cf2_escINDEX: /* in spec */
 939             FT_TRACE4(( " index\n" ));
 940
 941             CF2_FIXME;
 942             break;
 943
 944           case cf2_escROLL: /* in spec */
 945             FT_TRACE4(( " roll\n" ));
 946
 947             CF2_FIXME;
 948             break;
 949
 950           case cf2_escHFLEX:
 951             {
 952               static const FT_Bool  readFromStack[12] =
 953               {
 954                 TRUE /* dx1 */, FALSE /* dy1 */,
 955                 TRUE /* dx2 */, TRUE  /* dy2 */,
 956                 TRUE /* dx3 */, FALSE /* dy3 */,
 957                 TRUE /* dx4 */, FALSE /* dy4 */,
 958                 TRUE /* dx5 */, FALSE /* dy5 */,
 959                 TRUE /* dx6 */, FALSE /* dy6 */
 960               };
 961
 962
 963               FT_TRACE4(( " hflex\n" ));
 964
 965               cf2_doFlex( opStack,
 966                           &curX,
 967                           &curY,
 968                           &glyphPath,
 969                           readFromStack,
 970                           FALSE /* doConditionalLastRead */ );
 971             }
 972             continue;
 973
 974           case cf2_escFLEX:
 975             {
 976               static const FT_Bool  readFromStack[12] =
 977               {
 978                 TRUE /* dx1 */, TRUE /* dy1 */,
 979                 TRUE /* dx2 */, TRUE /* dy2 */,
 980                 TRUE /* dx3 */, TRUE /* dy3 */,
 981                 TRUE /* dx4 */, TRUE /* dy4 */,
 982                 TRUE /* dx5 */, TRUE /* dy5 */,
 983                 TRUE /* dx6 */, TRUE /* dy6 */
 984               };
 985
 986
 987               FT_TRACE4(( " flex\n" ));
 988
 989               cf2_doFlex( opStack,
 990                           &curX,
 991                           &curY,
 992                           &glyphPath,
 993                           readFromStack,
 994                           FALSE /* doConditionalLastRead */ );
 995             }
 996             break;      /* TODO: why is this not a continue? */
 997
 998           case cf2_escHFLEX1:
 999             {
1000               static const FT_Bool  readFromStack[12] =
1001               {
1002                 TRUE /* dx1 */, TRUE  /* dy1 */,
1003                 TRUE /* dx2 */, TRUE  /* dy2 */,
1004                 TRUE /* dx3 */, FALSE /* dy3 */,
1005                 TRUE /* dx4 */, FALSE /* dy4 */,
1006                 TRUE /* dx5 */, TRUE  /* dy5 */,
1007                 TRUE /* dx6 */, FALSE /* dy6 */
1008               };
1009
1010
1011               FT_TRACE4(( " hflex1\n" ));
1012
1013               cf2_doFlex( opStack,
1014                           &curX,
1015                           &curY,
1016                           &glyphPath,
1017                           readFromStack,
1018                           FALSE /* doConditionalLastRead */ );
1019             }
1020             continue;
1021
1022           case cf2_escFLEX1:
1023             {
1024               static const FT_Bool  readFromStack[12] =
1025               {
1026                 TRUE  /* dx1 */, TRUE  /* dy1 */,
1027                 TRUE  /* dx2 */, TRUE  /* dy2 */,
1028                 TRUE  /* dx3 */, TRUE  /* dy3 */,
1029                 TRUE  /* dx4 */, TRUE  /* dy4 */,
1030                 TRUE  /* dx5 */, TRUE  /* dy5 */,
1031                 FALSE /* dx6 */, FALSE /* dy6 */
1032               };
1033
1034
1035               FT_TRACE4(( " flex1\n" ));
1036
1037               cf2_doFlex( opStack,
1038                           &curX,
1039                           &curY,
1040                           &glyphPath,
1041                           readFromStack,
1042                           TRUE /* doConditionalLastRead */ );
1043             }
1044             continue;
1045
1046           case cf2_escRESERVED_1:
1047           case cf2_escRESERVED_2:
1048           case cf2_escRESERVED_6:
1049           case cf2_escRESERVED_7:
1050           case cf2_escRESERVED_8:
1051           case cf2_escRESERVED_13:
1052           case cf2_escRESERVED_16:
1053           case cf2_escRESERVED_17:
1054           case cf2_escRESERVED_19:
1055           case cf2_escRESERVED_25:
1056           case cf2_escRESERVED_31:
1057           case cf2_escRESERVED_32:
1058           case cf2_escRESERVED_33:
1059           default:
1060             FT_TRACE4(( " unknown op (12, %d)\n", op2 ));
1061
1062           }; /* end of switch statement checking `op2' */
1063
1064         } /* case cf2_cmdESC */
1065         break;
1066
1067       case cf2_cmdENDCHAR:
1068         FT_TRACE4(( " endchar\n" ));
1069
1070         if ( cf2_stack_count( opStack ) == 1 ||
1071              cf2_stack_count( opStack ) == 5 )
1072         {
1073           if ( !haveWidth )
1074             *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;
1075         }
1076
1077         /* width is defined or default after this */
1078         haveWidth = TRUE;
1079
1080         if ( font->decoder->width_only )
1081             goto exit;
1082
1083         /* close path if still open */
1084         cf2_glyphpath_closeOpenPath( &glyphPath );
1085
1086         if ( cf2_stack_count( opStack ) > 1 )
1087         {
1088           /* must be either 4 or 5 --                       */
1089           /* this is a (deprecated) implied `seac' operator */
1090
1091           CF2_UInt       achar;
1092           CF2_UInt       bchar;
1093           CF2_BufferRec  component;
1094           CF2_Fixed      dummyWidth;   /* ignore component width */
1095           FT_Error       error2;
1096
1097
1098           if ( doingSeac )
1099           {
1100             lastError = FT_THROW( Invalid_Glyph_Format );
1101             goto exit;      /* nested seac */
1102           }
1103
1104           achar = cf2_stack_popInt( opStack );
1105           bchar = cf2_stack_popInt( opStack );
1106
1107           curY = cf2_stack_popFixed( opStack );
1108           curX = cf2_stack_popFixed( opStack );
1109
1110           error2 = cf2_getSeacComponent( decoder, achar, &component );
1111           if ( error2 )
1112           {
1113              lastError = error2;      /* pass FreeType error through */
1114              goto exit;
1115           }
1116           cf2_interpT2CharString( font,
1117                                   &component,
1118                                   callbacks,
1119                                   translation,
1120                                   TRUE,
1121                                   curX,
1122                                   curY,
1123                                   &dummyWidth );
1124           cf2_freeSeacComponent( decoder, &component );
1125
1126           error2 = cf2_getSeacComponent( decoder, bchar, &component );
1127           if ( error2 )
1128           {
1129             lastError = error2;      /* pass FreeType error through */
1130             goto exit;
1131           }
1132           cf2_interpT2CharString( font,
1133                                   &component,
1134                                   callbacks,
1135                                   translation,
1136                                   TRUE,
1137                                   0,
1138                                   0,
1139                                   &dummyWidth );
1140           cf2_freeSeacComponent( decoder, &component );
1141         }
1142         goto exit;
1143
1144       case cf2_cmdCNTRMASK:
1145       case cf2_cmdHINTMASK:
1146         /* the final \n in the tracing message gets added in      */
1147         /* `cf2_hintmask_read' (which also traces the mask bytes) */
1148         FT_TRACE4(( op1 == cf2_cmdCNTRMASK ? " cntrmask" : " hintmask" ));
1149
1150         /* never add hints after the mask is computed */
1151         if ( cf2_stack_count( opStack ) > 1    &&
1152              cf2_hintmask_isValid( &hintMask ) )
1153         {
1154           FT_TRACE4(( "cf2_interpT2CharString: invalid hint mask\n" ));
1155           break;
1156         }
1157
1158         /* if there are arguments on the stack, there this is an */
1159         /* implied cf2_cmdVSTEMHM                                */
1160         cf2_doStems( font,
1161                      opStack,
1162                      &vStemHintArray,
1163                      width,
1164                      &haveWidth,
1165                      0 );
1166
1167         if ( font->decoder->width_only )
1168             goto exit;
1169
1170         if ( op1 == cf2_cmdHINTMASK )
1171         {
1172           /* consume the hint mask bytes which follow the operator */
1173           cf2_hintmask_read( &hintMask,
1174                              charstring,
1175                              cf2_arrstack_size( &hStemHintArray ) +
1176                                cf2_arrstack_size( &vStemHintArray ) );
1177         }
1178         else
1179         {
1180           /*
1181            * Consume the counter mask bytes which follow the operator:
1182            * Build a temporary hint map, just to place and lock those
1183            * stems participating in the counter mask.  These are most
1184            * likely the dominant hstems, and are grouped together in a
1185            * few counter groups, not necessarily in correspondence
1186            * with the hint groups.  This reduces the chances of
1187            * conflicts between hstems that are initially placed in
1188            * separate hint groups and then brought together.  The
1189            * positions are copied back to `hStemHintArray', so we can
1190            * discard `counterMask' and `counterHintMap'.
1191            *
1192            */
1193           CF2_HintMapRec   counterHintMap;
1194           CF2_HintMaskRec  counterMask;
1195
1196
1197           cf2_hintmap_init( &counterHintMap,
1198                             font,
1199                             &glyphPath.initialHintMap,
1200                             &glyphPath.hintMoves,
1201                             scaleY );
1202           cf2_hintmask_init( &counterMask, error );
1203
1204           cf2_hintmask_read( &counterMask,
1205                              charstring,
1206                              cf2_arrstack_size( &hStemHintArray ) +
1207                                cf2_arrstack_size( &vStemHintArray ) );
1208           cf2_hintmap_build( &counterHintMap,
1209                              &hStemHintArray,
1210                              &vStemHintArray,
1211                              &counterMask,
1212                              0,
1213                              FALSE );
1214         }
1215         break;
1216
1217       case cf2_cmdRMOVETO:
1218         FT_TRACE4(( " rmoveto\n" ));
1219
1220         if ( cf2_stack_count( opStack ) > 2 && !haveWidth )
1221           *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;
1222
1223         /* width is defined or default after this */
1224         haveWidth = TRUE;
1225
1226         if ( font->decoder->width_only )
1227             goto exit;
1228
1229         curY += cf2_stack_popFixed( opStack );
1230         curX += cf2_stack_popFixed( opStack );
1231
1232         cf2_glyphpath_moveTo( &glyphPath, curX, curY );
1233
1234         break;
1235
1236       case cf2_cmdHMOVETO:
1237         FT_TRACE4(( " hmoveto\n" ));
1238
1239         if ( cf2_stack_count( opStack ) > 1 && !haveWidth )
1240           *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;
1241
1242         /* width is defined or default after this */
1243         haveWidth = TRUE;
1244
1245         if ( font->decoder->width_only )
1246             goto exit;
1247
1248         curX += cf2_stack_popFixed( opStack );
1249
1250         cf2_glyphpath_moveTo( &glyphPath, curX, curY );
1251
1252         break;
1253
1254       case cf2_cmdRLINECURVE:
1255         {
1256           CF2_UInt  count = cf2_stack_count( opStack );
1257           CF2_UInt  index = 0;
1258
1259
1260           FT_TRACE4(( " rlinecurve\n" ));
1261
1262           while ( index + 6 < count )
1263           {
1264             curX += cf2_stack_getReal( opStack, index + 0 );
1265             curY += cf2_stack_getReal( opStack, index + 1 );
1266
1267             cf2_glyphpath_lineTo( &glyphPath, curX, curY );
1268             index += 2;
1269           }
1270
1271           while ( index < count )
1272           {
1273             CF2_Fixed  x1 = cf2_stack_getReal( opStack, index + 0 ) + curX;
1274             CF2_Fixed  y1 = cf2_stack_getReal( opStack, index + 1 ) + curY;
1275             CF2_Fixed  x2 = cf2_stack_getReal( opStack, index + 2 ) + x1;
1276             CF2_Fixed  y2 = cf2_stack_getReal( opStack, index + 3 ) + y1;
1277             CF2_Fixed  x3 = cf2_stack_getReal( opStack, index + 4 ) + x2;
1278             CF2_Fixed  y3 = cf2_stack_getReal( opStack, index + 5 ) + y2;
1279
1280
1281             cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 );
1282
1283             curX   = x3;
1284             curY   = y3;
1285             index += 6;
1286           }
1287
1288           cf2_stack_clear( opStack );
1289         }
1290         continue; /* no need to clear stack again */
1291
1292       case cf2_cmdVVCURVETO:
1293         {
1294           CF2_UInt  count = cf2_stack_count( opStack );
1295           CF2_UInt  index = 0;
1296
1297
1298           FT_TRACE4(( " vvcurveto\n" ));
1299
1300           while ( index < count )
1301           {
1302             CF2_Fixed  x1, y1, x2, y2, x3, y3;
1303
1304
1305             if ( ( count - index ) & 1 )
1306             {
1307               x1 = cf2_stack_getReal( opStack, index ) + curX;
1308
1309               ++index;
1310             }
1311             else
1312               x1 = curX;
1313
1314             y1 = cf2_stack_getReal( opStack, index + 0 ) + curY;
1315             x2 = cf2_stack_getReal( opStack, index + 1 ) + x1;
1316             y2 = cf2_stack_getReal( opStack, index + 2 ) + y1;
1317             x3 = x2;
1318             y3 = cf2_stack_getReal( opStack, index + 3 ) + y2;
1319
1320             cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 );
1321
1322             curX   = x3;
1323             curY   = y3;
1324             index += 4;
1325           }
1326
1327           cf2_stack_clear( opStack );
1328         }
1329         continue; /* no need to clear stack again */
1330
1331       case cf2_cmdHHCURVETO:
1332         {
1333           CF2_UInt  count = cf2_stack_count( opStack );
1334           CF2_UInt  index = 0;
1335
1336
1337           FT_TRACE4(( " hhcurveto\n" ));
1338
1339           while ( index < count )
1340           {
1341             CF2_Fixed  x1, y1, x2, y2, x3, y3;
1342
1343
1344             if ( ( count - index ) & 1 )
1345             {
1346               y1 = cf2_stack_getReal( opStack, index ) + curY;
1347
1348               ++index;
1349             }
1350             else
1351               y1 = curY;
1352
1353             x1 = cf2_stack_getReal( opStack, index + 0 ) + curX;
1354             x2 = cf2_stack_getReal( opStack, index + 1 ) + x1;
1355             y2 = cf2_stack_getReal( opStack, index + 2 ) + y1;
1356             x3 = cf2_stack_getReal( opStack, index + 3 ) + x2;
1357             y3 = y2;
1358
1359             cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 );
1360
1361             curX   = x3;
1362             curY   = y3;
1363             index += 4;
1364           }
1365
1366           cf2_stack_clear( opStack );
1367         }
1368         continue; /* no need to clear stack again */
1369
1370       case cf2_cmdVHCURVETO:
1371       case cf2_cmdHVCURVETO:
1372         {
1373           CF2_UInt  count = cf2_stack_count( opStack );
1374           CF2_UInt  index = 0;
1375
1376           FT_Bool  alternate = op1 == cf2_cmdHVCURVETO;
1377
1378
1379           FT_TRACE4(( alternate ? " hvcurveto\n" : " vhcurveto\n" ));
1380
1381           while ( index < count )
1382           {
1383             CF2_Fixed x1, x2, x3, y1, y2, y3;
1384
1385
1386             if ( alternate )
1387             {
1388               x1 = cf2_stack_getReal( opStack, index + 0 ) + curX;
1389               y1 = curY;
1390               x2 = cf2_stack_getReal( opStack, index + 1 ) + x1;
1391               y2 = cf2_stack_getReal( opStack, index + 2 ) + y1;
1392               y3 = cf2_stack_getReal( opStack, index + 3 ) + y2;
1393
1394               if ( count - index == 5 )
1395               {
1396                 x3 = cf2_stack_getReal( opStack, index + 4 ) + x2;
1397
1398                 ++index;
1399               }
1400               else
1401                 x3 = x2;
1402
1403               alternate = FALSE;
1404             }
1405             else
1406             {
1407               x1 = curX;
1408               y1 = cf2_stack_getReal( opStack, index + 0 ) + curY;
1409               x2 = cf2_stack_getReal( opStack, index + 1 ) + x1;
1410               y2 = cf2_stack_getReal( opStack, index + 2 ) + y1;
1411               x3 = cf2_stack_getReal( opStack, index + 3 ) + x2;
1412
1413               if ( count - index == 5 )
1414               {
1415                 y3 = cf2_stack_getReal( opStack, index + 4 ) + y2;
1416
1417                 ++index;
1418               }
1419               else
1420                 y3 = y2;
1421
1422               alternate = TRUE;
1423             }
1424
1425             cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 );
1426
1427             curX   = x3;
1428             curY   = y3;
1429             index += 4;
1430           }
1431
1432           cf2_stack_clear( opStack );
1433         }
1434         continue;     /* no need to clear stack again */
1435
1436       case cf2_cmdEXTENDEDNMBR:
1437         {
1438           CF2_Int  v;
1439
1440
1441           v = (FT_Short)( ( cf2_buf_readByte( charstring ) << 8 ) |
1442                             cf2_buf_readByte( charstring )        );
1443
1444           FT_TRACE4(( " %d", v ));
1445
1446           cf2_stack_pushInt( opStack, v );
1447         }
1448         continue;
1449
1450       default:
1451         /* numbers */
1452         {
1453           if ( /* op1 >= 32 && */ op1 <= 246 )
1454           {
1455             CF2_Int  v;
1456
1457
1458             v = op1 - 139;
1459
1460             FT_TRACE4(( " %d", v ));
1461
1462             /* -107 .. 107 */
1463             cf2_stack_pushInt( opStack, v );
1464           }
1465
1466           else if ( /* op1 >= 247 && */ op1 <= 250 )
1467           {
1468             CF2_Int  v;
1469
1470
1471             v  = op1;
1472             v -= 247;
1473             v *= 256;
1474             v += cf2_buf_readByte( charstring );
1475             v += 108;
1476
1477             FT_TRACE4(( " %d", v ));
1478
1479             /* 108 .. 1131 */
1480             cf2_stack_pushInt( opStack, v );
1481           }
1482
1483           else if ( /* op1 >= 251 && */ op1 <= 254 )
1484           {
1485             CF2_Int  v;
1486
1487
1488             v  = op1;
1489             v -= 251;
1490             v *= 256;
1491             v += cf2_buf_readByte( charstring );
1492             v  = -v - 108;
1493
1494             FT_TRACE4(( " %d", v ));
1495
1496             /* -1131 .. -108 */
1497             cf2_stack_pushInt( opStack, v );
1498           }
1499
1500           else /* op1 == 255 */
1501           {
1502             CF2_Fixed  v;
1503
1504
1505             v = (CF2_Fixed)
1506                   ( ( (FT_UInt32)cf2_buf_readByte( charstring ) << 24 ) |
1507                     ( (FT_UInt32)cf2_buf_readByte( charstring ) << 16 ) |
1508                     ( (FT_UInt32)cf2_buf_readByte( charstring ) <<  8 ) |
1509                       (FT_UInt32)cf2_buf_readByte( charstring )         );
1510
1511             FT_TRACE4(( " %.2f", v / 65536.0 ));
1512
1513             cf2_stack_pushFixed( opStack, v );
1514           }
1515         }
1516         continue;   /* don't clear stack */
1517
1518       } /* end of switch statement checking `op1' */
1519
1520       cf2_stack_clear( opStack );
1521
1522     } /* end of main interpreter loop */
1523
1524     /* we get here if the charstring ends without cf2_cmdENDCHAR */
1525     FT_TRACE4(( "cf2_interpT2CharString:"
1526                 "  charstring ends without ENDCHAR\n" ));
1527
1528   exit:
1529     /* check whether last error seen is also the first one */
1530     cf2_setError( error, lastError );
1531
1532     /* free resources from objects we've used */
1533     cf2_glyphpath_finalize( &glyphPath );
1534     cf2_arrstack_finalize( &vStemHintArray );
1535     cf2_arrstack_finalize( &hStemHintArray );
1536     cf2_arrstack_finalize( &subrStack );
1537     cf2_stack_free( opStack );
1538
1539     FT_TRACE4(( "\n" ));
1540
1541     return;
1542   }
1543
1544
1545 /* END */