| /**************************************************************************** |
| * |
| * ttinterp.c |
| * |
| * TrueType bytecode interpreter (body). |
| * |
| * Copyright 1996-2018 by |
| * David Turner, Robert Wilhelm, and Werner Lemberg. |
| * |
| * This file is part of the FreeType project, and may only be used, |
| * modified, and distributed under the terms of the FreeType project |
| * license, LICENSE.TXT. By continuing to use, modify, or distribute |
| * this file you indicate that you have read the license and |
| * understand and accept it fully. |
| * |
| */ |
| |
| |
| /* Greg Hitchcock from Microsoft has helped a lot in resolving unclear */ |
| /* issues; many thanks! */ |
| |
| |
| #include <ft2build.h> |
| #include FT_INTERNAL_DEBUG_H |
| #include FT_INTERNAL_CALC_H |
| #include FT_TRIGONOMETRY_H |
| #include FT_SYSTEM_H |
| #include FT_DRIVER_H |
| #include FT_MULTIPLE_MASTERS_H |
| |
| #include "ttinterp.h" |
| #include "tterrors.h" |
| #include "ttsubpix.h" |
| #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
| #include "ttgxvar.h" |
| #endif |
| |
| |
| #ifdef TT_USE_BYTECODE_INTERPRETER |
| |
| |
| /************************************************************************** |
| * |
| * 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_ttinterp |
| |
| |
| #define NO_SUBPIXEL_HINTING \ |
| ( ((TT_Driver)FT_FACE_DRIVER( exc->face ))->interpreter_version == \ |
| TT_INTERPRETER_VERSION_35 ) |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| #define SUBPIXEL_HINTING_INFINALITY \ |
| ( ((TT_Driver)FT_FACE_DRIVER( exc->face ))->interpreter_version == \ |
| TT_INTERPRETER_VERSION_38 ) |
| #endif |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| #define SUBPIXEL_HINTING_MINIMAL \ |
| ( ((TT_Driver)FT_FACE_DRIVER( exc->face ))->interpreter_version == \ |
| TT_INTERPRETER_VERSION_40 ) |
| #endif |
| |
| #define PROJECT( v1, v2 ) \ |
| exc->func_project( exc, \ |
| SUB_LONG( (v1)->x, (v2)->x ), \ |
| SUB_LONG( (v1)->y, (v2)->y ) ) |
| |
| #define DUALPROJ( v1, v2 ) \ |
| exc->func_dualproj( exc, \ |
| SUB_LONG( (v1)->x, (v2)->x ), \ |
| SUB_LONG( (v1)->y, (v2)->y ) ) |
| |
| #define FAST_PROJECT( v ) \ |
| exc->func_project( exc, (v)->x, (v)->y ) |
| |
| #define FAST_DUALPROJ( v ) \ |
| exc->func_dualproj( exc, (v)->x, (v)->y ) |
| |
| |
| /************************************************************************** |
| * |
| * Two simple bounds-checking macros. |
| */ |
| #define BOUNDS( x, n ) ( (FT_UInt)(x) >= (FT_UInt)(n) ) |
| #define BOUNDSL( x, n ) ( (FT_ULong)(x) >= (FT_ULong)(n) ) |
| |
| |
| #undef SUCCESS |
| #define SUCCESS 0 |
| |
| #undef FAILURE |
| #define FAILURE 1 |
| |
| |
| /************************************************************************** |
| * |
| * CODERANGE FUNCTIONS |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Goto_CodeRange |
| * |
| * @Description: |
| * Switches to a new code range (updates the code related elements in |
| * `exec', and `IP'). |
| * |
| * @Input: |
| * range :: |
| * The new execution code range. |
| * |
| * IP :: |
| * The new IP in the new code range. |
| * |
| * @InOut: |
| * exec :: |
| * The target execution context. |
| */ |
| FT_LOCAL_DEF( void ) |
| TT_Goto_CodeRange( TT_ExecContext exec, |
| FT_Int range, |
| FT_Long IP ) |
| { |
| TT_CodeRange* coderange; |
| |
| |
| FT_ASSERT( range >= 1 && range <= 3 ); |
| |
| coderange = &exec->codeRangeTable[range - 1]; |
| |
| FT_ASSERT( coderange->base ); |
| |
| /* NOTE: Because the last instruction of a program may be a CALL */ |
| /* which will return to the first byte *after* the code */ |
| /* range, we test for IP <= Size instead of IP < Size. */ |
| /* */ |
| FT_ASSERT( IP <= coderange->size ); |
| |
| exec->code = coderange->base; |
| exec->codeSize = coderange->size; |
| exec->IP = IP; |
| exec->curRange = range; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Set_CodeRange |
| * |
| * @Description: |
| * Sets a code range. |
| * |
| * @Input: |
| * range :: |
| * The code range index. |
| * |
| * base :: |
| * The new code base. |
| * |
| * length :: |
| * The range size in bytes. |
| * |
| * @InOut: |
| * exec :: |
| * The target execution context. |
| */ |
| FT_LOCAL_DEF( void ) |
| TT_Set_CodeRange( TT_ExecContext exec, |
| FT_Int range, |
| void* base, |
| FT_Long length ) |
| { |
| FT_ASSERT( range >= 1 && range <= 3 ); |
| |
| exec->codeRangeTable[range - 1].base = (FT_Byte*)base; |
| exec->codeRangeTable[range - 1].size = length; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Clear_CodeRange |
| * |
| * @Description: |
| * Clears a code range. |
| * |
| * @Input: |
| * range :: |
| * The code range index. |
| * |
| * @InOut: |
| * exec :: |
| * The target execution context. |
| */ |
| FT_LOCAL_DEF( void ) |
| TT_Clear_CodeRange( TT_ExecContext exec, |
| FT_Int range ) |
| { |
| FT_ASSERT( range >= 1 && range <= 3 ); |
| |
| exec->codeRangeTable[range - 1].base = NULL; |
| exec->codeRangeTable[range - 1].size = 0; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * EXECUTION CONTEXT ROUTINES |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Done_Context |
| * |
| * @Description: |
| * Destroys a given context. |
| * |
| * @Input: |
| * exec :: |
| * A handle to the target execution context. |
| * |
| * memory :: |
| * A handle to the parent memory object. |
| * |
| * @Note: |
| * Only the glyph loader and debugger should call this function. |
| */ |
| FT_LOCAL_DEF( void ) |
| TT_Done_Context( TT_ExecContext exec ) |
| { |
| FT_Memory memory = exec->memory; |
| |
| |
| /* points zone */ |
| exec->maxPoints = 0; |
| exec->maxContours = 0; |
| |
| /* free stack */ |
| FT_FREE( exec->stack ); |
| exec->stackSize = 0; |
| |
| /* free call stack */ |
| FT_FREE( exec->callStack ); |
| exec->callSize = 0; |
| exec->callTop = 0; |
| |
| /* free glyph code range */ |
| FT_FREE( exec->glyphIns ); |
| exec->glyphSize = 0; |
| |
| exec->size = NULL; |
| exec->face = NULL; |
| |
| FT_FREE( exec ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Init_Context |
| * |
| * @Description: |
| * Initializes a context object. |
| * |
| * @Input: |
| * memory :: |
| * A handle to the parent memory object. |
| * |
| * @InOut: |
| * exec :: |
| * A handle to the target execution context. |
| * |
| * @Return: |
| * FreeType error code. 0 means success. |
| */ |
| static FT_Error |
| Init_Context( TT_ExecContext exec, |
| FT_Memory memory ) |
| { |
| FT_Error error; |
| |
| |
| FT_TRACE1(( "Init_Context: new object at 0x%08p\n", exec )); |
| |
| exec->memory = memory; |
| exec->callSize = 32; |
| |
| if ( FT_NEW_ARRAY( exec->callStack, exec->callSize ) ) |
| goto Fail_Memory; |
| |
| /* all values in the context are set to 0 already, but this is */ |
| /* here as a remainder */ |
| exec->maxPoints = 0; |
| exec->maxContours = 0; |
| |
| exec->stackSize = 0; |
| exec->glyphSize = 0; |
| |
| exec->stack = NULL; |
| exec->glyphIns = NULL; |
| |
| exec->face = NULL; |
| exec->size = NULL; |
| |
| return FT_Err_Ok; |
| |
| Fail_Memory: |
| FT_ERROR(( "Init_Context: not enough memory for %p\n", exec )); |
| TT_Done_Context( exec ); |
| |
| return error; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Update_Max |
| * |
| * @Description: |
| * Checks the size of a buffer and reallocates it if necessary. |
| * |
| * @Input: |
| * memory :: |
| * A handle to the parent memory object. |
| * |
| * multiplier :: |
| * The size in bytes of each element in the buffer. |
| * |
| * new_max :: |
| * The new capacity (size) of the buffer. |
| * |
| * @InOut: |
| * size :: |
| * The address of the buffer's current size expressed |
| * in elements. |
| * |
| * buff :: |
| * The address of the buffer base pointer. |
| * |
| * @Return: |
| * FreeType error code. 0 means success. |
| */ |
| FT_LOCAL_DEF( FT_Error ) |
| Update_Max( FT_Memory memory, |
| FT_ULong* size, |
| FT_ULong multiplier, |
| void* _pbuff, |
| FT_ULong new_max ) |
| { |
| FT_Error error; |
| void** pbuff = (void**)_pbuff; |
| |
| |
| if ( *size < new_max ) |
| { |
| if ( FT_REALLOC( *pbuff, *size * multiplier, new_max * multiplier ) ) |
| return error; |
| *size = new_max; |
| } |
| |
| return FT_Err_Ok; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Load_Context |
| * |
| * @Description: |
| * Prepare an execution context for glyph hinting. |
| * |
| * @Input: |
| * face :: |
| * A handle to the source face object. |
| * |
| * size :: |
| * A handle to the source size object. |
| * |
| * @InOut: |
| * exec :: |
| * A handle to the target execution context. |
| * |
| * @Return: |
| * FreeType error code. 0 means success. |
| * |
| * @Note: |
| * Only the glyph loader and debugger should call this function. |
| */ |
| FT_LOCAL_DEF( FT_Error ) |
| TT_Load_Context( TT_ExecContext exec, |
| TT_Face face, |
| TT_Size size ) |
| { |
| FT_Int i; |
| FT_ULong tmp; |
| TT_MaxProfile* maxp; |
| FT_Error error; |
| |
| |
| exec->face = face; |
| maxp = &face->max_profile; |
| exec->size = size; |
| |
| if ( size ) |
| { |
| exec->numFDefs = size->num_function_defs; |
| exec->maxFDefs = size->max_function_defs; |
| exec->numIDefs = size->num_instruction_defs; |
| exec->maxIDefs = size->max_instruction_defs; |
| exec->FDefs = size->function_defs; |
| exec->IDefs = size->instruction_defs; |
| exec->pointSize = size->point_size; |
| exec->tt_metrics = size->ttmetrics; |
| exec->metrics = *size->metrics; |
| |
| exec->maxFunc = size->max_func; |
| exec->maxIns = size->max_ins; |
| |
| for ( i = 0; i < TT_MAX_CODE_RANGES; i++ ) |
| exec->codeRangeTable[i] = size->codeRangeTable[i]; |
| |
| /* set graphics state */ |
| exec->GS = size->GS; |
| |
| exec->cvtSize = size->cvt_size; |
| exec->cvt = size->cvt; |
| |
| exec->storeSize = size->storage_size; |
| exec->storage = size->storage; |
| |
| exec->twilight = size->twilight; |
| |
| /* In case of multi-threading it can happen that the old size object */ |
| /* no longer exists, thus we must clear all glyph zone references. */ |
| FT_ZERO( &exec->zp0 ); |
| exec->zp1 = exec->zp0; |
| exec->zp2 = exec->zp0; |
| } |
| |
| /* XXX: We reserve a little more elements on the stack to deal safely */ |
| /* with broken fonts like arialbs, courbs, timesbs, etc. */ |
| tmp = (FT_ULong)exec->stackSize; |
| error = Update_Max( exec->memory, |
| &tmp, |
| sizeof ( FT_F26Dot6 ), |
| (void*)&exec->stack, |
| maxp->maxStackElements + 32 ); |
| exec->stackSize = (FT_Long)tmp; |
| if ( error ) |
| return error; |
| |
| tmp = exec->glyphSize; |
| error = Update_Max( exec->memory, |
| &tmp, |
| sizeof ( FT_Byte ), |
| (void*)&exec->glyphIns, |
| maxp->maxSizeOfInstructions ); |
| exec->glyphSize = (FT_UShort)tmp; |
| if ( error ) |
| return error; |
| |
| exec->pts.n_points = 0; |
| exec->pts.n_contours = 0; |
| |
| exec->zp1 = exec->pts; |
| exec->zp2 = exec->pts; |
| exec->zp0 = exec->pts; |
| |
| exec->instruction_trap = FALSE; |
| |
| return FT_Err_Ok; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Save_Context |
| * |
| * @Description: |
| * Saves the code ranges in a `size' object. |
| * |
| * @Input: |
| * exec :: |
| * A handle to the source execution context. |
| * |
| * @InOut: |
| * size :: |
| * A handle to the target size object. |
| * |
| * @Note: |
| * Only the glyph loader and debugger should call this function. |
| */ |
| FT_LOCAL_DEF( void ) |
| TT_Save_Context( TT_ExecContext exec, |
| TT_Size size ) |
| { |
| FT_Int i; |
| |
| |
| /* XXX: Will probably disappear soon with all the code range */ |
| /* management, which is now rather obsolete. */ |
| /* */ |
| size->num_function_defs = exec->numFDefs; |
| size->num_instruction_defs = exec->numIDefs; |
| |
| size->max_func = exec->maxFunc; |
| size->max_ins = exec->maxIns; |
| |
| for ( i = 0; i < TT_MAX_CODE_RANGES; i++ ) |
| size->codeRangeTable[i] = exec->codeRangeTable[i]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * TT_Run_Context |
| * |
| * @Description: |
| * Executes one or more instructions in the execution context. |
| * |
| * @Input: |
| * debug :: |
| * A Boolean flag. If set, the function sets some internal |
| * variables and returns immediately, otherwise TT_RunIns() |
| * is called. |
| * |
| * This is commented out currently. |
| * |
| * @Input: |
| * exec :: |
| * A handle to the target execution context. |
| * |
| * @Return: |
| * TrueType error code. 0 means success. |
| */ |
| FT_LOCAL_DEF( FT_Error ) |
| TT_Run_Context( TT_ExecContext exec ) |
| { |
| TT_Goto_CodeRange( exec, tt_coderange_glyph, 0 ); |
| |
| exec->zp0 = exec->pts; |
| exec->zp1 = exec->pts; |
| exec->zp2 = exec->pts; |
| |
| exec->GS.gep0 = 1; |
| exec->GS.gep1 = 1; |
| exec->GS.gep2 = 1; |
| |
| exec->GS.projVector.x = 0x4000; |
| exec->GS.projVector.y = 0x0000; |
| |
| exec->GS.freeVector = exec->GS.projVector; |
| exec->GS.dualVector = exec->GS.projVector; |
| |
| exec->GS.round_state = 1; |
| exec->GS.loop = 1; |
| |
| /* some glyphs leave something on the stack. so we clean it */ |
| /* before a new execution. */ |
| exec->top = 0; |
| exec->callTop = 0; |
| |
| return exec->face->interpreter( exec ); |
| } |
| |
| |
| /* The default value for `scan_control' is documented as FALSE in the */ |
| /* TrueType specification. This is confusing since it implies a */ |
| /* Boolean value. However, this is not the case, thus both the */ |
| /* default values of our `scan_type' and `scan_control' fields (which */ |
| /* the documentation's `scan_control' variable is split into) are */ |
| /* zero. */ |
| |
| const TT_GraphicsState tt_default_graphics_state = |
| { |
| 0, 0, 0, |
| { 0x4000, 0 }, |
| { 0x4000, 0 }, |
| { 0x4000, 0 }, |
| |
| 1, 64, 1, |
| TRUE, 68, 0, 0, 9, 3, |
| 0, FALSE, 0, 1, 1, 1 |
| }; |
| |
| |
| /* documentation is in ttinterp.h */ |
| |
| FT_EXPORT_DEF( TT_ExecContext ) |
| TT_New_Context( TT_Driver driver ) |
| { |
| FT_Memory memory; |
| FT_Error error; |
| |
| TT_ExecContext exec = NULL; |
| |
| |
| if ( !driver ) |
| goto Fail; |
| |
| memory = driver->root.root.memory; |
| |
| /* allocate object */ |
| if ( FT_NEW( exec ) ) |
| goto Fail; |
| |
| /* initialize it; in case of error this deallocates `exec' too */ |
| error = Init_Context( exec, memory ); |
| if ( error ) |
| goto Fail; |
| |
| return exec; |
| |
| Fail: |
| return NULL; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * Before an opcode is executed, the interpreter verifies that there are |
| * enough arguments on the stack, with the help of the `Pop_Push_Count' |
| * table. |
| * |
| * For each opcode, the first column gives the number of arguments that |
| * are popped from the stack; the second one gives the number of those |
| * that are pushed in result. |
| * |
| * Opcodes which have a varying number of parameters in the data stream |
| * (NPUSHB, NPUSHW) are handled specially; they have a negative value in |
| * the `opcode_length' table, and the value in `Pop_Push_Count' is set |
| * to zero. |
| * |
| */ |
| |
| |
| #undef PACK |
| #define PACK( x, y ) ( ( x << 4 ) | y ) |
| |
| |
| static |
| const FT_Byte Pop_Push_Count[256] = |
| { |
| /* opcodes are gathered in groups of 16 */ |
| /* please keep the spaces as they are */ |
| |
| /* SVTCA y */ PACK( 0, 0 ), |
| /* SVTCA x */ PACK( 0, 0 ), |
| /* SPvTCA y */ PACK( 0, 0 ), |
| /* SPvTCA x */ PACK( 0, 0 ), |
| /* SFvTCA y */ PACK( 0, 0 ), |
| /* SFvTCA x */ PACK( 0, 0 ), |
| /* SPvTL // */ PACK( 2, 0 ), |
| /* SPvTL + */ PACK( 2, 0 ), |
| /* SFvTL // */ PACK( 2, 0 ), |
| /* SFvTL + */ PACK( 2, 0 ), |
| /* SPvFS */ PACK( 2, 0 ), |
| /* SFvFS */ PACK( 2, 0 ), |
| /* GPv */ PACK( 0, 2 ), |
| /* GFv */ PACK( 0, 2 ), |
| /* SFvTPv */ PACK( 0, 0 ), |
| /* ISECT */ PACK( 5, 0 ), |
| |
| /* SRP0 */ PACK( 1, 0 ), |
| /* SRP1 */ PACK( 1, 0 ), |
| /* SRP2 */ PACK( 1, 0 ), |
| /* SZP0 */ PACK( 1, 0 ), |
| /* SZP1 */ PACK( 1, 0 ), |
| /* SZP2 */ PACK( 1, 0 ), |
| /* SZPS */ PACK( 1, 0 ), |
| /* SLOOP */ PACK( 1, 0 ), |
| /* RTG */ PACK( 0, 0 ), |
| /* RTHG */ PACK( 0, 0 ), |
| /* SMD */ PACK( 1, 0 ), |
| /* ELSE */ PACK( 0, 0 ), |
| /* JMPR */ PACK( 1, 0 ), |
| /* SCvTCi */ PACK( 1, 0 ), |
| /* SSwCi */ PACK( 1, 0 ), |
| /* SSW */ PACK( 1, 0 ), |
| |
| /* DUP */ PACK( 1, 2 ), |
| /* POP */ PACK( 1, 0 ), |
| /* CLEAR */ PACK( 0, 0 ), |
| /* SWAP */ PACK( 2, 2 ), |
| /* DEPTH */ PACK( 0, 1 ), |
| /* CINDEX */ PACK( 1, 1 ), |
| /* MINDEX */ PACK( 1, 0 ), |
| /* AlignPTS */ PACK( 2, 0 ), |
| /* INS_$28 */ PACK( 0, 0 ), |
| /* UTP */ PACK( 1, 0 ), |
| /* LOOPCALL */ PACK( 2, 0 ), |
| /* CALL */ PACK( 1, 0 ), |
| /* FDEF */ PACK( 1, 0 ), |
| /* ENDF */ PACK( 0, 0 ), |
| /* MDAP[0] */ PACK( 1, 0 ), |
| /* MDAP[1] */ PACK( 1, 0 ), |
| |
| /* IUP[0] */ PACK( 0, 0 ), |
| /* IUP[1] */ PACK( 0, 0 ), |
| /* SHP[0] */ PACK( 0, 0 ), /* loops */ |
| /* SHP[1] */ PACK( 0, 0 ), /* loops */ |
| /* SHC[0] */ PACK( 1, 0 ), |
| /* SHC[1] */ PACK( 1, 0 ), |
| /* SHZ[0] */ PACK( 1, 0 ), |
| /* SHZ[1] */ PACK( 1, 0 ), |
| /* SHPIX */ PACK( 1, 0 ), /* loops */ |
| /* IP */ PACK( 0, 0 ), /* loops */ |
| /* MSIRP[0] */ PACK( 2, 0 ), |
| /* MSIRP[1] */ PACK( 2, 0 ), |
| /* AlignRP */ PACK( 0, 0 ), /* loops */ |
| /* RTDG */ PACK( 0, 0 ), |
| /* MIAP[0] */ PACK( 2, 0 ), |
| /* MIAP[1] */ PACK( 2, 0 ), |
| |
| /* NPushB */ PACK( 0, 0 ), |
| /* NPushW */ PACK( 0, 0 ), |
| /* WS */ PACK( 2, 0 ), |
| /* RS */ PACK( 1, 1 ), |
| /* WCvtP */ PACK( 2, 0 ), |
| /* RCvt */ PACK( 1, 1 ), |
| /* GC[0] */ PACK( 1, 1 ), |
| /* GC[1] */ PACK( 1, 1 ), |
| /* SCFS */ PACK( 2, 0 ), |
| /* MD[0] */ PACK( 2, 1 ), |
| /* MD[1] */ PACK( 2, 1 ), |
| /* MPPEM */ PACK( 0, 1 ), |
| /* MPS */ PACK( 0, 1 ), |
| /* FlipON */ PACK( 0, 0 ), |
| /* FlipOFF */ PACK( 0, 0 ), |
| /* DEBUG */ PACK( 1, 0 ), |
| |
| /* LT */ PACK( 2, 1 ), |
| /* LTEQ */ PACK( 2, 1 ), |
| /* GT */ PACK( 2, 1 ), |
| /* GTEQ */ PACK( 2, 1 ), |
| /* EQ */ PACK( 2, 1 ), |
| /* NEQ */ PACK( 2, 1 ), |
| /* ODD */ PACK( 1, 1 ), |
| /* EVEN */ PACK( 1, 1 ), |
| /* IF */ PACK( 1, 0 ), |
| /* EIF */ PACK( 0, 0 ), |
| /* AND */ PACK( 2, 1 ), |
| /* OR */ PACK( 2, 1 ), |
| /* NOT */ PACK( 1, 1 ), |
| /* DeltaP1 */ PACK( 1, 0 ), |
| /* SDB */ PACK( 1, 0 ), |
| /* SDS */ PACK( 1, 0 ), |
| |
| /* ADD */ PACK( 2, 1 ), |
| /* SUB */ PACK( 2, 1 ), |
| /* DIV */ PACK( 2, 1 ), |
| /* MUL */ PACK( 2, 1 ), |
| /* ABS */ PACK( 1, 1 ), |
| /* NEG */ PACK( 1, 1 ), |
| /* FLOOR */ PACK( 1, 1 ), |
| /* CEILING */ PACK( 1, 1 ), |
| /* ROUND[0] */ PACK( 1, 1 ), |
| /* ROUND[1] */ PACK( 1, 1 ), |
| /* ROUND[2] */ PACK( 1, 1 ), |
| /* ROUND[3] */ PACK( 1, 1 ), |
| /* NROUND[0] */ PACK( 1, 1 ), |
| /* NROUND[1] */ PACK( 1, 1 ), |
| /* NROUND[2] */ PACK( 1, 1 ), |
| /* NROUND[3] */ PACK( 1, 1 ), |
| |
| /* WCvtF */ PACK( 2, 0 ), |
| /* DeltaP2 */ PACK( 1, 0 ), |
| /* DeltaP3 */ PACK( 1, 0 ), |
| /* DeltaCn[0] */ PACK( 1, 0 ), |
| /* DeltaCn[1] */ PACK( 1, 0 ), |
| /* DeltaCn[2] */ PACK( 1, 0 ), |
| /* SROUND */ PACK( 1, 0 ), |
| /* S45Round */ PACK( 1, 0 ), |
| /* JROT */ PACK( 2, 0 ), |
| /* JROF */ PACK( 2, 0 ), |
| /* ROFF */ PACK( 0, 0 ), |
| /* INS_$7B */ PACK( 0, 0 ), |
| /* RUTG */ PACK( 0, 0 ), |
| /* RDTG */ PACK( 0, 0 ), |
| /* SANGW */ PACK( 1, 0 ), |
| /* AA */ PACK( 1, 0 ), |
| |
| /* FlipPT */ PACK( 0, 0 ), /* loops */ |
| /* FlipRgON */ PACK( 2, 0 ), |
| /* FlipRgOFF */ PACK( 2, 0 ), |
| /* INS_$83 */ PACK( 0, 0 ), |
| /* INS_$84 */ PACK( 0, 0 ), |
| /* ScanCTRL */ PACK( 1, 0 ), |
| /* SDPvTL[0] */ PACK( 2, 0 ), |
| /* SDPvTL[1] */ PACK( 2, 0 ), |
| /* GetINFO */ PACK( 1, 1 ), |
| /* IDEF */ PACK( 1, 0 ), |
| /* ROLL */ PACK( 3, 3 ), |
| /* MAX */ PACK( 2, 1 ), |
| /* MIN */ PACK( 2, 1 ), |
| /* ScanTYPE */ PACK( 1, 0 ), |
| /* InstCTRL */ PACK( 2, 0 ), |
| /* INS_$8F */ PACK( 0, 0 ), |
| |
| /* INS_$90 */ PACK( 0, 0 ), |
| /* GETVAR */ PACK( 0, 0 ), /* will be handled specially */ |
| /* GETDATA */ PACK( 0, 1 ), |
| /* INS_$93 */ PACK( 0, 0 ), |
| /* INS_$94 */ PACK( 0, 0 ), |
| /* INS_$95 */ PACK( 0, 0 ), |
| /* INS_$96 */ PACK( 0, 0 ), |
| /* INS_$97 */ PACK( 0, 0 ), |
| /* INS_$98 */ PACK( 0, 0 ), |
| /* INS_$99 */ PACK( 0, 0 ), |
| /* INS_$9A */ PACK( 0, 0 ), |
| /* INS_$9B */ PACK( 0, 0 ), |
| /* INS_$9C */ PACK( 0, 0 ), |
| /* INS_$9D */ PACK( 0, 0 ), |
| /* INS_$9E */ PACK( 0, 0 ), |
| /* INS_$9F */ PACK( 0, 0 ), |
| |
| /* INS_$A0 */ PACK( 0, 0 ), |
| /* INS_$A1 */ PACK( 0, 0 ), |
| /* INS_$A2 */ PACK( 0, 0 ), |
| /* INS_$A3 */ PACK( 0, 0 ), |
| /* INS_$A4 */ PACK( 0, 0 ), |
| /* INS_$A5 */ PACK( 0, 0 ), |
| /* INS_$A6 */ PACK( 0, 0 ), |
| /* INS_$A7 */ PACK( 0, 0 ), |
| /* INS_$A8 */ PACK( 0, 0 ), |
| /* INS_$A9 */ PACK( 0, 0 ), |
| /* INS_$AA */ PACK( 0, 0 ), |
| /* INS_$AB */ PACK( 0, 0 ), |
| /* INS_$AC */ PACK( 0, 0 ), |
| /* INS_$AD */ PACK( 0, 0 ), |
| /* INS_$AE */ PACK( 0, 0 ), |
| /* INS_$AF */ PACK( 0, 0 ), |
| |
| /* PushB[0] */ PACK( 0, 1 ), |
| /* PushB[1] */ PACK( 0, 2 ), |
| /* PushB[2] */ PACK( 0, 3 ), |
| /* PushB[3] */ PACK( 0, 4 ), |
| /* PushB[4] */ PACK( 0, 5 ), |
| /* PushB[5] */ PACK( 0, 6 ), |
| /* PushB[6] */ PACK( 0, 7 ), |
| /* PushB[7] */ PACK( 0, 8 ), |
| /* PushW[0] */ PACK( 0, 1 ), |
| /* PushW[1] */ PACK( 0, 2 ), |
| /* PushW[2] */ PACK( 0, 3 ), |
| /* PushW[3] */ PACK( 0, 4 ), |
| /* PushW[4] */ PACK( 0, 5 ), |
| /* PushW[5] */ PACK( 0, 6 ), |
| /* PushW[6] */ PACK( 0, 7 ), |
| /* PushW[7] */ PACK( 0, 8 ), |
| |
| /* MDRP[00] */ PACK( 1, 0 ), |
| /* MDRP[01] */ PACK( 1, 0 ), |
| /* MDRP[02] */ PACK( 1, 0 ), |
| /* MDRP[03] */ PACK( 1, 0 ), |
| /* MDRP[04] */ PACK( 1, 0 ), |
| /* MDRP[05] */ PACK( 1, 0 ), |
| /* MDRP[06] */ PACK( 1, 0 ), |
| /* MDRP[07] */ PACK( 1, 0 ), |
| /* MDRP[08] */ PACK( 1, 0 ), |
| /* MDRP[09] */ PACK( 1, 0 ), |
| /* MDRP[10] */ PACK( 1, 0 ), |
| /* MDRP[11] */ PACK( 1, 0 ), |
| /* MDRP[12] */ PACK( 1, 0 ), |
| /* MDRP[13] */ PACK( 1, 0 ), |
| /* MDRP[14] */ PACK( 1, 0 ), |
| /* MDRP[15] */ PACK( 1, 0 ), |
| |
| /* MDRP[16] */ PACK( 1, 0 ), |
| /* MDRP[17] */ PACK( 1, 0 ), |
| /* MDRP[18] */ PACK( 1, 0 ), |
| /* MDRP[19] */ PACK( 1, 0 ), |
| /* MDRP[20] */ PACK( 1, 0 ), |
| /* MDRP[21] */ PACK( 1, 0 ), |
| /* MDRP[22] */ PACK( 1, 0 ), |
| /* MDRP[23] */ PACK( 1, 0 ), |
| /* MDRP[24] */ PACK( 1, 0 ), |
| /* MDRP[25] */ PACK( 1, 0 ), |
| /* MDRP[26] */ PACK( 1, 0 ), |
| /* MDRP[27] */ PACK( 1, 0 ), |
| /* MDRP[28] */ PACK( 1, 0 ), |
| /* MDRP[29] */ PACK( 1, 0 ), |
| /* MDRP[30] */ PACK( 1, 0 ), |
| /* MDRP[31] */ PACK( 1, 0 ), |
| |
| /* MIRP[00] */ PACK( 2, 0 ), |
| /* MIRP[01] */ PACK( 2, 0 ), |
| /* MIRP[02] */ PACK( 2, 0 ), |
| /* MIRP[03] */ PACK( 2, 0 ), |
| /* MIRP[04] */ PACK( 2, 0 ), |
| /* MIRP[05] */ PACK( 2, 0 ), |
| /* MIRP[06] */ PACK( 2, 0 ), |
| /* MIRP[07] */ PACK( 2, 0 ), |
| /* MIRP[08] */ PACK( 2, 0 ), |
| /* MIRP[09] */ PACK( 2, 0 ), |
| /* MIRP[10] */ PACK( 2, 0 ), |
| /* MIRP[11] */ PACK( 2, 0 ), |
| /* MIRP[12] */ PACK( 2, 0 ), |
| /* MIRP[13] */ PACK( 2, 0 ), |
| /* MIRP[14] */ PACK( 2, 0 ), |
| /* MIRP[15] */ PACK( 2, 0 ), |
| |
| /* MIRP[16] */ PACK( 2, 0 ), |
| /* MIRP[17] */ PACK( 2, 0 ), |
| /* MIRP[18] */ PACK( 2, 0 ), |
| /* MIRP[19] */ PACK( 2, 0 ), |
| /* MIRP[20] */ PACK( 2, 0 ), |
| /* MIRP[21] */ PACK( 2, 0 ), |
| /* MIRP[22] */ PACK( 2, 0 ), |
| /* MIRP[23] */ PACK( 2, 0 ), |
| /* MIRP[24] */ PACK( 2, 0 ), |
| /* MIRP[25] */ PACK( 2, 0 ), |
| /* MIRP[26] */ PACK( 2, 0 ), |
| /* MIRP[27] */ PACK( 2, 0 ), |
| /* MIRP[28] */ PACK( 2, 0 ), |
| /* MIRP[29] */ PACK( 2, 0 ), |
| /* MIRP[30] */ PACK( 2, 0 ), |
| /* MIRP[31] */ PACK( 2, 0 ) |
| }; |
| |
| |
| #ifdef FT_DEBUG_LEVEL_TRACE |
| |
| /* the first hex digit gives the length of the opcode name; the space */ |
| /* after the digit is here just to increase readability of the source */ |
| /* code */ |
| |
| static |
| const char* const opcode_name[256] = |
| { |
| "7 SVTCA y", |
| "7 SVTCA x", |
| "8 SPvTCA y", |
| "8 SPvTCA x", |
| "8 SFvTCA y", |
| "8 SFvTCA x", |
| "8 SPvTL ||", |
| "7 SPvTL +", |
| "8 SFvTL ||", |
| "7 SFvTL +", |
| "5 SPvFS", |
| "5 SFvFS", |
| "3 GPv", |
| "3 GFv", |
| "6 SFvTPv", |
| "5 ISECT", |
| |
| "4 SRP0", |
| "4 SRP1", |
| "4 SRP2", |
| "4 SZP0", |
| "4 SZP1", |
| "4 SZP2", |
| "4 SZPS", |
| "5 SLOOP", |
| "3 RTG", |
| "4 RTHG", |
| "3 SMD", |
| "4 ELSE", |
| "4 JMPR", |
| "6 SCvTCi", |
| "5 SSwCi", |
| "3 SSW", |
| |
| "3 DUP", |
| "3 POP", |
| "5 CLEAR", |
| "4 SWAP", |
| "5 DEPTH", |
| "6 CINDEX", |
| "6 MINDEX", |
| "8 AlignPTS", |
| "7 INS_$28", |
| "3 UTP", |
| "8 LOOPCALL", |
| "4 CALL", |
| "4 FDEF", |
| "4 ENDF", |
| "7 MDAP[0]", |
| "7 MDAP[1]", |
| |
| "6 IUP[0]", |
| "6 IUP[1]", |
| "6 SHP[0]", |
| "6 SHP[1]", |
| "6 SHC[0]", |
| "6 SHC[1]", |
| "6 SHZ[0]", |
| "6 SHZ[1]", |
| "5 SHPIX", |
| "2 IP", |
| "8 MSIRP[0]", |
| "8 MSIRP[1]", |
| "7 AlignRP", |
| "4 RTDG", |
| "7 MIAP[0]", |
| "7 MIAP[1]", |
| |
| "6 NPushB", |
| "6 NPushW", |
| "2 WS", |
| "2 RS", |
| "5 WCvtP", |
| "4 RCvt", |
| "5 GC[0]", |
| "5 GC[1]", |
| "4 SCFS", |
| "5 MD[0]", |
| "5 MD[1]", |
| "5 MPPEM", |
| "3 MPS", |
| "6 FlipON", |
| "7 FlipOFF", |
| "5 DEBUG", |
| |
| "2 LT", |
| "4 LTEQ", |
| "2 GT", |
| "4 GTEQ", |
| "2 EQ", |
| "3 NEQ", |
| "3 ODD", |
| "4 EVEN", |
| "2 IF", |
| "3 EIF", |
| "3 AND", |
| "2 OR", |
| "3 NOT", |
| "7 DeltaP1", |
| "3 SDB", |
| "3 SDS", |
| |
| "3 ADD", |
| "3 SUB", |
| "3 DIV", |
| "3 MUL", |
| "3 ABS", |
| "3 NEG", |
| "5 FLOOR", |
| "7 CEILING", |
| "8 ROUND[0]", |
| "8 ROUND[1]", |
| "8 ROUND[2]", |
| "8 ROUND[3]", |
| "9 NROUND[0]", |
| "9 NROUND[1]", |
| "9 NROUND[2]", |
| "9 NROUND[3]", |
| |
| "5 WCvtF", |
| "7 DeltaP2", |
| "7 DeltaP3", |
| "A DeltaCn[0]", |
| "A DeltaCn[1]", |
| "A DeltaCn[2]", |
| "6 SROUND", |
| "8 S45Round", |
| "4 JROT", |
| "4 JROF", |
| "4 ROFF", |
| "7 INS_$7B", |
| "4 RUTG", |
| "4 RDTG", |
| "5 SANGW", |
| "2 AA", |
| |
| "6 FlipPT", |
| "8 FlipRgON", |
| "9 FlipRgOFF", |
| "7 INS_$83", |
| "7 INS_$84", |
| "8 ScanCTRL", |
| "9 SDPvTL[0]", |
| "9 SDPvTL[1]", |
| "7 GetINFO", |
| "4 IDEF", |
| "4 ROLL", |
| "3 MAX", |
| "3 MIN", |
| "8 ScanTYPE", |
| "8 InstCTRL", |
| "7 INS_$8F", |
| |
| "7 INS_$90", |
| #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
| "6 GETVAR", |
| "7 GETDATA", |
| #else |
| "7 INS_$91", |
| "7 INS_$92", |
| #endif |
| "7 INS_$93", |
| "7 INS_$94", |
| "7 INS_$95", |
| "7 INS_$96", |
| "7 INS_$97", |
| "7 INS_$98", |
| "7 INS_$99", |
| "7 INS_$9A", |
| "7 INS_$9B", |
| "7 INS_$9C", |
| "7 INS_$9D", |
| "7 INS_$9E", |
| "7 INS_$9F", |
| |
| "7 INS_$A0", |
| "7 INS_$A1", |
| "7 INS_$A2", |
| "7 INS_$A3", |
| "7 INS_$A4", |
| "7 INS_$A5", |
| "7 INS_$A6", |
| "7 INS_$A7", |
| "7 INS_$A8", |
| "7 INS_$A9", |
| "7 INS_$AA", |
| "7 INS_$AB", |
| "7 INS_$AC", |
| "7 INS_$AD", |
| "7 INS_$AE", |
| "7 INS_$AF", |
| |
| "8 PushB[0]", |
| "8 PushB[1]", |
| "8 PushB[2]", |
| "8 PushB[3]", |
| "8 PushB[4]", |
| "8 PushB[5]", |
| "8 PushB[6]", |
| "8 PushB[7]", |
| "8 PushW[0]", |
| "8 PushW[1]", |
| "8 PushW[2]", |
| "8 PushW[3]", |
| "8 PushW[4]", |
| "8 PushW[5]", |
| "8 PushW[6]", |
| "8 PushW[7]", |
| |
| "7 MDRP[G]", |
| "7 MDRP[B]", |
| "7 MDRP[W]", |
| "7 MDRP[?]", |
| "8 MDRP[rG]", |
| "8 MDRP[rB]", |
| "8 MDRP[rW]", |
| "8 MDRP[r?]", |
| "8 MDRP[mG]", |
| "8 MDRP[mB]", |
| "8 MDRP[mW]", |
| "8 MDRP[m?]", |
| "9 MDRP[mrG]", |
| "9 MDRP[mrB]", |
| "9 MDRP[mrW]", |
| "9 MDRP[mr?]", |
| |
| "8 MDRP[pG]", |
| "8 MDRP[pB]", |
| "8 MDRP[pW]", |
| "8 MDRP[p?]", |
| "9 MDRP[prG]", |
| "9 MDRP[prB]", |
| "9 MDRP[prW]", |
| "9 MDRP[pr?]", |
| "9 MDRP[pmG]", |
| "9 MDRP[pmB]", |
| "9 MDRP[pmW]", |
| "9 MDRP[pm?]", |
| "A MDRP[pmrG]", |
| "A MDRP[pmrB]", |
| "A MDRP[pmrW]", |
| "A MDRP[pmr?]", |
| |
| "7 MIRP[G]", |
| "7 MIRP[B]", |
| "7 MIRP[W]", |
| "7 MIRP[?]", |
| "8 MIRP[rG]", |
| "8 MIRP[rB]", |
| "8 MIRP[rW]", |
| "8 MIRP[r?]", |
| "8 MIRP[mG]", |
| "8 MIRP[mB]", |
| "8 MIRP[mW]", |
| "8 MIRP[m?]", |
| "9 MIRP[mrG]", |
| "9 MIRP[mrB]", |
| "9 MIRP[mrW]", |
| "9 MIRP[mr?]", |
| |
| "8 MIRP[pG]", |
| "8 MIRP[pB]", |
| "8 MIRP[pW]", |
| "8 MIRP[p?]", |
| "9 MIRP[prG]", |
| "9 MIRP[prB]", |
| "9 MIRP[prW]", |
| "9 MIRP[pr?]", |
| "9 MIRP[pmG]", |
| "9 MIRP[pmB]", |
| "9 MIRP[pmW]", |
| "9 MIRP[pm?]", |
| "A MIRP[pmrG]", |
| "A MIRP[pmrB]", |
| "A MIRP[pmrW]", |
| "A MIRP[pmr?]" |
| }; |
| |
| #endif /* FT_DEBUG_LEVEL_TRACE */ |
| |
| |
| static |
| const FT_Char opcode_length[256] = |
| { |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| |
| -1,-2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 2, 3, 4, 5, 6, 7, 8, 9, 3, 5, 7, 9, 11,13,15,17, |
| |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 |
| }; |
| |
| #undef PACK |
| |
| |
| #ifndef FT_CONFIG_OPTION_NO_ASSEMBLER |
| |
| #if defined( __arm__ ) && \ |
| ( defined( __thumb2__ ) || !defined( __thumb__ ) ) |
| |
| #define TT_MulFix14 TT_MulFix14_arm |
| |
| static FT_Int32 |
| TT_MulFix14_arm( FT_Int32 a, |
| FT_Int b ) |
| { |
| FT_Int32 t, t2; |
| |
| |
| #if defined( __CC_ARM ) || defined( __ARMCC__ ) |
| |
| __asm |
| { |
| smull t2, t, b, a /* (lo=t2,hi=t) = a*b */ |
| mov a, t, asr #31 /* a = (hi >> 31) */ |
| add a, a, #0x2000 /* a += 0x2000 */ |
| adds t2, t2, a /* t2 += a */ |
| adc t, t, #0 /* t += carry */ |
| mov a, t2, lsr #14 /* a = t2 >> 14 */ |
| orr a, a, t, lsl #18 /* a |= t << 18 */ |
| } |
| |
| #elif defined( __GNUC__ ) |
| |
| __asm__ __volatile__ ( |
| "smull %1, %2, %4, %3\n\t" /* (lo=%1,hi=%2) = a*b */ |
| "mov %0, %2, asr #31\n\t" /* %0 = (hi >> 31) */ |
| #if defined( __clang__ ) && defined( __thumb2__ ) |
| "add.w %0, %0, #0x2000\n\t" /* %0 += 0x2000 */ |
| #else |
| "add %0, %0, #0x2000\n\t" /* %0 += 0x2000 */ |
| #endif |
| "adds %1, %1, %0\n\t" /* %1 += %0 */ |
| "adc %2, %2, #0\n\t" /* %2 += carry */ |
| "mov %0, %1, lsr #14\n\t" /* %0 = %1 >> 16 */ |
| "orr %0, %0, %2, lsl #18\n\t" /* %0 |= %2 << 16 */ |
| : "=r"(a), "=&r"(t2), "=&r"(t) |
| : "r"(a), "r"(b) |
| : "cc" ); |
| |
| #endif |
| |
| return a; |
| } |
| |
| #endif /* __arm__ && ( __thumb2__ || !__thumb__ ) */ |
| |
| #endif /* !FT_CONFIG_OPTION_NO_ASSEMBLER */ |
| |
| |
| #if defined( __GNUC__ ) && \ |
| ( defined( __i386__ ) || defined( __x86_64__ ) ) |
| |
| #define TT_MulFix14 TT_MulFix14_long_long |
| |
| /* Temporarily disable the warning that C90 doesn't support `long long'. */ |
| #if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 406 |
| #pragma GCC diagnostic push |
| #endif |
| #pragma GCC diagnostic ignored "-Wlong-long" |
| |
| /* This is declared `noinline' because inlining the function results */ |
| /* in slower code. The `pure' attribute indicates that the result */ |
| /* only depends on the parameters. */ |
| static __attribute__(( noinline )) |
| __attribute__(( pure )) FT_Int32 |
| TT_MulFix14_long_long( FT_Int32 a, |
| FT_Int b ) |
| { |
| |
| long long ret = (long long)a * b; |
| |
| /* The following line assumes that right shifting of signed values */ |
| /* will actually preserve the sign bit. The exact behaviour is */ |
| /* undefined, but this is true on x86 and x86_64. */ |
| long long tmp = ret >> 63; |
| |
| |
| ret += 0x2000 + tmp; |
| |
| return (FT_Int32)( ret >> 14 ); |
| } |
| |
| #if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 406 |
| #pragma GCC diagnostic pop |
| #endif |
| |
| #endif /* __GNUC__ && ( __i386__ || __x86_64__ ) */ |
| |
| |
| #ifndef TT_MulFix14 |
| |
| /* Compute (a*b)/2^14 with maximum accuracy and rounding. */ |
| /* This is optimized to be faster than calling FT_MulFix() */ |
| /* for platforms where sizeof(int) == 2. */ |
| static FT_Int32 |
| TT_MulFix14( FT_Int32 a, |
| FT_Int b ) |
| { |
| FT_Int32 sign; |
| FT_UInt32 ah, al, mid, lo, hi; |
| |
| |
| sign = a ^ b; |
| |
| if ( a < 0 ) |
| a = -a; |
| if ( b < 0 ) |
| b = -b; |
| |
| ah = (FT_UInt32)( ( a >> 16 ) & 0xFFFFU ); |
| al = (FT_UInt32)( a & 0xFFFFU ); |
| |
| lo = al * b; |
| mid = ah * b; |
| hi = mid >> 16; |
| mid = ( mid << 16 ) + ( 1 << 13 ); /* rounding */ |
| lo += mid; |
| if ( lo < mid ) |
| hi += 1; |
| |
| mid = ( lo >> 14 ) | ( hi << 18 ); |
| |
| return sign >= 0 ? (FT_Int32)mid : -(FT_Int32)mid; |
| } |
| |
| #endif /* !TT_MulFix14 */ |
| |
| |
| #if defined( __GNUC__ ) && \ |
| ( defined( __i386__ ) || \ |
| defined( __x86_64__ ) || \ |
| defined( __arm__ ) ) |
| |
| #define TT_DotFix14 TT_DotFix14_long_long |
| |
| #if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 406 |
| #pragma GCC diagnostic push |
| #endif |
| #pragma GCC diagnostic ignored "-Wlong-long" |
| |
| static __attribute__(( pure )) FT_Int32 |
| TT_DotFix14_long_long( FT_Int32 ax, |
| FT_Int32 ay, |
| FT_Int bx, |
| FT_Int by ) |
| { |
| /* Temporarily disable the warning that C90 doesn't support */ |
| /* `long long'. */ |
| |
| long long temp1 = (long long)ax * bx; |
| long long temp2 = (long long)ay * by; |
| |
| |
| temp1 += temp2; |
| temp2 = temp1 >> 63; |
| temp1 += 0x2000 + temp2; |
| |
| return (FT_Int32)( temp1 >> 14 ); |
| |
| } |
| |
| #if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 406 |
| #pragma GCC diagnostic pop |
| #endif |
| |
| #endif /* __GNUC__ && (__arm__ || __i386__ || __x86_64__) */ |
| |
| |
| #ifndef TT_DotFix14 |
| |
| /* compute (ax*bx+ay*by)/2^14 with maximum accuracy and rounding */ |
| static FT_Int32 |
| TT_DotFix14( FT_Int32 ax, |
| FT_Int32 ay, |
| FT_Int bx, |
| FT_Int by ) |
| { |
| FT_Int32 m, s, hi1, hi2, hi; |
| FT_UInt32 l, lo1, lo2, lo; |
| |
| |
| /* compute ax*bx as 64-bit value */ |
| l = (FT_UInt32)( ( ax & 0xFFFFU ) * bx ); |
| m = ( ax >> 16 ) * bx; |
| |
| lo1 = l + ( (FT_UInt32)m << 16 ); |
| hi1 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo1 < l ); |
| |
| /* compute ay*by as 64-bit value */ |
| l = (FT_UInt32)( ( ay & 0xFFFFU ) * by ); |
| m = ( ay >> 16 ) * by; |
| |
| lo2 = l + ( (FT_UInt32)m << 16 ); |
| hi2 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo2 < l ); |
| |
| /* add them */ |
| lo = lo1 + lo2; |
| hi = hi1 + hi2 + ( lo < lo1 ); |
| |
| /* divide the result by 2^14 with rounding */ |
| s = hi >> 31; |
| l = lo + (FT_UInt32)s; |
| hi += s + ( l < lo ); |
| lo = l; |
| |
| l = lo + 0x2000U; |
| hi += ( l < lo ); |
| |
| return (FT_Int32)( ( (FT_UInt32)hi << 18 ) | ( l >> 14 ) ); |
| } |
| |
| #endif /* TT_DotFix14 */ |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Current_Ratio |
| * |
| * @Description: |
| * Returns the current aspect ratio scaling factor depending on the |
| * projection vector's state and device resolutions. |
| * |
| * @Return: |
| * The aspect ratio in 16.16 format, always <= 1.0 . |
| */ |
| static FT_Long |
| Current_Ratio( TT_ExecContext exc ) |
| { |
| if ( !exc->tt_metrics.ratio ) |
| { |
| if ( exc->GS.projVector.y == 0 ) |
| exc->tt_metrics.ratio = exc->tt_metrics.x_ratio; |
| |
| else if ( exc->GS.projVector.x == 0 ) |
| exc->tt_metrics.ratio = exc->tt_metrics.y_ratio; |
| |
| else |
| { |
| FT_F26Dot6 x, y; |
| |
| |
| x = TT_MulFix14( exc->tt_metrics.x_ratio, |
| exc->GS.projVector.x ); |
| y = TT_MulFix14( exc->tt_metrics.y_ratio, |
| exc->GS.projVector.y ); |
| exc->tt_metrics.ratio = FT_Hypot( x, y ); |
| } |
| } |
| return exc->tt_metrics.ratio; |
| } |
| |
| |
| FT_CALLBACK_DEF( FT_Long ) |
| Current_Ppem( TT_ExecContext exc ) |
| { |
| return exc->tt_metrics.ppem; |
| } |
| |
| |
| FT_CALLBACK_DEF( FT_Long ) |
| Current_Ppem_Stretched( TT_ExecContext exc ) |
| { |
| return FT_MulFix( exc->tt_metrics.ppem, Current_Ratio( exc ) ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * Functions related to the control value table (CVT). |
| * |
| */ |
| |
| |
| FT_CALLBACK_DEF( FT_F26Dot6 ) |
| Read_CVT( TT_ExecContext exc, |
| FT_ULong idx ) |
| { |
| return exc->cvt[idx]; |
| } |
| |
| |
| FT_CALLBACK_DEF( FT_F26Dot6 ) |
| Read_CVT_Stretched( TT_ExecContext exc, |
| FT_ULong idx ) |
| { |
| return FT_MulFix( exc->cvt[idx], Current_Ratio( exc ) ); |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| Write_CVT( TT_ExecContext exc, |
| FT_ULong idx, |
| FT_F26Dot6 value ) |
| { |
| exc->cvt[idx] = value; |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| Write_CVT_Stretched( TT_ExecContext exc, |
| FT_ULong idx, |
| FT_F26Dot6 value ) |
| { |
| exc->cvt[idx] = FT_DivFix( value, Current_Ratio( exc ) ); |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| Move_CVT( TT_ExecContext exc, |
| FT_ULong idx, |
| FT_F26Dot6 value ) |
| { |
| exc->cvt[idx] += value; |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| Move_CVT_Stretched( TT_ExecContext exc, |
| FT_ULong idx, |
| FT_F26Dot6 value ) |
| { |
| exc->cvt[idx] += FT_DivFix( value, Current_Ratio( exc ) ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * GetShortIns |
| * |
| * @Description: |
| * Returns a short integer taken from the instruction stream at |
| * address IP. |
| * |
| * @Return: |
| * Short read at code[IP]. |
| * |
| * @Note: |
| * This one could become a macro. |
| */ |
| static FT_Short |
| GetShortIns( TT_ExecContext exc ) |
| { |
| /* Reading a byte stream so there is no endianness (DaveP) */ |
| exc->IP += 2; |
| return (FT_Short)( ( exc->code[exc->IP - 2] << 8 ) + |
| exc->code[exc->IP - 1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Ins_Goto_CodeRange |
| * |
| * @Description: |
| * Goes to a certain code range in the instruction stream. |
| * |
| * @Input: |
| * aRange :: |
| * The index of the code range. |
| * |
| * aIP :: |
| * The new IP address in the code range. |
| * |
| * @Return: |
| * SUCCESS or FAILURE. |
| */ |
| static FT_Bool |
| Ins_Goto_CodeRange( TT_ExecContext exc, |
| FT_Int aRange, |
| FT_Long aIP ) |
| { |
| TT_CodeRange* range; |
| |
| |
| if ( aRange < 1 || aRange > 3 ) |
| { |
| exc->error = FT_THROW( Bad_Argument ); |
| return FAILURE; |
| } |
| |
| range = &exc->codeRangeTable[aRange - 1]; |
| |
| if ( !range->base ) /* invalid coderange */ |
| { |
| exc->error = FT_THROW( Invalid_CodeRange ); |
| return FAILURE; |
| } |
| |
| /* NOTE: Because the last instruction of a program may be a CALL */ |
| /* which will return to the first byte *after* the code */ |
| /* range, we test for aIP <= Size, instead of aIP < Size. */ |
| |
| if ( aIP > range->size ) |
| { |
| exc->error = FT_THROW( Code_Overflow ); |
| return FAILURE; |
| } |
| |
| exc->code = range->base; |
| exc->codeSize = range->size; |
| exc->IP = aIP; |
| exc->curRange = aRange; |
| |
| return SUCCESS; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Direct_Move |
| * |
| * @Description: |
| * Moves a point by a given distance along the freedom vector. The |
| * point will be `touched'. |
| * |
| * @Input: |
| * point :: |
| * The index of the point to move. |
| * |
| * distance :: |
| * The distance to apply. |
| * |
| * @InOut: |
| * zone :: |
| * The affected glyph zone. |
| * |
| * @Note: |
| * See `ttinterp.h' for details on backward compatibility mode. |
| * `Touches' the point. |
| */ |
| static void |
| Direct_Move( TT_ExecContext exc, |
| TT_GlyphZone zone, |
| FT_UShort point, |
| FT_F26Dot6 distance ) |
| { |
| FT_F26Dot6 v; |
| |
| |
| v = exc->GS.freeVector.x; |
| |
| if ( v != 0 ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| ( !exc->ignore_x_mode || |
| ( exc->sph_tweak_flags & SPH_TWEAK_ALLOW_X_DMOVE ) ) ) |
| zone->cur[point].x = ADD_LONG( zone->cur[point].x, |
| FT_MulDiv( distance, |
| v, |
| exc->F_dot_P ) ); |
| else |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* Exception to the post-IUP curfew: Allow the x component of */ |
| /* diagonal moves, but only post-IUP. DejaVu tries to adjust */ |
| /* diagonal stems like on `Z' and `z' post-IUP. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && !exc->backward_compatibility ) |
| zone->cur[point].x = ADD_LONG( zone->cur[point].x, |
| FT_MulDiv( distance, |
| v, |
| exc->F_dot_P ) ); |
| else |
| #endif |
| |
| if ( NO_SUBPIXEL_HINTING ) |
| zone->cur[point].x = ADD_LONG( zone->cur[point].x, |
| FT_MulDiv( distance, |
| v, |
| exc->F_dot_P ) ); |
| |
| zone->tags[point] |= FT_CURVE_TAG_TOUCH_X; |
| } |
| |
| v = exc->GS.freeVector.y; |
| |
| if ( v != 0 ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| if ( !( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility && |
| exc->iupx_called && |
| exc->iupy_called ) ) |
| #endif |
| zone->cur[point].y = ADD_LONG( zone->cur[point].y, |
| FT_MulDiv( distance, |
| v, |
| exc->F_dot_P ) ); |
| |
| zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Direct_Move_Orig |
| * |
| * @Description: |
| * Moves the *original* position of a point by a given distance along |
| * the freedom vector. Obviously, the point will not be `touched'. |
| * |
| * @Input: |
| * point :: |
| * The index of the point to move. |
| * |
| * distance :: |
| * The distance to apply. |
| * |
| * @InOut: |
| * zone :: |
| * The affected glyph zone. |
| */ |
| static void |
| Direct_Move_Orig( TT_ExecContext exc, |
| TT_GlyphZone zone, |
| FT_UShort point, |
| FT_F26Dot6 distance ) |
| { |
| FT_F26Dot6 v; |
| |
| |
| v = exc->GS.freeVector.x; |
| |
| if ( v != 0 ) |
| zone->org[point].x = ADD_LONG( zone->org[point].x, |
| FT_MulDiv( distance, |
| v, |
| exc->F_dot_P ) ); |
| |
| v = exc->GS.freeVector.y; |
| |
| if ( v != 0 ) |
| zone->org[point].y = ADD_LONG( zone->org[point].y, |
| FT_MulDiv( distance, |
| v, |
| exc->F_dot_P ) ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * Special versions of Direct_Move() |
| * |
| * The following versions are used whenever both vectors are both |
| * along one of the coordinate unit vectors, i.e. in 90% of the cases. |
| * See `ttinterp.h' for details on backward compatibility mode. |
| * |
| */ |
| |
| |
| static void |
| Direct_Move_X( TT_ExecContext exc, |
| TT_GlyphZone zone, |
| FT_UShort point, |
| FT_F26Dot6 distance ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && !exc->ignore_x_mode ) |
| zone->cur[point].x = ADD_LONG( zone->cur[point].x, distance ); |
| else |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| if ( SUBPIXEL_HINTING_MINIMAL && !exc->backward_compatibility ) |
| zone->cur[point].x = ADD_LONG( zone->cur[point].x, distance ); |
| else |
| #endif |
| |
| if ( NO_SUBPIXEL_HINTING ) |
| zone->cur[point].x = ADD_LONG( zone->cur[point].x, distance ); |
| |
| zone->tags[point] |= FT_CURVE_TAG_TOUCH_X; |
| } |
| |
| |
| static void |
| Direct_Move_Y( TT_ExecContext exc, |
| TT_GlyphZone zone, |
| FT_UShort point, |
| FT_F26Dot6 distance ) |
| { |
| FT_UNUSED( exc ); |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| if ( !( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility && |
| exc->iupx_called && exc->iupy_called ) ) |
| #endif |
| zone->cur[point].y = ADD_LONG( zone->cur[point].y, distance ); |
| |
| zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * Special versions of Direct_Move_Orig() |
| * |
| * The following versions are used whenever both vectors are both |
| * along one of the coordinate unit vectors, i.e. in 90% of the cases. |
| * |
| */ |
| |
| |
| static void |
| Direct_Move_Orig_X( TT_ExecContext exc, |
| TT_GlyphZone zone, |
| FT_UShort point, |
| FT_F26Dot6 distance ) |
| { |
| FT_UNUSED( exc ); |
| |
| zone->org[point].x = ADD_LONG( zone->org[point].x, distance ); |
| } |
| |
| |
| static void |
| Direct_Move_Orig_Y( TT_ExecContext exc, |
| TT_GlyphZone zone, |
| FT_UShort point, |
| FT_F26Dot6 distance ) |
| { |
| FT_UNUSED( exc ); |
| |
| zone->org[point].y = ADD_LONG( zone->org[point].y, distance ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_None |
| * |
| * @Description: |
| * Does not round, but adds engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance (not) to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * The compensated distance. |
| * |
| * @Note: |
| * The TrueType specification says very few about the relationship |
| * between rounding and engine compensation. However, it seems from |
| * the description of super round that we should add the compensation |
| * before rounding. |
| */ |
| static FT_F26Dot6 |
| Round_None( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| FT_UNUSED( exc ); |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = ADD_LONG( distance, compensation ); |
| if ( val < 0 ) |
| val = 0; |
| } |
| else |
| { |
| val = SUB_LONG( distance, compensation ); |
| if ( val > 0 ) |
| val = 0; |
| } |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_To_Grid |
| * |
| * @Description: |
| * Rounds value to grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| */ |
| static FT_F26Dot6 |
| Round_To_Grid( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| FT_UNUSED( exc ); |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = FT_PIX_ROUND_LONG( ADD_LONG( distance, compensation ) ); |
| if ( val < 0 ) |
| val = 0; |
| } |
| else |
| { |
| val = NEG_LONG( FT_PIX_ROUND_LONG( SUB_LONG( compensation, |
| distance ) ) ); |
| if ( val > 0 ) |
| val = 0; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_To_Half_Grid |
| * |
| * @Description: |
| * Rounds value to half grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| */ |
| static FT_F26Dot6 |
| Round_To_Half_Grid( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| FT_UNUSED( exc ); |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = ADD_LONG( FT_PIX_FLOOR( ADD_LONG( distance, compensation ) ), |
| 32 ); |
| if ( val < 0 ) |
| val = 32; |
| } |
| else |
| { |
| val = NEG_LONG( ADD_LONG( FT_PIX_FLOOR( SUB_LONG( compensation, |
| distance ) ), |
| 32 ) ); |
| if ( val > 0 ) |
| val = -32; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_Down_To_Grid |
| * |
| * @Description: |
| * Rounds value down to grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| */ |
| static FT_F26Dot6 |
| Round_Down_To_Grid( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| FT_UNUSED( exc ); |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = FT_PIX_FLOOR( ADD_LONG( distance, compensation ) ); |
| if ( val < 0 ) |
| val = 0; |
| } |
| else |
| { |
| val = NEG_LONG( FT_PIX_FLOOR( SUB_LONG( compensation, distance ) ) ); |
| if ( val > 0 ) |
| val = 0; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_Up_To_Grid |
| * |
| * @Description: |
| * Rounds value up to grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| */ |
| static FT_F26Dot6 |
| Round_Up_To_Grid( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| FT_UNUSED( exc ); |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = FT_PIX_CEIL_LONG( ADD_LONG( distance, compensation ) ); |
| if ( val < 0 ) |
| val = 0; |
| } |
| else |
| { |
| val = NEG_LONG( FT_PIX_CEIL_LONG( SUB_LONG( compensation, |
| distance ) ) ); |
| if ( val > 0 ) |
| val = 0; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_To_Double_Grid |
| * |
| * @Description: |
| * Rounds value to double grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| */ |
| static FT_F26Dot6 |
| Round_To_Double_Grid( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| FT_UNUSED( exc ); |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = FT_PAD_ROUND_LONG( ADD_LONG( distance, compensation ), 32 ); |
| if ( val < 0 ) |
| val = 0; |
| } |
| else |
| { |
| val = NEG_LONG( FT_PAD_ROUND_LONG( SUB_LONG( compensation, distance ), |
| 32 ) ); |
| if ( val > 0 ) |
| val = 0; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_Super |
| * |
| * @Description: |
| * Super-rounds value to grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| * |
| * @Note: |
| * The TrueType specification says very little about the relationship |
| * between rounding and engine compensation. However, it seems from |
| * the description of super round that we should add the compensation |
| * before rounding. |
| */ |
| static FT_F26Dot6 |
| Round_Super( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = ADD_LONG( distance, |
| exc->threshold - exc->phase + compensation ) & |
| -exc->period; |
| val = ADD_LONG( val, exc->phase ); |
| if ( val < 0 ) |
| val = exc->phase; |
| } |
| else |
| { |
| val = NEG_LONG( SUB_LONG( exc->threshold - exc->phase + compensation, |
| distance ) & |
| -exc->period ); |
| val = SUB_LONG( val, exc->phase ); |
| if ( val > 0 ) |
| val = -exc->phase; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Round_Super_45 |
| * |
| * @Description: |
| * Super-rounds value to grid after adding engine compensation. |
| * |
| * @Input: |
| * distance :: |
| * The distance to round. |
| * |
| * compensation :: |
| * The engine compensation. |
| * |
| * @Return: |
| * Rounded distance. |
| * |
| * @Note: |
| * There is a separate function for Round_Super_45() as we may need |
| * greater precision. |
| */ |
| static FT_F26Dot6 |
| Round_Super_45( TT_ExecContext exc, |
| FT_F26Dot6 distance, |
| FT_F26Dot6 compensation ) |
| { |
| FT_F26Dot6 val; |
| |
| |
| if ( distance >= 0 ) |
| { |
| val = ( ADD_LONG( distance, |
| exc->threshold - exc->phase + compensation ) / |
| exc->period ) * exc->period; |
| val = ADD_LONG( val, exc->phase ); |
| if ( val < 0 ) |
| val = exc->phase; |
| } |
| else |
| { |
| val = NEG_LONG( ( SUB_LONG( exc->threshold - exc->phase + compensation, |
| distance ) / |
| exc->period ) * exc->period ); |
| val = SUB_LONG( val, exc->phase ); |
| if ( val > 0 ) |
| val = -exc->phase; |
| } |
| |
| return val; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Compute_Round |
| * |
| * @Description: |
| * Sets the rounding mode. |
| * |
| * @Input: |
| * round_mode :: |
| * The rounding mode to be used. |
| */ |
| static void |
| Compute_Round( TT_ExecContext exc, |
| FT_Byte round_mode ) |
| { |
| switch ( round_mode ) |
| { |
| case TT_Round_Off: |
| exc->func_round = (TT_Round_Func)Round_None; |
| break; |
| |
| case TT_Round_To_Grid: |
| exc->func_round = (TT_Round_Func)Round_To_Grid; |
| break; |
| |
| case TT_Round_Up_To_Grid: |
| exc->func_round = (TT_Round_Func)Round_Up_To_Grid; |
| break; |
| |
| case TT_Round_Down_To_Grid: |
| exc->func_round = (TT_Round_Func)Round_Down_To_Grid; |
| break; |
| |
| case TT_Round_To_Half_Grid: |
| exc->func_round = (TT_Round_Func)Round_To_Half_Grid; |
| break; |
| |
| case TT_Round_To_Double_Grid: |
| exc->func_round = (TT_Round_Func)Round_To_Double_Grid; |
| break; |
| |
| case TT_Round_Super: |
| exc->func_round = (TT_Round_Func)Round_Super; |
| break; |
| |
| case TT_Round_Super_45: |
| exc->func_round = (TT_Round_Func)Round_Super_45; |
| break; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * SetSuperRound |
| * |
| * @Description: |
| * Sets Super Round parameters. |
| * |
| * @Input: |
| * GridPeriod :: |
| * The grid period. |
| * |
| * selector :: |
| * The SROUND opcode. |
| */ |
| static void |
| SetSuperRound( TT_ExecContext exc, |
| FT_F2Dot14 GridPeriod, |
| FT_Long selector ) |
| { |
| switch ( (FT_Int)( selector & 0xC0 ) ) |
| { |
| case 0: |
| exc->period = GridPeriod / 2; |
| break; |
| |
| case 0x40: |
| exc->period = GridPeriod; |
| break; |
| |
| case 0x80: |
| exc->period = GridPeriod * 2; |
| break; |
| |
| /* This opcode is reserved, but... */ |
| case 0xC0: |
| exc->period = GridPeriod; |
| break; |
| } |
| |
| switch ( (FT_Int)( selector & 0x30 ) ) |
| { |
| case 0: |
| exc->phase = 0; |
| break; |
| |
| case 0x10: |
| exc->phase = exc->period / 4; |
| break; |
| |
| case 0x20: |
| exc->phase = exc->period / 2; |
| break; |
| |
| case 0x30: |
| exc->phase = exc->period * 3 / 4; |
| break; |
| } |
| |
| if ( ( selector & 0x0F ) == 0 ) |
| exc->threshold = exc->period - 1; |
| else |
| exc->threshold = ( (FT_Int)( selector & 0x0F ) - 4 ) * exc->period / 8; |
| |
| /* convert to F26Dot6 format */ |
| exc->period >>= 8; |
| exc->phase >>= 8; |
| exc->threshold >>= 8; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Project |
| * |
| * @Description: |
| * Computes the projection of vector given by (v2-v1) along the |
| * current projection vector. |
| * |
| * @Input: |
| * v1 :: |
| * First input vector. |
| * v2 :: |
| * Second input vector. |
| * |
| * @Return: |
| * The distance in F26dot6 format. |
| */ |
| static FT_F26Dot6 |
| Project( TT_ExecContext exc, |
| FT_Pos dx, |
| FT_Pos dy ) |
| { |
| return TT_DotFix14( dx, dy, |
| exc->GS.projVector.x, |
| exc->GS.projVector.y ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Dual_Project |
| * |
| * @Description: |
| * Computes the projection of the vector given by (v2-v1) along the |
| * current dual vector. |
| * |
| * @Input: |
| * v1 :: |
| * First input vector. |
| * v2 :: |
| * Second input vector. |
| * |
| * @Return: |
| * The distance in F26dot6 format. |
| */ |
| static FT_F26Dot6 |
| Dual_Project( TT_ExecContext exc, |
| FT_Pos dx, |
| FT_Pos dy ) |
| { |
| return TT_DotFix14( dx, dy, |
| exc->GS.dualVector.x, |
| exc->GS.dualVector.y ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Project_x |
| * |
| * @Description: |
| * Computes the projection of the vector given by (v2-v1) along the |
| * horizontal axis. |
| * |
| * @Input: |
| * v1 :: |
| * First input vector. |
| * v2 :: |
| * Second input vector. |
| * |
| * @Return: |
| * The distance in F26dot6 format. |
| */ |
| static FT_F26Dot6 |
| Project_x( TT_ExecContext exc, |
| FT_Pos dx, |
| FT_Pos dy ) |
| { |
| FT_UNUSED( exc ); |
| FT_UNUSED( dy ); |
| |
| return dx; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Project_y |
| * |
| * @Description: |
| * Computes the projection of the vector given by (v2-v1) along the |
| * vertical axis. |
| * |
| * @Input: |
| * v1 :: |
| * First input vector. |
| * v2 :: |
| * Second input vector. |
| * |
| * @Return: |
| * The distance in F26dot6 format. |
| */ |
| static FT_F26Dot6 |
| Project_y( TT_ExecContext exc, |
| FT_Pos dx, |
| FT_Pos dy ) |
| { |
| FT_UNUSED( exc ); |
| FT_UNUSED( dx ); |
| |
| return dy; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Compute_Funcs |
| * |
| * @Description: |
| * Computes the projection and movement function pointers according |
| * to the current graphics state. |
| */ |
| static void |
| Compute_Funcs( TT_ExecContext exc ) |
| { |
| if ( exc->GS.freeVector.x == 0x4000 ) |
| exc->F_dot_P = exc->GS.projVector.x; |
| else if ( exc->GS.freeVector.y == 0x4000 ) |
| exc->F_dot_P = exc->GS.projVector.y; |
| else |
| exc->F_dot_P = |
| ( (FT_Long)exc->GS.projVector.x * exc->GS.freeVector.x + |
| (FT_Long)exc->GS.projVector.y * exc->GS.freeVector.y ) >> 14; |
| |
| if ( exc->GS.projVector.x == 0x4000 ) |
| exc->func_project = (TT_Project_Func)Project_x; |
| else if ( exc->GS.projVector.y == 0x4000 ) |
| exc->func_project = (TT_Project_Func)Project_y; |
| else |
| exc->func_project = (TT_Project_Func)Project; |
| |
| if ( exc->GS.dualVector.x == 0x4000 ) |
| exc->func_dualproj = (TT_Project_Func)Project_x; |
| else if ( exc->GS.dualVector.y == 0x4000 ) |
| exc->func_dualproj = (TT_Project_Func)Project_y; |
| else |
| exc->func_dualproj = (TT_Project_Func)Dual_Project; |
| |
| exc->func_move = (TT_Move_Func)Direct_Move; |
| exc->func_move_orig = (TT_Move_Func)Direct_Move_Orig; |
| |
| if ( exc->F_dot_P == 0x4000L ) |
| { |
| if ( exc->GS.freeVector.x == 0x4000 ) |
| { |
| exc->func_move = (TT_Move_Func)Direct_Move_X; |
| exc->func_move_orig = (TT_Move_Func)Direct_Move_Orig_X; |
| } |
| else if ( exc->GS.freeVector.y == 0x4000 ) |
| { |
| exc->func_move = (TT_Move_Func)Direct_Move_Y; |
| exc->func_move_orig = (TT_Move_Func)Direct_Move_Orig_Y; |
| } |
| } |
| |
| /* at small sizes, F_dot_P can become too small, resulting */ |
| /* in overflows and `spikes' in a number of glyphs like `w'. */ |
| |
| if ( FT_ABS( exc->F_dot_P ) < 0x400L ) |
| exc->F_dot_P = 0x4000L; |
| |
| /* Disable cached aspect ratio */ |
| exc->tt_metrics.ratio = 0; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * @Function: |
| * Normalize |
| * |
| * @Description: |
| * Norms a vector. |
| * |
| * @Input: |
| * Vx :: |
| * The horizontal input vector coordinate. |
| * Vy :: |
| * The vertical input vector coordinate. |
| * |
| * @Output: |
| * R :: |
| * The normed unit vector. |
| * |
| * @Return: |
| * Returns FAILURE if a vector parameter is zero. |
| * |
| * @Note: |
| * In case Vx and Vy are both zero, `Normalize' returns SUCCESS, and |
| * R is undefined. |
| */ |
| static FT_Bool |
| Normalize( FT_F26Dot6 Vx, |
| FT_F26Dot6 Vy, |
| FT_UnitVector* R ) |
| { |
| FT_Vector V; |
| |
| |
| if ( Vx == 0 && Vy == 0 ) |
| { |
| /* XXX: UNDOCUMENTED! It seems that it is possible to try */ |
| /* to normalize the vector (0,0). Return immediately. */ |
| return SUCCESS; |
| } |
| |
| V.x = Vx; |
| V.y = Vy; |
| |
| FT_Vector_NormLen( &V ); |
| |
| R->x = (FT_F2Dot14)( V.x / 4 ); |
| R->y = (FT_F2Dot14)( V.y / 4 ); |
| |
| return SUCCESS; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * Here we start with the implementation of the various opcodes. |
| * |
| */ |
| |
| |
| #define ARRAY_BOUND_ERROR \ |
| do \ |
| { \ |
| exc->error = FT_THROW( Invalid_Reference ); \ |
| return; \ |
| } while (0) |
| |
| |
| /************************************************************************** |
| * |
| * MPPEM[]: Measure Pixel Per EM |
| * Opcode range: 0x4B |
| * Stack: --> Euint16 |
| */ |
| static void |
| Ins_MPPEM( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = exc->func_cur_ppem( exc ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MPS[]: Measure Point Size |
| * Opcode range: 0x4C |
| * Stack: --> Euint16 |
| */ |
| static void |
| Ins_MPS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( NO_SUBPIXEL_HINTING ) |
| { |
| /* Microsoft's GDI bytecode interpreter always returns value 12; */ |
| /* we return the current PPEM value instead. */ |
| args[0] = exc->func_cur_ppem( exc ); |
| } |
| else |
| { |
| /* A possible practical application of the MPS instruction is to */ |
| /* implement optical scaling and similar features, which should be */ |
| /* based on perceptual attributes, thus independent of the */ |
| /* resolution. */ |
| args[0] = exc->pointSize; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DUP[]: DUPlicate the stack's top element |
| * Opcode range: 0x20 |
| * Stack: StkElt --> StkElt StkElt |
| */ |
| static void |
| Ins_DUP( FT_Long* args ) |
| { |
| args[1] = args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * POP[]: POP the stack's top element |
| * Opcode range: 0x21 |
| * Stack: StkElt --> |
| */ |
| static void |
| Ins_POP( void ) |
| { |
| /* nothing to do */ |
| } |
| |
| |
| /************************************************************************** |
| * |
| * CLEAR[]: CLEAR the entire stack |
| * Opcode range: 0x22 |
| * Stack: StkElt... --> |
| */ |
| static void |
| Ins_CLEAR( TT_ExecContext exc ) |
| { |
| exc->new_top = 0; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SWAP[]: SWAP the stack's top two elements |
| * Opcode range: 0x23 |
| * Stack: 2 * StkElt --> 2 * StkElt |
| */ |
| static void |
| Ins_SWAP( FT_Long* args ) |
| { |
| FT_Long L; |
| |
| |
| L = args[0]; |
| args[0] = args[1]; |
| args[1] = L; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DEPTH[]: return the stack DEPTH |
| * Opcode range: 0x24 |
| * Stack: --> uint32 |
| */ |
| static void |
| Ins_DEPTH( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = exc->top; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * LT[]: Less Than |
| * Opcode range: 0x50 |
| * Stack: int32? int32? --> bool |
| */ |
| static void |
| Ins_LT( FT_Long* args ) |
| { |
| args[0] = ( args[0] < args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * LTEQ[]: Less Than or EQual |
| * Opcode range: 0x51 |
| * Stack: int32? int32? --> bool |
| */ |
| static void |
| Ins_LTEQ( FT_Long* args ) |
| { |
| args[0] = ( args[0] <= args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * GT[]: Greater Than |
| * Opcode range: 0x52 |
| * Stack: int32? int32? --> bool |
| */ |
| static void |
| Ins_GT( FT_Long* args ) |
| { |
| args[0] = ( args[0] > args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * GTEQ[]: Greater Than or EQual |
| * Opcode range: 0x53 |
| * Stack: int32? int32? --> bool |
| */ |
| static void |
| Ins_GTEQ( FT_Long* args ) |
| { |
| args[0] = ( args[0] >= args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * EQ[]: EQual |
| * Opcode range: 0x54 |
| * Stack: StkElt StkElt --> bool |
| */ |
| static void |
| Ins_EQ( FT_Long* args ) |
| { |
| args[0] = ( args[0] == args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * NEQ[]: Not EQual |
| * Opcode range: 0x55 |
| * Stack: StkElt StkElt --> bool |
| */ |
| static void |
| Ins_NEQ( FT_Long* args ) |
| { |
| args[0] = ( args[0] != args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ODD[]: Is ODD |
| * Opcode range: 0x56 |
| * Stack: f26.6 --> bool |
| */ |
| static void |
| Ins_ODD( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = ( ( exc->func_round( exc, args[0], 0 ) & 127 ) == 64 ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * EVEN[]: Is EVEN |
| * Opcode range: 0x57 |
| * Stack: f26.6 --> bool |
| */ |
| static void |
| Ins_EVEN( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = ( ( exc->func_round( exc, args[0], 0 ) & 127 ) == 0 ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * AND[]: logical AND |
| * Opcode range: 0x5A |
| * Stack: uint32 uint32 --> uint32 |
| */ |
| static void |
| Ins_AND( FT_Long* args ) |
| { |
| args[0] = ( args[0] && args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * OR[]: logical OR |
| * Opcode range: 0x5B |
| * Stack: uint32 uint32 --> uint32 |
| */ |
| static void |
| Ins_OR( FT_Long* args ) |
| { |
| args[0] = ( args[0] || args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * NOT[]: logical NOT |
| * Opcode range: 0x5C |
| * Stack: StkElt --> uint32 |
| */ |
| static void |
| Ins_NOT( FT_Long* args ) |
| { |
| args[0] = !args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ADD[]: ADD |
| * Opcode range: 0x60 |
| * Stack: f26.6 f26.6 --> f26.6 |
| */ |
| static void |
| Ins_ADD( FT_Long* args ) |
| { |
| args[0] = ADD_LONG( args[0], args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SUB[]: SUBtract |
| * Opcode range: 0x61 |
| * Stack: f26.6 f26.6 --> f26.6 |
| */ |
| static void |
| Ins_SUB( FT_Long* args ) |
| { |
| args[0] = SUB_LONG( args[0], args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DIV[]: DIVide |
| * Opcode range: 0x62 |
| * Stack: f26.6 f26.6 --> f26.6 |
| */ |
| static void |
| Ins_DIV( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( args[1] == 0 ) |
| exc->error = FT_THROW( Divide_By_Zero ); |
| else |
| args[0] = FT_MulDiv_No_Round( args[0], 64L, args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MUL[]: MULtiply |
| * Opcode range: 0x63 |
| * Stack: f26.6 f26.6 --> f26.6 |
| */ |
| static void |
| Ins_MUL( FT_Long* args ) |
| { |
| args[0] = FT_MulDiv( args[0], args[1], 64L ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ABS[]: ABSolute value |
| * Opcode range: 0x64 |
| * Stack: f26.6 --> f26.6 |
| */ |
| static void |
| Ins_ABS( FT_Long* args ) |
| { |
| if ( args[0] < 0 ) |
| args[0] = NEG_LONG( args[0] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * NEG[]: NEGate |
| * Opcode range: 0x65 |
| * Stack: f26.6 --> f26.6 |
| */ |
| static void |
| Ins_NEG( FT_Long* args ) |
| { |
| args[0] = NEG_LONG( args[0] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * FLOOR[]: FLOOR |
| * Opcode range: 0x66 |
| * Stack: f26.6 --> f26.6 |
| */ |
| static void |
| Ins_FLOOR( FT_Long* args ) |
| { |
| args[0] = FT_PIX_FLOOR( args[0] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * CEILING[]: CEILING |
| * Opcode range: 0x67 |
| * Stack: f26.6 --> f26.6 |
| */ |
| static void |
| Ins_CEILING( FT_Long* args ) |
| { |
| args[0] = FT_PIX_CEIL_LONG( args[0] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * RS[]: Read Store |
| * Opcode range: 0x43 |
| * Stack: uint32 --> uint32 |
| */ |
| static void |
| Ins_RS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong I = (FT_ULong)args[0]; |
| |
| |
| if ( BOUNDSL( I, exc->storeSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| ARRAY_BOUND_ERROR; |
| else |
| args[0] = 0; |
| } |
| else |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* subpixel hinting - avoid Typeman Dstroke and */ |
| /* IStroke and Vacuform rounds */ |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| ( ( I == 24 && |
| ( exc->face->sph_found_func_flags & |
| ( SPH_FDEF_SPACING_1 | |
| SPH_FDEF_SPACING_2 ) ) ) || |
| ( I == 22 && |
| ( exc->sph_in_func_flags & |
| SPH_FDEF_TYPEMAN_STROKES ) ) || |
| ( I == 8 && |
| ( exc->face->sph_found_func_flags & |
| SPH_FDEF_VACUFORM_ROUND_1 ) && |
| exc->iup_called ) ) ) |
| args[0] = 0; |
| else |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| args[0] = exc->storage[I]; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * WS[]: Write Store |
| * Opcode range: 0x42 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_WS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong I = (FT_ULong)args[0]; |
| |
| |
| if ( BOUNDSL( I, exc->storeSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| ARRAY_BOUND_ERROR; |
| } |
| else |
| exc->storage[I] = args[1]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * WCVTP[]: Write CVT in Pixel units |
| * Opcode range: 0x44 |
| * Stack: f26.6 uint32 --> |
| */ |
| static void |
| Ins_WCVTP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong I = (FT_ULong)args[0]; |
| |
| |
| if ( BOUNDSL( I, exc->cvtSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| ARRAY_BOUND_ERROR; |
| } |
| else |
| exc->func_write_cvt( exc, I, args[1] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * WCVTF[]: Write CVT in Funits |
| * Opcode range: 0x70 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_WCVTF( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong I = (FT_ULong)args[0]; |
| |
| |
| if ( BOUNDSL( I, exc->cvtSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| ARRAY_BOUND_ERROR; |
| } |
| else |
| exc->cvt[I] = FT_MulFix( args[1], exc->tt_metrics.scale ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * RCVT[]: Read CVT |
| * Opcode range: 0x45 |
| * Stack: uint32 --> f26.6 |
| */ |
| static void |
| Ins_RCVT( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong I = (FT_ULong)args[0]; |
| |
| |
| if ( BOUNDSL( I, exc->cvtSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| ARRAY_BOUND_ERROR; |
| else |
| args[0] = 0; |
| } |
| else |
| args[0] = exc->func_read_cvt( exc, I ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * AA[]: Adjust Angle |
| * Opcode range: 0x7F |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_AA( void ) |
| { |
| /* intentionally no longer supported */ |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DEBUG[]: DEBUG. Unsupported. |
| * Opcode range: 0x4F |
| * Stack: uint32 --> |
| * |
| * Note: The original instruction pops a value from the stack. |
| */ |
| static void |
| Ins_DEBUG( TT_ExecContext exc ) |
| { |
| exc->error = FT_THROW( Debug_OpCode ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ROUND[ab]: ROUND value |
| * Opcode range: 0x68-0x6B |
| * Stack: f26.6 --> f26.6 |
| */ |
| static void |
| Ins_ROUND( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = exc->func_round( |
| exc, |
| args[0], |
| exc->tt_metrics.compensations[exc->opcode - 0x68] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * NROUND[ab]: No ROUNDing of value |
| * Opcode range: 0x6C-0x6F |
| * Stack: f26.6 --> f26.6 |
| */ |
| static void |
| Ins_NROUND( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = Round_None( |
| exc, |
| args[0], |
| exc->tt_metrics.compensations[exc->opcode - 0x6C] ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MAX[]: MAXimum |
| * Opcode range: 0x8B |
| * Stack: int32? int32? --> int32 |
| */ |
| static void |
| Ins_MAX( FT_Long* args ) |
| { |
| if ( args[1] > args[0] ) |
| args[0] = args[1]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MIN[]: MINimum |
| * Opcode range: 0x8C |
| * Stack: int32? int32? --> int32 |
| */ |
| static void |
| Ins_MIN( FT_Long* args ) |
| { |
| if ( args[1] < args[0] ) |
| args[0] = args[1]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MINDEX[]: Move INDEXed element |
| * Opcode range: 0x26 |
| * Stack: int32? --> StkElt |
| */ |
| static void |
| Ins_MINDEX( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Long L, K; |
| |
| |
| L = args[0]; |
| |
| if ( L <= 0 || L > exc->args ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| } |
| else |
| { |
| K = exc->stack[exc->args - L]; |
| |
| FT_ARRAY_MOVE( &exc->stack[exc->args - L ], |
| &exc->stack[exc->args - L + 1], |
| ( L - 1 ) ); |
| |
| exc->stack[exc->args - 1] = K; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * CINDEX[]: Copy INDEXed element |
| * Opcode range: 0x25 |
| * Stack: int32 --> StkElt |
| */ |
| static void |
| Ins_CINDEX( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Long L; |
| |
| |
| L = args[0]; |
| |
| if ( L <= 0 || L > exc->args ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| args[0] = 0; |
| } |
| else |
| args[0] = exc->stack[exc->args - L]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ROLL[]: ROLL top three elements |
| * Opcode range: 0x8A |
| * Stack: 3 * StkElt --> 3 * StkElt |
| */ |
| static void |
| Ins_ROLL( FT_Long* args ) |
| { |
| FT_Long A, B, C; |
| |
| |
| A = args[2]; |
| B = args[1]; |
| C = args[0]; |
| |
| args[2] = C; |
| args[1] = A; |
| args[0] = B; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MANAGING THE FLOW OF CONTROL |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * SLOOP[]: Set LOOP variable |
| * Opcode range: 0x17 |
| * Stack: int32? --> |
| */ |
| static void |
| Ins_SLOOP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( args[0] < 0 ) |
| exc->error = FT_THROW( Bad_Argument ); |
| else |
| { |
| /* we heuristically limit the number of loops to 16 bits */ |
| exc->GS.loop = args[0] > 0xFFFFL ? 0xFFFFL : args[0]; |
| } |
| } |
| |
| |
| static FT_Bool |
| SkipCode( TT_ExecContext exc ) |
| { |
| exc->IP += exc->length; |
| |
| if ( exc->IP < exc->codeSize ) |
| { |
| exc->opcode = exc->code[exc->IP]; |
| |
| exc->length = opcode_length[exc->opcode]; |
| if ( exc->length < 0 ) |
| { |
| if ( exc->IP + 1 >= exc->codeSize ) |
| goto Fail_Overflow; |
| exc->length = 2 - exc->length * exc->code[exc->IP + 1]; |
| } |
| |
| if ( exc->IP + exc->length <= exc->codeSize ) |
| return SUCCESS; |
| } |
| |
| Fail_Overflow: |
| exc->error = FT_THROW( Code_Overflow ); |
| return FAILURE; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * IF[]: IF test |
| * Opcode range: 0x58 |
| * Stack: StkElt --> |
| */ |
| static void |
| Ins_IF( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Int nIfs; |
| FT_Bool Out; |
| |
| |
| if ( args[0] != 0 ) |
| return; |
| |
| nIfs = 1; |
| Out = 0; |
| |
| do |
| { |
| if ( SkipCode( exc ) == FAILURE ) |
| return; |
| |
| switch ( exc->opcode ) |
| { |
| case 0x58: /* IF */ |
| nIfs++; |
| break; |
| |
| case 0x1B: /* ELSE */ |
| Out = FT_BOOL( nIfs == 1 ); |
| break; |
| |
| case 0x59: /* EIF */ |
| nIfs--; |
| Out = FT_BOOL( nIfs == 0 ); |
| break; |
| } |
| } while ( Out == 0 ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ELSE[]: ELSE |
| * Opcode range: 0x1B |
| * Stack: --> |
| */ |
| static void |
| Ins_ELSE( TT_ExecContext exc ) |
| { |
| FT_Int nIfs; |
| |
| |
| nIfs = 1; |
| |
| do |
| { |
| if ( SkipCode( exc ) == FAILURE ) |
| return; |
| |
| switch ( exc->opcode ) |
| { |
| case 0x58: /* IF */ |
| nIfs++; |
| break; |
| |
| case 0x59: /* EIF */ |
| nIfs--; |
| break; |
| } |
| } while ( nIfs != 0 ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * EIF[]: End IF |
| * Opcode range: 0x59 |
| * Stack: --> |
| */ |
| static void |
| Ins_EIF( void ) |
| { |
| /* nothing to do */ |
| } |
| |
| |
| /************************************************************************** |
| * |
| * JMPR[]: JuMP Relative |
| * Opcode range: 0x1C |
| * Stack: int32 --> |
| */ |
| static void |
| Ins_JMPR( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( args[0] == 0 && exc->args == 0 ) |
| { |
| exc->error = FT_THROW( Bad_Argument ); |
| return; |
| } |
| |
| exc->IP += args[0]; |
| if ( exc->IP < 0 || |
| ( exc->callTop > 0 && |
| exc->IP > exc->callStack[exc->callTop - 1].Def->end ) ) |
| { |
| exc->error = FT_THROW( Bad_Argument ); |
| return; |
| } |
| |
| exc->step_ins = FALSE; |
| |
| if ( args[0] < 0 ) |
| { |
| if ( ++exc->neg_jump_counter > exc->neg_jump_counter_max ) |
| exc->error = FT_THROW( Execution_Too_Long ); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * JROT[]: Jump Relative On True |
| * Opcode range: 0x78 |
| * Stack: StkElt int32 --> |
| */ |
| static void |
| Ins_JROT( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( args[1] != 0 ) |
| Ins_JMPR( exc, args ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * JROF[]: Jump Relative On False |
| * Opcode range: 0x79 |
| * Stack: StkElt int32 --> |
| */ |
| static void |
| Ins_JROF( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( args[1] == 0 ) |
| Ins_JMPR( exc, args ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DEFINING AND USING FUNCTIONS AND INSTRUCTIONS |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * FDEF[]: Function DEFinition |
| * Opcode range: 0x2C |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_FDEF( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong n; |
| TT_DefRecord* rec; |
| TT_DefRecord* limit; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* arguments to opcodes are skipped by `SKIP_Code' */ |
| FT_Byte opcode_pattern[9][12] = { |
| /* #0 inline delta function 1 */ |
| { |
| 0x4B, /* PPEM */ |
| 0x53, /* GTEQ */ |
| 0x23, /* SWAP */ |
| 0x4B, /* PPEM */ |
| 0x51, /* LTEQ */ |
| 0x5A, /* AND */ |
| 0x58, /* IF */ |
| 0x38, /* SHPIX */ |
| 0x1B, /* ELSE */ |
| 0x21, /* POP */ |
| 0x21, /* POP */ |
| 0x59 /* EIF */ |
| }, |
| /* #1 inline delta function 2 */ |
| { |
| 0x4B, /* PPEM */ |
| 0x54, /* EQ */ |
| 0x58, /* IF */ |
| 0x38, /* SHPIX */ |
| 0x1B, /* ELSE */ |
| 0x21, /* POP */ |
| 0x21, /* POP */ |
| 0x59 /* EIF */ |
| }, |
| /* #2 diagonal stroke function */ |
| { |
| 0x20, /* DUP */ |
| 0x20, /* DUP */ |
| 0xB0, /* PUSHB_1 */ |
| /* 1 */ |
| 0x60, /* ADD */ |
| 0x46, /* GC_cur */ |
| 0xB0, /* PUSHB_1 */ |
| /* 64 */ |
| 0x23, /* SWAP */ |
| 0x42 /* WS */ |
| }, |
| /* #3 VacuFormRound function */ |
| { |
| 0x45, /* RCVT */ |
| 0x23, /* SWAP */ |
| 0x46, /* GC_cur */ |
| 0x60, /* ADD */ |
| 0x20, /* DUP */ |
| 0xB0 /* PUSHB_1 */ |
| /* 38 */ |
| }, |
| /* #4 TTFautohint bytecode (old) */ |
| { |
| 0x20, /* DUP */ |
| 0x64, /* ABS */ |
| 0xB0, /* PUSHB_1 */ |
| /* 32 */ |
| 0x60, /* ADD */ |
| 0x66, /* FLOOR */ |
| 0x23, /* SWAP */ |
| 0xB0 /* PUSHB_1 */ |
| }, |
| /* #5 spacing function 1 */ |
| { |
| 0x01, /* SVTCA_x */ |
| 0xB0, /* PUSHB_1 */ |
| /* 24 */ |
| 0x43, /* RS */ |
| 0x58 /* IF */ |
| }, |
| /* #6 spacing function 2 */ |
| { |
| 0x01, /* SVTCA_x */ |
| 0x18, /* RTG */ |
| 0xB0, /* PUSHB_1 */ |
| /* 24 */ |
| 0x43, /* RS */ |
| 0x58 /* IF */ |
| }, |
| /* #7 TypeMan Talk DiagEndCtrl function */ |
| { |
| 0x01, /* SVTCA_x */ |
| 0x20, /* DUP */ |
| 0xB0, /* PUSHB_1 */ |
| /* 3 */ |
| 0x25, /* CINDEX */ |
| }, |
| /* #8 TypeMan Talk Align */ |
| { |
| 0x06, /* SPVTL */ |
| 0x7D, /* RDTG */ |
| }, |
| }; |
| FT_UShort opcode_patterns = 9; |
| FT_UShort opcode_pointer[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| FT_UShort opcode_size[9] = { 12, 8, 8, 6, 7, 4, 5, 4, 2 }; |
| FT_UShort i; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| |
| /* FDEF is only allowed in `prep' or `fpgm' */ |
| if ( exc->curRange == tt_coderange_glyph ) |
| { |
| exc->error = FT_THROW( DEF_In_Glyf_Bytecode ); |
| return; |
| } |
| |
| /* some font programs are broken enough to redefine functions! */ |
| /* We will then parse the current table. */ |
| |
| rec = exc->FDefs; |
| limit = rec + exc->numFDefs; |
| n = (FT_ULong)args[0]; |
| |
| for ( ; rec < limit; rec++ ) |
| { |
| if ( rec->opc == n ) |
| break; |
| } |
| |
| if ( rec == limit ) |
| { |
| /* check that there is enough room for new functions */ |
| if ( exc->numFDefs >= exc->maxFDefs ) |
| { |
| exc->error = FT_THROW( Too_Many_Function_Defs ); |
| return; |
| } |
| exc->numFDefs++; |
| } |
| |
| /* Although FDEF takes unsigned 32-bit integer, */ |
| /* func # must be within unsigned 16-bit integer */ |
| if ( n > 0xFFFFU ) |
| { |
| exc->error = FT_THROW( Too_Many_Function_Defs ); |
| return; |
| } |
| |
| rec->range = exc->curRange; |
| rec->opc = (FT_UInt16)n; |
| rec->start = exc->IP + 1; |
| rec->active = TRUE; |
| rec->inline_delta = FALSE; |
| rec->sph_fdef_flags = 0x0000; |
| |
| if ( n > exc->maxFunc ) |
| exc->maxFunc = (FT_UInt16)n; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* We don't know for sure these are typeman functions, */ |
| /* however they are only active when RS 22 is called */ |
| if ( n >= 64 && n <= 66 ) |
| rec->sph_fdef_flags |= SPH_FDEF_TYPEMAN_STROKES; |
| #endif |
| |
| /* Now skip the whole function definition. */ |
| /* We don't allow nested IDEFS & FDEFs. */ |
| |
| while ( SkipCode( exc ) == SUCCESS ) |
| { |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| for ( i = 0; i < opcode_patterns; i++ ) |
| { |
| if ( opcode_pointer[i] < opcode_size[i] && |
| exc->opcode == opcode_pattern[i][opcode_pointer[i]] ) |
| { |
| opcode_pointer[i] += 1; |
| |
| if ( opcode_pointer[i] == opcode_size[i] ) |
| { |
| FT_TRACE6(( "sph: Function %d, opcode ptrn: %d, %s %s\n", |
| i, n, |
| exc->face->root.family_name, |
| exc->face->root.style_name )); |
| |
| switch ( i ) |
| { |
| case 0: |
| rec->sph_fdef_flags |= SPH_FDEF_INLINE_DELTA_1; |
| exc->face->sph_found_func_flags |= SPH_FDEF_INLINE_DELTA_1; |
| break; |
| |
| case 1: |
| rec->sph_fdef_flags |= SPH_FDEF_INLINE_DELTA_2; |
| exc->face->sph_found_func_flags |= SPH_FDEF_INLINE_DELTA_2; |
| break; |
| |
| case 2: |
| switch ( n ) |
| { |
| /* needs to be implemented still */ |
| case 58: |
| rec->sph_fdef_flags |= SPH_FDEF_DIAGONAL_STROKE; |
| exc->face->sph_found_func_flags |= SPH_FDEF_DIAGONAL_STROKE; |
| } |
| break; |
| |
| case 3: |
| switch ( n ) |
| { |
| case 0: |
| rec->sph_fdef_flags |= SPH_FDEF_VACUFORM_ROUND_1; |
| exc->face->sph_found_func_flags |= SPH_FDEF_VACUFORM_ROUND_1; |
| } |
| break; |
| |
| case 4: |
| /* probably not necessary to detect anymore */ |
| rec->sph_fdef_flags |= SPH_FDEF_TTFAUTOHINT_1; |
| exc->face->sph_found_func_flags |= SPH_FDEF_TTFAUTOHINT_1; |
| break; |
| |
| case 5: |
| switch ( n ) |
| { |
| case 0: |
| case 1: |
| case 2: |
| case 4: |
| case 7: |
| case 8: |
| rec->sph_fdef_flags |= SPH_FDEF_SPACING_1; |
| exc->face->sph_found_func_flags |= SPH_FDEF_SPACING_1; |
| } |
| break; |
| |
| case 6: |
| switch ( n ) |
| { |
| case 0: |
| case 1: |
| case 2: |
| case 4: |
| case 7: |
| case 8: |
| rec->sph_fdef_flags |= SPH_FDEF_SPACING_2; |
| exc->face->sph_found_func_flags |= SPH_FDEF_SPACING_2; |
| } |
| break; |
| |
| case 7: |
| rec->sph_fdef_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL; |
| exc->face->sph_found_func_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL; |
| break; |
| |
| case 8: |
| #if 0 |
| rec->sph_fdef_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL; |
| exc->face->sph_found_func_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL; |
| #endif |
| break; |
| } |
| opcode_pointer[i] = 0; |
| } |
| } |
| |
| else |
| opcode_pointer[i] = 0; |
| } |
| |
| /* Set sph_compatibility_mode only when deltas are detected */ |
| exc->face->sph_compatibility_mode = |
| ( ( exc->face->sph_found_func_flags & SPH_FDEF_INLINE_DELTA_1 ) | |
| ( exc->face->sph_found_func_flags & SPH_FDEF_INLINE_DELTA_2 ) ); |
| } |
| |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| switch ( exc->opcode ) |
| { |
| case 0x89: /* IDEF */ |
| case 0x2C: /* FDEF */ |
| exc->error = FT_THROW( Nested_DEFS ); |
| return; |
| |
| case 0x2D: /* ENDF */ |
| rec->end = exc->IP; |
| return; |
| } |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ENDF[]: END Function definition |
| * Opcode range: 0x2D |
| * Stack: --> |
| */ |
| static void |
| Ins_ENDF( TT_ExecContext exc ) |
| { |
| TT_CallRec* pRec; |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| exc->sph_in_func_flags = 0x0000; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| if ( exc->callTop <= 0 ) /* We encountered an ENDF without a call */ |
| { |
| exc->error = FT_THROW( ENDF_In_Exec_Stream ); |
| return; |
| } |
| |
| exc->callTop--; |
| |
| pRec = &exc->callStack[exc->callTop]; |
| |
| pRec->Cur_Count--; |
| |
| exc->step_ins = FALSE; |
| |
| if ( pRec->Cur_Count > 0 ) |
| { |
| exc->callTop++; |
| exc->IP = pRec->Def->start; |
| } |
| else |
| /* Loop through the current function */ |
| Ins_Goto_CodeRange( exc, pRec->Caller_Range, pRec->Caller_IP ); |
| |
| /* Exit the current call frame. */ |
| |
| /* NOTE: If the last instruction of a program is a */ |
| /* CALL or LOOPCALL, the return address is */ |
| /* always out of the code range. This is a */ |
| /* valid address, and it is why we do not test */ |
| /* the result of Ins_Goto_CodeRange() here! */ |
| } |
| |
| |
| /************************************************************************** |
| * |
| * CALL[]: CALL function |
| * Opcode range: 0x2B |
| * Stack: uint32? --> |
| */ |
| static void |
| Ins_CALL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong F; |
| TT_CallRec* pCrec; |
| TT_DefRecord* def; |
| |
| |
| /* first of all, check the index */ |
| |
| F = (FT_ULong)args[0]; |
| if ( BOUNDSL( F, exc->maxFunc + 1 ) ) |
| goto Fail; |
| |
| /* Except for some old Apple fonts, all functions in a TrueType */ |
| /* font are defined in increasing order, starting from 0. This */ |
| /* means that we normally have */ |
| /* */ |
| /* exc->maxFunc+1 == exc->numFDefs */ |
| /* exc->FDefs[n].opc == n for n in 0..exc->maxFunc */ |
| /* */ |
| /* If this isn't true, we need to look up the function table. */ |
| |
| def = exc->FDefs + F; |
| if ( exc->maxFunc + 1 != exc->numFDefs || def->opc != F ) |
| { |
| /* look up the FDefs table */ |
| TT_DefRecord* limit; |
| |
| |
| def = exc->FDefs; |
| limit = def + exc->numFDefs; |
| |
| while ( def < limit && def->opc != F ) |
| def++; |
| |
| if ( def == limit ) |
| goto Fail; |
| } |
| |
| /* check that the function is active */ |
| if ( !def->active ) |
| goto Fail; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| ( ( exc->iup_called && |
| ( exc->sph_tweak_flags & SPH_TWEAK_NO_CALL_AFTER_IUP ) ) || |
| ( def->sph_fdef_flags & SPH_FDEF_VACUFORM_ROUND_1 ) ) ) |
| goto Fail; |
| else |
| exc->sph_in_func_flags = def->sph_fdef_flags; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| /* check the call stack */ |
| if ( exc->callTop >= exc->callSize ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| pCrec = exc->callStack + exc->callTop; |
| |
| pCrec->Caller_Range = exc->curRange; |
| pCrec->Caller_IP = exc->IP + 1; |
| pCrec->Cur_Count = 1; |
| pCrec->Def = def; |
| |
| exc->callTop++; |
| |
| Ins_Goto_CodeRange( exc, def->range, def->start ); |
| |
| exc->step_ins = FALSE; |
| |
| return; |
| |
| Fail: |
| exc->error = FT_THROW( Invalid_Reference ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * LOOPCALL[]: LOOP and CALL function |
| * Opcode range: 0x2A |
| * Stack: uint32? Eint16? --> |
| */ |
| static void |
| Ins_LOOPCALL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong F; |
| TT_CallRec* pCrec; |
| TT_DefRecord* def; |
| |
| |
| /* first of all, check the index */ |
| F = (FT_ULong)args[1]; |
| if ( BOUNDSL( F, exc->maxFunc + 1 ) ) |
| goto Fail; |
| |
| /* Except for some old Apple fonts, all functions in a TrueType */ |
| /* font are defined in increasing order, starting from 0. This */ |
| /* means that we normally have */ |
| /* */ |
| /* exc->maxFunc+1 == exc->numFDefs */ |
| /* exc->FDefs[n].opc == n for n in 0..exc->maxFunc */ |
| /* */ |
| /* If this isn't true, we need to look up the function table. */ |
| |
| def = exc->FDefs + F; |
| if ( exc->maxFunc + 1 != exc->numFDefs || def->opc != F ) |
| { |
| /* look up the FDefs table */ |
| TT_DefRecord* limit; |
| |
| |
| def = exc->FDefs; |
| limit = def + exc->numFDefs; |
| |
| while ( def < limit && def->opc != F ) |
| def++; |
| |
| if ( def == limit ) |
| goto Fail; |
| } |
| |
| /* check that the function is active */ |
| if ( !def->active ) |
| goto Fail; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| ( def->sph_fdef_flags & SPH_FDEF_VACUFORM_ROUND_1 ) ) |
| goto Fail; |
| else |
| exc->sph_in_func_flags = def->sph_fdef_flags; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| /* check stack */ |
| if ( exc->callTop >= exc->callSize ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| if ( args[0] > 0 ) |
| { |
| pCrec = exc->callStack + exc->callTop; |
| |
| pCrec->Caller_Range = exc->curRange; |
| pCrec->Caller_IP = exc->IP + 1; |
| pCrec->Cur_Count = (FT_Int)args[0]; |
| pCrec->Def = def; |
| |
| exc->callTop++; |
| |
| Ins_Goto_CodeRange( exc, def->range, def->start ); |
| |
| exc->step_ins = FALSE; |
| |
| exc->loopcall_counter += (FT_ULong)args[0]; |
| if ( exc->loopcall_counter > exc->loopcall_counter_max ) |
| exc->error = FT_THROW( Execution_Too_Long ); |
| } |
| |
| return; |
| |
| Fail: |
| exc->error = FT_THROW( Invalid_Reference ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * IDEF[]: Instruction DEFinition |
| * Opcode range: 0x89 |
| * Stack: Eint8 --> |
| */ |
| static void |
| Ins_IDEF( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| TT_DefRecord* def; |
| TT_DefRecord* limit; |
| |
| |
| /* we enable IDEF only in `prep' or `fpgm' */ |
| if ( exc->curRange == tt_coderange_glyph ) |
| { |
| exc->error = FT_THROW( DEF_In_Glyf_Bytecode ); |
| return; |
| } |
| |
| /* First of all, look for the same function in our table */ |
| |
| def = exc->IDefs; |
| limit = def + exc->numIDefs; |
| |
| for ( ; def < limit; def++ ) |
| if ( def->opc == (FT_ULong)args[0] ) |
| break; |
| |
| if ( def == limit ) |
| { |
| /* check that there is enough room for a new instruction */ |
| if ( exc->numIDefs >= exc->maxIDefs ) |
| { |
| exc->error = FT_THROW( Too_Many_Instruction_Defs ); |
| return; |
| } |
| exc->numIDefs++; |
| } |
| |
| /* opcode must be unsigned 8-bit integer */ |
| if ( 0 > args[0] || args[0] > 0x00FF ) |
| { |
| exc->error = FT_THROW( Too_Many_Instruction_Defs ); |
| return; |
| } |
| |
| def->opc = (FT_Byte)args[0]; |
| def->start = exc->IP + 1; |
| def->range = exc->curRange; |
| def->active = TRUE; |
| |
| if ( (FT_ULong)args[0] > exc->maxIns ) |
| exc->maxIns = (FT_Byte)args[0]; |
| |
| /* Now skip the whole function definition. */ |
| /* We don't allow nested IDEFs & FDEFs. */ |
| |
| while ( SkipCode( exc ) == SUCCESS ) |
| { |
| switch ( exc->opcode ) |
| { |
| case 0x89: /* IDEF */ |
| case 0x2C: /* FDEF */ |
| exc->error = FT_THROW( Nested_DEFS ); |
| return; |
| case 0x2D: /* ENDF */ |
| def->end = exc->IP; |
| return; |
| } |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * PUSHING DATA ONTO THE INTERPRETER STACK |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * NPUSHB[]: PUSH N Bytes |
| * Opcode range: 0x40 |
| * Stack: --> uint32... |
| */ |
| static void |
| Ins_NPUSHB( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort L, K; |
| |
| |
| L = (FT_UShort)exc->code[exc->IP + 1]; |
| |
| if ( BOUNDS( L, exc->stackSize + 1 - exc->top ) ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| for ( K = 1; K <= L; K++ ) |
| args[K - 1] = exc->code[exc->IP + K + 1]; |
| |
| exc->new_top += L; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * NPUSHW[]: PUSH N Words |
| * Opcode range: 0x41 |
| * Stack: --> int32... |
| */ |
| static void |
| Ins_NPUSHW( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort L, K; |
| |
| |
| L = (FT_UShort)exc->code[exc->IP + 1]; |
| |
| if ( BOUNDS( L, exc->stackSize + 1 - exc->top ) ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| exc->IP += 2; |
| |
| for ( K = 0; K < L; K++ ) |
| args[K] = GetShortIns( exc ); |
| |
| exc->step_ins = FALSE; |
| exc->new_top += L; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * PUSHB[abc]: PUSH Bytes |
| * Opcode range: 0xB0-0xB7 |
| * Stack: --> uint32... |
| */ |
| static void |
| Ins_PUSHB( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort L, K; |
| |
| |
| L = (FT_UShort)( exc->opcode - 0xB0 + 1 ); |
| |
| if ( BOUNDS( L, exc->stackSize + 1 - exc->top ) ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| for ( K = 1; K <= L; K++ ) |
| args[K - 1] = exc->code[exc->IP + K]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * PUSHW[abc]: PUSH Words |
| * Opcode range: 0xB8-0xBF |
| * Stack: --> int32... |
| */ |
| static void |
| Ins_PUSHW( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort L, K; |
| |
| |
| L = (FT_UShort)( exc->opcode - 0xB8 + 1 ); |
| |
| if ( BOUNDS( L, exc->stackSize + 1 - exc->top ) ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| exc->IP++; |
| |
| for ( K = 0; K < L; K++ ) |
| args[K] = GetShortIns( exc ); |
| |
| exc->step_ins = FALSE; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MANAGING THE GRAPHICS STATE |
| * |
| */ |
| |
| |
| static FT_Bool |
| Ins_SxVTL( TT_ExecContext exc, |
| FT_UShort aIdx1, |
| FT_UShort aIdx2, |
| FT_UnitVector* Vec ) |
| { |
| FT_Long A, B, C; |
| FT_Vector* p1; |
| FT_Vector* p2; |
| |
| FT_Byte opcode = exc->opcode; |
| |
| |
| if ( BOUNDS( aIdx1, exc->zp2.n_points ) || |
| BOUNDS( aIdx2, exc->zp1.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return FAILURE; |
| } |
| |
| p1 = exc->zp1.cur + aIdx2; |
| p2 = exc->zp2.cur + aIdx1; |
| |
| A = SUB_LONG( p1->x, p2->x ); |
| B = SUB_LONG( p1->y, p2->y ); |
| |
| /* If p1 == p2, SPvTL and SFvTL behave the same as */ |
| /* SPvTCA[X] and SFvTCA[X], respectively. */ |
| /* */ |
| /* Confirmed by Greg Hitchcock. */ |
| |
| if ( A == 0 && B == 0 ) |
| { |
| A = 0x4000; |
| opcode = 0; |
| } |
| |
| if ( ( opcode & 1 ) != 0 ) |
| { |
| C = B; /* counter clockwise rotation */ |
| B = A; |
| A = NEG_LONG( C ); |
| } |
| |
| Normalize( A, B, Vec ); |
| |
| return SUCCESS; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SVTCA[a]: Set (F and P) Vectors to Coordinate Axis |
| * Opcode range: 0x00-0x01 |
| * Stack: --> |
| * |
| * SPvTCA[a]: Set PVector to Coordinate Axis |
| * Opcode range: 0x02-0x03 |
| * Stack: --> |
| * |
| * SFvTCA[a]: Set FVector to Coordinate Axis |
| * Opcode range: 0x04-0x05 |
| * Stack: --> |
| */ |
| static void |
| Ins_SxyTCA( TT_ExecContext exc ) |
| { |
| FT_Short AA, BB; |
| |
| FT_Byte opcode = exc->opcode; |
| |
| |
| AA = (FT_Short)( ( opcode & 1 ) << 14 ); |
| BB = (FT_Short)( AA ^ 0x4000 ); |
| |
| if ( opcode < 4 ) |
| { |
| exc->GS.projVector.x = AA; |
| exc->GS.projVector.y = BB; |
| |
| exc->GS.dualVector.x = AA; |
| exc->GS.dualVector.y = BB; |
| } |
| |
| if ( ( opcode & 2 ) == 0 ) |
| { |
| exc->GS.freeVector.x = AA; |
| exc->GS.freeVector.y = BB; |
| } |
| |
| Compute_Funcs( exc ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SPvTL[a]: Set PVector To Line |
| * Opcode range: 0x06-0x07 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_SPVTL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( Ins_SxVTL( exc, |
| (FT_UShort)args[1], |
| (FT_UShort)args[0], |
| &exc->GS.projVector ) == SUCCESS ) |
| { |
| exc->GS.dualVector = exc->GS.projVector; |
| Compute_Funcs( exc ); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SFvTL[a]: Set FVector To Line |
| * Opcode range: 0x08-0x09 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_SFVTL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( Ins_SxVTL( exc, |
| (FT_UShort)args[1], |
| (FT_UShort)args[0], |
| &exc->GS.freeVector ) == SUCCESS ) |
| { |
| Compute_Funcs( exc ); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SFvTPv[]: Set FVector To PVector |
| * Opcode range: 0x0E |
| * Stack: --> |
| */ |
| static void |
| Ins_SFVTPV( TT_ExecContext exc ) |
| { |
| exc->GS.freeVector = exc->GS.projVector; |
| Compute_Funcs( exc ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SPvFS[]: Set PVector From Stack |
| * Opcode range: 0x0A |
| * Stack: f2.14 f2.14 --> |
| */ |
| static void |
| Ins_SPVFS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Short S; |
| FT_Long X, Y; |
| |
| |
| /* Only use low 16bits, then sign extend */ |
| S = (FT_Short)args[1]; |
| Y = (FT_Long)S; |
| S = (FT_Short)args[0]; |
| X = (FT_Long)S; |
| |
| Normalize( X, Y, &exc->GS.projVector ); |
| |
| exc->GS.dualVector = exc->GS.projVector; |
| Compute_Funcs( exc ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SFvFS[]: Set FVector From Stack |
| * Opcode range: 0x0B |
| * Stack: f2.14 f2.14 --> |
| */ |
| static void |
| Ins_SFVFS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Short S; |
| FT_Long X, Y; |
| |
| |
| /* Only use low 16bits, then sign extend */ |
| S = (FT_Short)args[1]; |
| Y = (FT_Long)S; |
| S = (FT_Short)args[0]; |
| X = S; |
| |
| Normalize( X, Y, &exc->GS.freeVector ); |
| Compute_Funcs( exc ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * GPv[]: Get Projection Vector |
| * Opcode range: 0x0C |
| * Stack: ef2.14 --> ef2.14 |
| */ |
| static void |
| Ins_GPV( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = exc->GS.projVector.x; |
| args[1] = exc->GS.projVector.y; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * GFv[]: Get Freedom Vector |
| * Opcode range: 0x0D |
| * Stack: ef2.14 --> ef2.14 |
| */ |
| static void |
| Ins_GFV( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| args[0] = exc->GS.freeVector.x; |
| args[1] = exc->GS.freeVector.y; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SRP0[]: Set Reference Point 0 |
| * Opcode range: 0x10 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SRP0( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.rp0 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SRP1[]: Set Reference Point 1 |
| * Opcode range: 0x11 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SRP1( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.rp1 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SRP2[]: Set Reference Point 2 |
| * Opcode range: 0x12 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SRP2( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.rp2 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SMD[]: Set Minimum Distance |
| * Opcode range: 0x1A |
| * Stack: f26.6 --> |
| */ |
| static void |
| Ins_SMD( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.minimum_distance = args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SCVTCI[]: Set Control Value Table Cut In |
| * Opcode range: 0x1D |
| * Stack: f26.6 --> |
| */ |
| static void |
| Ins_SCVTCI( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.control_value_cutin = (FT_F26Dot6)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SSWCI[]: Set Single Width Cut In |
| * Opcode range: 0x1E |
| * Stack: f26.6 --> |
| */ |
| static void |
| Ins_SSWCI( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.single_width_cutin = (FT_F26Dot6)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SSW[]: Set Single Width |
| * Opcode range: 0x1F |
| * Stack: int32? --> |
| */ |
| static void |
| Ins_SSW( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.single_width_value = FT_MulFix( args[0], |
| exc->tt_metrics.scale ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * FLIPON[]: Set auto-FLIP to ON |
| * Opcode range: 0x4D |
| * Stack: --> |
| */ |
| static void |
| Ins_FLIPON( TT_ExecContext exc ) |
| { |
| exc->GS.auto_flip = TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * FLIPOFF[]: Set auto-FLIP to OFF |
| * Opcode range: 0x4E |
| * Stack: --> |
| */ |
| static void |
| Ins_FLIPOFF( TT_ExecContext exc ) |
| { |
| exc->GS.auto_flip = FALSE; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SANGW[]: Set ANGle Weight |
| * Opcode range: 0x7E |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SANGW( void ) |
| { |
| /* instruction not supported anymore */ |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SDB[]: Set Delta Base |
| * Opcode range: 0x5E |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SDB( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| exc->GS.delta_base = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SDS[]: Set Delta Shift |
| * Opcode range: 0x5F |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SDS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( (FT_ULong)args[0] > 6UL ) |
| exc->error = FT_THROW( Bad_Argument ); |
| else |
| exc->GS.delta_shift = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * RTHG[]: Round To Half Grid |
| * Opcode range: 0x19 |
| * Stack: --> |
| */ |
| static void |
| Ins_RTHG( TT_ExecContext exc ) |
| { |
| exc->GS.round_state = TT_Round_To_Half_Grid; |
| exc->func_round = (TT_Round_Func)Round_To_Half_Grid; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * RTG[]: Round To Grid |
| * Opcode range: 0x18 |
| * Stack: --> |
| */ |
| static void |
| Ins_RTG( TT_ExecContext exc ) |
| { |
| exc->GS.round_state = TT_Round_To_Grid; |
| exc->func_round = (TT_Round_Func)Round_To_Grid; |
| } |
| |
| |
| /************************************************************************** |
| * RTDG[]: Round To Double Grid |
| * Opcode range: 0x3D |
| * Stack: --> |
| */ |
| static void |
| Ins_RTDG( TT_ExecContext exc ) |
| { |
| exc->GS.round_state = TT_Round_To_Double_Grid; |
| exc->func_round = (TT_Round_Func)Round_To_Double_Grid; |
| } |
| |
| |
| /************************************************************************** |
| * RUTG[]: Round Up To Grid |
| * Opcode range: 0x7C |
| * Stack: --> |
| */ |
| static void |
| Ins_RUTG( TT_ExecContext exc ) |
| { |
| exc->GS.round_state = TT_Round_Up_To_Grid; |
| exc->func_round = (TT_Round_Func)Round_Up_To_Grid; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * RDTG[]: Round Down To Grid |
| * Opcode range: 0x7D |
| * Stack: --> |
| */ |
| static void |
| Ins_RDTG( TT_ExecContext exc ) |
| { |
| exc->GS.round_state = TT_Round_Down_To_Grid; |
| exc->func_round = (TT_Round_Func)Round_Down_To_Grid; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ROFF[]: Round OFF |
| * Opcode range: 0x7A |
| * Stack: --> |
| */ |
| static void |
| Ins_ROFF( TT_ExecContext exc ) |
| { |
| exc->GS.round_state = TT_Round_Off; |
| exc->func_round = (TT_Round_Func)Round_None; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SROUND[]: Super ROUND |
| * Opcode range: 0x76 |
| * Stack: Eint8 --> |
| */ |
| static void |
| Ins_SROUND( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| SetSuperRound( exc, 0x4000, args[0] ); |
| |
| exc->GS.round_state = TT_Round_Super; |
| exc->func_round = (TT_Round_Func)Round_Super; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * S45ROUND[]: Super ROUND 45 degrees |
| * Opcode range: 0x77 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_S45ROUND( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| SetSuperRound( exc, 0x2D41, args[0] ); |
| |
| exc->GS.round_state = TT_Round_Super_45; |
| exc->func_round = (TT_Round_Func)Round_Super_45; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * GC[a]: Get Coordinate projected onto |
| * Opcode range: 0x46-0x47 |
| * Stack: uint32 --> f26.6 |
| * |
| * XXX: UNDOCUMENTED: Measures from the original glyph must be taken |
| * along the dual projection vector! |
| */ |
| static void |
| Ins_GC( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong L; |
| FT_F26Dot6 R; |
| |
| |
| L = (FT_ULong)args[0]; |
| |
| if ( BOUNDSL( L, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| R = 0; |
| } |
| else |
| { |
| if ( exc->opcode & 1 ) |
| R = FAST_DUALPROJ( &exc->zp2.org[L] ); |
| else |
| R = FAST_PROJECT( &exc->zp2.cur[L] ); |
| } |
| |
| args[0] = R; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SCFS[]: Set Coordinate From Stack |
| * Opcode range: 0x48 |
| * Stack: f26.6 uint32 --> |
| * |
| * Formula: |
| * |
| * OA := OA + ( value - OA.p )/( f.p ) * f |
| */ |
| static void |
| Ins_SCFS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Long K; |
| FT_UShort L; |
| |
| |
| L = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( L, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| K = FAST_PROJECT( &exc->zp2.cur[L] ); |
| |
| exc->func_move( exc, &exc->zp2, L, SUB_LONG( args[1], K ) ); |
| |
| /* UNDOCUMENTED! The MS rasterizer does that with */ |
| /* twilight points (confirmed by Greg Hitchcock) */ |
| if ( exc->GS.gep2 == 0 ) |
| exc->zp2.org[L] = exc->zp2.cur[L]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MD[a]: Measure Distance |
| * Opcode range: 0x49-0x4A |
| * Stack: uint32 uint32 --> f26.6 |
| * |
| * XXX: UNDOCUMENTED: Measure taken in the original glyph must be along |
| * the dual projection vector. |
| * |
| * XXX: UNDOCUMENTED: Flag attributes are inverted! |
| * 0 => measure distance in original outline |
| * 1 => measure distance in grid-fitted outline |
| * |
| * XXX: UNDOCUMENTED: `zp0 - zp1', and not `zp2 - zp1! |
| */ |
| static void |
| Ins_MD( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort K, L; |
| FT_F26Dot6 D; |
| |
| |
| K = (FT_UShort)args[1]; |
| L = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( L, exc->zp0.n_points ) || |
| BOUNDS( K, exc->zp1.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| D = 0; |
| } |
| else |
| { |
| if ( exc->opcode & 1 ) |
| D = PROJECT( exc->zp0.cur + L, exc->zp1.cur + K ); |
| else |
| { |
| /* XXX: UNDOCUMENTED: twilight zone special case */ |
| |
| if ( exc->GS.gep0 == 0 || exc->GS.gep1 == 0 ) |
| { |
| FT_Vector* vec1 = exc->zp0.org + L; |
| FT_Vector* vec2 = exc->zp1.org + K; |
| |
| |
| D = DUALPROJ( vec1, vec2 ); |
| } |
| else |
| { |
| FT_Vector* vec1 = exc->zp0.orus + L; |
| FT_Vector* vec2 = exc->zp1.orus + K; |
| |
| |
| if ( exc->metrics.x_scale == exc->metrics.y_scale ) |
| { |
| /* this should be faster */ |
| D = DUALPROJ( vec1, vec2 ); |
| D = FT_MulFix( D, exc->metrics.x_scale ); |
| } |
| else |
| { |
| FT_Vector vec; |
| |
| |
| vec.x = FT_MulFix( vec1->x - vec2->x, exc->metrics.x_scale ); |
| vec.y = FT_MulFix( vec1->y - vec2->y, exc->metrics.y_scale ); |
| |
| D = FAST_DUALPROJ( &vec ); |
| } |
| } |
| } |
| } |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* Disable Type 2 Vacuform Rounds - e.g. Arial Narrow */ |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| FT_ABS( D ) == 64 ) |
| D += 1; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| args[0] = D; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SDPvTL[a]: Set Dual PVector to Line |
| * Opcode range: 0x86-0x87 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_SDPVTL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Long A, B, C; |
| FT_UShort p1, p2; /* was FT_Int in pas type ERROR */ |
| |
| FT_Byte opcode = exc->opcode; |
| |
| |
| p1 = (FT_UShort)args[1]; |
| p2 = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( p2, exc->zp1.n_points ) || |
| BOUNDS( p1, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| { |
| FT_Vector* v1 = exc->zp1.org + p2; |
| FT_Vector* v2 = exc->zp2.org + p1; |
| |
| |
| A = SUB_LONG( v1->x, v2->x ); |
| B = SUB_LONG( v1->y, v2->y ); |
| |
| /* If v1 == v2, SDPvTL behaves the same as */ |
| /* SVTCA[X], respectively. */ |
| /* */ |
| /* Confirmed by Greg Hitchcock. */ |
| |
| if ( A == 0 && B == 0 ) |
| { |
| A = 0x4000; |
| opcode = 0; |
| } |
| } |
| |
| if ( ( opcode & 1 ) != 0 ) |
| { |
| C = B; /* counter clockwise rotation */ |
| B = A; |
| A = NEG_LONG( C ); |
| } |
| |
| Normalize( A, B, &exc->GS.dualVector ); |
| |
| { |
| FT_Vector* v1 = exc->zp1.cur + p2; |
| FT_Vector* v2 = exc->zp2.cur + p1; |
| |
| |
| A = SUB_LONG( v1->x, v2->x ); |
| B = SUB_LONG( v1->y, v2->y ); |
| |
| if ( A == 0 && B == 0 ) |
| { |
| A = 0x4000; |
| opcode = 0; |
| } |
| } |
| |
| if ( ( opcode & 1 ) != 0 ) |
| { |
| C = B; /* counter clockwise rotation */ |
| B = A; |
| A = NEG_LONG( C ); |
| } |
| |
| Normalize( A, B, &exc->GS.projVector ); |
| Compute_Funcs( exc ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SZP0[]: Set Zone Pointer 0 |
| * Opcode range: 0x13 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SZP0( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| switch ( (FT_Int)args[0] ) |
| { |
| case 0: |
| exc->zp0 = exc->twilight; |
| break; |
| |
| case 1: |
| exc->zp0 = exc->pts; |
| break; |
| |
| default: |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| exc->GS.gep0 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SZP1[]: Set Zone Pointer 1 |
| * Opcode range: 0x14 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SZP1( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| switch ( (FT_Int)args[0] ) |
| { |
| case 0: |
| exc->zp1 = exc->twilight; |
| break; |
| |
| case 1: |
| exc->zp1 = exc->pts; |
| break; |
| |
| default: |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| exc->GS.gep1 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SZP2[]: Set Zone Pointer 2 |
| * Opcode range: 0x15 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SZP2( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| switch ( (FT_Int)args[0] ) |
| { |
| case 0: |
| exc->zp2 = exc->twilight; |
| break; |
| |
| case 1: |
| exc->zp2 = exc->pts; |
| break; |
| |
| default: |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| exc->GS.gep2 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SZPS[]: Set Zone PointerS |
| * Opcode range: 0x16 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SZPS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| switch ( (FT_Int)args[0] ) |
| { |
| case 0: |
| exc->zp0 = exc->twilight; |
| break; |
| |
| case 1: |
| exc->zp0 = exc->pts; |
| break; |
| |
| default: |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| exc->zp1 = exc->zp0; |
| exc->zp2 = exc->zp0; |
| |
| exc->GS.gep0 = (FT_UShort)args[0]; |
| exc->GS.gep1 = (FT_UShort)args[0]; |
| exc->GS.gep2 = (FT_UShort)args[0]; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * INSTCTRL[]: INSTruction ConTRoL |
| * Opcode range: 0x8E |
| * Stack: int32 int32 --> |
| */ |
| static void |
| Ins_INSTCTRL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong K, L, Kf; |
| |
| |
| K = (FT_ULong)args[1]; |
| L = (FT_ULong)args[0]; |
| |
| /* selector values cannot be `OR'ed; */ |
| /* they are indices starting with index 1, not flags */ |
| if ( K < 1 || K > 3 ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| /* convert index to flag value */ |
| Kf = 1 << ( K - 1 ); |
| |
| if ( L != 0 ) |
| { |
| /* arguments to selectors look like flag values */ |
| if ( L != Kf ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| } |
| |
| exc->GS.instruct_control &= ~(FT_Byte)Kf; |
| exc->GS.instruct_control |= (FT_Byte)L; |
| |
| if ( K == 3 ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* INSTCTRL modifying flag 3 also has an effect */ |
| /* outside of the CVT program */ |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| exc->ignore_x_mode = FT_BOOL( L == 4 ); |
| #endif |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* Native ClearType fonts sign a waiver that turns off all backward */ |
| /* compatibility hacks and lets them program points to the grid like */ |
| /* it's 1996. They might sign a waiver for just one glyph, though. */ |
| if ( SUBPIXEL_HINTING_MINIMAL ) |
| exc->backward_compatibility = !FT_BOOL( L == 4 ); |
| #endif |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SCANCTRL[]: SCAN ConTRoL |
| * Opcode range: 0x85 |
| * Stack: uint32? --> |
| */ |
| static void |
| Ins_SCANCTRL( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Int A; |
| |
| |
| /* Get Threshold */ |
| A = (FT_Int)( args[0] & 0xFF ); |
| |
| if ( A == 0xFF ) |
| { |
| exc->GS.scan_control = TRUE; |
| return; |
| } |
| else if ( A == 0 ) |
| { |
| exc->GS.scan_control = FALSE; |
| return; |
| } |
| |
| if ( ( args[0] & 0x100 ) != 0 && exc->tt_metrics.ppem <= A ) |
| exc->GS.scan_control = TRUE; |
| |
| if ( ( args[0] & 0x200 ) != 0 && exc->tt_metrics.rotated ) |
| exc->GS.scan_control = TRUE; |
| |
| if ( ( args[0] & 0x400 ) != 0 && exc->tt_metrics.stretched ) |
| exc->GS.scan_control = TRUE; |
| |
| if ( ( args[0] & 0x800 ) != 0 && exc->tt_metrics.ppem > A ) |
| exc->GS.scan_control = FALSE; |
| |
| if ( ( args[0] & 0x1000 ) != 0 && exc->tt_metrics.rotated ) |
| exc->GS.scan_control = FALSE; |
| |
| if ( ( args[0] & 0x2000 ) != 0 && exc->tt_metrics.stretched ) |
| exc->GS.scan_control = FALSE; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SCANTYPE[]: SCAN TYPE |
| * Opcode range: 0x8D |
| * Stack: uint16 --> |
| */ |
| static void |
| Ins_SCANTYPE( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| if ( args[0] >= 0 ) |
| exc->GS.scan_type = (FT_Int)args[0] & 0xFFFF; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MANAGING OUTLINES |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * FLIPPT[]: FLIP PoinT |
| * Opcode range: 0x80 |
| * Stack: uint32... --> |
| */ |
| static void |
| Ins_FLIPPT( TT_ExecContext exc ) |
| { |
| FT_UShort point; |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* See `ttinterp.h' for details on backward compatibility mode. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility && |
| exc->iupx_called && |
| exc->iupy_called ) |
| goto Fail; |
| #endif |
| |
| if ( exc->top < exc->GS.loop ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Too_Few_Arguments ); |
| goto Fail; |
| } |
| |
| while ( exc->GS.loop > 0 ) |
| { |
| exc->args--; |
| |
| point = (FT_UShort)exc->stack[exc->args]; |
| |
| if ( BOUNDS( point, exc->pts.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| } |
| else |
| exc->pts.tags[point] ^= FT_CURVE_TAG_ON; |
| |
| exc->GS.loop--; |
| } |
| |
| Fail: |
| exc->GS.loop = 1; |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * FLIPRGON[]: FLIP RanGe ON |
| * Opcode range: 0x81 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_FLIPRGON( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort I, K, L; |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* See `ttinterp.h' for details on backward compatibility mode. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility && |
| exc->iupx_called && |
| exc->iupy_called ) |
| return; |
| #endif |
| |
| K = (FT_UShort)args[1]; |
| L = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( K, exc->pts.n_points ) || |
| BOUNDS( L, exc->pts.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| for ( I = L; I <= K; I++ ) |
| exc->pts.tags[I] |= FT_CURVE_TAG_ON; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * FLIPRGOFF: FLIP RanGe OFF |
| * Opcode range: 0x82 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_FLIPRGOFF( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort I, K, L; |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* See `ttinterp.h' for details on backward compatibility mode. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility && |
| exc->iupx_called && |
| exc->iupy_called ) |
| return; |
| #endif |
| |
| K = (FT_UShort)args[1]; |
| L = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( K, exc->pts.n_points ) || |
| BOUNDS( L, exc->pts.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| for ( I = L; I <= K; I++ ) |
| exc->pts.tags[I] &= ~FT_CURVE_TAG_ON; |
| } |
| |
| |
| static FT_Bool |
| Compute_Point_Displacement( TT_ExecContext exc, |
| FT_F26Dot6* x, |
| FT_F26Dot6* y, |
| TT_GlyphZone zone, |
| FT_UShort* refp ) |
| { |
| TT_GlyphZoneRec zp; |
| FT_UShort p; |
| FT_F26Dot6 d; |
| |
| |
| if ( exc->opcode & 1 ) |
| { |
| zp = exc->zp0; |
| p = exc->GS.rp1; |
| } |
| else |
| { |
| zp = exc->zp1; |
| p = exc->GS.rp2; |
| } |
| |
| if ( BOUNDS( p, zp.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| *refp = 0; |
| return FAILURE; |
| } |
| |
| *zone = zp; |
| *refp = p; |
| |
| d = PROJECT( zp.cur + p, zp.org + p ); |
| |
| *x = FT_MulDiv( d, (FT_Long)exc->GS.freeVector.x, exc->F_dot_P ); |
| *y = FT_MulDiv( d, (FT_Long)exc->GS.freeVector.y, exc->F_dot_P ); |
| |
| return SUCCESS; |
| } |
| |
| |
| /* See `ttinterp.h' for details on backward compatibility mode. */ |
| static void |
| Move_Zp2_Point( TT_ExecContext exc, |
| FT_UShort point, |
| FT_F26Dot6 dx, |
| FT_F26Dot6 dy, |
| FT_Bool touch ) |
| { |
| if ( exc->GS.freeVector.x != 0 ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| if ( !( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility ) ) |
| #endif |
| exc->zp2.cur[point].x = ADD_LONG( exc->zp2.cur[point].x, dx ); |
| |
| if ( touch ) |
| exc->zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X; |
| } |
| |
| if ( exc->GS.freeVector.y != 0 ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| if ( !( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility && |
| exc->iupx_called && |
| exc->iupy_called ) ) |
| #endif |
| exc->zp2.cur[point].y = ADD_LONG( exc->zp2.cur[point].y, dy ); |
| |
| if ( touch ) |
| exc->zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SHP[a]: SHift Point by the last point |
| * Opcode range: 0x32-0x33 |
| * Stack: uint32... --> |
| */ |
| static void |
| Ins_SHP( TT_ExecContext exc ) |
| { |
| TT_GlyphZoneRec zp; |
| FT_UShort refp; |
| |
| FT_F26Dot6 dx, dy; |
| FT_UShort point; |
| |
| |
| if ( exc->top < exc->GS.loop ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| if ( Compute_Point_Displacement( exc, &dx, &dy, &zp, &refp ) ) |
| return; |
| |
| while ( exc->GS.loop > 0 ) |
| { |
| exc->args--; |
| point = (FT_UShort)exc->stack[exc->args]; |
| |
| if ( BOUNDS( point, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| } |
| else |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* doesn't follow Cleartype spec but produces better result */ |
| if ( SUBPIXEL_HINTING_INFINALITY && exc->ignore_x_mode ) |
| Move_Zp2_Point( exc, point, 0, dy, TRUE ); |
| else |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| Move_Zp2_Point( exc, point, dx, dy, TRUE ); |
| |
| exc->GS.loop--; |
| } |
| |
| Fail: |
| exc->GS.loop = 1; |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SHC[a]: SHift Contour |
| * Opcode range: 0x34-35 |
| * Stack: uint32 --> |
| * |
| * UNDOCUMENTED: According to Greg Hitchcock, there is one (virtual) |
| * contour in the twilight zone, namely contour number |
| * zero which includes all points of it. |
| */ |
| static void |
| Ins_SHC( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| TT_GlyphZoneRec zp; |
| FT_UShort refp; |
| FT_F26Dot6 dx, dy; |
| |
| FT_Short contour, bounds; |
| FT_UShort start, limit, i; |
| |
| |
| contour = (FT_Short)args[0]; |
| bounds = ( exc->GS.gep2 == 0 ) ? 1 : exc->zp2.n_contours; |
| |
| if ( BOUNDS( contour, bounds ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| if ( Compute_Point_Displacement( exc, &dx, &dy, &zp, &refp ) ) |
| return; |
| |
| if ( contour == 0 ) |
| start = 0; |
| else |
| start = (FT_UShort)( exc->zp2.contours[contour - 1] + 1 - |
| exc->zp2.first_point ); |
| |
| /* we use the number of points if in the twilight zone */ |
| if ( exc->GS.gep2 == 0 ) |
| limit = exc->zp2.n_points; |
| else |
| limit = (FT_UShort)( exc->zp2.contours[contour] - |
| exc->zp2.first_point + 1 ); |
| |
| for ( i = start; i < limit; i++ ) |
| { |
| if ( zp.cur != exc->zp2.cur || refp != i ) |
| Move_Zp2_Point( exc, i, dx, dy, TRUE ); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SHZ[a]: SHift Zone |
| * Opcode range: 0x36-37 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_SHZ( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| TT_GlyphZoneRec zp; |
| FT_UShort refp; |
| FT_F26Dot6 dx, |
| dy; |
| |
| FT_UShort limit, i; |
| |
| |
| if ( BOUNDS( args[0], 2 ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| if ( Compute_Point_Displacement( exc, &dx, &dy, &zp, &refp ) ) |
| return; |
| |
| /* XXX: UNDOCUMENTED! SHZ doesn't move the phantom points. */ |
| /* Twilight zone has no real contours, so use `n_points'. */ |
| /* Normal zone's `n_points' includes phantoms, so must */ |
| /* use end of last contour. */ |
| if ( exc->GS.gep2 == 0 ) |
| limit = (FT_UShort)exc->zp2.n_points; |
| else if ( exc->GS.gep2 == 1 && exc->zp2.n_contours > 0 ) |
| limit = (FT_UShort)( exc->zp2.contours[exc->zp2.n_contours - 1] + 1 ); |
| else |
| limit = 0; |
| |
| /* XXX: UNDOCUMENTED! SHZ doesn't touch the points */ |
| for ( i = 0; i < limit; i++ ) |
| { |
| if ( zp.cur != exc->zp2.cur || refp != i ) |
| Move_Zp2_Point( exc, i, dx, dy, FALSE ); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * SHPIX[]: SHift points by a PIXel amount |
| * Opcode range: 0x38 |
| * Stack: f26.6 uint32... --> |
| */ |
| static void |
| Ins_SHPIX( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_F26Dot6 dx, dy; |
| FT_UShort point; |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| FT_Int B1, B2; |
| #endif |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| FT_Bool in_twilight = FT_BOOL( exc->GS.gep0 == 0 || |
| exc->GS.gep1 == 0 || |
| exc->GS.gep2 == 0 ); |
| #endif |
| |
| |
| |
| if ( exc->top < exc->GS.loop + 1 ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| dx = TT_MulFix14( args[0], exc->GS.freeVector.x ); |
| dy = TT_MulFix14( args[0], exc->GS.freeVector.y ); |
| |
| while ( exc->GS.loop > 0 ) |
| { |
| exc->args--; |
| |
| point = (FT_UShort)exc->stack[exc->args]; |
| |
| if ( BOUNDS( point, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| } |
| else |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| /* If not using ignore_x_mode rendering, allow ZP2 move. */ |
| /* If inline deltas aren't allowed, skip ZP2 move. */ |
| /* If using ignore_x_mode rendering, allow ZP2 point move if: */ |
| /* - freedom vector is y and sph_compatibility_mode is off */ |
| /* - the glyph is composite and the move is in the Y direction */ |
| /* - the glyph is specifically set to allow SHPIX moves */ |
| /* - the move is on a previously Y-touched point */ |
| |
| if ( exc->ignore_x_mode ) |
| { |
| /* save point for later comparison */ |
| if ( exc->GS.freeVector.y != 0 ) |
| B1 = exc->zp2.cur[point].y; |
| else |
| B1 = exc->zp2.cur[point].x; |
| |
| if ( !exc->face->sph_compatibility_mode && |
| exc->GS.freeVector.y != 0 ) |
| { |
| Move_Zp2_Point( exc, point, dx, dy, TRUE ); |
| |
| /* save new point */ |
| if ( exc->GS.freeVector.y != 0 ) |
| { |
| B2 = exc->zp2.cur[point].y; |
| |
| /* reverse any disallowed moves */ |
| if ( ( exc->sph_tweak_flags & SPH_TWEAK_SKIP_NONPIXEL_Y_MOVES ) && |
| ( B1 & 63 ) != 0 && |
| ( B2 & 63 ) != 0 && |
| B1 != B2 ) |
| Move_Zp2_Point( exc, |
| point, |
| NEG_LONG( dx ), |
| NEG_LONG( dy ), |
| TRUE ); |
| } |
| } |
| else if ( exc->face->sph_compatibility_mode ) |
| { |
| if ( exc->sph_tweak_flags & SPH_TWEAK_ROUND_NONPIXEL_Y_MOVES ) |
| { |
| dx = FT_PIX_ROUND( B1 + dx ) - B1; |
| dy = FT_PIX_ROUND( B1 + dy ) - B1; |
| } |
| |
| /* skip post-iup deltas */ |
| if ( exc->iup_called && |
| ( ( exc->sph_in_func_flags & SPH_FDEF_INLINE_DELTA_1 ) || |
| ( exc->sph_in_func_flags & SPH_FDEF_INLINE_DELTA_2 ) ) ) |
| goto Skip; |
| |
| if ( !( exc->sph_tweak_flags & SPH_TWEAK_ALWAYS_SKIP_DELTAP ) && |
| ( ( exc->is_composite && exc->GS.freeVector.y != 0 ) || |
| ( exc->zp2.tags[point] & FT_CURVE_TAG_TOUCH_Y ) || |
| ( exc->sph_tweak_flags & SPH_TWEAK_DO_SHPIX ) ) ) |
| Move_Zp2_Point( exc, point, 0, dy, TRUE ); |
| |
| /* save new point */ |
| if ( exc->GS.freeVector.y != 0 ) |
| { |
| B2 = exc->zp2.cur[point].y; |
| |
| /* reverse any disallowed moves */ |
| if ( ( B1 & 63 ) == 0 && |
| ( B2 & 63 ) != 0 && |
| B1 != B2 ) |
| Move_Zp2_Point( exc, point, 0, NEG_LONG( dy ), TRUE ); |
| } |
| } |
| else if ( exc->sph_in_func_flags & SPH_FDEF_TYPEMAN_DIAGENDCTRL ) |
| Move_Zp2_Point( exc, point, dx, dy, TRUE ); |
| } |
| else |
| Move_Zp2_Point( exc, point, dx, dy, TRUE ); |
| } |
| else |
| #endif |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility ) |
| { |
| /* Special case: allow SHPIX to move points in the twilight zone. */ |
| /* Otherwise, treat SHPIX the same as DELTAP. Unbreaks various */ |
| /* fonts such as older versions of Rokkitt and DTL Argo T Light */ |
| /* that would glitch severely after calling ALIGNRP after a */ |
| /* blocked SHPIX. */ |
| if ( in_twilight || |
| ( !( exc->iupx_called && exc->iupy_called ) && |
| ( ( exc->is_composite && exc->GS.freeVector.y != 0 ) || |
| ( exc->zp2.tags[point] & FT_CURVE_TAG_TOUCH_Y ) ) ) ) |
| Move_Zp2_Point( exc, point, 0, dy, TRUE ); |
| } |
| else |
| #endif |
| Move_Zp2_Point( exc, point, dx, dy, TRUE ); |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| Skip: |
| #endif |
| exc->GS.loop--; |
| } |
| |
| Fail: |
| exc->GS.loop = 1; |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MSIRP[a]: Move Stack Indirect Relative Position |
| * Opcode range: 0x3A-0x3B |
| * Stack: f26.6 uint32 --> |
| */ |
| static void |
| Ins_MSIRP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort point = 0; |
| FT_F26Dot6 distance; |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| FT_F26Dot6 control_value_cutin = 0; |
| FT_F26Dot6 delta; |
| |
| |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| control_value_cutin = exc->GS.control_value_cutin; |
| |
| if ( exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 && |
| !( exc->sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) ) |
| control_value_cutin = 0; |
| } |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| point = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( point, exc->zp1.n_points ) || |
| BOUNDS( exc->GS.rp0, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| /* UNDOCUMENTED! The MS rasterizer does that with */ |
| /* twilight points (confirmed by Greg Hitchcock) */ |
| if ( exc->GS.gep1 == 0 ) |
| { |
| exc->zp1.org[point] = exc->zp0.org[exc->GS.rp0]; |
| exc->func_move_orig( exc, &exc->zp1, point, args[1] ); |
| exc->zp1.cur[point] = exc->zp1.org[point]; |
| } |
| |
| distance = PROJECT( exc->zp1.cur + point, exc->zp0.cur + exc->GS.rp0 ); |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| delta = SUB_LONG( distance, args[1] ); |
| if ( delta < 0 ) |
| delta = NEG_LONG( delta ); |
| |
| /* subpixel hinting - make MSIRP respect CVT cut-in; */ |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 && |
| delta >= control_value_cutin ) |
| distance = args[1]; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| exc->func_move( exc, |
| &exc->zp1, |
| point, |
| SUB_LONG( args[1], distance ) ); |
| |
| exc->GS.rp1 = exc->GS.rp0; |
| exc->GS.rp2 = point; |
| |
| if ( ( exc->opcode & 1 ) != 0 ) |
| exc->GS.rp0 = point; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MDAP[a]: Move Direct Absolute Point |
| * Opcode range: 0x2E-0x2F |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_MDAP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort point; |
| FT_F26Dot6 cur_dist; |
| FT_F26Dot6 distance; |
| |
| |
| point = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( point, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| if ( ( exc->opcode & 1 ) != 0 ) |
| { |
| cur_dist = FAST_PROJECT( &exc->zp0.cur[point] ); |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 ) |
| distance = SUB_LONG( |
| Round_None( exc, |
| cur_dist, |
| exc->tt_metrics.compensations[0] ), |
| cur_dist ); |
| else |
| #endif |
| distance = SUB_LONG( |
| exc->func_round( exc, |
| cur_dist, |
| exc->tt_metrics.compensations[0] ), |
| cur_dist ); |
| } |
| else |
| distance = 0; |
| |
| exc->func_move( exc, &exc->zp0, point, distance ); |
| |
| exc->GS.rp0 = point; |
| exc->GS.rp1 = point; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MIAP[a]: Move Indirect Absolute Point |
| * Opcode range: 0x3E-0x3F |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_MIAP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong cvtEntry; |
| FT_UShort point; |
| FT_F26Dot6 distance; |
| FT_F26Dot6 org_dist; |
| FT_F26Dot6 control_value_cutin; |
| |
| |
| control_value_cutin = exc->GS.control_value_cutin; |
| cvtEntry = (FT_ULong)args[1]; |
| point = (FT_UShort)args[0]; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 && |
| exc->GS.freeVector.y == 0 && |
| !( exc->sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) ) |
| control_value_cutin = 0; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| if ( BOUNDS( point, exc->zp0.n_points ) || |
| BOUNDSL( cvtEntry, exc->cvtSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| /* UNDOCUMENTED! */ |
| /* */ |
| /* The behaviour of an MIAP instruction is quite different when used */ |
| /* in the twilight zone. */ |
| /* */ |
| /* First, no control value cut-in test is performed as it would fail */ |
| /* anyway. Second, the original point, i.e. (org_x,org_y) of */ |
| /* zp0.point, is set to the absolute, unrounded distance found in the */ |
| /* CVT. */ |
| /* */ |
| /* This is used in the CVT programs of the Microsoft fonts Arial, */ |
| /* Times, etc., in order to re-adjust some key font heights. It */ |
| /* allows the use of the IP instruction in the twilight zone, which */ |
| /* otherwise would be invalid according to the specification. */ |
| /* */ |
| /* We implement it with a special sequence for the twilight zone. */ |
| /* This is a bad hack, but it seems to work. */ |
| /* */ |
| /* Confirmed by Greg Hitchcock. */ |
| |
| distance = exc->func_read_cvt( exc, cvtEntry ); |
| |
| if ( exc->GS.gep0 == 0 ) /* If in twilight zone */ |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* Only adjust if not in sph_compatibility_mode or ignore_x_mode. */ |
| /* Determined via experimentation and may be incorrect... */ |
| if ( !( SUBPIXEL_HINTING_INFINALITY && |
| ( exc->ignore_x_mode && |
| exc->face->sph_compatibility_mode ) ) ) |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| exc->zp0.org[point].x = TT_MulFix14( distance, |
| exc->GS.freeVector.x ); |
| exc->zp0.org[point].y = TT_MulFix14( distance, |
| exc->GS.freeVector.y ), |
| exc->zp0.cur[point] = exc->zp0.org[point]; |
| } |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| ( exc->sph_tweak_flags & SPH_TWEAK_MIAP_HACK ) && |
| distance > 0 && |
| exc->GS.freeVector.y != 0 ) |
| distance = 0; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| org_dist = FAST_PROJECT( &exc->zp0.cur[point] ); |
| |
| if ( ( exc->opcode & 1 ) != 0 ) /* rounding and control cut-in flag */ |
| { |
| FT_F26Dot6 delta; |
| |
| |
| delta = SUB_LONG( distance, org_dist ); |
| if ( delta < 0 ) |
| delta = NEG_LONG( delta ); |
| |
| if ( delta > control_value_cutin ) |
| distance = org_dist; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 ) |
| distance = Round_None( exc, |
| distance, |
| exc->tt_metrics.compensations[0] ); |
| else |
| #endif |
| distance = exc->func_round( exc, |
| distance, |
| exc->tt_metrics.compensations[0] ); |
| } |
| |
| exc->func_move( exc, &exc->zp0, point, SUB_LONG( distance, org_dist ) ); |
| |
| Fail: |
| exc->GS.rp0 = point; |
| exc->GS.rp1 = point; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MDRP[abcde]: Move Direct Relative Point |
| * Opcode range: 0xC0-0xDF |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_MDRP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort point = 0; |
| FT_F26Dot6 org_dist, distance, minimum_distance; |
| |
| |
| minimum_distance = exc->GS.minimum_distance; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 && |
| !( exc->sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) ) |
| minimum_distance = 0; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| point = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( point, exc->zp1.n_points ) || |
| BOUNDS( exc->GS.rp0, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| /* XXX: Is there some undocumented feature while in the */ |
| /* twilight zone? */ |
| |
| /* XXX: UNDOCUMENTED: twilight zone special case */ |
| |
| if ( exc->GS.gep0 == 0 || exc->GS.gep1 == 0 ) |
| { |
| FT_Vector* vec1 = &exc->zp1.org[point]; |
| FT_Vector* vec2 = &exc->zp0.org[exc->GS.rp0]; |
| |
| |
| org_dist = DUALPROJ( vec1, vec2 ); |
| } |
| else |
| { |
| FT_Vector* vec1 = &exc->zp1.orus[point]; |
| FT_Vector* vec2 = &exc->zp0.orus[exc->GS.rp0]; |
| |
| |
| if ( exc->metrics.x_scale == exc->metrics.y_scale ) |
| { |
| /* this should be faster */ |
| org_dist = DUALPROJ( vec1, vec2 ); |
| org_dist = FT_MulFix( org_dist, exc->metrics.x_scale ); |
| } |
| else |
| { |
| FT_Vector vec; |
| |
| |
| vec.x = FT_MulFix( SUB_LONG( vec1->x, vec2->x ), |
| exc->metrics.x_scale ); |
| vec.y = FT_MulFix( SUB_LONG( vec1->y, vec2->y ), |
| exc->metrics.y_scale ); |
| |
| org_dist = FAST_DUALPROJ( &vec ); |
| } |
| } |
| |
| /* single width cut-in test */ |
| |
| /* |org_dist - single_width_value| < single_width_cutin */ |
| if ( exc->GS.single_width_cutin > 0 && |
| org_dist < exc->GS.single_width_value + |
| exc->GS.single_width_cutin && |
| org_dist > exc->GS.single_width_value - |
| exc->GS.single_width_cutin ) |
| { |
| if ( org_dist >= 0 ) |
| org_dist = exc->GS.single_width_value; |
| else |
| org_dist = -exc->GS.single_width_value; |
| } |
| |
| /* round flag */ |
| |
| if ( ( exc->opcode & 4 ) != 0 ) |
| { |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 ) |
| distance = Round_None( |
| exc, |
| org_dist, |
| exc->tt_metrics.compensations[exc->opcode & 3] ); |
| else |
| #endif |
| distance = exc->func_round( |
| exc, |
| org_dist, |
| exc->tt_metrics.compensations[exc->opcode & 3] ); |
| } |
| else |
| distance = Round_None( |
| exc, |
| org_dist, |
| exc->tt_metrics.compensations[exc->opcode & 3] ); |
| |
| /* minimum distance flag */ |
| |
| if ( ( exc->opcode & 8 ) != 0 ) |
| { |
| if ( org_dist >= 0 ) |
| { |
| if ( distance < minimum_distance ) |
| distance = minimum_distance; |
| } |
| else |
| { |
| if ( distance > NEG_LONG( minimum_distance ) ) |
| distance = NEG_LONG( minimum_distance ); |
| } |
| } |
| |
| /* now move the point */ |
| |
| org_dist = PROJECT( exc->zp1.cur + point, exc->zp0.cur + exc->GS.rp0 ); |
| |
| exc->func_move( exc, &exc->zp1, point, SUB_LONG( distance, org_dist ) ); |
| |
| Fail: |
| exc->GS.rp1 = exc->GS.rp0; |
| exc->GS.rp2 = point; |
| |
| if ( ( exc->opcode & 16 ) != 0 ) |
| exc->GS.rp0 = point; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MIRP[abcde]: Move Indirect Relative Point |
| * Opcode range: 0xE0-0xFF |
| * Stack: int32? uint32 --> |
| */ |
| static void |
| Ins_MIRP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort point; |
| FT_ULong cvtEntry; |
| |
| FT_F26Dot6 cvt_dist, |
| distance, |
| cur_dist, |
| org_dist, |
| control_value_cutin, |
| minimum_distance; |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| FT_Int B1 = 0; /* pacify compiler */ |
| FT_Int B2 = 0; |
| FT_Bool reverse_move = FALSE; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| FT_F26Dot6 delta; |
| |
| |
| minimum_distance = exc->GS.minimum_distance; |
| control_value_cutin = exc->GS.control_value_cutin; |
| point = (FT_UShort)args[0]; |
| cvtEntry = (FT_ULong)( ADD_LONG( args[1], 1 ) ); |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.x != 0 && |
| !( exc->sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) ) |
| control_value_cutin = minimum_distance = 0; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| /* XXX: UNDOCUMENTED! cvt[-1] = 0 always */ |
| |
| if ( BOUNDS( point, exc->zp1.n_points ) || |
| BOUNDSL( cvtEntry, exc->cvtSize + 1 ) || |
| BOUNDS( exc->GS.rp0, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| if ( !cvtEntry ) |
| cvt_dist = 0; |
| else |
| cvt_dist = exc->func_read_cvt( exc, cvtEntry - 1 ); |
| |
| /* single width test */ |
| |
| delta = SUB_LONG( cvt_dist, exc->GS.single_width_value ); |
| if ( delta < 0 ) |
| delta = NEG_LONG( delta ); |
| |
| if ( delta < exc->GS.single_width_cutin ) |
| { |
| if ( cvt_dist >= 0 ) |
| cvt_dist = exc->GS.single_width_value; |
| else |
| cvt_dist = -exc->GS.single_width_value; |
| } |
| |
| /* UNDOCUMENTED! The MS rasterizer does that with */ |
| /* twilight points (confirmed by Greg Hitchcock) */ |
| if ( exc->GS.gep1 == 0 ) |
| { |
| exc->zp1.org[point].x = exc->zp0.org[exc->GS.rp0].x + |
| TT_MulFix14( cvt_dist, |
| exc->GS.freeVector.x ); |
| exc->zp1.org[point].y = exc->zp0.org[exc->GS.rp0].y + |
| TT_MulFix14( cvt_dist, |
| exc->GS.freeVector.y ); |
| exc->zp1.cur[point] = exc->zp1.org[point]; |
| } |
| |
| org_dist = DUALPROJ( &exc->zp1.org[point], &exc->zp0.org[exc->GS.rp0] ); |
| cur_dist = PROJECT ( &exc->zp1.cur[point], &exc->zp0.cur[exc->GS.rp0] ); |
| |
| /* auto-flip test */ |
| |
| if ( exc->GS.auto_flip ) |
| { |
| if ( ( org_dist ^ cvt_dist ) < 0 ) |
| cvt_dist = -cvt_dist; |
| } |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.freeVector.y != 0 && |
| ( exc->sph_tweak_flags & SPH_TWEAK_TIMES_NEW_ROMAN_HACK ) ) |
| { |
| if ( cur_dist < -64 ) |
| cvt_dist -= 16; |
| else if ( cur_dist > 64 && cur_dist < 84 ) |
| cvt_dist += 32; |
| } |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| /* control value cut-in and round */ |
| |
| if ( ( exc->opcode & 4 ) != 0 ) |
| { |
| /* XXX: UNDOCUMENTED! Only perform cut-in test when both points */ |
| /* refer to the same zone. */ |
| |
| if ( exc->GS.gep0 == exc->GS.gep1 ) |
| { |
| /* XXX: According to Greg Hitchcock, the following wording is */ |
| /* the right one: */ |
| /* */ |
| /* When the absolute difference between the value in */ |
| /* the table [CVT] and the measurement directly from */ |
| /* the outline is _greater_ than the cut_in value, the */ |
| /* outline measurement is used. */ |
| /* */ |
| /* This is from `instgly.doc'. The description in */ |
| /* `ttinst2.doc', version 1.66, is thus incorrect since */ |
| /* it implies `>=' instead of `>'. */ |
| |
| delta = SUB_LONG( cvt_dist, org_dist ); |
| if ( delta < 0 ) |
| delta = NEG_LONG( delta ); |
| |
| if ( delta > control_value_cutin ) |
| cvt_dist = org_dist; |
| } |
| |
| distance = exc->func_round( |
| exc, |
| cvt_dist, |
| exc->tt_metrics.compensations[exc->opcode & 3] ); |
| } |
| else |
| { |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /* do cvt cut-in always in MIRP for sph */ |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->GS.gep0 == exc->GS.gep1 ) |
| { |
| delta = SUB_LONG( cvt_dist, org_dist ); |
| if ( delta < 0 ) |
| delta = NEG_LONG( delta ); |
| |
| if ( delta > control_value_cutin ) |
| cvt_dist = org_dist; |
| } |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| distance = Round_None( |
| exc, |
| cvt_dist, |
| exc->tt_metrics.compensations[exc->opcode & 3] ); |
| } |
| |
| /* minimum distance test */ |
| |
| if ( ( exc->opcode & 8 ) != 0 ) |
| { |
| if ( org_dist >= 0 ) |
| { |
| if ( distance < minimum_distance ) |
| distance = minimum_distance; |
| } |
| else |
| { |
| if ( distance > NEG_LONG( minimum_distance ) ) |
| distance = NEG_LONG( minimum_distance ); |
| } |
| } |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| B1 = exc->zp1.cur[point].y; |
| |
| /* Round moves if necessary */ |
| if ( exc->ignore_x_mode && |
| exc->GS.freeVector.y != 0 && |
| ( exc->sph_tweak_flags & SPH_TWEAK_ROUND_NONPIXEL_Y_MOVES ) ) |
| distance = FT_PIX_ROUND( B1 + distance - cur_dist ) - B1 + cur_dist; |
| |
| if ( exc->ignore_x_mode && |
| exc->GS.freeVector.y != 0 && |
| ( exc->opcode & 16 ) == 0 && |
| ( exc->opcode & 8 ) == 0 && |
| ( exc->sph_tweak_flags & SPH_TWEAK_COURIER_NEW_2_HACK ) ) |
| distance += 64; |
| } |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| exc->func_move( exc, |
| &exc->zp1, |
| point, |
| SUB_LONG( distance, cur_dist ) ); |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| B2 = exc->zp1.cur[point].y; |
| |
| /* Reverse move if necessary */ |
| if ( exc->ignore_x_mode ) |
| { |
| if ( exc->face->sph_compatibility_mode && |
| exc->GS.freeVector.y != 0 && |
| ( B1 & 63 ) == 0 && |
| ( B2 & 63 ) != 0 ) |
| reverse_move = TRUE; |
| |
| if ( ( exc->sph_tweak_flags & SPH_TWEAK_SKIP_NONPIXEL_Y_MOVES ) && |
| exc->GS.freeVector.y != 0 && |
| ( B2 & 63 ) != 0 && |
| ( B1 & 63 ) != 0 ) |
| reverse_move = TRUE; |
| } |
| |
| if ( reverse_move ) |
| exc->func_move( exc, |
| &exc->zp1, |
| point, |
| SUB_LONG( cur_dist, distance ) ); |
| } |
| |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| Fail: |
| exc->GS.rp1 = exc->GS.rp0; |
| |
| if ( ( exc->opcode & 16 ) != 0 ) |
| exc->GS.rp0 = point; |
| |
| exc->GS.rp2 = point; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ALIGNRP[]: ALIGN Relative Point |
| * Opcode range: 0x3C |
| * Stack: uint32 uint32... --> |
| */ |
| static void |
| Ins_ALIGNRP( TT_ExecContext exc ) |
| { |
| FT_UShort point; |
| FT_F26Dot6 distance; |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->iup_called && |
| ( exc->sph_tweak_flags & SPH_TWEAK_NO_ALIGNRP_AFTER_IUP ) ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| if ( exc->top < exc->GS.loop || |
| BOUNDS( exc->GS.rp0, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| while ( exc->GS.loop > 0 ) |
| { |
| exc->args--; |
| |
| point = (FT_UShort)exc->stack[exc->args]; |
| |
| if ( BOUNDS( point, exc->zp1.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| } |
| else |
| { |
| distance = PROJECT( exc->zp1.cur + point, |
| exc->zp0.cur + exc->GS.rp0 ); |
| |
| exc->func_move( exc, &exc->zp1, point, NEG_LONG( distance ) ); |
| } |
| |
| exc->GS.loop--; |
| } |
| |
| Fail: |
| exc->GS.loop = 1; |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ISECT[]: moves point to InterSECTion |
| * Opcode range: 0x0F |
| * Stack: 5 * uint32 --> |
| */ |
| static void |
| Ins_ISECT( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort point, |
| a0, a1, |
| b0, b1; |
| |
| FT_F26Dot6 discriminant, dotproduct; |
| |
| FT_F26Dot6 dx, dy, |
| dax, day, |
| dbx, dby; |
| |
| FT_F26Dot6 val; |
| |
| FT_Vector R; |
| |
| |
| point = (FT_UShort)args[0]; |
| |
| a0 = (FT_UShort)args[1]; |
| a1 = (FT_UShort)args[2]; |
| b0 = (FT_UShort)args[3]; |
| b1 = (FT_UShort)args[4]; |
| |
| if ( BOUNDS( b0, exc->zp0.n_points ) || |
| BOUNDS( b1, exc->zp0.n_points ) || |
| BOUNDS( a0, exc->zp1.n_points ) || |
| BOUNDS( a1, exc->zp1.n_points ) || |
| BOUNDS( point, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| /* Cramer's rule */ |
| |
| dbx = SUB_LONG( exc->zp0.cur[b1].x, exc->zp0.cur[b0].x ); |
| dby = SUB_LONG( exc->zp0.cur[b1].y, exc->zp0.cur[b0].y ); |
| |
| dax = SUB_LONG( exc->zp1.cur[a1].x, exc->zp1.cur[a0].x ); |
| day = SUB_LONG( exc->zp1.cur[a1].y, exc->zp1.cur[a0].y ); |
| |
| dx = SUB_LONG( exc->zp0.cur[b0].x, exc->zp1.cur[a0].x ); |
| dy = SUB_LONG( exc->zp0.cur[b0].y, exc->zp1.cur[a0].y ); |
| |
| discriminant = ADD_LONG( FT_MulDiv( dax, NEG_LONG( dby ), 0x40 ), |
| FT_MulDiv( day, dbx, 0x40 ) ); |
| dotproduct = ADD_LONG( FT_MulDiv( dax, dbx, 0x40 ), |
| FT_MulDiv( day, dby, 0x40 ) ); |
| |
| /* The discriminant above is actually a cross product of vectors */ |
| /* da and db. Together with the dot product, they can be used as */ |
| /* surrogates for sine and cosine of the angle between the vectors. */ |
| /* Indeed, */ |
| /* dotproduct = |da||db|cos(angle) */ |
| /* discriminant = |da||db|sin(angle) . */ |
| /* We use these equations to reject grazing intersections by */ |
| /* thresholding abs(tan(angle)) at 1/19, corresponding to 3 degrees. */ |
| if ( MUL_LONG( 19, FT_ABS( discriminant ) ) > FT_ABS( dotproduct ) ) |
| { |
| val = ADD_LONG( FT_MulDiv( dx, NEG_LONG( dby ), 0x40 ), |
| FT_MulDiv( dy, dbx, 0x40 ) ); |
| |
| R.x = FT_MulDiv( val, dax, discriminant ); |
| R.y = FT_MulDiv( val, day, discriminant ); |
| |
| /* XXX: Block in backward_compatibility and/or post-IUP? */ |
| exc->zp2.cur[point].x = ADD_LONG( exc->zp1.cur[a0].x, R.x ); |
| exc->zp2.cur[point].y = ADD_LONG( exc->zp1.cur[a0].y, R.y ); |
| } |
| else |
| { |
| /* else, take the middle of the middles of A and B */ |
| |
| /* XXX: Block in backward_compatibility and/or post-IUP? */ |
| exc->zp2.cur[point].x = |
| ADD_LONG( ADD_LONG( exc->zp1.cur[a0].x, exc->zp1.cur[a1].x ), |
| ADD_LONG( exc->zp0.cur[b0].x, exc->zp0.cur[b1].x ) ) / 4; |
| exc->zp2.cur[point].y = |
| ADD_LONG( ADD_LONG( exc->zp1.cur[a0].y, exc->zp1.cur[a1].y ), |
| ADD_LONG( exc->zp0.cur[b0].y, exc->zp0.cur[b1].y ) ) / 4; |
| } |
| |
| exc->zp2.tags[point] |= FT_CURVE_TAG_TOUCH_BOTH; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * ALIGNPTS[]: ALIGN PoinTS |
| * Opcode range: 0x27 |
| * Stack: uint32 uint32 --> |
| */ |
| static void |
| Ins_ALIGNPTS( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort p1, p2; |
| FT_F26Dot6 distance; |
| |
| |
| p1 = (FT_UShort)args[0]; |
| p2 = (FT_UShort)args[1]; |
| |
| if ( BOUNDS( p1, exc->zp1.n_points ) || |
| BOUNDS( p2, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| distance = PROJECT( exc->zp0.cur + p2, exc->zp1.cur + p1 ) / 2; |
| |
| exc->func_move( exc, &exc->zp1, p1, distance ); |
| exc->func_move( exc, &exc->zp0, p2, NEG_LONG( distance ) ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * IP[]: Interpolate Point |
| * Opcode range: 0x39 |
| * Stack: uint32... --> |
| */ |
| |
| /* SOMETIMES, DUMBER CODE IS BETTER CODE */ |
| |
| static void |
| Ins_IP( TT_ExecContext exc ) |
| { |
| FT_F26Dot6 old_range, cur_range; |
| FT_Vector* orus_base; |
| FT_Vector* cur_base; |
| FT_Int twilight; |
| |
| |
| if ( exc->top < exc->GS.loop ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| /* |
| * We need to deal in a special way with the twilight zone. |
| * Otherwise, by definition, the value of exc->twilight.orus[n] is (0,0), |
| * for every n. |
| */ |
| twilight = ( exc->GS.gep0 == 0 || |
| exc->GS.gep1 == 0 || |
| exc->GS.gep2 == 0 ); |
| |
| if ( BOUNDS( exc->GS.rp1, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto Fail; |
| } |
| |
| if ( twilight ) |
| orus_base = &exc->zp0.org[exc->GS.rp1]; |
| else |
| orus_base = &exc->zp0.orus[exc->GS.rp1]; |
| |
| cur_base = &exc->zp0.cur[exc->GS.rp1]; |
| |
| /* XXX: There are some glyphs in some braindead but popular */ |
| /* fonts out there (e.g. [aeu]grave in monotype.ttf) */ |
| /* calling IP[] with bad values of rp[12]. */ |
| /* Do something sane when this odd thing happens. */ |
| if ( BOUNDS( exc->GS.rp1, exc->zp0.n_points ) || |
| BOUNDS( exc->GS.rp2, exc->zp1.n_points ) ) |
| { |
| old_range = 0; |
| cur_range = 0; |
| } |
| else |
| { |
| if ( twilight ) |
| old_range = DUALPROJ( &exc->zp1.org[exc->GS.rp2], orus_base ); |
| else if ( exc->metrics.x_scale == exc->metrics.y_scale ) |
| old_range = DUALPROJ( &exc->zp1.orus[exc->GS.rp2], orus_base ); |
| else |
| { |
| FT_Vector vec; |
| |
| |
| vec.x = FT_MulFix( SUB_LONG( exc->zp1.orus[exc->GS.rp2].x, |
| orus_base->x ), |
| exc->metrics.x_scale ); |
| vec.y = FT_MulFix( SUB_LONG( exc->zp1.orus[exc->GS.rp2].y, |
| orus_base->y ), |
| exc->metrics.y_scale ); |
| |
| old_range = FAST_DUALPROJ( &vec ); |
| } |
| |
| cur_range = PROJECT( &exc->zp1.cur[exc->GS.rp2], cur_base ); |
| } |
| |
| for ( ; exc->GS.loop > 0; exc->GS.loop-- ) |
| { |
| FT_UInt point = (FT_UInt)exc->stack[--exc->args]; |
| FT_F26Dot6 org_dist, cur_dist, new_dist; |
| |
| |
| /* check point bounds */ |
| if ( BOUNDS( point, exc->zp2.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| continue; |
| } |
| |
| if ( twilight ) |
| org_dist = DUALPROJ( &exc->zp2.org[point], orus_base ); |
| else if ( exc->metrics.x_scale == exc->metrics.y_scale ) |
| org_dist = DUALPROJ( &exc->zp2.orus[point], orus_base ); |
| else |
| { |
| FT_Vector vec; |
| |
| |
| vec.x = FT_MulFix( SUB_LONG( exc->zp2.orus[point].x, |
| orus_base->x ), |
| exc->metrics.x_scale ); |
| vec.y = FT_MulFix( SUB_LONG( exc->zp2.orus[point].y, |
| orus_base->y ), |
| exc->metrics.y_scale ); |
| |
| org_dist = FAST_DUALPROJ( &vec ); |
| } |
| |
| cur_dist = PROJECT( &exc->zp2.cur[point], cur_base ); |
| |
| if ( org_dist ) |
| { |
| if ( old_range ) |
| new_dist = FT_MulDiv( org_dist, cur_range, old_range ); |
| else |
| { |
| /* This is the same as what MS does for the invalid case: */ |
| /* */ |
| /* delta = (Original_Pt - Original_RP1) - */ |
| /* (Current_Pt - Current_RP1) ; */ |
| /* */ |
| /* In FreeType speak: */ |
| /* */ |
| /* delta = org_dist - cur_dist . */ |
| /* */ |
| /* We move `point' by `new_dist - cur_dist' after leaving */ |
| /* this block, thus we have */ |
| /* */ |
| /* new_dist - cur_dist = delta , */ |
| /* new_dist - cur_dist = org_dist - cur_dist , */ |
| /* new_dist = org_dist . */ |
| |
| new_dist = org_dist; |
| } |
| } |
| else |
| new_dist = 0; |
| |
| exc->func_move( exc, |
| &exc->zp2, |
| (FT_UShort)point, |
| SUB_LONG( new_dist, cur_dist ) ); |
| } |
| |
| Fail: |
| exc->GS.loop = 1; |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * UTP[a]: UnTouch Point |
| * Opcode range: 0x29 |
| * Stack: uint32 --> |
| */ |
| static void |
| Ins_UTP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UShort point; |
| FT_Byte mask; |
| |
| |
| point = (FT_UShort)args[0]; |
| |
| if ( BOUNDS( point, exc->zp0.n_points ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| |
| mask = 0xFF; |
| |
| if ( exc->GS.freeVector.x != 0 ) |
| mask &= ~FT_CURVE_TAG_TOUCH_X; |
| |
| if ( exc->GS.freeVector.y != 0 ) |
| mask &= ~FT_CURVE_TAG_TOUCH_Y; |
| |
| exc->zp0.tags[point] &= mask; |
| } |
| |
| |
| /* Local variables for Ins_IUP: */ |
| typedef struct IUP_WorkerRec_ |
| { |
| FT_Vector* orgs; /* original and current coordinate */ |
| FT_Vector* curs; /* arrays */ |
| FT_Vector* orus; |
| FT_UInt max_points; |
| |
| } IUP_WorkerRec, *IUP_Worker; |
| |
| |
| static void |
| _iup_worker_shift( IUP_Worker worker, |
| FT_UInt p1, |
| FT_UInt p2, |
| FT_UInt p ) |
| { |
| FT_UInt i; |
| FT_F26Dot6 dx; |
| |
| |
| dx = SUB_LONG( worker->curs[p].x, worker->orgs[p].x ); |
| if ( dx != 0 ) |
| { |
| for ( i = p1; i < p; i++ ) |
| worker->curs[i].x = ADD_LONG( worker->curs[i].x, dx ); |
| |
| for ( i = p + 1; i <= p2; i++ ) |
| worker->curs[i].x = ADD_LONG( worker->curs[i].x, dx ); |
| } |
| } |
| |
| |
| static void |
| _iup_worker_interpolate( IUP_Worker worker, |
| FT_UInt p1, |
| FT_UInt p2, |
| FT_UInt ref1, |
| FT_UInt ref2 ) |
| { |
| FT_UInt i; |
| FT_F26Dot6 orus1, orus2, org1, org2, cur1, cur2, delta1, delta2; |
| |
| |
| if ( p1 > p2 ) |
| return; |
| |
| if ( BOUNDS( ref1, worker->max_points ) || |
| BOUNDS( ref2, worker->max_points ) ) |
| return; |
| |
| orus1 = worker->orus[ref1].x; |
| orus2 = worker->orus[ref2].x; |
| |
| if ( orus1 > orus2 ) |
| { |
| FT_F26Dot6 tmp_o; |
| FT_UInt tmp_r; |
| |
| |
| tmp_o = orus1; |
| orus1 = orus2; |
| orus2 = tmp_o; |
| |
| tmp_r = ref1; |
| ref1 = ref2; |
| ref2 = tmp_r; |
| } |
| |
| org1 = worker->orgs[ref1].x; |
| org2 = worker->orgs[ref2].x; |
| cur1 = worker->curs[ref1].x; |
| cur2 = worker->curs[ref2].x; |
| delta1 = SUB_LONG( cur1, org1 ); |
| delta2 = SUB_LONG( cur2, org2 ); |
| |
| if ( cur1 == cur2 || orus1 == orus2 ) |
| { |
| |
| /* trivial snap or shift of untouched points */ |
| for ( i = p1; i <= p2; i++ ) |
| { |
| FT_F26Dot6 x = worker->orgs[i].x; |
| |
| |
| if ( x <= org1 ) |
| x = ADD_LONG( x, delta1 ); |
| |
| else if ( x >= org2 ) |
| x = ADD_LONG( x, delta2 ); |
| |
| else |
| x = cur1; |
| |
| worker->curs[i].x = x; |
| } |
| } |
| else |
| { |
| FT_Fixed scale = 0; |
| FT_Bool scale_valid = 0; |
| |
| |
| /* interpolation */ |
| for ( i = p1; i <= p2; i++ ) |
| { |
| FT_F26Dot6 x = worker->orgs[i].x; |
| |
| |
| if ( x <= org1 ) |
| x = ADD_LONG( x, delta1 ); |
| |
| else if ( x >= org2 ) |
| x = ADD_LONG( x, delta2 ); |
| |
| else |
| { |
| if ( !scale_valid ) |
| { |
| scale_valid = 1; |
| scale = FT_DivFix( SUB_LONG( cur2, cur1 ), |
| SUB_LONG( orus2, orus1 ) ); |
| } |
| |
| x = ADD_LONG( cur1, |
| FT_MulFix( SUB_LONG( worker->orus[i].x, orus1 ), |
| scale ) ); |
| } |
| worker->curs[i].x = x; |
| } |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * IUP[a]: Interpolate Untouched Points |
| * Opcode range: 0x30-0x31 |
| * Stack: --> |
| */ |
| static void |
| Ins_IUP( TT_ExecContext exc ) |
| { |
| IUP_WorkerRec V; |
| FT_Byte mask; |
| |
| FT_UInt first_point; /* first point of contour */ |
| FT_UInt end_point; /* end point (last+1) of contour */ |
| |
| FT_UInt first_touched; /* first touched point in contour */ |
| FT_UInt cur_touched; /* current touched point in contour */ |
| |
| FT_UInt point; /* current point */ |
| FT_Short contour; /* current contour */ |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* See `ttinterp.h' for details on backward compatibility mode. */ |
| /* Allow IUP until it has been called on both axes. Immediately */ |
| /* return on subsequent ones. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility ) |
| { |
| if ( exc->iupx_called && exc->iupy_called ) |
| return; |
| |
| if ( exc->opcode & 1 ) |
| exc->iupx_called = TRUE; |
| else |
| exc->iupy_called = TRUE; |
| } |
| #endif |
| |
| /* ignore empty outlines */ |
| if ( exc->pts.n_contours == 0 ) |
| return; |
| |
| if ( exc->opcode & 1 ) |
| { |
| mask = FT_CURVE_TAG_TOUCH_X; |
| V.orgs = exc->pts.org; |
| V.curs = exc->pts.cur; |
| V.orus = exc->pts.orus; |
| } |
| else |
| { |
| mask = FT_CURVE_TAG_TOUCH_Y; |
| V.orgs = (FT_Vector*)( (FT_Pos*)exc->pts.org + 1 ); |
| V.curs = (FT_Vector*)( (FT_Pos*)exc->pts.cur + 1 ); |
| V.orus = (FT_Vector*)( (FT_Pos*)exc->pts.orus + 1 ); |
| } |
| V.max_points = exc->pts.n_points; |
| |
| contour = 0; |
| point = 0; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode ) |
| { |
| exc->iup_called = TRUE; |
| if ( exc->sph_tweak_flags & SPH_TWEAK_SKIP_IUP ) |
| return; |
| } |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| do |
| { |
| end_point = exc->pts.contours[contour] - exc->pts.first_point; |
| first_point = point; |
| |
| if ( BOUNDS( end_point, exc->pts.n_points ) ) |
| end_point = exc->pts.n_points - 1; |
| |
| while ( point <= end_point && ( exc->pts.tags[point] & mask ) == 0 ) |
| point++; |
| |
| if ( point <= end_point ) |
| { |
| first_touched = point; |
| cur_touched = point; |
| |
| point++; |
| |
| while ( point <= end_point ) |
| { |
| if ( ( exc->pts.tags[point] & mask ) != 0 ) |
| { |
| _iup_worker_interpolate( &V, |
| cur_touched + 1, |
| point - 1, |
| cur_touched, |
| point ); |
| cur_touched = point; |
| } |
| |
| point++; |
| } |
| |
| if ( cur_touched == first_touched ) |
| _iup_worker_shift( &V, first_point, end_point, cur_touched ); |
| else |
| { |
| _iup_worker_interpolate( &V, |
| (FT_UShort)( cur_touched + 1 ), |
| end_point, |
| cur_touched, |
| first_touched ); |
| |
| if ( first_touched > 0 ) |
| _iup_worker_interpolate( &V, |
| first_point, |
| first_touched - 1, |
| cur_touched, |
| first_touched ); |
| } |
| } |
| contour++; |
| } while ( contour < exc->pts.n_contours ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DELTAPn[]: DELTA exceptions P1, P2, P3 |
| * Opcode range: 0x5D,0x71,0x72 |
| * Stack: uint32 (2 * uint32)... --> |
| */ |
| static void |
| Ins_DELTAP( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong nump, k; |
| FT_UShort A; |
| FT_ULong C, P; |
| FT_Long B; |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| FT_UShort B1, B2; |
| |
| |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->ignore_x_mode && |
| exc->iup_called && |
| ( exc->sph_tweak_flags & SPH_TWEAK_NO_DELTAP_AFTER_IUP ) ) |
| goto Fail; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| P = (FT_ULong)exc->func_cur_ppem( exc ); |
| nump = (FT_ULong)args[0]; /* some points theoretically may occur more |
| than once, thus UShort isn't enough */ |
| |
| for ( k = 1; k <= nump; k++ ) |
| { |
| if ( exc->args < 2 ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Too_Few_Arguments ); |
| exc->args = 0; |
| goto Fail; |
| } |
| |
| exc->args -= 2; |
| |
| A = (FT_UShort)exc->stack[exc->args + 1]; |
| B = exc->stack[exc->args]; |
| |
| /* XXX: Because some popular fonts contain some invalid DeltaP */ |
| /* instructions, we simply ignore them when the stacked */ |
| /* point reference is off limit, rather than returning an */ |
| /* error. As a delta instruction doesn't change a glyph */ |
| /* in great ways, this shouldn't be a problem. */ |
| |
| if ( !BOUNDS( A, exc->zp0.n_points ) ) |
| { |
| C = ( (FT_ULong)B & 0xF0 ) >> 4; |
| |
| switch ( exc->opcode ) |
| { |
| case 0x5D: |
| break; |
| |
| case 0x71: |
| C += 16; |
| break; |
| |
| case 0x72: |
| C += 32; |
| break; |
| } |
| |
| C += exc->GS.delta_base; |
| |
| if ( P == C ) |
| { |
| B = ( (FT_ULong)B & 0xF ) - 8; |
| if ( B >= 0 ) |
| B++; |
| B *= 1L << ( 6 - exc->GS.delta_shift ); |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| /* |
| * Allow delta move if |
| * |
| * - not using ignore_x_mode rendering, |
| * - glyph is specifically set to allow it, or |
| * - glyph is composite and freedom vector is not in subpixel |
| * direction. |
| */ |
| if ( !exc->ignore_x_mode || |
| ( exc->sph_tweak_flags & SPH_TWEAK_ALWAYS_DO_DELTAP ) || |
| ( exc->is_composite && exc->GS.freeVector.y != 0 ) ) |
| exc->func_move( exc, &exc->zp0, A, B ); |
| |
| /* Otherwise, apply subpixel hinting and compatibility mode */ |
| /* rules, always skipping deltas in subpixel direction. */ |
| else if ( exc->ignore_x_mode && exc->GS.freeVector.y != 0 ) |
| { |
| /* save the y value of the point now; compare after move */ |
| B1 = (FT_UShort)exc->zp0.cur[A].y; |
| |
| /* Standard subpixel hinting: Allow y move for y-touched */ |
| /* points. This messes up DejaVu ... */ |
| if ( !exc->face->sph_compatibility_mode && |
| ( exc->zp0.tags[A] & FT_CURVE_TAG_TOUCH_Y ) ) |
| exc->func_move( exc, &exc->zp0, A, B ); |
| |
| /* compatibility mode */ |
| else if ( exc->face->sph_compatibility_mode && |
| !( exc->sph_tweak_flags & SPH_TWEAK_ALWAYS_SKIP_DELTAP ) ) |
| { |
| if ( exc->sph_tweak_flags & SPH_TWEAK_ROUND_NONPIXEL_Y_MOVES ) |
| B = FT_PIX_ROUND( B1 + B ) - B1; |
| |
| /* Allow delta move if using sph_compatibility_mode, */ |
| /* IUP has not been called, and point is touched on Y. */ |
| if ( !exc->iup_called && |
| ( exc->zp0.tags[A] & FT_CURVE_TAG_TOUCH_Y ) ) |
| exc->func_move( exc, &exc->zp0, A, B ); |
| } |
| |
| B2 = (FT_UShort)exc->zp0.cur[A].y; |
| |
| /* Reverse this move if it results in a disallowed move */ |
| if ( exc->GS.freeVector.y != 0 && |
| ( ( exc->face->sph_compatibility_mode && |
| ( B1 & 63 ) == 0 && |
| ( B2 & 63 ) != 0 ) || |
| ( ( exc->sph_tweak_flags & |
| SPH_TWEAK_SKIP_NONPIXEL_Y_MOVES_DELTAP ) && |
| ( B1 & 63 ) != 0 && |
| ( B2 & 63 ) != 0 ) ) ) |
| exc->func_move( exc, &exc->zp0, A, NEG_LONG( B ) ); |
| } |
| } |
| else |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| { |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* See `ttinterp.h' for details on backward compatibility */ |
| /* mode. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->backward_compatibility ) |
| { |
| if ( !( exc->iupx_called && exc->iupy_called ) && |
| ( ( exc->is_composite && exc->GS.freeVector.y != 0 ) || |
| ( exc->zp0.tags[A] & FT_CURVE_TAG_TOUCH_Y ) ) ) |
| exc->func_move( exc, &exc->zp0, A, B ); |
| } |
| else |
| #endif |
| exc->func_move( exc, &exc->zp0, A, B ); |
| } |
| } |
| } |
| else |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Invalid_Reference ); |
| } |
| |
| Fail: |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * DELTACn[]: DELTA exceptions C1, C2, C3 |
| * Opcode range: 0x73,0x74,0x75 |
| * Stack: uint32 (2 * uint32)... --> |
| */ |
| static void |
| Ins_DELTAC( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_ULong nump, k; |
| FT_ULong A, C, P; |
| FT_Long B; |
| |
| |
| P = (FT_ULong)exc->func_cur_ppem( exc ); |
| nump = (FT_ULong)args[0]; |
| |
| for ( k = 1; k <= nump; k++ ) |
| { |
| if ( exc->args < 2 ) |
| { |
| if ( exc->pedantic_hinting ) |
| exc->error = FT_THROW( Too_Few_Arguments ); |
| exc->args = 0; |
| goto Fail; |
| } |
| |
| exc->args -= 2; |
| |
| A = (FT_ULong)exc->stack[exc->args + 1]; |
| B = exc->stack[exc->args]; |
| |
| if ( BOUNDSL( A, exc->cvtSize ) ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| return; |
| } |
| } |
| else |
| { |
| C = ( (FT_ULong)B & 0xF0 ) >> 4; |
| |
| switch ( exc->opcode ) |
| { |
| case 0x73: |
| break; |
| |
| case 0x74: |
| C += 16; |
| break; |
| |
| case 0x75: |
| C += 32; |
| break; |
| } |
| |
| C += exc->GS.delta_base; |
| |
| if ( P == C ) |
| { |
| B = ( (FT_ULong)B & 0xF ) - 8; |
| if ( B >= 0 ) |
| B++; |
| B *= 1L << ( 6 - exc->GS.delta_shift ); |
| |
| exc->func_move_cvt( exc, A, B ); |
| } |
| } |
| } |
| |
| Fail: |
| exc->new_top = exc->args; |
| } |
| |
| |
| /************************************************************************** |
| * |
| * MISC. INSTRUCTIONS |
| * |
| */ |
| |
| |
| /************************************************************************** |
| * |
| * GETINFO[]: GET INFOrmation |
| * Opcode range: 0x88 |
| * Stack: uint32 --> uint32 |
| * |
| * XXX: UNDOCUMENTED: Selector bits higher than 9 are currently (May |
| * 2015) not documented in the OpenType specification. |
| * |
| * Selector bit 11 is incorrectly described as bit 8, while the |
| * real meaning of bit 8 (vertical LCD subpixels) stays |
| * undocumented. The same mistake can be found in Greg Hitchcock's |
| * whitepaper. |
| */ |
| static void |
| Ins_GETINFO( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_Long K; |
| TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( exc->face ); |
| |
| |
| K = 0; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| /********************************* |
| * RASTERIZER VERSION |
| * Selector Bit: 0 |
| * Return Bit(s): 0-7 |
| */ |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| ( args[0] & 1 ) != 0 && |
| exc->subpixel_hinting ) |
| { |
| if ( exc->ignore_x_mode ) |
| { |
| /* if in ClearType backward compatibility mode, */ |
| /* we sometimes change the TrueType version dynamically */ |
| K = exc->rasterizer_version; |
| FT_TRACE6(( "Setting rasterizer version %d\n", |
| exc->rasterizer_version )); |
| } |
| else |
| K = TT_INTERPRETER_VERSION_38; |
| } |
| else |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| if ( ( args[0] & 1 ) != 0 ) |
| K = driver->interpreter_version; |
| |
| /********************************* |
| * GLYPH ROTATED |
| * Selector Bit: 1 |
| * Return Bit(s): 8 |
| */ |
| if ( ( args[0] & 2 ) != 0 && exc->tt_metrics.rotated ) |
| K |= 1 << 8; |
| |
| /********************************* |
| * GLYPH STRETCHED |
| * Selector Bit: 2 |
| * Return Bit(s): 9 |
| */ |
| if ( ( args[0] & 4 ) != 0 && exc->tt_metrics.stretched ) |
| K |= 1 << 9; |
| |
| #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
| /********************************* |
| * VARIATION GLYPH |
| * Selector Bit: 3 |
| * Return Bit(s): 10 |
| * |
| * XXX: UNDOCUMENTED! |
| */ |
| if ( (args[0] & 8 ) != 0 && exc->face->blend ) |
| K |= 1 << 10; |
| #endif |
| |
| /********************************* |
| * BI-LEVEL HINTING AND |
| * GRAYSCALE RENDERING |
| * Selector Bit: 5 |
| * Return Bit(s): 12 |
| */ |
| if ( ( args[0] & 32 ) != 0 && exc->grayscale ) |
| K |= 1 << 12; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* Toggle the following flags only outside of monochrome mode. */ |
| /* Otherwise, instructions may behave weirdly and rendering results */ |
| /* may differ between v35 and v40 mode, e.g., in `Times New Roman */ |
| /* Bold Italic'. */ |
| if ( SUBPIXEL_HINTING_MINIMAL && exc->subpixel_hinting_lean ) |
| { |
| /********************************* |
| * HINTING FOR SUBPIXEL |
| * Selector Bit: 6 |
| * Return Bit(s): 13 |
| * |
| * v40 does subpixel hinting by default. |
| */ |
| if ( ( args[0] & 64 ) != 0 ) |
| K |= 1 << 13; |
| |
| /********************************* |
| * VERTICAL LCD SUBPIXELS? |
| * Selector Bit: 8 |
| * Return Bit(s): 15 |
| */ |
| if ( ( args[0] & 256 ) != 0 && exc->vertical_lcd_lean ) |
| K |= 1 << 15; |
| |
| /********************************* |
| * SUBPIXEL POSITIONED? |
| * Selector Bit: 10 |
| * Return Bit(s): 17 |
| * |
| * XXX: FreeType supports it, dependent on what client does? |
| */ |
| if ( ( args[0] & 1024 ) != 0 ) |
| K |= 1 << 17; |
| |
| /********************************* |
| * SYMMETRICAL SMOOTHING |
| * Selector Bit: 11 |
| * Return Bit(s): 18 |
| * |
| * The only smoothing method FreeType supports unless someone sets |
| * FT_LOAD_TARGET_MONO. |
| */ |
| if ( ( args[0] & 2048 ) != 0 && exc->subpixel_hinting_lean ) |
| K |= 1 << 18; |
| |
| /********************************* |
| * CLEARTYPE HINTING AND |
| * GRAYSCALE RENDERING |
| * Selector Bit: 12 |
| * Return Bit(s): 19 |
| * |
| * Grayscale rendering is what FreeType does anyway unless someone |
| * sets FT_LOAD_TARGET_MONO or FT_LOAD_TARGET_LCD(_V) |
| */ |
| if ( ( args[0] & 4096 ) != 0 && exc->grayscale_cleartype ) |
| K |= 1 << 19; |
| } |
| #endif |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| |
| if ( SUBPIXEL_HINTING_INFINALITY && |
| exc->rasterizer_version >= TT_INTERPRETER_VERSION_35 ) |
| { |
| |
| if ( exc->rasterizer_version >= 37 ) |
| { |
| /********************************* |
| * HINTING FOR SUBPIXEL |
| * Selector Bit: 6 |
| * Return Bit(s): 13 |
| */ |
| if ( ( args[0] & 64 ) != 0 && exc->subpixel_hinting ) |
| K |= 1 << 13; |
| |
| /********************************* |
| * COMPATIBLE WIDTHS ENABLED |
| * Selector Bit: 7 |
| * Return Bit(s): 14 |
| * |
| * Functionality still needs to be added |
| */ |
| if ( ( args[0] & 128 ) != 0 && exc->compatible_widths ) |
| K |= 1 << 14; |
| |
| /********************************* |
| * VERTICAL LCD SUBPIXELS? |
| * Selector Bit: 8 |
| * Return Bit(s): 15 |
| * |
| * Functionality still needs to be added |
| */ |
| if ( ( args[0] & 256 ) != 0 && exc->vertical_lcd ) |
| K |= 1 << 15; |
| |
| /********************************* |
| * HINTING FOR BGR? |
| * Selector Bit: 9 |
| * Return Bit(s): 16 |
| * |
| * Functionality still needs to be added |
| */ |
| if ( ( args[0] & 512 ) != 0 && exc->bgr ) |
| K |= 1 << 16; |
| |
| if ( exc->rasterizer_version >= 38 ) |
| { |
| /********************************* |
| * SUBPIXEL POSITIONED? |
| * Selector Bit: 10 |
| * Return Bit(s): 17 |
| * |
| * Functionality still needs to be added |
| */ |
| if ( ( args[0] & 1024 ) != 0 && exc->subpixel_positioned ) |
| K |= 1 << 17; |
| |
| /********************************* |
| * SYMMETRICAL SMOOTHING |
| * Selector Bit: 11 |
| * Return Bit(s): 18 |
| * |
| * Functionality still needs to be added |
| */ |
| if ( ( args[0] & 2048 ) != 0 && exc->symmetrical_smoothing ) |
| K |= 1 << 18; |
| |
| /********************************* |
| * GRAY CLEARTYPE |
| * Selector Bit: 12 |
| * Return Bit(s): 19 |
| * |
| * Functionality still needs to be added |
| */ |
| if ( ( args[0] & 4096 ) != 0 && exc->gray_cleartype ) |
| K |= 1 << 19; |
| } |
| } |
| } |
| |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| args[0] = K; |
| } |
| |
| |
| #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
| |
| /************************************************************************** |
| * |
| * GETVARIATION[]: get normalized variation (blend) coordinates |
| * Opcode range: 0x91 |
| * Stack: --> f2.14... |
| * |
| * XXX: UNDOCUMENTED! There is no official documentation from Apple for |
| * this bytecode instruction. Active only if a font has GX |
| * variation axes. |
| */ |
| static void |
| Ins_GETVARIATION( TT_ExecContext exc, |
| FT_Long* args ) |
| { |
| FT_UInt num_axes = exc->face->blend->num_axis; |
| FT_Fixed* coords = exc->face->blend->normalizedcoords; |
| |
| FT_UInt i; |
| |
| |
| if ( BOUNDS( num_axes, exc->stackSize + 1 - exc->top ) ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| if ( coords ) |
| { |
| for ( i = 0; i < num_axes; i++ ) |
| args[i] = coords[i] >> 2; /* convert 16.16 to 2.14 format */ |
| } |
| else |
| { |
| for ( i = 0; i < num_axes; i++ ) |
| args[i] = 0; |
| } |
| } |
| |
| |
| /************************************************************************** |
| * |
| * GETDATA[]: no idea what this is good for |
| * Opcode range: 0x92 |
| * Stack: --> 17 |
| * |
| * XXX: UNDOCUMENTED! There is no documentation from Apple for this |
| * very weird bytecode instruction. |
| */ |
| static void |
| Ins_GETDATA( FT_Long* args ) |
| { |
| args[0] = 17; |
| } |
| |
| #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */ |
| |
| |
| static void |
| Ins_UNKNOWN( TT_ExecContext exc ) |
| { |
| TT_DefRecord* def = exc->IDefs; |
| TT_DefRecord* limit = def + exc->numIDefs; |
| |
| |
| for ( ; def < limit; def++ ) |
| { |
| if ( (FT_Byte)def->opc == exc->opcode && def->active ) |
| { |
| TT_CallRec* call; |
| |
| |
| if ( exc->callTop >= exc->callSize ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| return; |
| } |
| |
| call = exc->callStack + exc->callTop++; |
| |
| call->Caller_Range = exc->curRange; |
| call->Caller_IP = exc->IP + 1; |
| call->Cur_Count = 1; |
| call->Def = def; |
| |
| Ins_Goto_CodeRange( exc, def->range, def->start ); |
| |
| exc->step_ins = FALSE; |
| return; |
| } |
| } |
| |
| exc->error = FT_THROW( Invalid_Opcode ); |
| } |
| |
| |
| /************************************************************************** |
| * |
| * RUN |
| * |
| * This function executes a run of opcodes. It will exit in the |
| * following cases: |
| * |
| * - Errors (in which case it returns FALSE). |
| * |
| * - Reaching the end of the main code range (returns TRUE). |
| * Reaching the end of a code range within a function call is an |
| * error. |
| * |
| * - After executing one single opcode, if the flag `Instruction_Trap' |
| * is set to TRUE (returns TRUE). |
| * |
| * On exit with TRUE, test IP < CodeSize to know whether it comes from |
| * an instruction trap or a normal termination. |
| * |
| * |
| * Note: The documented DEBUG opcode pops a value from the stack. This |
| * behaviour is unsupported; here a DEBUG opcode is always an |
| * error. |
| * |
| * |
| * THIS IS THE INTERPRETER'S MAIN LOOP. |
| * |
| */ |
| |
| |
| /* documentation is in ttinterp.h */ |
| |
| FT_EXPORT_DEF( FT_Error ) |
| TT_RunIns( TT_ExecContext exc ) |
| { |
| FT_ULong ins_counter = 0; /* executed instructions counter */ |
| FT_ULong num_twilight_points; |
| FT_UShort i; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| FT_Byte opcode_pattern[1][2] = { |
| /* #8 TypeMan Talk Align */ |
| { |
| 0x06, /* SPVTL */ |
| 0x7D, /* RDTG */ |
| }, |
| }; |
| FT_UShort opcode_patterns = 1; |
| FT_UShort opcode_pointer[1] = { 0 }; |
| FT_UShort opcode_size[1] = { 1 }; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| exc->iup_called = FALSE; |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL |
| /* |
| * Toggle backward compatibility according to what font wants, except |
| * when |
| * |
| * 1) we have a `tricky' font that heavily relies on the interpreter to |
| * render glyphs correctly, for example DFKai-SB, or |
| * 2) FT_RENDER_MODE_MONO (i.e, monochome rendering) is requested. |
| * |
| * In those cases, backward compatibility needs to be turned off to get |
| * correct rendering. The rendering is then completely up to the |
| * font's programming. |
| * |
| */ |
| if ( SUBPIXEL_HINTING_MINIMAL && |
| exc->subpixel_hinting_lean && |
| !FT_IS_TRICKY( &exc->face->root ) ) |
| exc->backward_compatibility = !( exc->GS.instruct_control & 4 ); |
| else |
| exc->backward_compatibility = FALSE; |
| |
| exc->iupx_called = FALSE; |
| exc->iupy_called = FALSE; |
| #endif |
| |
| /* We restrict the number of twilight points to a reasonable, */ |
| /* heuristic value to avoid slow execution of malformed bytecode. */ |
| num_twilight_points = FT_MAX( 30, |
| 2 * ( exc->pts.n_points + exc->cvtSize ) ); |
| if ( exc->twilight.n_points > num_twilight_points ) |
| { |
| if ( num_twilight_points > 0xFFFFU ) |
| num_twilight_points = 0xFFFFU; |
| |
| FT_TRACE5(( "TT_RunIns: Resetting number of twilight points\n" |
| " from %d to the more reasonable value %d\n", |
| exc->twilight.n_points, |
| num_twilight_points )); |
| exc->twilight.n_points = (FT_UShort)num_twilight_points; |
| } |
| |
| /* Set up loop detectors. We restrict the number of LOOPCALL loops */ |
| /* and the number of JMPR, JROT, and JROF calls with a negative */ |
| /* argument to values that depend on various parameters like the */ |
| /* size of the CVT table or the number of points in the current */ |
| /* glyph (if applicable). */ |
| /* */ |
| /* The idea is that in real-world bytecode you either iterate over */ |
| /* all CVT entries (in the `prep' table), or over all points (or */ |
| /* contours, in the `glyf' table) of a glyph, and such iterations */ |
| /* don't happen very often. */ |
| exc->loopcall_counter = 0; |
| exc->neg_jump_counter = 0; |
| |
| /* The maximum values are heuristic. */ |
| if ( exc->pts.n_points ) |
| exc->loopcall_counter_max = FT_MAX( 50, |
| 10 * exc->pts.n_points ) + |
| FT_MAX( 50, |
| exc->cvtSize / 10 ); |
| else |
| exc->loopcall_counter_max = 300 + 8 * exc->cvtSize; |
| |
| /* as a protection against an unreasonable number of CVT entries */ |
| /* we assume at most 100 control values per glyph for the counter */ |
| if ( exc->loopcall_counter_max > |
| 100 * (FT_ULong)exc->face->root.num_glyphs ) |
| exc->loopcall_counter_max = 100 * (FT_ULong)exc->face->root.num_glyphs; |
| |
| FT_TRACE5(( "TT_RunIns: Limiting total number of loops in LOOPCALL" |
| " to %d\n", exc->loopcall_counter_max )); |
| |
| exc->neg_jump_counter_max = exc->loopcall_counter_max; |
| FT_TRACE5(( "TT_RunIns: Limiting total number of backward jumps" |
| " to %d\n", exc->neg_jump_counter_max )); |
| |
| /* set PPEM and CVT functions */ |
| exc->tt_metrics.ratio = 0; |
| if ( exc->metrics.x_ppem != exc->metrics.y_ppem ) |
| { |
| /* non-square pixels, use the stretched routines */ |
| exc->func_cur_ppem = Current_Ppem_Stretched; |
| exc->func_read_cvt = Read_CVT_Stretched; |
| exc->func_write_cvt = Write_CVT_Stretched; |
| exc->func_move_cvt = Move_CVT_Stretched; |
| } |
| else |
| { |
| /* square pixels, use normal routines */ |
| exc->func_cur_ppem = Current_Ppem; |
| exc->func_read_cvt = Read_CVT; |
| exc->func_write_cvt = Write_CVT; |
| exc->func_move_cvt = Move_CVT; |
| } |
| |
| Compute_Funcs( exc ); |
| Compute_Round( exc, (FT_Byte)exc->GS.round_state ); |
| |
| do |
| { |
| exc->opcode = exc->code[exc->IP]; |
| |
| #ifdef FT_DEBUG_LEVEL_TRACE |
| { |
| FT_Long cnt = FT_MIN( 8, exc->top ); |
| FT_Long n; |
| |
| |
| /* if tracing level is 7, show current code position */ |
| /* and the first few stack elements also */ |
| FT_TRACE6(( " " )); |
| FT_TRACE7(( "%06d ", exc->IP )); |
| FT_TRACE6(( opcode_name[exc->opcode] + 2 )); |
| FT_TRACE7(( "%*s", *opcode_name[exc->opcode] == 'A' |
| ? 2 |
| : 12 - ( *opcode_name[exc->opcode] - '0' ), |
| "#" )); |
| for ( n = 1; n <= cnt; n++ ) |
| FT_TRACE7(( " %d", exc->stack[exc->top - n] )); |
| FT_TRACE6(( "\n" )); |
| } |
| #endif /* FT_DEBUG_LEVEL_TRACE */ |
| |
| if ( ( exc->length = opcode_length[exc->opcode] ) < 0 ) |
| { |
| if ( exc->IP + 1 >= exc->codeSize ) |
| goto LErrorCodeOverflow_; |
| |
| exc->length = 2 - exc->length * exc->code[exc->IP + 1]; |
| } |
| |
| if ( exc->IP + exc->length > exc->codeSize ) |
| goto LErrorCodeOverflow_; |
| |
| /* First, let's check for empty stack and overflow */ |
| exc->args = exc->top - ( Pop_Push_Count[exc->opcode] >> 4 ); |
| |
| /* `args' is the top of the stack once arguments have been popped. */ |
| /* One can also interpret it as the index of the last argument. */ |
| if ( exc->args < 0 ) |
| { |
| if ( exc->pedantic_hinting ) |
| { |
| exc->error = FT_THROW( Too_Few_Arguments ); |
| goto LErrorLabel_; |
| } |
| |
| /* push zeroes onto the stack */ |
| for ( i = 0; i < Pop_Push_Count[exc->opcode] >> 4; i++ ) |
| exc->stack[i] = 0; |
| exc->args = 0; |
| } |
| |
| #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
| if ( exc->opcode == 0x91 ) |
| { |
| /* this is very special: GETVARIATION returns */ |
| /* a variable number of arguments */ |
| |
| /* it is the job of the application to `activate' GX handling, */ |
| /* this is, calling any of the GX API functions on the current */ |
| /* font to select a variation instance */ |
| if ( exc->face->blend ) |
| exc->new_top = exc->args + exc->face->blend->num_axis; |
| } |
| else |
| #endif |
| exc->new_top = exc->args + ( Pop_Push_Count[exc->opcode] & 15 ); |
| |
| /* `new_top' is the new top of the stack, after the instruction's */ |
| /* execution. `top' will be set to `new_top' after the `switch' */ |
| /* statement. */ |
| if ( exc->new_top > exc->stackSize ) |
| { |
| exc->error = FT_THROW( Stack_Overflow ); |
| goto LErrorLabel_; |
| } |
| |
| exc->step_ins = TRUE; |
| exc->error = FT_Err_Ok; |
| |
| #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY |
| |
| if ( SUBPIXEL_HINTING_INFINALITY ) |
| { |
| for ( i = 0; i < opcode_patterns; i++ ) |
| { |
| if ( opcode_pointer[i] < opcode_size[i] && |
| exc->opcode == opcode_pattern[i][opcode_pointer[i]] ) |
| { |
| opcode_pointer[i] += 1; |
| |
| if ( opcode_pointer[i] == opcode_size[i] ) |
| { |
| FT_TRACE6(( "sph: opcode ptrn: %d, %s %s\n", |
| i, |
| exc->face->root.family_name, |
| exc->face->root.style_name )); |
| |
| switch ( i ) |
| { |
| case 0: |
| break; |
| } |
| opcode_pointer[i] = 0; |
| } |
| } |
| else |
| opcode_pointer[i] = 0; |
| } |
| } |
| |
| #endif /* TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY */ |
| |
| { |
| FT_Long* args = exc->stack + exc->args; |
| FT_Byte opcode = exc->opcode; |
| |
| |
| switch ( opcode ) |
| { |
| case 0x00: /* SVTCA y */ |
| case 0x01: /* SVTCA x */ |
| case 0x02: /* SPvTCA y */ |
| case 0x03: /* SPvTCA x */ |
| case 0x04: /* SFvTCA y */ |
| case 0x05: /* SFvTCA x */ |
| Ins_SxyTCA( exc ); |
| break; |
| |
| case 0x06: /* SPvTL // */ |
| case 0x07: /* SPvTL + */ |
| Ins_SPVTL( exc, args ); |
| break; |
| |
| case 0x08: /* SFvTL // */ |
| case 0x09: /* SFvTL + */ |
| Ins_SFVTL( exc, args ); |
| break; |
| |
| case 0x0A: /* SPvFS */ |
| Ins_SPVFS( exc, args ); |
| break; |
| |
| case 0x0B: /* SFvFS */ |
| Ins_SFVFS( exc, args ); |
| break; |
| |
| case 0x0C: /* GPv */ |
| Ins_GPV( exc, args ); |
| break; |
| |
| case 0x0D: /* GFv */ |
| Ins_GFV( exc, args ); |
| break; |
| |
| case 0x0E: /* SFvTPv */ |
| Ins_SFVTPV( exc ); |
| break; |
| |
| case 0x0F: /* ISECT */ |
| Ins_ISECT( exc, args ); |
| break; |
| |
| case 0x10: /* SRP0 */ |
| Ins_SRP0( exc, args ); |
| break; |
| |
| case 0x11: /* SRP1 */ |
| Ins_SRP1( exc, args ); |
| break; |
| |
| case 0x12: /* SRP2 */ |
| Ins_SRP2( exc, args ); |
| break; |
| |
| case 0x13: /* SZP0 */ |
| Ins_SZP0( exc, args ); |
| break; |
| |
| case 0x14: /* SZP1 */ |
| Ins_SZP1( exc, args ); |
| break; |
| |
| case 0x15: /* SZP2 */ |
| Ins_SZP2( exc, args ); |
| break; |
| |
| case 0x16: /* SZPS */ |
| Ins_SZPS( exc, args ); |
| break; |
| |
| case 0x17: /* SLOOP */ |
| Ins_SLOOP( exc, args ); |
| break; |
| |
| case 0x18: /* RTG */ |
| Ins_RTG( exc ); |
| break; |
| |
| case 0x19: /* RTHG */ |
| Ins_RTHG( exc ); |
| break; |
| |
| case 0x1A: /* SMD */ |
| Ins_SMD( exc, args ); |
| break; |
| |
| case 0x1B: /* ELSE */ |
| Ins_ELSE( exc ); |
| break; |
| |
| case 0x1C: /* JMPR */ |
| Ins_JMPR( exc, args ); |
| break; |
| |
| case 0x1D: /* SCVTCI */ |
| Ins_SCVTCI( exc, args ); |
| break; |
| |
| case 0x1E: /* SSWCI */ |
| Ins_SSWCI( exc, args ); |
| break; |
| |
| case 0x1F: /* SSW */ |
| Ins_SSW( exc, args ); |
| break; |
| |
| case 0x20: /* DUP */ |
| Ins_DUP( args ); |
| break; |
| |
| case 0x21: /* POP */ |
| Ins_POP(); |
| break; |
| |
| case 0x22: /* CLEAR */ |
| Ins_CLEAR( exc ); |
| break; |
| |
| case 0x23: /* SWAP */ |
| Ins_SWAP( args ); |
| break; |
| |
| case 0x24: /* DEPTH */ |
| Ins_DEPTH( exc, args ); |
| break; |
| |
| case 0x25: /* CINDEX */ |
| Ins_CINDEX( exc, args ); |
| break; |
| |
| case 0x26: /* MINDEX */ |
| Ins_MINDEX( exc, args ); |
| break; |
| |
| case 0x27: /* ALIGNPTS */ |
| Ins_ALIGNPTS( exc, args ); |
| break; |
| |
| case 0x28: /* RAW */ |
| Ins_UNKNOWN( exc ); |
| break; |
| |
| case 0x29: /* UTP */ |
| Ins_UTP( exc, args ); |
| break; |
| |
| case 0x2A: /* LOOPCALL */ |
| Ins_LOOPCALL( exc, args ); |
| break; |
| |
| case 0x2B: /* CALL */ |
| Ins_CALL( exc, args ); |
| break; |
| |
| case 0x2C: /* FDEF */ |
| Ins_FDEF( exc, args ); |
| break; |
| |
| case 0x2D: /* ENDF */ |
| Ins_ENDF( exc ); |
| break; |
| |
| case 0x2E: /* MDAP */ |
| case 0x2F: /* MDAP */ |
| Ins_MDAP( exc, args ); |
| break; |
| |
| case 0x30: /* IUP */ |
| case 0x31: /* IUP */ |
| Ins_IUP( exc ); |
| break; |
| |
| case 0x32: /* SHP */ |
| case 0x33: /* SHP */ |
| Ins_SHP( exc ); |
| break; |
| |
| case 0x34: /* SHC */ |
| case 0x35: /* SHC */ |
| Ins_SHC( exc, args ); |
| break; |
| |
| case 0x36: /* SHZ */ |
| case 0x37: /* SHZ */ |
| Ins_SHZ( exc, args ); |
| break; |
| |
| case 0x38: /* SHPIX */ |
| Ins_SHPIX( exc, args ); |
| break; |
| |
| case 0x39: /* IP */ |
| Ins_IP( exc ); |
| break; |
| |
| case 0x3A: /* MSIRP */ |
| case 0x3B: /* MSIRP */ |
| Ins_MSIRP( exc, args ); |
| break; |
| |
| case 0x3C: /* AlignRP */ |
| Ins_ALIGNRP( exc ); |
| break; |
| |
| case 0x3D: /* RTDG */ |
| Ins_RTDG( exc ); |
| break; |
| |
| case 0x3E: /* MIAP */ |
| case 0x3F: /* MIAP */ |
| Ins_MIAP( exc, args ); |
| break; |
| |
| case 0x40: /* NPUSHB */ |
| Ins_NPUSHB( exc, args ); |
| break; |
| |
| case 0x41: /* NPUSHW */ |
| Ins_NPUSHW( exc, args ); |
| break; |
| |
| case 0x42: /* WS */ |
| Ins_WS( exc, args ); |
| break; |
| |
| case 0x43: /* RS */ |
| Ins_RS( exc, args ); |
| break; |
| |
| case 0x44: /* WCVTP */ |
| Ins_WCVTP( exc, args ); |
| break; |
| |
| case 0x45: /* RCVT */ |
| Ins_RCVT( exc, args ); |
| break; |
| |
| case 0x46: /* GC */ |
| case 0x47: /* GC */ |
| Ins_GC( exc, args ); |
| break; |
| |
| case 0x48: /* SCFS */ |
| Ins_SCFS( exc, args ); |
| break; |
| |
| case 0x49: /* MD */ |
| case 0x4A: /* MD */ |
| Ins_MD( exc, args ); |
| break; |
| |
| case 0x4B: /* MPPEM */ |
| Ins_MPPEM( exc, args ); |
| break; |
| |
| case 0x4C: /* MPS */ |
| Ins_MPS( exc, args ); |
| break; |
| |
| case 0x4D: /* FLIPON */ |
| Ins_FLIPON( exc ); |
| break; |
| |
| case 0x4E: /* FLIPOFF */ |
| Ins_FLIPOFF( exc ); |
| break; |
| |
| case 0x4F: /* DEBUG */ |
| Ins_DEBUG( exc ); |
| break; |
| |
| case 0x50: /* LT */ |
| Ins_LT( args ); |
| break; |
| |
| case 0x51: /* LTEQ */ |
| Ins_LTEQ( args ); |
| break; |
| |
| case 0x52: /* GT */ |
| Ins_GT( args ); |
| break; |
| |
| case 0x53: /* GTEQ */ |
| Ins_GTEQ( args ); |
| break; |
| |
| case 0x54: /* EQ */ |
| Ins_EQ( args ); |
| break; |
| |
| case 0x55: /* NEQ */ |
| Ins_NEQ( args ); |
| break; |
| |
| case 0x56: /* ODD */ |
| Ins_ODD( exc, args ); |
| break; |
| |
| case 0x57: /* EVEN */ |
| Ins_EVEN( exc, args ); |
| break; |
| |
| case 0x58: /* IF */ |
| Ins_IF( exc, args ); |
| break; |
| |
| case 0x59: /* EIF */ |
| Ins_EIF(); |
| break; |
| |
| case 0x5A: /* AND */ |
| Ins_AND( args ); |
| break; |
| |
| case 0x5B: /* OR */ |
| Ins_OR( args ); |
| break; |
| |
| case 0x5C: /* NOT */ |
| Ins_NOT( args ); |
| break; |
| |
| case 0x5D: /* DELTAP1 */ |
| Ins_DELTAP( exc, args ); |
| break; |
| |
| case 0x5E: /* SDB */ |
| Ins_SDB( exc, args ); |
| break; |
| |
| case 0x5F: /* SDS */ |
| Ins_SDS( exc, args ); |
| break; |
| |
| case 0x60: /* ADD */ |
| Ins_ADD( args ); |
| break; |
| |
| case 0x61: /* SUB */ |
| Ins_SUB( args ); |
| break; |
| |
| case 0x62: /* DIV */ |
| Ins_DIV( exc, args ); |
| break; |
| |
| case 0x63: /* MUL */ |
| Ins_MUL( args ); |
| break; |
| |
| case 0x64: /* ABS */ |
| Ins_ABS( args ); |
| break; |
| |
| case 0x65: /* NEG */ |
| Ins_NEG( args ); |
| break; |
| |
| case 0x66: /* FLOOR */ |
| Ins_FLOOR( args ); |
| break; |
| |
| case 0x67: /* CEILING */ |
| Ins_CEILING( args ); |
| break; |
| |
| case 0x68: /* ROUND */ |
| case 0x69: /* ROUND */ |
| case 0x6A: /* ROUND */ |
| case 0x6B: /* ROUND */ |
| Ins_ROUND( exc, args ); |
| break; |
| |
| case 0x6C: /* NROUND */ |
| case 0x6D: /* NROUND */ |
| case 0x6E: /* NRRUND */ |
| case 0x6F: /* NROUND */ |
| Ins_NROUND( exc, args ); |
| break; |
| |
| case 0x70: /* WCVTF */ |
| Ins_WCVTF( exc, args ); |
| break; |
| |
| case 0x71: /* DELTAP2 */ |
| case 0x72: /* DELTAP3 */ |
| Ins_DELTAP( exc, args ); |
| break; |
| |
| case 0x73: /* DELTAC0 */ |
| case 0x74: /* DELTAC1 */ |
| case 0x75: /* DELTAC2 */ |
| Ins_DELTAC( exc, args ); |
| break; |
| |
| case 0x76: /* SROUND */ |
| Ins_SROUND( exc, args ); |
| break; |
| |
| case 0x77: /* S45Round */ |
| Ins_S45ROUND( exc, args ); |
| break; |
| |
| case 0x78: /* JROT */ |
| Ins_JROT( exc, args ); |
| break; |
| |
| case 0x79: /* JROF */ |
| Ins_JROF( exc, args ); |
| break; |
| |
| case 0x7A: /* ROFF */ |
| Ins_ROFF( exc ); |
| break; |
| |
| case 0x7B: /* ???? */ |
| Ins_UNKNOWN( exc ); |
| break; |
| |
| case 0x7C: /* RUTG */ |
| Ins_RUTG( exc ); |
| break; |
| |
| case 0x7D: /* RDTG */ |
| Ins_RDTG( exc ); |
| break; |
| |
| case 0x7E: /* SANGW */ |
| Ins_SANGW(); |
| break; |
| |
| case 0x7F: /* AA */ |
| Ins_AA(); |
| break; |
| |
| case 0x80: /* FLIPPT */ |
| Ins_FLIPPT( exc ); |
| break; |
| |
| case 0x81: /* FLIPRGON */ |
| Ins_FLIPRGON( exc, args ); |
| break; |
| |
| case 0x82: /* FLIPRGOFF */ |
| Ins_FLIPRGOFF( exc, args ); |
| break; |
| |
| case 0x83: /* UNKNOWN */ |
| case 0x84: /* UNKNOWN */ |
| Ins_UNKNOWN( exc ); |
| break; |
| |
| case 0x85: /* SCANCTRL */ |
| Ins_SCANCTRL( exc, args ); |
| break; |
| |
| case 0x86: /* SDPvTL */ |
| case 0x87: /* SDPvTL */ |
| Ins_SDPVTL( exc, args ); |
| break; |
| |
| case 0x88: /* GETINFO */ |
| Ins_GETINFO( exc, args ); |
| break; |
| |
| case 0x89: /* IDEF */ |
| Ins_IDEF( exc, args ); |
| break; |
| |
| case 0x8A: /* ROLL */ |
| Ins_ROLL( args ); |
| break; |
| |
| case 0x8B: /* MAX */ |
| Ins_MAX( args ); |
| break; |
| |
| case 0x8C: /* MIN */ |
| Ins_MIN( args ); |
| break; |
| |
| case 0x8D: /* SCANTYPE */ |
| Ins_SCANTYPE( exc, args ); |
| break; |
| |
| case 0x8E: /* INSTCTRL */ |
| Ins_INSTCTRL( exc, args ); |
| break; |
| |
| case 0x8F: /* ADJUST */ |
| case 0x90: /* ADJUST */ |
| Ins_UNKNOWN( exc ); |
| break; |
| |
| #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
| case 0x91: |
| /* it is the job of the application to `activate' GX handling, */ |
| /* this is, calling any of the GX API functions on the current */ |
| /* font to select a variation instance */ |
| if ( exc->face->blend ) |
| Ins_GETVARIATION( exc, args ); |
| else |
| Ins_UNKNOWN( exc ); |
| break; |
| |
| case 0x92: |
| /* there is at least one MS font (LaoUI.ttf version 5.01) that */ |
| /* uses IDEFs for 0x91 and 0x92; for this reason we activate */ |
| /* GETDATA for GX fonts only, similar to GETVARIATION */ |
| if ( exc->face->blend ) |
| Ins_GETDATA( args ); |
| else |
| Ins_UNKNOWN( exc ); |
| break; |
| #endif |
| |
| default: |
| if ( opcode >= 0xE0 ) |
| Ins_MIRP( exc, args ); |
| else if ( opcode >= 0xC0 ) |
| Ins_MDRP( exc, args ); |
| else if ( opcode >= 0xB8 ) |
| Ins_PUSHW( exc, args ); |
| else if ( opcode >= 0xB0 ) |
| Ins_PUSHB( exc, args ); |
| else |
| Ins_UNKNOWN( exc ); |
| } |
| } |
| |
| if ( exc->error ) |
| { |
| switch ( exc->error ) |
| { |
| /* looking for redefined instructions */ |
| case FT_ERR( Invalid_Opcode ): |
| { |
| TT_DefRecord* def = exc->IDefs; |
| TT_DefRecord* limit = def + exc->numIDefs; |
| |
| |
| for ( ; def < limit; def++ ) |
| { |
| if ( def->active && exc->opcode == (FT_Byte)def->opc ) |
| { |
| TT_CallRec* callrec; |
| |
| |
| if ( exc->callTop >= exc->callSize ) |
| { |
| exc->error = FT_THROW( Invalid_Reference ); |
| goto LErrorLabel_; |
| } |
| |
| callrec = &exc->callStack[exc->callTop]; |
| |
| callrec->Caller_Range = exc->curRange; |
| callrec->Caller_IP = exc->IP + 1; |
| callrec->Cur_Count = 1; |
| callrec->Def = def; |
| |
| if ( Ins_Goto_CodeRange( exc, |
| def->range, |
| def->start ) == FAILURE ) |
| goto LErrorLabel_; |
| |
| goto LSuiteLabel_; |
| } |
| } |
| } |
| |
| exc->error = FT_THROW( Invalid_Opcode ); |
| goto LErrorLabel_; |
| |
| #if 0 |
| break; /* Unreachable code warning suppression. */ |
| /* Leave to remind in case a later change the editor */ |
| /* to consider break; */ |
| #endif |
| |
| default: |
| goto LErrorLabel_; |
| |
| #if 0 |
| break; |
| #endif |
| } |
| } |
| |
| exc->top = exc->new_top; |
| |
| if ( exc->step_ins ) |
| exc->IP += exc->length; |
| |
| /* increment instruction counter and check if we didn't */ |
| /* run this program for too long (e.g. infinite loops). */ |
| if ( ++ins_counter > TT_CONFIG_OPTION_MAX_RUNNABLE_OPCODES ) |
| return FT_THROW( Execution_Too_Long ); |
| |
| LSuiteLabel_: |
| if ( exc->IP >= exc->codeSize ) |
| { |
| if ( exc->callTop > 0 ) |
| { |
| exc->error = FT_THROW( Code_Overflow ); |
| goto LErrorLabel_; |
| } |
| else |
| goto LNo_Error_; |
| } |
| } while ( !exc->instruction_trap ); |
| |
| LNo_Error_: |
| FT_TRACE4(( " %d instruction%s executed\n", |
| ins_counter, |
| ins_counter == 1 ? "" : "s" )); |
| return FT_Err_Ok; |
| |
| LErrorCodeOverflow_: |
| exc->error = FT_THROW( Code_Overflow ); |
| |
| LErrorLabel_: |
| if ( exc->error && !exc->instruction_trap ) |
| FT_TRACE1(( " The interpreter returned error 0x%x\n", exc->error )); |
| |
| return exc->error; |
| } |
| |
| #else /* !TT_USE_BYTECODE_INTERPRETER */ |
| |
| /* ANSI C doesn't like empty source files */ |
| typedef int _tt_interp_dummy; |
| |
| #endif /* !TT_USE_BYTECODE_INTERPRETER */ |
| |
| |
| /* END */ |