core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.c - Issue 815103002: Update freetype to 2.5.4.

Unified Diff: core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.c

Issue 815103002: Update freetype to 2.5.4. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: Adjust GYP and GN Created 6 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.h ('k') | core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2read.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.c

diff --git a/core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.c b/core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.c

deleted file mode 100644

index fc111000126648594a3cd760424054ed2496b0d3..0000000000000000000000000000000000000000

--- a/core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2intrp.c

+++ /dev/null

@@ -1,1549 +0,0 @@

-/***************************************************************************/

-/* */

-/* cf2intrp.c */

-/* */

-/* Adobe's CFF Interpreter (body). */

-/* */

-/* This software, and all works of authorship, whether in source or */

-/* object code form as indicated by the copyright notice(s) included */

-/* herein (collectively, the "Work") is made available, and may only be */

-/* used, modified, and distributed under the FreeType Project License, */

-/* LICENSE.TXT. Additionally, subject to the terms and conditions of the */

-/* FreeType Project License, each contributor to the Work hereby grants */

-/* to any individual or legal entity exercising permissions granted by */

-/* the FreeType Project License and this section (hereafter, "You" or */

-/* "Your") a perpetual, worldwide, non-exclusive, no-charge, */

-/* royalty-free, irrevocable (except as stated in this section) patent */

-/* license to make, have made, use, offer to sell, sell, import, and */

-/* otherwise transfer the Work, where such license applies only to those */

-/* patent claims licensable by such contributor that are necessarily */

-/* infringed by their contribution(s) alone or by combination of their */

-/* contribution(s) with the Work to which such contribution(s) was */

-/* submitted. If You institute patent litigation against any entity */

-/* (including a cross-claim or counterclaim in a lawsuit) alleging that */

-/* the Work or a contribution incorporated within the Work constitutes */

-/* direct or contributory patent infringement, then any patent licenses */

-/* granted to You under this License for that Work shall terminate as of */

-/* the date such litigation is filed. */

-/* */

-/* By using, modifying, or distributing the Work you indicate that you */

-/* have read and understood the terms and conditions of the */

-/* FreeType Project License as well as those provided in this section, */

-/* and you accept them fully. */

-/* */

-/***************************************************************************/

-#include "cf2ft.h"

-#include "../../include/freetype/internal/ftdebug.h"

-#include "cf2glue.h"

-#include "cf2font.h"

-#include "cf2stack.h"

-#include "cf2hints.h"

-#include "cf2error.h"

- /*************************************************************************/

- /* */

- /* The macro FT_COMPONENT is used in trace mode. It is an implicit */

- /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */

- /* messages during execution. */

- /* */

-#undef FT_COMPONENT

-#define FT_COMPONENT trace_cf2interp

- /* some operators are not implemented yet */

-#define CF2_FIXME FT_TRACE4(( "cf2_interpT2CharString:" \

- " operator not implemented yet\n" ))

- FT_LOCAL_DEF( void )

- cf2_hintmask_init( CF2_HintMask hintmask,

- FT_Error* error )

- {

- FT_ZERO( hintmask );

- hintmask->error = error;

- }

- FT_LOCAL_DEF( FT_Bool )

- cf2_hintmask_isValid( const CF2_HintMask hintmask )

- {

- return hintmask->isValid;

- }

- FT_LOCAL_DEF( FT_Bool )

- cf2_hintmask_isNew( const CF2_HintMask hintmask )

- {

- return hintmask->isNew;

- }

- FT_LOCAL_DEF( void )

- cf2_hintmask_setNew( CF2_HintMask hintmask,

- FT_Bool val )

- {

- hintmask->isNew = val;

- }

- /* clients call `getMaskPtr' in order to iterate */

- /* through hint mask */

- FT_LOCAL_DEF( FT_Byte* )

- cf2_hintmask_getMaskPtr( CF2_HintMask hintmask )

- {

- return hintmask->mask;

- }

- static size_t

- cf2_hintmask_setCounts( CF2_HintMask hintmask,

- size_t bitCount )

- {

- if ( bitCount > CF2_MAX_HINTS )

- {

- /* total of h and v stems must be <= 96 */

- CF2_SET_ERROR( hintmask->error, Invalid_Glyph_Format );

- return 0;

- }

- hintmask->bitCount = bitCount;

- hintmask->byteCount = ( hintmask->bitCount + 7 ) / 8;

- hintmask->isValid = TRUE;

- hintmask->isNew = TRUE;

- return bitCount;

- }

- /* consume the hintmask bytes from the charstring, advancing the src */

- /* pointer */

- static void

- cf2_hintmask_read( CF2_HintMask hintmask,

- CF2_Buffer charstring,

- size_t bitCount )

- {

- size_t i;

-#ifndef CF2_NDEBUG

- /* these are the bits in the final mask byte that should be zero */

- /* Note: this variable is only used in an assert expression below */

- /* and then only if CF2_NDEBUG is not defined */

- CF2_UInt mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;

-#endif

- /* initialize counts and isValid */

- if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )

- return;

- FT_ASSERT( hintmask->byteCount > 0 );

- FT_TRACE4(( " (maskbytes:" ));

- /* set mask and advance interpreter's charstring pointer */

- for ( i = 0; i < hintmask->byteCount; i++ )

- {

- hintmask->mask[i] = (FT_Byte)cf2_buf_readByte( charstring );

- FT_TRACE4(( " 0x%02X", hintmask->mask[i] ));

- }

- FT_TRACE4(( ")\n" ));

- /* assert any unused bits in last byte are zero unless there's a prior */

- /* error */

- /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */

-#ifndef CF2_NDEBUG

- FT_ASSERT( ( hintmask->mask[hintmask->byteCount - 1] & mask ) == 0 ||

- *hintmask->error );

-#endif

- }

- FT_LOCAL_DEF( void )

- cf2_hintmask_setAll( CF2_HintMask hintmask,

- size_t bitCount )

- {

- size_t i;

- CF2_UInt mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;

- /* initialize counts and isValid */

- if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )

- return;

- FT_ASSERT( hintmask->byteCount > 0 );

- FT_ASSERT( hintmask->byteCount <

- sizeof ( hintmask->mask ) / sizeof ( hintmask->mask[0] ) );

- /* set mask to all ones */

- for ( i = 0; i < hintmask->byteCount; i++ )

- hintmask->mask[i] = 0xFF;

- /* clear unused bits */

- /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */

- hintmask->mask[hintmask->byteCount - 1] &= ~mask;

- }

- /* Type2 charstring opcodes */

- enum

- {

- cf2_cmdRESERVED_0, /* 0 */

- cf2_cmdHSTEM, /* 1 */

- cf2_cmdRESERVED_2, /* 2 */

- cf2_cmdVSTEM, /* 3 */

- cf2_cmdVMOVETO, /* 4 */

- cf2_cmdRLINETO, /* 5 */

- cf2_cmdHLINETO, /* 6 */

- cf2_cmdVLINETO, /* 7 */

- cf2_cmdRRCURVETO, /* 8 */

- cf2_cmdRESERVED_9, /* 9 */

- cf2_cmdCALLSUBR, /* 10 */

- cf2_cmdRETURN, /* 11 */

- cf2_cmdESC, /* 12 */

- cf2_cmdRESERVED_13, /* 13 */

- cf2_cmdENDCHAR, /* 14 */

- cf2_cmdRESERVED_15, /* 15 */

- cf2_cmdRESERVED_16, /* 16 */

- cf2_cmdRESERVED_17, /* 17 */

- cf2_cmdHSTEMHM, /* 18 */

- cf2_cmdHINTMASK, /* 19 */

- cf2_cmdCNTRMASK, /* 20 */

- cf2_cmdRMOVETO, /* 21 */

- cf2_cmdHMOVETO, /* 22 */

- cf2_cmdVSTEMHM, /* 23 */

- cf2_cmdRCURVELINE, /* 24 */

- cf2_cmdRLINECURVE, /* 25 */

- cf2_cmdVVCURVETO, /* 26 */

- cf2_cmdHHCURVETO, /* 27 */

- cf2_cmdEXTENDEDNMBR, /* 28 */

- cf2_cmdCALLGSUBR, /* 29 */

- cf2_cmdVHCURVETO, /* 30 */

- cf2_cmdHVCURVETO /* 31 */

- };

- enum

- {

- cf2_escDOTSECTION, /* 0 */

- cf2_escRESERVED_1, /* 1 */

- cf2_escRESERVED_2, /* 2 */

- cf2_escAND, /* 3 */

- cf2_escOR, /* 4 */

- cf2_escNOT, /* 5 */

- cf2_escRESERVED_6, /* 6 */

- cf2_escRESERVED_7, /* 7 */

- cf2_escRESERVED_8, /* 8 */

- cf2_escABS, /* 9 */

- cf2_escADD, /* 10 like otherADD */

- cf2_escSUB, /* 11 like otherSUB */

- cf2_escDIV, /* 12 */

- cf2_escRESERVED_13, /* 13 */

- cf2_escNEG, /* 14 */

- cf2_escEQ, /* 15 */

- cf2_escRESERVED_16, /* 16 */

- cf2_escRESERVED_17, /* 17 */

- cf2_escDROP, /* 18 */

- cf2_escRESERVED_19, /* 19 */

- cf2_escPUT, /* 20 like otherPUT */

- cf2_escGET, /* 21 like otherGET */

- cf2_escIFELSE, /* 22 like otherIFELSE */

- cf2_escRANDOM, /* 23 like otherRANDOM */

- cf2_escMUL, /* 24 like otherMUL */

- cf2_escRESERVED_25, /* 25 */

- cf2_escSQRT, /* 26 */

- cf2_escDUP, /* 27 like otherDUP */

- cf2_escEXCH, /* 28 like otherEXCH */

- cf2_escINDEX, /* 29 */

- cf2_escROLL, /* 30 */

- cf2_escRESERVED_31, /* 31 */

- cf2_escRESERVED_32, /* 32 */

- cf2_escRESERVED_33, /* 33 */

- cf2_escHFLEX, /* 34 */

- cf2_escFLEX, /* 35 */

- cf2_escHFLEX1, /* 36 */

- cf2_escFLEX1 /* 37 */

- };

- /* `stemHintArray' does not change once we start drawing the outline. */

- static void

- cf2_doStems( const CF2_Font font,

- CF2_Stack opStack,

- CF2_ArrStack stemHintArray,

- CF2_Fixed* width,

- FT_Bool* haveWidth,

- CF2_Fixed hintOffset )

- {

- CF2_UInt i;

- CF2_UInt count = cf2_stack_count( opStack );

- FT_Bool hasWidthArg = (FT_Bool)( count & 1 );

- /* variable accumulates delta values from operand stack */

- CF2_Fixed position = hintOffset;

- if ( hasWidthArg && ! *haveWidth )

- *width = cf2_stack_getReal( opStack, 0 ) +

- cf2_getNominalWidthX( font->decoder );

- if ( font->decoder->width_only )

- goto exit;

- for ( i = hasWidthArg ? 1 : 0; i < count; i += 2 )

- {

- /* construct a CF2_StemHint and push it onto the list */

- CF2_StemHintRec stemhint;

- stemhint.min =

- position += cf2_stack_getReal( opStack, i );

- stemhint.max =

- position += cf2_stack_getReal( opStack, i + 1 );

- stemhint.used = FALSE;

- stemhint.maxDS =

- stemhint.minDS = 0;

- cf2_arrstack_push( stemHintArray, &stemhint ); /* defer error check */

- }

- cf2_stack_clear( opStack );

- exit:

- /* cf2_doStems must define a width (may be default) */

- *haveWidth = TRUE;

- }

- static void

- cf2_doFlex( CF2_Stack opStack,

- CF2_Fixed* curX,

- CF2_Fixed* curY,

- CF2_GlyphPath glyphPath,

- const FT_Bool* readFromStack,

- FT_Bool doConditionalLastRead )

- {

- CF2_Fixed vals[14];

- CF2_UInt index;

- FT_Bool isHFlex;

- CF2_Int top, i, j;

- vals[0] = *curX;

- vals[1] = *curY;

- index = 0;

- isHFlex = readFromStack[9] == FALSE;

- top = isHFlex ? 9 : 10;

- for ( i = 0; i < top; i++ )

- {

- vals[i + 2] = vals[i];

- if ( readFromStack[i] )

- vals[i + 2] += cf2_stack_getReal( opStack, index++ );

- }

- if ( isHFlex )

- vals[9 + 2] = *curY;

- if ( doConditionalLastRead )

- {

- FT_Bool lastIsX = (FT_Bool)( cf2_fixedAbs( vals[10] - *curX ) >

- cf2_fixedAbs( vals[11] - *curY ) );

- CF2_Fixed lastVal = cf2_stack_getReal( opStack, index );

- if ( lastIsX )

- {

- vals[12] = vals[10] + lastVal;

- vals[13] = *curY;

- }

- else

- {

- vals[12] = *curX;

- vals[13] = vals[11] + lastVal;

- }

- else

- {

- if ( readFromStack[10] )

- vals[12] = vals[10] + cf2_stack_getReal( opStack, index++ );

- else

- vals[12] = *curX;

- if ( readFromStack[11] )

- vals[13] = vals[11] + cf2_stack_getReal( opStack, index );

- else

- vals[13] = *curY;

- }

- for ( j = 0; j < 2; j++ )

- cf2_glyphpath_curveTo( glyphPath, vals[j * 6 + 2],

- vals[j * 6 + 3],

- vals[j * 6 + 4],

- vals[j * 6 + 5],

- vals[j * 6 + 6],

- vals[j * 6 + 7] );

- cf2_stack_clear( opStack );

- *curX = vals[12];

- *curY = vals[13];

- }

- /*

- * `error' is a shared error code used by many objects in this

- * routine. Before the code continues from an error, it must check and

- * record the error in `*error'. The idea is that this shared

- * error code will record the first error encountered. If testing

- * for an error anyway, the cost of `goto exit' is small, so we do it,

- * even if continuing would be safe. In this case, `lastError' is

- * set, so the testing and storing can be done in one place, at `exit'.

- *

- * Continuing after an error is intended for objects which do their own

- * testing of `*error', e.g., array stack functions. This allows us to

- * avoid an extra test after the call.

- *

- * Unimplemented opcodes are ignored.

- *

- */

- FT_LOCAL_DEF( void )

- cf2_interpT2CharString( CF2_Font font,

- CF2_Buffer buf,

- CF2_OutlineCallbacks callbacks,

- const FT_Vector* translation,

- FT_Bool doingSeac,

- CF2_Fixed curX,

- CF2_Fixed curY,

- CF2_Fixed* width )

- {

- /* lastError is used for errors that are immediately tested */

- FT_Error lastError = FT_Err_Ok;

- /* pointer to parsed font object */

- CFF_Decoder* decoder = font->decoder;

- FT_Error* error = &font->error;

- FT_Memory memory = font->memory;

- CF2_Fixed scaleY = font->innerTransform.d;

- CF2_Fixed nominalWidthX = cf2_getNominalWidthX( decoder );

- /* save this for hinting seac accents */

- CF2_Fixed hintOriginY = curY;

- CF2_Stack opStack = NULL;

- FT_Byte op1; /* first opcode byte */

- /* instruction limit; 20,000,000 matches Avalon */

- FT_UInt32 instructionLimit = 20000000UL;

- CF2_ArrStackRec subrStack;

- FT_Bool haveWidth;

- CF2_Buffer charstring = NULL;

- CF2_Int charstringIndex = -1; /* initialize to empty */

- /* TODO: placeholders for hint structures */

- /* objects used for hinting */

- CF2_ArrStackRec hStemHintArray;

- CF2_ArrStackRec vStemHintArray;

- CF2_HintMaskRec hintMask;

- CF2_GlyphPathRec glyphPath;

- /* initialize the remaining objects */

- cf2_arrstack_init( &subrStack,

- memory,

- error,

- sizeof ( CF2_BufferRec ) );

- cf2_arrstack_init( &hStemHintArray,

- memory,

- error,

- sizeof ( CF2_StemHintRec ) );

- cf2_arrstack_init( &vStemHintArray,

- memory,

- error,

- sizeof ( CF2_StemHintRec ) );

- /* initialize CF2_StemHint arrays */

- cf2_hintmask_init( &hintMask, error );

- /* initialize path map to manage drawing operations */

- /* Note: last 4 params are used to handle `MoveToPermissive', which */

- /* may need to call `hintMap.Build' */

- /* TODO: MoveToPermissive is gone; are these still needed? */

- cf2_glyphpath_init( &glyphPath,

- font,

- callbacks,

- scaleY,

- /* hShift, */

- &hStemHintArray,

- &vStemHintArray,

- &hintMask,

- hintOriginY,

- &font->blues,

- translation );

- /*

- * Initialize state for width parsing. From the CFF Spec:

- *

- * The first stack-clearing operator, which must be one of hstem,

- * hstemhm, vstem, vstemhm, cntrmask, hintmask, hmoveto, vmoveto,

- * rmoveto, or endchar, takes an additional argument - the width (as

- * described earlier), which may be expressed as zero or one numeric

- * argument.

- *

- * What we implement here uses the first validly specified width, but

- * does not detect errors for specifying more than one width.

- *

- * If one of the above operators occurs without explicitly specifying

- * a width, we assume the default width.

- *

- */

- haveWidth = FALSE;

- *width = cf2_getDefaultWidthX( decoder );

- /*

- * Note: at this point, all pointers to resources must be NULL

- * and all local objects must be initialized.

- * There must be no branches to exit: above this point.

- *

- */

- /* allocate an operand stack */

- opStack = cf2_stack_init( memory, error );

- if ( !opStack )

- {

- lastError = FT_THROW( Out_Of_Memory );

- goto exit;

- }

- /* initialize subroutine stack by placing top level charstring as */

- /* first element (max depth plus one for the charstring) */

- /* Note: Caller owns and must finalize the first charstring. */

- /* Our copy of it does not change that requirement. */

- cf2_arrstack_setCount( &subrStack, CF2_MAX_SUBR + 1 );

- charstring = (CF2_Buffer)cf2_arrstack_getBuffer( &subrStack );

- *charstring = *buf; /* structure copy */

- charstringIndex = 0; /* entry is valid now */

- /* catch errors so far */

- if ( *error )

- goto exit;

- /* main interpreter loop */

- while ( 1 )

- {

- if ( cf2_buf_isEnd( charstring ) )

- {

- /* If we've reached the end of the charstring, simulate a */

- /* cf2_cmdRETURN or cf2_cmdENDCHAR. */

- if ( charstringIndex )

- op1 = cf2_cmdRETURN; /* end of buffer for subroutine */

- else

- op1 = cf2_cmdENDCHAR; /* end of buffer for top level charstring */

- }

- else

- op1 = (FT_Byte)cf2_buf_readByte( charstring );

- /* check for errors once per loop */

- if ( *error )

- goto exit;

- instructionLimit--;

- if ( instructionLimit == 0 )

- {

- lastError = FT_THROW( Invalid_Glyph_Format );

- goto exit;

- }

- switch( op1 )

- {

- case cf2_cmdRESERVED_0:

- case cf2_cmdRESERVED_2:

- case cf2_cmdRESERVED_9:

- case cf2_cmdRESERVED_13:

- case cf2_cmdRESERVED_15:

- case cf2_cmdRESERVED_16:

- case cf2_cmdRESERVED_17:

- /* we may get here if we have a prior error */

- FT_TRACE4(( " unknown op (%d)\n", op1 ));

- break;

- case cf2_cmdHSTEMHM:

- case cf2_cmdHSTEM:

- FT_TRACE4(( op1 == cf2_cmdHSTEMHM ? " hstemhm\n" : " hstem\n" ));

- /* never add hints after the mask is computed */

- if ( cf2_hintmask_isValid( &hintMask ) )

- FT_TRACE4(( "cf2_interpT2CharString:"

- " invalid horizontal hint mask\n" ));

- cf2_doStems( font,

- opStack,

- &hStemHintArray,

- width,

- &haveWidth,

- 0 );

- if ( font->decoder->width_only )

- goto exit;

- break;

- case cf2_cmdVSTEMHM:

- case cf2_cmdVSTEM:

- FT_TRACE4(( op1 == cf2_cmdVSTEMHM ? " vstemhm\n" : " vstem\n" ));

- /* never add hints after the mask is computed */

- if ( cf2_hintmask_isValid( &hintMask ) )

- FT_TRACE4(( "cf2_interpT2CharString:"

- " invalid vertical hint mask\n" ));

- cf2_doStems( font,

- opStack,

- &vStemHintArray,

- width,

- &haveWidth,

- 0 );

- if ( font->decoder->width_only )

- goto exit;

- break;

- case cf2_cmdVMOVETO:

- FT_TRACE4(( " vmoveto\n" ));

- if ( cf2_stack_count( opStack ) > 1 && !haveWidth )

- *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;

- /* width is defined or default after this */

- haveWidth = TRUE;

- if ( font->decoder->width_only )

- goto exit;

- curY += cf2_stack_popFixed( opStack );

- cf2_glyphpath_moveTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- break;

- case cf2_cmdRLINETO:

- {

- CF2_UInt index;

- CF2_UInt count = cf2_stack_count( opStack );

- FT_TRACE4(( " rlineto\n" ));

- for ( index = 0; index < count; index += 2 )

- {

- curX += cf2_stack_getReal( opStack, index + 0 );

- curY += cf2_stack_getReal( opStack, index + 1 );

- cf2_glyphpath_lineTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- }

- cf2_stack_clear( opStack );

- }

- continue; /* no need to clear stack again */

- case cf2_cmdHLINETO:

- case cf2_cmdVLINETO:

- {

- CF2_UInt index;

- CF2_UInt count = cf2_stack_count( opStack );

- FT_Bool isX = op1 == cf2_cmdHLINETO;

- FT_TRACE4(( isX ? " hlineto\n" : " vlineto\n" ));

- for ( index = 0; index < count; index++ )

- {

- CF2_Fixed v = cf2_stack_getReal( opStack, index );

- if ( isX )

- curX += v;

- else

- curY += v;

- isX = !isX;

- cf2_glyphpath_lineTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- }

- cf2_stack_clear( opStack );

- }

- continue;

- case cf2_cmdRCURVELINE:

- case cf2_cmdRRCURVETO:

- {

- CF2_UInt count = cf2_stack_count( opStack );

- CF2_UInt index = 0;

- FT_TRACE4(( op1 == cf2_cmdRCURVELINE ? " rcurveline\n"

- : " rrcurveto\n" ));

- while ( index + 6 <= count )

- {

- CF2_Fixed x1 = cf2_stack_getReal( opStack, index + 0 ) + curX;

- CF2_Fixed y1 = cf2_stack_getReal( opStack, index + 1 ) + curY;

- CF2_Fixed x2 = cf2_stack_getReal( opStack, index + 2 ) + x1;

- CF2_Fixed y2 = cf2_stack_getReal( opStack, index + 3 ) + y1;

- CF2_Fixed x3 = cf2_stack_getReal( opStack, index + 4 ) + x2;

- CF2_Fixed y3 = cf2_stack_getReal( opStack, index + 5 ) + y2;

- cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- curX = x3;

- curY = y3;

- index += 6;

- }

- if ( op1 == cf2_cmdRCURVELINE )

- {

- curX += cf2_stack_getReal( opStack, index + 0 );

- curY += cf2_stack_getReal( opStack, index + 1 );

- cf2_glyphpath_lineTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- }

- cf2_stack_clear( opStack );

- }

- continue; /* no need to clear stack again */

- case cf2_cmdCALLGSUBR:

- case cf2_cmdCALLSUBR:

- {

- CF2_UInt subrIndex;

- FT_TRACE4(( op1 == cf2_cmdCALLGSUBR ? " callgsubr"

- : " callsubr" ));

- if ( charstringIndex > CF2_MAX_SUBR )

- {

- /* max subr plus one for charstring */

- lastError = FT_THROW( Invalid_Glyph_Format );

- goto exit; /* overflow of stack */

- }

- /* push our current CFF charstring region on subrStack */

- charstring = (CF2_Buffer)

- cf2_arrstack_getPointer( &subrStack,

- charstringIndex + 1 );

- /* set up the new CFF region and pointer */

- subrIndex = cf2_stack_popInt( opStack );

- switch ( op1 )

- {

- case cf2_cmdCALLGSUBR:

- FT_TRACE4(( "(%d)\n", subrIndex + decoder->globals_bias ));

- if ( cf2_initGlobalRegionBuffer( decoder,

- subrIndex,

- charstring ) )

- {

- lastError = FT_THROW( Invalid_Glyph_Format );

- goto exit; /* subroutine lookup or stream error */

- }

- break;

- default:

- /* cf2_cmdCALLSUBR */

- FT_TRACE4(( "(%d)\n", subrIndex + decoder->locals_bias ));

- if ( cf2_initLocalRegionBuffer( decoder,

- subrIndex,

- charstring ) )

- {

- lastError = FT_THROW( Invalid_Glyph_Format );

- goto exit; /* subroutine lookup or stream error */

- }

- charstringIndex += 1; /* entry is valid now */

- }

- continue; /* do not clear the stack */

- case cf2_cmdRETURN:

- FT_TRACE4(( " return\n" ));

- if ( charstringIndex < 1 )

- {

- /* Note: cannot return from top charstring */

- lastError = FT_THROW( Invalid_Glyph_Format );

- goto exit; /* underflow of stack */

- }

- /* restore position in previous charstring */

- charstring = (CF2_Buffer)

- cf2_arrstack_getPointer( &subrStack,

- --charstringIndex );

- continue; /* do not clear the stack */

- case cf2_cmdESC:

- {

- FT_Byte op2 = (FT_Byte)cf2_buf_readByte( charstring );

- switch ( op2 )

- {

- case cf2_escDOTSECTION:

- /* something about `flip type of locking' -- ignore it */

- FT_TRACE4(( " dotsection\n" ));

- break;

- /* TODO: should these operators be supported? */

- case cf2_escAND: /* in spec */

- FT_TRACE4(( " and\n" ));

- CF2_FIXME;

- break;

- case cf2_escOR: /* in spec */

- FT_TRACE4(( " or\n" ));

- CF2_FIXME;

- break;

- case cf2_escNOT: /* in spec */

- FT_TRACE4(( " not\n" ));

- CF2_FIXME;

- break;

- case cf2_escABS: /* in spec */

- FT_TRACE4(( " abs\n" ));

- CF2_FIXME;

- break;

- case cf2_escADD: /* in spec */

- FT_TRACE4(( " add\n" ));

- CF2_FIXME;

- break;

- case cf2_escSUB: /* in spec */

- FT_TRACE4(( " sub\n" ));

- CF2_FIXME;

- break;

- case cf2_escDIV: /* in spec */

- FT_TRACE4(( " div\n" ));

- CF2_FIXME;

- break;

- case cf2_escNEG: /* in spec */

- FT_TRACE4(( " neg\n" ));

- CF2_FIXME;

- break;

- case cf2_escEQ: /* in spec */

- FT_TRACE4(( " eq\n" ));

- CF2_FIXME;

- break;

- case cf2_escDROP: /* in spec */

- FT_TRACE4(( " drop\n" ));

- CF2_FIXME;

- break;

- case cf2_escPUT: /* in spec */

- FT_TRACE4(( " put\n" ));

- CF2_FIXME;

- break;

- case cf2_escGET: /* in spec */

- FT_TRACE4(( " get\n" ));

- CF2_FIXME;

- break;

- case cf2_escIFELSE: /* in spec */

- FT_TRACE4(( " ifelse\n" ));

- CF2_FIXME;

- break;

- case cf2_escRANDOM: /* in spec */

- FT_TRACE4(( " random\n" ));

- CF2_FIXME;

- break;

- case cf2_escMUL: /* in spec */

- FT_TRACE4(( " mul\n" ));

- CF2_FIXME;

- break;

- case cf2_escSQRT: /* in spec */

- FT_TRACE4(( " sqrt\n" ));

- CF2_FIXME;

- break;

- case cf2_escDUP: /* in spec */

- FT_TRACE4(( " dup\n" ));

- CF2_FIXME;

- break;

- case cf2_escEXCH: /* in spec */

- FT_TRACE4(( " exch\n" ));

- CF2_FIXME;

- break;

- case cf2_escINDEX: /* in spec */

- FT_TRACE4(( " index\n" ));

- CF2_FIXME;

- break;

- case cf2_escROLL: /* in spec */

- FT_TRACE4(( " roll\n" ));

- CF2_FIXME;

- break;

- case cf2_escHFLEX:

- {

- static const FT_Bool readFromStack[12] =

- {

- TRUE /* dx1 */, FALSE /* dy1 */,

- TRUE /* dx2 */, TRUE /* dy2 */,

- TRUE /* dx3 */, FALSE /* dy3 */,

- TRUE /* dx4 */, FALSE /* dy4 */,

- TRUE /* dx5 */, FALSE /* dy5 */,

- TRUE /* dx6 */, FALSE /* dy6 */

- };

- FT_TRACE4(( " hflex\n" ));

- cf2_doFlex( opStack,

- &curX,

- &curY,

- &glyphPath,

- readFromStack,

- FALSE /* doConditionalLastRead */ );

- }

- continue;

- case cf2_escFLEX:

- {

- static const FT_Bool readFromStack[12] =

- {

- TRUE /* dx1 */, TRUE /* dy1 */,

- TRUE /* dx2 */, TRUE /* dy2 */,

- TRUE /* dx3 */, TRUE /* dy3 */,

- TRUE /* dx4 */, TRUE /* dy4 */,

- TRUE /* dx5 */, TRUE /* dy5 */,

- TRUE /* dx6 */, TRUE /* dy6 */

- };

- FT_TRACE4(( " flex\n" ));

- cf2_doFlex( opStack,

- &curX,

- &curY,

- &glyphPath,

- readFromStack,

- FALSE /* doConditionalLastRead */ );

- }

- break; /* TODO: why is this not a continue? */

- case cf2_escHFLEX1:

- {

- static const FT_Bool readFromStack[12] =

- {

- TRUE /* dx1 */, TRUE /* dy1 */,

- TRUE /* dx2 */, TRUE /* dy2 */,

- TRUE /* dx3 */, FALSE /* dy3 */,

- TRUE /* dx4 */, FALSE /* dy4 */,

- TRUE /* dx5 */, TRUE /* dy5 */,

- TRUE /* dx6 */, FALSE /* dy6 */

- };

- FT_TRACE4(( " hflex1\n" ));

- cf2_doFlex( opStack,

- &curX,

- &curY,

- &glyphPath,

- readFromStack,

- FALSE /* doConditionalLastRead */ );

- }

- continue;

- case cf2_escFLEX1:

- {

- static const FT_Bool readFromStack[12] =

- {

- TRUE /* dx1 */, TRUE /* dy1 */,

- TRUE /* dx2 */, TRUE /* dy2 */,

- TRUE /* dx3 */, TRUE /* dy3 */,

- TRUE /* dx4 */, TRUE /* dy4 */,

- TRUE /* dx5 */, TRUE /* dy5 */,

- FALSE /* dx6 */, FALSE /* dy6 */

- };

- FT_TRACE4(( " flex1\n" ));

- cf2_doFlex( opStack,

- &curX,

- &curY,

- &glyphPath,

- readFromStack,

- TRUE /* doConditionalLastRead */ );

- }

- continue;

- case cf2_escRESERVED_1:

- case cf2_escRESERVED_2:

- case cf2_escRESERVED_6:

- case cf2_escRESERVED_7:

- case cf2_escRESERVED_8:

- case cf2_escRESERVED_13:

- case cf2_escRESERVED_16:

- case cf2_escRESERVED_17:

- case cf2_escRESERVED_19:

- case cf2_escRESERVED_25:

- case cf2_escRESERVED_31:

- case cf2_escRESERVED_32:

- case cf2_escRESERVED_33:

- default:

- FT_TRACE4(( " unknown op (12, %d)\n", op2 ));

- }; /* end of switch statement checking `op2' */

- } /* case cf2_cmdESC */

- break;

- case cf2_cmdENDCHAR:

- FT_TRACE4(( " endchar\n" ));

- if ( cf2_stack_count( opStack ) == 1 ||

- cf2_stack_count( opStack ) == 5 )

- {

- if ( !haveWidth )

- *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;

- }

- /* width is defined or default after this */

- haveWidth = TRUE;

- if ( font->decoder->width_only )

- goto exit;

- /* close path if still open */

- cf2_glyphpath_closeOpenPath( &glyphPath );

- if ( cf2_stack_count( opStack ) > 1 )

- {

- /* must be either 4 or 5 -- */

- /* this is a (deprecated) implied `seac' operator */

- CF2_UInt achar;

- CF2_UInt bchar;

- CF2_BufferRec component;

- CF2_Fixed dummyWidth; /* ignore component width */

- FT_Error error2;

- if ( doingSeac )

- {

- lastError = FT_THROW( Invalid_Glyph_Format );

- goto exit; /* nested seac */

- }

- achar = cf2_stack_popInt( opStack );

- bchar = cf2_stack_popInt( opStack );

- curY = cf2_stack_popFixed( opStack );

- curX = cf2_stack_popFixed( opStack );

- error2 = cf2_getSeacComponent( decoder, achar, &component );

- if ( error2 )

- {

- lastError = error2; /* pass FreeType error through */

- goto exit;

- }

- cf2_interpT2CharString( font,

- &component,

- callbacks,

- translation,

- TRUE,

- curX,

- curY,

- &dummyWidth );

- cf2_freeSeacComponent( decoder, &component );

- error2 = cf2_getSeacComponent( decoder, bchar, &component );

- if ( error2 )

- {

- lastError = error2; /* pass FreeType error through */

- goto exit;

- }

- cf2_interpT2CharString( font,

- &component,

- callbacks,

- translation,

- TRUE,

- 0,

- &dummyWidth );

- cf2_freeSeacComponent( decoder, &component );

- }

- goto exit;

- case cf2_cmdCNTRMASK:

- case cf2_cmdHINTMASK:

- /* the final \n in the tracing message gets added in */

- /* `cf2_hintmask_read' (which also traces the mask bytes) */

- FT_TRACE4(( op1 == cf2_cmdCNTRMASK ? " cntrmask" : " hintmask" ));

- /* if there are arguments on the stack, there this is an */

- /* implied cf2_cmdVSTEMHM */

- if ( cf2_stack_count( opStack ) != 0 )

- {

- /* never add hints after the mask is computed */

- if ( cf2_hintmask_isValid( &hintMask ) )

- FT_TRACE4(( "cf2_interpT2CharString: invalid hint mask\n" ));

- }

- cf2_doStems( font,

- opStack,

- &vStemHintArray,

- width,

- &haveWidth,

- 0 );

- if ( font->decoder->width_only )

- goto exit;

- if ( op1 == cf2_cmdHINTMASK )

- {

- /* consume the hint mask bytes which follow the operator */

- cf2_hintmask_read( &hintMask,

- charstring,

- cf2_arrstack_size( &hStemHintArray ) +

- cf2_arrstack_size( &vStemHintArray ) );

- }

- else

- {

- /*

- * Consume the counter mask bytes which follow the operator:

- * Build a temporary hint map, just to place and lock those

- * stems participating in the counter mask. These are most

- * likely the dominant hstems, and are grouped together in a

- * few counter groups, not necessarily in correspondence

- * with the hint groups. This reduces the chances of

- * conflicts between hstems that are initially placed in

- * separate hint groups and then brought together. The

- * positions are copied back to `hStemHintArray', so we can

- * discard `counterMask' and `counterHintMap'.

- *

- */

- CF2_HintMapRec counterHintMap;

- CF2_HintMaskRec counterMask;

- cf2_hintmap_init( &counterHintMap,

- font,

- &glyphPath.initialHintMap,

- &glyphPath.hintMoves,

- scaleY );

- cf2_hintmask_init( &counterMask, error );

- cf2_hintmask_read( &counterMask,

- charstring,

- cf2_arrstack_size( &hStemHintArray ) +

- cf2_arrstack_size( &vStemHintArray ) );

- cf2_hintmap_build( &counterHintMap,

- &hStemHintArray,

- &vStemHintArray,

- &counterMask,

- 0,

- FALSE );

- }

- break;

- case cf2_cmdRMOVETO:

- FT_TRACE4(( " rmoveto\n" ));

- if ( cf2_stack_count( opStack ) > 2 && !haveWidth )

- *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;

- /* width is defined or default after this */

- haveWidth = TRUE;

- if ( font->decoder->width_only )

- goto exit;

- curY += cf2_stack_popFixed( opStack );

- curX += cf2_stack_popFixed( opStack );

- cf2_glyphpath_moveTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- break;

- case cf2_cmdHMOVETO:

- FT_TRACE4(( " hmoveto\n" ));

- if ( cf2_stack_count( opStack ) > 1 && !haveWidth )

- *width = cf2_stack_getReal( opStack, 0 ) + nominalWidthX;

- /* width is defined or default after this */

- haveWidth = TRUE;

- if ( font->decoder->width_only )

- goto exit;

- curX += cf2_stack_popFixed( opStack );

- cf2_glyphpath_moveTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- break;

- case cf2_cmdRLINECURVE:

- {

- CF2_UInt count = cf2_stack_count( opStack );

- CF2_UInt index = 0;

- FT_TRACE4(( " rlinecurve\n" ));

- while ( index + 6 < count )

- {

- curX += cf2_stack_getReal( opStack, index + 0 );

- curY += cf2_stack_getReal( opStack, index + 1 );

- cf2_glyphpath_lineTo( &glyphPath, curX, curY );

- if (glyphPath.callbacks && glyphPath.callbacks->error && *glyphPath.callbacks->error) goto exit;

- index += 2;

- }

- while ( index < count )