/***************************************************************************/ | |
/* */ | |
/* cf2intrp.c */ | |
/* */ | |
/* Adobe's CFF Interpreter (body). */ | |
/* */ | |
/* Copyright 2007-2014 Adobe Systems Incorporated. */ | |
/* */ | |
/* 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 FT_INTERNAL_DEBUG_H | |
#include "cf2glue.h" | |
#include "cf2font.h" | |
#include "cf2stack.h" | |
#include "cf2hints.h" | |
#include "cf2intrp.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" )); | |
break; | |
} | |
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" )); | |
break; | |
} | |
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 ); | |
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 ); | |
} | |
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 ); | |
} | |
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 ); | |
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 ); | |
} | |
cf2_stack_clear( opStack ); | |
} | |
continue; /* no need to clear stack again */ | |
case cf2_cmdCALLGSUBR: | |
case cf2_cmdCALLSUBR: | |
{ | |
CF2_Int subrNum; | |
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, | |
(size_t)charstringIndex + 1 ); | |
/* set up the new CFF region and pointer */ | |
subrNum = cf2_stack_popInt( opStack ); | |
switch ( op1 ) | |
{ | |
case cf2_cmdCALLGSUBR: | |
FT_TRACE4(( " (idx %d, entering level %d)\n", | |
subrNum + decoder->globals_bias, | |
charstringIndex + 1 )); | |
if ( cf2_initGlobalRegionBuffer( decoder, | |
subrNum, | |
charstring ) ) | |
{ | |
lastError = FT_THROW( Invalid_Glyph_Format ); | |
goto exit; /* subroutine lookup or stream error */ | |
} | |
break; | |
default: | |
/* cf2_cmdCALLSUBR */ | |
FT_TRACE4(( " (idx %d, entering level %d)\n", | |
subrNum + decoder->locals_bias, | |
charstringIndex + 1 )); | |
if ( cf2_initLocalRegionBuffer( decoder, | |
subrNum, | |
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 (leaving level %d)\n", charstringIndex )); | |
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, | |
(CF2_UInt)--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_Int achar; | |
CF2_Int 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, | |
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" )); | |
/* never add hints after the mask is computed */ | |
if ( cf2_stack_count( opStack ) > 1 && | |
cf2_hintmask_isValid( &hintMask ) ) | |
{ | |
FT_TRACE4(( "cf2_interpT2CharString: invalid hint mask\n" )); | |
break; | |
} | |
/* if there are arguments on the stack, there this is an */ | |
/* implied cf2_cmdVSTEMHM */ | |
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 ); | |
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 ); | |
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 ); | |
index += 2; | |
} | |
while ( index < 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 ); | |
curX = x3; | |
curY = y3; | |
index += 6; | |
} | |
cf2_stack_clear( opStack ); | |
} | |
continue; /* no need to clear stack again */ | |
case cf2_cmdVVCURVETO: | |
{ | |
CF2_UInt count, count1 = cf2_stack_count( opStack ); | |
CF2_UInt index = 0; | |
/* if `cf2_stack_count' isn't of the form 4n or 4n+1, */ | |
/* we enforce it by clearing the second bit */ | |
/* (and sorting the stack indexing to suit) */ | |
count = count1 & ~2U; | |
index += count1 - count; | |
FT_TRACE4(( " vvcurveto\n" )); | |
while ( index < count ) | |
{ | |
CF2_Fixed x1, y1, x2, y2, x3, y3; | |
if ( ( count - index ) & 1 ) | |
{ | |
x1 = cf2_stack_getReal( opStack, index ) + curX; | |
++index; | |
} | |
else | |
x1 = curX; | |
y1 = cf2_stack_getReal( opStack, index + 0 ) + curY; | |
x2 = cf2_stack_getReal( opStack, index + 1 ) + x1; | |
y2 = cf2_stack_getReal( opStack, index + 2 ) + y1; | |
x3 = x2; | |
y3 = cf2_stack_getReal( opStack, index + 3 ) + y2; | |
cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 ); | |
curX = x3; | |
curY = y3; | |
index += 4; | |
} | |
cf2_stack_clear( opStack ); | |
} | |
continue; /* no need to clear stack again */ | |
case cf2_cmdHHCURVETO: | |
{ | |
CF2_UInt count, count1 = cf2_stack_count( opStack ); | |
CF2_UInt index = 0; | |
/* if `cf2_stack_count' isn't of the form 4n or 4n+1, */ | |
/* we enforce it by clearing the second bit */ | |
/* (and sorting the stack indexing to suit) */ | |
count = count1 & ~2U; | |
index += count1 - count; | |
FT_TRACE4(( " hhcurveto\n" )); | |
while ( index < count ) | |
{ | |
CF2_Fixed x1, y1, x2, y2, x3, y3; | |
if ( ( count - index ) & 1 ) | |
{ | |
y1 = cf2_stack_getReal( opStack, index ) + curY; | |
++index; | |
} | |
else | |
y1 = curY; | |
x1 = cf2_stack_getReal( opStack, index + 0 ) + curX; | |
x2 = cf2_stack_getReal( opStack, index + 1 ) + x1; | |
y2 = cf2_stack_getReal( opStack, index + 2 ) + y1; | |
x3 = cf2_stack_getReal( opStack, index + 3 ) + x2; | |
y3 = y2; | |
cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 ); | |
curX = x3; | |
curY = y3; | |
index += 4; | |
} | |
cf2_stack_clear( opStack ); | |
} | |
continue; /* no need to clear stack again */ | |
case cf2_cmdVHCURVETO: | |
case cf2_cmdHVCURVETO: | |
{ | |
CF2_UInt count, count1 = cf2_stack_count( opStack ); | |
CF2_UInt index = 0; | |
FT_Bool alternate = op1 == cf2_cmdHVCURVETO; | |
/* if `cf2_stack_count' isn't of the form 8n, 8n+1, */ | |
/* 8n+4, or 8n+5, we enforce it by clearing the */ | |
/* second bit */ | |
/* (and sorting the stack indexing to suit) */ | |
count = count1 & ~2U; | |
index += count1 - count; | |
FT_TRACE4(( alternate ? " hvcurveto\n" : " vhcurveto\n" )); | |
while ( index < count ) | |
{ | |
CF2_Fixed x1, x2, x3, y1, y2, y3; | |
if ( alternate ) | |
{ | |
x1 = cf2_stack_getReal( opStack, index + 0 ) + curX; | |
y1 = curY; | |
x2 = cf2_stack_getReal( opStack, index + 1 ) + x1; | |
y2 = cf2_stack_getReal( opStack, index + 2 ) + y1; | |
y3 = cf2_stack_getReal( opStack, index + 3 ) + y2; | |
if ( count - index == 5 ) | |
{ | |
x3 = cf2_stack_getReal( opStack, index + 4 ) + x2; | |
++index; | |
} | |
else | |
x3 = x2; | |
alternate = FALSE; | |
} | |
else | |
{ | |
x1 = curX; | |
y1 = cf2_stack_getReal( opStack, index + 0 ) + curY; | |
x2 = cf2_stack_getReal( opStack, index + 1 ) + x1; | |
y2 = cf2_stack_getReal( opStack, index + 2 ) + y1; | |
x3 = cf2_stack_getReal( opStack, index + 3 ) + x2; | |
if ( count - index == 5 ) | |
{ | |
y3 = cf2_stack_getReal( opStack, index + 4 ) + y2; | |
++index; | |
} | |
else | |
y3 = y2; | |
alternate = TRUE; | |
} | |
cf2_glyphpath_curveTo( &glyphPath, x1, y1, x2, y2, x3, y3 ); | |
curX = x3; | |
curY = y3; | |
index += 4; | |
} | |
cf2_stack_clear( opStack ); | |
} | |
continue; /* no need to clear stack again */ | |
case cf2_cmdEXTENDEDNMBR: | |
{ | |
CF2_Int v; | |
#if defined(COBALT) | |
// NOTE: This code is modified as a result of gcc processing | |
// the second cf2_buf_readByte before the first, causing the glyph | |
// to fail. | |
CF2_Int byte1 = cf2_buf_readByte( charstring ); | |
CF2_Int byte2 = cf2_buf_readByte( charstring ); | |
v = (FT_Short)( ( byte1 << 8 ) | | |
byte2 ); | |
#else | |
v = (FT_Short)( ( cf2_buf_readByte( charstring ) << 8 ) | | |
cf2_buf_readByte( charstring ) ); | |
#endif | |
FT_TRACE4(( " %d", v )); | |
cf2_stack_pushInt( opStack, v ); | |
} | |
continue; | |
default: | |
/* numbers */ | |
{ | |
if ( /* op1 >= 32 && */ op1 <= 246 ) | |
{ | |
CF2_Int v; | |
v = op1 - 139; | |
FT_TRACE4(( " %d", v )); | |
/* -107 .. 107 */ | |
cf2_stack_pushInt( opStack, v ); | |
} | |
else if ( /* op1 >= 247 && */ op1 <= 250 ) | |
{ | |
CF2_Int v; | |
v = op1; | |
v -= 247; | |
v *= 256; | |
v += cf2_buf_readByte( charstring ); | |
v += 108; | |
FT_TRACE4(( " %d", v )); | |
/* 108 .. 1131 */ | |
cf2_stack_pushInt( opStack, v ); | |
} | |
else if ( /* op1 >= 251 && */ op1 <= 254 ) | |
{ | |
CF2_Int v; | |
v = op1; | |
v -= 251; | |
v *= 256; | |
v += cf2_buf_readByte( charstring ); | |
v = -v - 108; | |
FT_TRACE4(( " %d", v )); | |
/* -1131 .. -108 */ | |
cf2_stack_pushInt( opStack, v ); | |
} | |
else /* op1 == 255 */ | |
{ | |
CF2_Fixed v; | |
#if defined(COBALT) | |
// NOTE: This code is modified as a result of gcc not | |
// processing the cf2_buf_readByte's from left to right, causing | |
// the glyph to fail. | |
FT_UInt32 byte1 = (FT_UInt32)cf2_buf_readByte( charstring ); | |
FT_UInt32 byte2 = (FT_UInt32)cf2_buf_readByte( charstring ); | |
FT_UInt32 byte3 = (FT_UInt32)cf2_buf_readByte( charstring ); | |
FT_UInt32 byte4 = (FT_UInt32)cf2_buf_readByte( charstring ); | |
v = (CF2_Fixed) | |
( ( byte1 << 24 ) | | |
( byte2 << 16 ) | | |
( byte3 << 8 ) | | |
byte4 ); | |
#else | |
v = (CF2_Fixed) | |
( ( (FT_UInt32)cf2_buf_readByte( charstring ) << 24 ) | | |
( (FT_UInt32)cf2_buf_readByte( charstring ) << 16 ) | | |
( (FT_UInt32)cf2_buf_readByte( charstring ) << 8 ) | | |
(FT_UInt32)cf2_buf_readByte( charstring ) ); | |
#endif | |
FT_TRACE4(( " %.2f", v / 65536.0 )); | |
cf2_stack_pushFixed( opStack, v ); | |
} | |
} | |
continue; /* don't clear stack */ | |
} /* end of switch statement checking `op1' */ | |
cf2_stack_clear( opStack ); | |
} /* end of main interpreter loop */ | |
/* we get here if the charstring ends without cf2_cmdENDCHAR */ | |
FT_TRACE4(( "cf2_interpT2CharString:" | |
" charstring ends without ENDCHAR\n" )); | |
exit: | |
/* check whether last error seen is also the first one */ | |
cf2_setError( error, lastError ); | |
/* free resources from objects we've used */ | |
cf2_glyphpath_finalize( &glyphPath ); | |
cf2_arrstack_finalize( &vStemHintArray ); | |
cf2_arrstack_finalize( &hStemHintArray ); | |
cf2_arrstack_finalize( &subrStack ); | |
cf2_stack_free( opStack ); | |
FT_TRACE4(( "\n" )); | |
return; | |
} | |
/* END */ |