| Index: core/src/fxge/fx_freetype/fxft2.5.01/src/truetype/ttinterp.c
|
| diff --git a/core/src/fxge/fx_freetype/fxft2.5.01/src/truetype/ttinterp.c b/core/src/fxge/fx_freetype/fxft2.5.01/src/truetype/ttinterp.c
|
| deleted file mode 100644
|
| index b7d2b62b3da728f1a8b154ae2a85bf3d3ab1a461..0000000000000000000000000000000000000000
|
| --- a/core/src/fxge/fx_freetype/fxft2.5.01/src/truetype/ttinterp.c
|
| +++ /dev/null
|
| @@ -1,8952 +0,0 @@
|
| -/***************************************************************************/
|
| -/* */
|
| -/* ttinterp.c */
|
| -/* */
|
| -/* TrueType bytecode interpreter (body). */
|
| -/* */
|
| -/* Copyright 1996-2013 */
|
| -/* 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 "../../include/ft2build.h"
|
| -#include "../../include/freetype/internal/ftdebug.h"
|
| -#include "../../include/freetype/internal/ftcalc.h"
|
| -#include "../../include/freetype/fttrigon.h"
|
| -#include "../../include/freetype/ftsystem.h"
|
| -#include "../../include/freetype/ftttdrv.h"
|
| -
|
| -#include "ttinterp.h"
|
| -#include "tterrors.h"
|
| -#include "ttsubpix.h"
|
| -
|
| -
|
| -#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
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* In order to detect infinite loops in the code, we set up a counter */
|
| - /* within the run loop. A single stroke of interpretation is now */
|
| - /* limited to a maximum number of opcodes defined below. */
|
| - /* */
|
| -#define MAX_RUNNABLE_OPCODES 1000000L
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* There are two kinds of implementations: */
|
| - /* */
|
| - /* a. static implementation */
|
| - /* */
|
| - /* The current execution context is a static variable, which fields */
|
| - /* are accessed directly by the interpreter during execution. The */
|
| - /* context is named `cur'. */
|
| - /* */
|
| - /* This version is non-reentrant, of course. */
|
| - /* */
|
| - /* b. indirect implementation */
|
| - /* */
|
| - /* The current execution context is passed to _each_ function as its */
|
| - /* first argument, and each field is thus accessed indirectly. */
|
| - /* */
|
| - /* This version is fully re-entrant. */
|
| - /* */
|
| - /* The idea is that an indirect implementation may be slower to execute */
|
| - /* on low-end processors that are used in some systems (like 386s or */
|
| - /* even 486s). */
|
| - /* */
|
| - /* As a consequence, the indirect implementation is now the default, as */
|
| - /* its performance costs can be considered negligible in our context. */
|
| - /* Note, however, that we kept the same source with macros because: */
|
| - /* */
|
| - /* - The code is kept very close in design to the Pascal code used for */
|
| - /* development. */
|
| - /* */
|
| - /* - It's much more readable that way! */
|
| - /* */
|
| - /* - It's still open to experimentation and tuning. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| -#ifndef TT_CONFIG_OPTION_STATIC_INTERPRETER /* indirect implementation */
|
| -
|
| -#define CUR (*exc) /* see ttobjs.h */
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* This macro is used whenever `exec' is unused in a function, to avoid */
|
| - /* stupid warnings from pedantic compilers. */
|
| - /* */
|
| -#define FT_UNUSED_EXEC FT_UNUSED( exc )
|
| -
|
| -#else /* static implementation */
|
| -
|
| -#define CUR cur
|
| -
|
| -#define FT_UNUSED_EXEC int __dummy = __dummy
|
| -
|
| - static
|
| - TT_ExecContextRec cur; /* static exec. context variable */
|
| -
|
| - /* apparently, we have a _lot_ of direct indexing when accessing */
|
| - /* the static `cur', which makes the code bigger (due to all the */
|
| - /* four bytes addresses). */
|
| -
|
| -#endif /* TT_CONFIG_OPTION_STATIC_INTERPRETER */
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* The instruction argument stack. */
|
| - /* */
|
| -#define INS_ARG EXEC_OP_ FT_Long* args /* see ttobjs.h for EXEC_OP_ */
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* This macro is used whenever `args' is unused in a function, to avoid */
|
| - /* stupid warnings from pedantic compilers. */
|
| - /* */
|
| -#define FT_UNUSED_ARG FT_UNUSED_EXEC; FT_UNUSED( args )
|
| -
|
| -
|
| -#define SUBPIXEL_HINTING \
|
| - ( ((TT_Driver)FT_FACE_DRIVER( CUR.face ))->interpreter_version == \
|
| - TT_INTERPRETER_VERSION_38 )
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* The following macros hide the use of EXEC_ARG and EXEC_ARG_ to */
|
| - /* increase readability of the code. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| -#define SKIP_Code() \
|
| - SkipCode( EXEC_ARG )
|
| -
|
| -#define GET_ShortIns() \
|
| - GetShortIns( EXEC_ARG )
|
| -
|
| -#define NORMalize( x, y, v ) \
|
| - Normalize( EXEC_ARG_ x, y, v )
|
| -
|
| -#define SET_SuperRound( scale, flags ) \
|
| - SetSuperRound( EXEC_ARG_ scale, flags )
|
| -
|
| -#define ROUND_None( d, c ) \
|
| - Round_None( EXEC_ARG_ d, c )
|
| -
|
| -#define INS_Goto_CodeRange( range, ip ) \
|
| - Ins_Goto_CodeRange( EXEC_ARG_ range, ip )
|
| -
|
| -#define CUR_Func_move( z, p, d ) \
|
| - CUR.func_move( EXEC_ARG_ z, p, d )
|
| -
|
| -#define CUR_Func_move_orig( z, p, d ) \
|
| - CUR.func_move_orig( EXEC_ARG_ z, p, d )
|
| -
|
| -#define CUR_Func_round( d, c ) \
|
| - CUR.func_round( EXEC_ARG_ d, c )
|
| -
|
| -#define CUR_Func_read_cvt( index ) \
|
| - CUR.func_read_cvt( EXEC_ARG_ index )
|
| -
|
| -#define CUR_Func_write_cvt( index, val ) \
|
| - CUR.func_write_cvt( EXEC_ARG_ index, val )
|
| -
|
| -#define CUR_Func_move_cvt( index, val ) \
|
| - CUR.func_move_cvt( EXEC_ARG_ index, val )
|
| -
|
| -#define CURRENT_Ratio() \
|
| - Current_Ratio( EXEC_ARG )
|
| -
|
| -#define CURRENT_Ppem() \
|
| - Current_Ppem( EXEC_ARG )
|
| -
|
| -#define CUR_Ppem() \
|
| - Cur_PPEM( EXEC_ARG )
|
| -
|
| -#define INS_SxVTL( a, b, c, d ) \
|
| - Ins_SxVTL( EXEC_ARG_ a, b, c, d )
|
| -
|
| -#define COMPUTE_Funcs() \
|
| - Compute_Funcs( EXEC_ARG )
|
| -
|
| -#define COMPUTE_Round( a ) \
|
| - Compute_Round( EXEC_ARG_ a )
|
| -
|
| -#define COMPUTE_Point_Displacement( a, b, c, d ) \
|
| - Compute_Point_Displacement( EXEC_ARG_ a, b, c, d )
|
| -
|
| -#define MOVE_Zp2_Point( a, b, c, t ) \
|
| - Move_Zp2_Point( EXEC_ARG_ a, b, c, t )
|
| -
|
| -
|
| -#define CUR_Func_project( v1, v2 ) \
|
| - CUR.func_project( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
|
| -
|
| -#define CUR_Func_dualproj( v1, v2 ) \
|
| - CUR.func_dualproj( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
|
| -
|
| -#define CUR_fast_project( v ) \
|
| - CUR.func_project( EXEC_ARG_ (v)->x, (v)->y )
|
| -
|
| -#define CUR_fast_dualproj( v ) \
|
| - CUR.func_dualproj( EXEC_ARG_ (v)->x, (v)->y )
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* Instruction dispatch function, as used by the interpreter. */
|
| - /* */
|
| - typedef void (*TInstruction_Function)( INS_ARG );
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* 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) )
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* This macro computes (a*2^14)/b and complements TT_MulFix14. */
|
| - /* */
|
| -#define TT_DivFix14( a, b ) \
|
| - FT_DivFix( a, (b) << 2 )
|
| -
|
| -
|
| -#undef SUCCESS
|
| -#define SUCCESS 0
|
| -
|
| -#undef FAILURE
|
| -#define FAILURE 1
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| -#define GUESS_VECTOR( V ) \
|
| - if ( CUR.face->unpatented_hinting ) \
|
| - { \
|
| - CUR.GS.V.x = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0x4000 : 0 ); \
|
| - CUR.GS.V.y = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0 : 0x4000 ); \
|
| - }
|
| -#else
|
| -#define GUESS_VECTOR( V )
|
| -#endif
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* 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. */
|
| - /* */
|
| - /* <Return> */
|
| - /* FreeType error code. 0 means success. */
|
| - /* */
|
| - FT_LOCAL_DEF( FT_Error )
|
| - 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 != NULL );
|
| -
|
| - /* 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( (FT_ULong)IP <= coderange->size );
|
| -
|
| - exec->code = coderange->base;
|
| - exec->codeSize = coderange->size;
|
| - exec->IP = IP;
|
| - exec->curRange = range;
|
| -
|
| - return FT_Err_Ok;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <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. */
|
| - /* */
|
| - /* <Return> */
|
| - /* FreeType error code. 0 means success. */
|
| - /* */
|
| - FT_LOCAL_DEF( FT_Error )
|
| - 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;
|
| -
|
| - return FT_Err_Ok;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <Function> */
|
| - /* TT_Clear_CodeRange */
|
| - /* */
|
| - /* <Description> */
|
| - /* Clears a code range. */
|
| - /* */
|
| - /* <Input> */
|
| - /* range :: The code range index. */
|
| - /* */
|
| - /* <InOut> */
|
| - /* exec :: The target execution context. */
|
| - /* */
|
| - /* <Return> */
|
| - /* FreeType error code. 0 means success. */
|
| - /* */
|
| - /* <Note> */
|
| - /* Does not set the Error variable. */
|
| - /* */
|
| - FT_LOCAL_DEF( FT_Error )
|
| - 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;
|
| -
|
| - return FT_Err_Ok;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* 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. */
|
| - /* */
|
| - /* <Return> */
|
| - /* FreeType error code. 0 means success. */
|
| - /* */
|
| - /* <Note> */
|
| - /* Only the glyph loader and debugger should call this function. */
|
| - /* */
|
| - FT_LOCAL_DEF( FT_Error )
|
| - 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 );
|
| -
|
| - return FT_Err_Ok;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <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_Long 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->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_memset( &exec->zp0, 0, sizeof ( 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 = exec->stackSize;
|
| - error = Update_Max( exec->memory,
|
| - &tmp,
|
| - sizeof ( FT_F26Dot6 ),
|
| - (void*)&exec->stack,
|
| - maxp->maxStackElements + 32 );
|
| - exec->stackSize = (FT_UInt)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. */
|
| - /* */
|
| - /* <Return> */
|
| - /* FreeType error code. 0 means success. */
|
| - /* */
|
| - /* <Note> */
|
| - /* Only the glyph loader and debugger should call this function. */
|
| - /* */
|
| - FT_LOCAL_DEF( FT_Error )
|
| - 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];
|
| -
|
| - return FT_Err_Ok;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <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. */
|
| - /* */
|
| - /* <Note> */
|
| - /* Only the glyph loader and debugger should call this function. */
|
| - /* */
|
| - FT_LOCAL_DEF( FT_Error )
|
| - TT_Run_Context( TT_ExecContext exec,
|
| - FT_Bool debug )
|
| - {
|
| - FT_Error error;
|
| -
|
| -
|
| - if ( ( error = TT_Goto_CodeRange( exec, tt_coderange_glyph, 0 ) )
|
| - != FT_Err_Ok )
|
| - return error;
|
| -
|
| - 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;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - exec->GS.both_x_axis = TRUE;
|
| -#endif
|
| -
|
| - 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;
|
| -
|
| -#if 1
|
| - FT_UNUSED( debug );
|
| -
|
| - return exec->face->interpreter( exec );
|
| -#else
|
| - if ( !debug )
|
| - return TT_RunIns( exec );
|
| - else
|
| - return FT_Err_Ok;
|
| -#endif
|
| - }
|
| -
|
| -
|
| - /* 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 },
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - TRUE,
|
| -#endif
|
| -
|
| - 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 )
|
| - {
|
| - TT_ExecContext exec;
|
| - FT_Memory memory;
|
| -
|
| -
|
| - memory = driver->root.root.memory;
|
| - exec = driver->context;
|
| -
|
| - if ( !driver->context )
|
| - {
|
| - FT_Error error;
|
| -
|
| -
|
| - /* 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;
|
| -
|
| - /* store it into the driver */
|
| - driver->context = exec;
|
| - }
|
| -
|
| - return driver->context;
|
| -
|
| - 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 ),
|
| - /* SHP[1] */ PACK( 0, 0 ),
|
| - /* SHC[0] */ PACK( 1, 0 ),
|
| - /* SHC[1] */ PACK( 1, 0 ),
|
| - /* SHZ[0] */ PACK( 1, 0 ),
|
| - /* SHZ[1] */ PACK( 1, 0 ),
|
| - /* SHPIX */ PACK( 1, 0 ),
|
| - /* IP */ PACK( 0, 0 ),
|
| - /* MSIRP[0] */ PACK( 2, 0 ),
|
| - /* MSIRP[1] */ PACK( 2, 0 ),
|
| - /* AlignRP */ PACK( 0, 0 ),
|
| - /* 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 ),
|
| - /* 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 ),
|
| - /* INS_$91 */ PACK( 0, 0 ),
|
| - /* INS_$92 */ PACK( 0, 0 ),
|
| - /* 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
|
| -
|
| - static
|
| - const char* const opcode_name[256] =
|
| - {
|
| - "SVTCA y",
|
| - "SVTCA x",
|
| - "SPvTCA y",
|
| - "SPvTCA x",
|
| - "SFvTCA y",
|
| - "SFvTCA x",
|
| - "SPvTL ||",
|
| - "SPvTL +",
|
| - "SFvTL ||",
|
| - "SFvTL +",
|
| - "SPvFS",
|
| - "SFvFS",
|
| - "GPV",
|
| - "GFV",
|
| - "SFvTPv",
|
| - "ISECT",
|
| -
|
| - "SRP0",
|
| - "SRP1",
|
| - "SRP2",
|
| - "SZP0",
|
| - "SZP1",
|
| - "SZP2",
|
| - "SZPS",
|
| - "SLOOP",
|
| - "RTG",
|
| - "RTHG",
|
| - "SMD",
|
| - "ELSE",
|
| - "JMPR",
|
| - "SCvTCi",
|
| - "SSwCi",
|
| - "SSW",
|
| -
|
| - "DUP",
|
| - "POP",
|
| - "CLEAR",
|
| - "SWAP",
|
| - "DEPTH",
|
| - "CINDEX",
|
| - "MINDEX",
|
| - "AlignPTS",
|
| - "INS_$28",
|
| - "UTP",
|
| - "LOOPCALL",
|
| - "CALL",
|
| - "FDEF",
|
| - "ENDF",
|
| - "MDAP[0]",
|
| - "MDAP[1]",
|
| -
|
| - "IUP[0]",
|
| - "IUP[1]",
|
| - "SHP[0]",
|
| - "SHP[1]",
|
| - "SHC[0]",
|
| - "SHC[1]",
|
| - "SHZ[0]",
|
| - "SHZ[1]",
|
| - "SHPIX",
|
| - "IP",
|
| - "MSIRP[0]",
|
| - "MSIRP[1]",
|
| - "AlignRP",
|
| - "RTDG",
|
| - "MIAP[0]",
|
| - "MIAP[1]",
|
| -
|
| - "NPushB",
|
| - "NPushW",
|
| - "WS",
|
| - "RS",
|
| - "WCvtP",
|
| - "RCvt",
|
| - "GC[0]",
|
| - "GC[1]",
|
| - "SCFS",
|
| - "MD[0]",
|
| - "MD[1]",
|
| - "MPPEM",
|
| - "MPS",
|
| - "FlipON",
|
| - "FlipOFF",
|
| - "DEBUG",
|
| -
|
| - "LT",
|
| - "LTEQ",
|
| - "GT",
|
| - "GTEQ",
|
| - "EQ",
|
| - "NEQ",
|
| - "ODD",
|
| - "EVEN",
|
| - "IF",
|
| - "EIF",
|
| - "AND",
|
| - "OR",
|
| - "NOT",
|
| - "DeltaP1",
|
| - "SDB",
|
| - "SDS",
|
| -
|
| - "ADD",
|
| - "SUB",
|
| - "DIV",
|
| - "MUL",
|
| - "ABS",
|
| - "NEG",
|
| - "FLOOR",
|
| - "CEILING",
|
| - "ROUND[0]",
|
| - "ROUND[1]",
|
| - "ROUND[2]",
|
| - "ROUND[3]",
|
| - "NROUND[0]",
|
| - "NROUND[1]",
|
| - "NROUND[2]",
|
| - "NROUND[3]",
|
| -
|
| - "WCvtF",
|
| - "DeltaP2",
|
| - "DeltaP3",
|
| - "DeltaCn[0]",
|
| - "DeltaCn[1]",
|
| - "DeltaCn[2]",
|
| - "SROUND",
|
| - "S45Round",
|
| - "JROT",
|
| - "JROF",
|
| - "ROFF",
|
| - "INS_$7B",
|
| - "RUTG",
|
| - "RDTG",
|
| - "SANGW",
|
| - "AA",
|
| -
|
| - "FlipPT",
|
| - "FlipRgON",
|
| - "FlipRgOFF",
|
| - "INS_$83",
|
| - "INS_$84",
|
| - "ScanCTRL",
|
| - "SDVPTL[0]",
|
| - "SDVPTL[1]",
|
| - "GetINFO",
|
| - "IDEF",
|
| - "ROLL",
|
| - "MAX",
|
| - "MIN",
|
| - "ScanTYPE",
|
| - "InstCTRL",
|
| - "INS_$8F",
|
| -
|
| - "INS_$90",
|
| - "INS_$91",
|
| - "INS_$92",
|
| - "INS_$93",
|
| - "INS_$94",
|
| - "INS_$95",
|
| - "INS_$96",
|
| - "INS_$97",
|
| - "INS_$98",
|
| - "INS_$99",
|
| - "INS_$9A",
|
| - "INS_$9B",
|
| - "INS_$9C",
|
| - "INS_$9D",
|
| - "INS_$9E",
|
| - "INS_$9F",
|
| -
|
| - "INS_$A0",
|
| - "INS_$A1",
|
| - "INS_$A2",
|
| - "INS_$A3",
|
| - "INS_$A4",
|
| - "INS_$A5",
|
| - "INS_$A6",
|
| - "INS_$A7",
|
| - "INS_$A8",
|
| - "INS_$A9",
|
| - "INS_$AA",
|
| - "INS_$AB",
|
| - "INS_$AC",
|
| - "INS_$AD",
|
| - "INS_$AE",
|
| - "INS_$AF",
|
| -
|
| - "PushB[0]",
|
| - "PushB[1]",
|
| - "PushB[2]",
|
| - "PushB[3]",
|
| - "PushB[4]",
|
| - "PushB[5]",
|
| - "PushB[6]",
|
| - "PushB[7]",
|
| - "PushW[0]",
|
| - "PushW[1]",
|
| - "PushW[2]",
|
| - "PushW[3]",
|
| - "PushW[4]",
|
| - "PushW[5]",
|
| - "PushW[6]",
|
| - "PushW[7]",
|
| -
|
| - "MDRP[00]",
|
| - "MDRP[01]",
|
| - "MDRP[02]",
|
| - "MDRP[03]",
|
| - "MDRP[04]",
|
| - "MDRP[05]",
|
| - "MDRP[06]",
|
| - "MDRP[07]",
|
| - "MDRP[08]",
|
| - "MDRP[09]",
|
| - "MDRP[10]",
|
| - "MDRP[11]",
|
| - "MDRP[12]",
|
| - "MDRP[13]",
|
| - "MDRP[14]",
|
| - "MDRP[15]",
|
| -
|
| - "MDRP[16]",
|
| - "MDRP[17]",
|
| - "MDRP[18]",
|
| - "MDRP[19]",
|
| - "MDRP[20]",
|
| - "MDRP[21]",
|
| - "MDRP[22]",
|
| - "MDRP[23]",
|
| - "MDRP[24]",
|
| - "MDRP[25]",
|
| - "MDRP[26]",
|
| - "MDRP[27]",
|
| - "MDRP[28]",
|
| - "MDRP[29]",
|
| - "MDRP[30]",
|
| - "MDRP[31]",
|
| -
|
| - "MIRP[00]",
|
| - "MIRP[01]",
|
| - "MIRP[02]",
|
| - "MIRP[03]",
|
| - "MIRP[04]",
|
| - "MIRP[05]",
|
| - "MIRP[06]",
|
| - "MIRP[07]",
|
| - "MIRP[08]",
|
| - "MIRP[09]",
|
| - "MIRP[10]",
|
| - "MIRP[11]",
|
| - "MIRP[12]",
|
| - "MIRP[13]",
|
| - "MIRP[14]",
|
| - "MIRP[15]",
|
| -
|
| - "MIRP[16]",
|
| - "MIRP[17]",
|
| - "MIRP[18]",
|
| - "MIRP[19]",
|
| - "MIRP[20]",
|
| - "MIRP[21]",
|
| - "MIRP[22]",
|
| - "MIRP[23]",
|
| - "MIRP[24]",
|
| - "MIRP[25]",
|
| - "MIRP[26]",
|
| - "MIRP[27]",
|
| - "MIRP[28]",
|
| - "MIRP[29]",
|
| - "MIRP[30]",
|
| - "MIRP[31]"
|
| - };
|
| -
|
| -#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
|
| -
|
| -#if 1
|
| -
|
| - 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;
|
| - }
|
| -
|
| -#else
|
| -
|
| - /* compute (a*b)/2^14 with maximum accuracy and rounding */
|
| - static FT_Int32
|
| - TT_MulFix14( FT_Int32 a,
|
| - FT_Int b )
|
| - {
|
| - FT_Int32 m, s, hi;
|
| - FT_UInt32 l, lo;
|
| -
|
| -
|
| - /* compute ax*bx as 64-bit value */
|
| - l = (FT_UInt32)( ( a & 0xFFFFU ) * b );
|
| - m = ( a >> 16 ) * b;
|
| -
|
| - lo = l + ( (FT_UInt32)m << 16 );
|
| - hi = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo < l );
|
| -
|
| - /* 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
|
| -
|
| -
|
| - /* 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 ) );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <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( EXEC_OP )
|
| - {
|
| - if ( !CUR.tt_metrics.ratio )
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - if ( CUR.GS.both_x_axis )
|
| - CUR.tt_metrics.ratio = CUR.tt_metrics.x_ratio;
|
| - else
|
| - CUR.tt_metrics.ratio = CUR.tt_metrics.y_ratio;
|
| - }
|
| - else
|
| -#endif
|
| - {
|
| - if ( CUR.GS.projVector.y == 0 )
|
| - CUR.tt_metrics.ratio = CUR.tt_metrics.x_ratio;
|
| -
|
| - else if ( CUR.GS.projVector.x == 0 )
|
| - CUR.tt_metrics.ratio = CUR.tt_metrics.y_ratio;
|
| -
|
| - else
|
| - {
|
| - FT_F26Dot6 x, y;
|
| -
|
| -
|
| - x = TT_MulFix14( CUR.tt_metrics.x_ratio,
|
| - CUR.GS.projVector.x );
|
| - y = TT_MulFix14( CUR.tt_metrics.y_ratio,
|
| - CUR.GS.projVector.y );
|
| - CUR.tt_metrics.ratio = FT_Hypot( x, y );
|
| - }
|
| - }
|
| - }
|
| - return CUR.tt_metrics.ratio;
|
| - }
|
| -
|
| -
|
| - static FT_Long
|
| - Current_Ppem( EXEC_OP )
|
| - {
|
| - return FT_MulFix( CUR.tt_metrics.ppem, CURRENT_Ratio() );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* Functions related to the control value table (CVT). */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - FT_CALLBACK_DEF( FT_F26Dot6 )
|
| - Read_CVT( EXEC_OP_ FT_ULong idx )
|
| - {
|
| - return CUR.cvt[idx];
|
| - }
|
| -
|
| -
|
| - FT_CALLBACK_DEF( FT_F26Dot6 )
|
| - Read_CVT_Stretched( EXEC_OP_ FT_ULong idx )
|
| - {
|
| - return FT_MulFix( CUR.cvt[idx], CURRENT_Ratio() );
|
| - }
|
| -
|
| -
|
| - FT_CALLBACK_DEF( void )
|
| - Write_CVT( EXEC_OP_ FT_ULong idx,
|
| - FT_F26Dot6 value )
|
| - {
|
| - CUR.cvt[idx] = value;
|
| - }
|
| -
|
| -
|
| - FT_CALLBACK_DEF( void )
|
| - Write_CVT_Stretched( EXEC_OP_ FT_ULong idx,
|
| - FT_F26Dot6 value )
|
| - {
|
| - CUR.cvt[idx] = FT_DivFix( value, CURRENT_Ratio() );
|
| - }
|
| -
|
| -
|
| - FT_CALLBACK_DEF( void )
|
| - Move_CVT( EXEC_OP_ FT_ULong idx,
|
| - FT_F26Dot6 value )
|
| - {
|
| - CUR.cvt[idx] += value;
|
| - }
|
| -
|
| -
|
| - FT_CALLBACK_DEF( void )
|
| - Move_CVT_Stretched( EXEC_OP_ FT_ULong idx,
|
| - FT_F26Dot6 value )
|
| - {
|
| - CUR.cvt[idx] += FT_DivFix( value, CURRENT_Ratio() );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <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( EXEC_OP )
|
| - {
|
| - /* Reading a byte stream so there is no endianess (DaveP) */
|
| - CUR.IP += 2;
|
| - return (FT_Short)( ( CUR.code[CUR.IP - 2] << 8 ) +
|
| - CUR.code[CUR.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( EXEC_OP_ FT_Int aRange,
|
| - FT_ULong aIP )
|
| - {
|
| - TT_CodeRange* range;
|
| -
|
| -
|
| - if ( aRange < 1 || aRange > 3 )
|
| - {
|
| - CUR.error = FT_THROW( Bad_Argument );
|
| - return FAILURE;
|
| - }
|
| -
|
| - range = &CUR.codeRangeTable[aRange - 1];
|
| -
|
| - if ( range->base == NULL ) /* invalid coderange */
|
| - {
|
| - CUR.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 )
|
| - {
|
| - CUR.error = FT_THROW( Code_Overflow );
|
| - return FAILURE;
|
| - }
|
| -
|
| - CUR.code = range->base;
|
| - CUR.codeSize = range->size;
|
| - CUR.IP = aIP;
|
| - CUR.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. */
|
| - /* */
|
| - static void
|
| - Direct_Move( EXEC_OP_ TT_GlyphZone zone,
|
| - FT_UShort point,
|
| - FT_F26Dot6 distance )
|
| - {
|
| - FT_F26Dot6 v;
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - FT_ASSERT( !CUR.face->unpatented_hinting );
|
| -#endif
|
| -
|
| - v = CUR.GS.freeVector.x;
|
| -
|
| - if ( v != 0 )
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( !SUBPIXEL_HINTING ||
|
| - ( !CUR.ignore_x_mode ||
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_ALLOW_X_DMOVE ) ) )
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| - zone->cur[point].x += FT_MulDiv( distance, v, CUR.F_dot_P );
|
| -
|
| - zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
|
| - }
|
| -
|
| - v = CUR.GS.freeVector.y;
|
| -
|
| - if ( v != 0 )
|
| - {
|
| - zone->cur[point].y += FT_MulDiv( distance, v, CUR.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( EXEC_OP_ TT_GlyphZone zone,
|
| - FT_UShort point,
|
| - FT_F26Dot6 distance )
|
| - {
|
| - FT_F26Dot6 v;
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - FT_ASSERT( !CUR.face->unpatented_hinting );
|
| -#endif
|
| -
|
| - v = CUR.GS.freeVector.x;
|
| -
|
| - if ( v != 0 )
|
| - zone->org[point].x += FT_MulDiv( distance, v, CUR.F_dot_P );
|
| -
|
| - v = CUR.GS.freeVector.y;
|
| -
|
| - if ( v != 0 )
|
| - zone->org[point].y += FT_MulDiv( distance, v, CUR.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. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - static void
|
| - Direct_Move_X( EXEC_OP_ TT_GlyphZone zone,
|
| - FT_UShort point,
|
| - FT_F26Dot6 distance )
|
| - {
|
| - FT_UNUSED_EXEC;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( !SUBPIXEL_HINTING ||
|
| - !CUR.ignore_x_mode )
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| - zone->cur[point].x += distance;
|
| -
|
| - zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
|
| - }
|
| -
|
| -
|
| - static void
|
| - Direct_Move_Y( EXEC_OP_ TT_GlyphZone zone,
|
| - FT_UShort point,
|
| - FT_F26Dot6 distance )
|
| - {
|
| - FT_UNUSED_EXEC;
|
| -
|
| - 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( EXEC_OP_ TT_GlyphZone zone,
|
| - FT_UShort point,
|
| - FT_F26Dot6 distance )
|
| - {
|
| - FT_UNUSED_EXEC;
|
| -
|
| - zone->org[point].x += distance;
|
| - }
|
| -
|
| -
|
| - static void
|
| - Direct_Move_Orig_Y( EXEC_OP_ TT_GlyphZone zone,
|
| - FT_UShort point,
|
| - FT_F26Dot6 distance )
|
| - {
|
| - FT_UNUSED_EXEC;
|
| -
|
| - 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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = distance + compensation;
|
| - if ( distance && val < 0 )
|
| - val = 0;
|
| - }
|
| - else
|
| - {
|
| - val = 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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = distance + compensation + 32;
|
| - if ( distance && val > 0 )
|
| - val &= ~63;
|
| - else
|
| - val = 0;
|
| - }
|
| - else
|
| - {
|
| - val = -FT_PIX_ROUND( 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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = FT_PIX_FLOOR( distance + compensation ) + 32;
|
| - if ( distance && val < 0 )
|
| - val = 0;
|
| - }
|
| - else
|
| - {
|
| - val = -( FT_PIX_FLOOR( compensation - distance ) + 32 );
|
| - if ( val > 0 )
|
| - val = 0;
|
| - }
|
| -
|
| - 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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = distance + compensation;
|
| - if ( distance && val > 0 )
|
| - val &= ~63;
|
| - else
|
| - val = 0;
|
| - }
|
| - else
|
| - {
|
| - val = -( ( compensation - distance ) & -64 );
|
| - 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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = distance + compensation + 63;
|
| - if ( distance && val > 0 )
|
| - val &= ~63;
|
| - else
|
| - val = 0;
|
| - }
|
| - else
|
| - {
|
| - val = -FT_PIX_CEIL( 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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = distance + compensation + 16;
|
| - if ( distance && val > 0 )
|
| - val &= ~31;
|
| - else
|
| - val = 0;
|
| - }
|
| - else
|
| - {
|
| - val = -FT_PAD_ROUND( 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 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_Super( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = ( distance - CUR.phase + CUR.threshold + compensation ) &
|
| - -CUR.period;
|
| - if ( distance && val < 0 )
|
| - val = 0;
|
| - val += CUR.phase;
|
| - }
|
| - else
|
| - {
|
| - val = -( ( CUR.threshold - CUR.phase - distance + compensation ) &
|
| - -CUR.period );
|
| - if ( val > 0 )
|
| - val = 0;
|
| - val -= CUR.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( EXEC_OP_ FT_F26Dot6 distance,
|
| - FT_F26Dot6 compensation )
|
| - {
|
| - FT_F26Dot6 val;
|
| -
|
| -
|
| - if ( distance >= 0 )
|
| - {
|
| - val = ( ( distance - CUR.phase + CUR.threshold + compensation ) /
|
| - CUR.period ) * CUR.period;
|
| - if ( distance && val < 0 )
|
| - val = 0;
|
| - val += CUR.phase;
|
| - }
|
| - else
|
| - {
|
| - val = -( ( ( CUR.threshold - CUR.phase - distance + compensation ) /
|
| - CUR.period ) * CUR.period );
|
| - if ( val > 0 )
|
| - val = 0;
|
| - val -= CUR.phase;
|
| - }
|
| -
|
| - return val;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <Function> */
|
| - /* Compute_Round */
|
| - /* */
|
| - /* <Description> */
|
| - /* Sets the rounding mode. */
|
| - /* */
|
| - /* <Input> */
|
| - /* round_mode :: The rounding mode to be used. */
|
| - /* */
|
| - static void
|
| - Compute_Round( EXEC_OP_ FT_Byte round_mode )
|
| - {
|
| - switch ( round_mode )
|
| - {
|
| - case TT_Round_Off:
|
| - CUR.func_round = (TT_Round_Func)Round_None;
|
| - break;
|
| -
|
| - case TT_Round_To_Grid:
|
| - CUR.func_round = (TT_Round_Func)Round_To_Grid;
|
| - break;
|
| -
|
| - case TT_Round_Up_To_Grid:
|
| - CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
|
| - break;
|
| -
|
| - case TT_Round_Down_To_Grid:
|
| - CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
|
| - break;
|
| -
|
| - case TT_Round_To_Half_Grid:
|
| - CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
|
| - break;
|
| -
|
| - case TT_Round_To_Double_Grid:
|
| - CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
|
| - break;
|
| -
|
| - case TT_Round_Super:
|
| - CUR.func_round = (TT_Round_Func)Round_Super;
|
| - break;
|
| -
|
| - case TT_Round_Super_45:
|
| - CUR.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( EXEC_OP_ FT_F26Dot6 GridPeriod,
|
| - FT_Long selector )
|
| - {
|
| - switch ( (FT_Int)( selector & 0xC0 ) )
|
| - {
|
| - case 0:
|
| - CUR.period = GridPeriod / 2;
|
| - break;
|
| -
|
| - case 0x40:
|
| - CUR.period = GridPeriod;
|
| - break;
|
| -
|
| - case 0x80:
|
| - CUR.period = GridPeriod * 2;
|
| - break;
|
| -
|
| - /* This opcode is reserved, but... */
|
| -
|
| - case 0xC0:
|
| - CUR.period = GridPeriod;
|
| - break;
|
| - }
|
| -
|
| - switch ( (FT_Int)( selector & 0x30 ) )
|
| - {
|
| - case 0:
|
| - CUR.phase = 0;
|
| - break;
|
| -
|
| - case 0x10:
|
| - CUR.phase = CUR.period / 4;
|
| - break;
|
| -
|
| - case 0x20:
|
| - CUR.phase = CUR.period / 2;
|
| - break;
|
| -
|
| - case 0x30:
|
| - CUR.phase = CUR.period * 3 / 4;
|
| - break;
|
| - }
|
| -
|
| - if ( ( selector & 0x0F ) == 0 )
|
| - CUR.threshold = CUR.period - 1;
|
| - else
|
| - CUR.threshold = ( (FT_Int)( selector & 0x0F ) - 4 ) * CUR.period / 8;
|
| -
|
| - CUR.period /= 256;
|
| - CUR.phase /= 256;
|
| - CUR.threshold /= 256;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* <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( EXEC_OP_ FT_Pos dx,
|
| - FT_Pos dy )
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - FT_ASSERT( !CUR.face->unpatented_hinting );
|
| -#endif
|
| -
|
| - return TT_DotFix14( (FT_UInt32)dx, (FT_UInt32)dy,
|
| - CUR.GS.projVector.x,
|
| - CUR.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( EXEC_OP_ FT_Pos dx,
|
| - FT_Pos dy )
|
| - {
|
| - return TT_DotFix14( (FT_UInt32)dx, (FT_UInt32)dy,
|
| - CUR.GS.dualVector.x,
|
| - CUR.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( EXEC_OP_ FT_Pos dx,
|
| - FT_Pos dy )
|
| - {
|
| - FT_UNUSED_EXEC;
|
| - 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( EXEC_OP_ FT_Pos dx,
|
| - FT_Pos dy )
|
| - {
|
| - FT_UNUSED_EXEC;
|
| - 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( EXEC_OP )
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - /* If both vectors point rightwards along the x axis, set */
|
| - /* `both-x-axis' true, otherwise set it false. The x values only */
|
| - /* need be tested because the vector has been normalised to a unit */
|
| - /* vector of length 0x4000 = unity. */
|
| - CUR.GS.both_x_axis = (FT_Bool)( CUR.GS.projVector.x == 0x4000 &&
|
| - CUR.GS.freeVector.x == 0x4000 );
|
| -
|
| - /* Throw away projection and freedom vector information */
|
| - /* because the patents don't allow them to be stored. */
|
| - /* The relevant US Patents are 5155805 and 5325479. */
|
| - CUR.GS.projVector.x = 0;
|
| - CUR.GS.projVector.y = 0;
|
| - CUR.GS.freeVector.x = 0;
|
| - CUR.GS.freeVector.y = 0;
|
| -
|
| - if ( CUR.GS.both_x_axis )
|
| - {
|
| - CUR.func_project = Project_x;
|
| - CUR.func_move = Direct_Move_X;
|
| - CUR.func_move_orig = Direct_Move_Orig_X;
|
| - }
|
| - else
|
| - {
|
| - CUR.func_project = Project_y;
|
| - CUR.func_move = Direct_Move_Y;
|
| - CUR.func_move_orig = Direct_Move_Orig_Y;
|
| - }
|
| -
|
| - if ( CUR.GS.dualVector.x == 0x4000 )
|
| - CUR.func_dualproj = Project_x;
|
| - else if ( CUR.GS.dualVector.y == 0x4000 )
|
| - CUR.func_dualproj = Project_y;
|
| - else
|
| - CUR.func_dualproj = Dual_Project;
|
| -
|
| - /* Force recalculation of cached aspect ratio */
|
| - CUR.tt_metrics.ratio = 0;
|
| -
|
| - return;
|
| - }
|
| -#endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING */
|
| -
|
| - if ( CUR.GS.freeVector.x == 0x4000 )
|
| - CUR.F_dot_P = CUR.GS.projVector.x;
|
| - else if ( CUR.GS.freeVector.y == 0x4000 )
|
| - CUR.F_dot_P = CUR.GS.projVector.y;
|
| - else
|
| - CUR.F_dot_P = ( (FT_Long)CUR.GS.projVector.x * CUR.GS.freeVector.x +
|
| - (FT_Long)CUR.GS.projVector.y * CUR.GS.freeVector.y ) >>
|
| - 14;
|
| -
|
| - if ( CUR.GS.projVector.x == 0x4000 )
|
| - CUR.func_project = (TT_Project_Func)Project_x;
|
| - else if ( CUR.GS.projVector.y == 0x4000 )
|
| - CUR.func_project = (TT_Project_Func)Project_y;
|
| - else
|
| - CUR.func_project = (TT_Project_Func)Project;
|
| -
|
| - if ( CUR.GS.dualVector.x == 0x4000 )
|
| - CUR.func_dualproj = (TT_Project_Func)Project_x;
|
| - else if ( CUR.GS.dualVector.y == 0x4000 )
|
| - CUR.func_dualproj = (TT_Project_Func)Project_y;
|
| - else
|
| - CUR.func_dualproj = (TT_Project_Func)Dual_Project;
|
| -
|
| - CUR.func_move = (TT_Move_Func)Direct_Move;
|
| - CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig;
|
| -
|
| - if ( CUR.F_dot_P == 0x4000L )
|
| - {
|
| - if ( CUR.GS.freeVector.x == 0x4000 )
|
| - {
|
| - CUR.func_move = (TT_Move_Func)Direct_Move_X;
|
| - CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig_X;
|
| - }
|
| - else if ( CUR.GS.freeVector.y == 0x4000 )
|
| - {
|
| - CUR.func_move = (TT_Move_Func)Direct_Move_Y;
|
| - CUR.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( CUR.F_dot_P ) < 0x400L )
|
| - CUR.F_dot_P = 0x4000L;
|
| -
|
| - /* Disable cached aspect ratio */
|
| - CUR.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( EXEC_OP_ FT_F26Dot6 Vx,
|
| - FT_F26Dot6 Vy,
|
| - FT_UnitVector* R )
|
| - {
|
| - FT_F26Dot6 W;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - if ( FT_ABS( Vx ) < 0x4000L && FT_ABS( Vy ) < 0x4000L )
|
| - {
|
| - 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;
|
| - }
|
| -
|
| - Vx *= 0x4000;
|
| - Vy *= 0x4000;
|
| - }
|
| -
|
| - W = FT_Hypot( Vx, Vy );
|
| -
|
| - R->x = (FT_F2Dot14)TT_DivFix14( Vx, W );
|
| - R->y = (FT_F2Dot14)TT_DivFix14( Vy, W );
|
| -
|
| - return SUCCESS;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* Here we start with the implementation of the various opcodes. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - static FT_Bool
|
| - Ins_SxVTL( EXEC_OP_ FT_UShort aIdx1,
|
| - FT_UShort aIdx2,
|
| - FT_Int aOpc,
|
| - FT_UnitVector* Vec )
|
| - {
|
| - FT_Long A, B, C;
|
| - FT_Vector* p1;
|
| - FT_Vector* p2;
|
| -
|
| -
|
| - if ( BOUNDS( aIdx1, CUR.zp2.n_points ) ||
|
| - BOUNDS( aIdx2, CUR.zp1.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return FAILURE;
|
| - }
|
| -
|
| - p1 = CUR.zp1.cur + aIdx2;
|
| - p2 = CUR.zp2.cur + aIdx1;
|
| -
|
| - A = p1->x - p2->x;
|
| - B = 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;
|
| - aOpc = 0;
|
| - }
|
| -
|
| - if ( ( aOpc & 1 ) != 0 )
|
| - {
|
| - C = B; /* counter clockwise rotation */
|
| - B = A;
|
| - A = -C;
|
| - }
|
| -
|
| - NORMalize( A, B, Vec );
|
| -
|
| - return SUCCESS;
|
| - }
|
| -
|
| -
|
| - /* When not using the big switch statements, the interpreter uses a */
|
| - /* call table defined later below in this source. Each opcode must */
|
| - /* thus have a corresponding function, even trivial ones. */
|
| - /* */
|
| - /* They are all defined there. */
|
| -
|
| -#define DO_SVTCA \
|
| - { \
|
| - FT_Short A, B; \
|
| - \
|
| - \
|
| - A = (FT_Short)( CUR.opcode & 1 ) << 14; \
|
| - B = A ^ (FT_Short)0x4000; \
|
| - \
|
| - CUR.GS.freeVector.x = A; \
|
| - CUR.GS.projVector.x = A; \
|
| - CUR.GS.dualVector.x = A; \
|
| - \
|
| - CUR.GS.freeVector.y = B; \
|
| - CUR.GS.projVector.y = B; \
|
| - CUR.GS.dualVector.y = B; \
|
| - \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#define DO_SPVTCA \
|
| - { \
|
| - FT_Short A, B; \
|
| - \
|
| - \
|
| - A = (FT_Short)( CUR.opcode & 1 ) << 14; \
|
| - B = A ^ (FT_Short)0x4000; \
|
| - \
|
| - CUR.GS.projVector.x = A; \
|
| - CUR.GS.dualVector.x = A; \
|
| - \
|
| - CUR.GS.projVector.y = B; \
|
| - CUR.GS.dualVector.y = B; \
|
| - \
|
| - GUESS_VECTOR( freeVector ); \
|
| - \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#define DO_SFVTCA \
|
| - { \
|
| - FT_Short A, B; \
|
| - \
|
| - \
|
| - A = (FT_Short)( CUR.opcode & 1 ) << 14; \
|
| - B = A ^ (FT_Short)0x4000; \
|
| - \
|
| - CUR.GS.freeVector.x = A; \
|
| - CUR.GS.freeVector.y = B; \
|
| - \
|
| - GUESS_VECTOR( projVector ); \
|
| - \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#define DO_SPVTL \
|
| - if ( INS_SxVTL( (FT_UShort)args[1], \
|
| - (FT_UShort)args[0], \
|
| - CUR.opcode, \
|
| - &CUR.GS.projVector ) == SUCCESS ) \
|
| - { \
|
| - CUR.GS.dualVector = CUR.GS.projVector; \
|
| - GUESS_VECTOR( freeVector ); \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#define DO_SFVTL \
|
| - if ( INS_SxVTL( (FT_UShort)args[1], \
|
| - (FT_UShort)args[0], \
|
| - CUR.opcode, \
|
| - &CUR.GS.freeVector ) == SUCCESS ) \
|
| - { \
|
| - GUESS_VECTOR( projVector ); \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#define DO_SFVTPV \
|
| - GUESS_VECTOR( projVector ); \
|
| - CUR.GS.freeVector = CUR.GS.projVector; \
|
| - COMPUTE_Funcs();
|
| -
|
| -
|
| -#define DO_SPVFS \
|
| - { \
|
| - 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, &CUR.GS.projVector ); \
|
| - \
|
| - CUR.GS.dualVector = CUR.GS.projVector; \
|
| - GUESS_VECTOR( freeVector ); \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#define DO_SFVFS \
|
| - { \
|
| - 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, &CUR.GS.freeVector ); \
|
| - GUESS_VECTOR( projVector ); \
|
| - COMPUTE_Funcs(); \
|
| - }
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| -#define DO_GPV \
|
| - if ( CUR.face->unpatented_hinting ) \
|
| - { \
|
| - args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
|
| - args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
|
| - } \
|
| - else \
|
| - { \
|
| - args[0] = CUR.GS.projVector.x; \
|
| - args[1] = CUR.GS.projVector.y; \
|
| - }
|
| -#else
|
| -#define DO_GPV \
|
| - args[0] = CUR.GS.projVector.x; \
|
| - args[1] = CUR.GS.projVector.y;
|
| -#endif
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| -#define DO_GFV \
|
| - if ( CUR.face->unpatented_hinting ) \
|
| - { \
|
| - args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
|
| - args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
|
| - } \
|
| - else \
|
| - { \
|
| - args[0] = CUR.GS.freeVector.x; \
|
| - args[1] = CUR.GS.freeVector.y; \
|
| - }
|
| -#else
|
| -#define DO_GFV \
|
| - args[0] = CUR.GS.freeVector.x; \
|
| - args[1] = CUR.GS.freeVector.y;
|
| -#endif
|
| -
|
| -
|
| -#define DO_SRP0 \
|
| - CUR.GS.rp0 = (FT_UShort)args[0];
|
| -
|
| -
|
| -#define DO_SRP1 \
|
| - CUR.GS.rp1 = (FT_UShort)args[0];
|
| -
|
| -
|
| -#define DO_SRP2 \
|
| - CUR.GS.rp2 = (FT_UShort)args[0];
|
| -
|
| -
|
| -#define DO_RTHG \
|
| - CUR.GS.round_state = TT_Round_To_Half_Grid; \
|
| - CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
|
| -
|
| -
|
| -#define DO_RTG \
|
| - CUR.GS.round_state = TT_Round_To_Grid; \
|
| - CUR.func_round = (TT_Round_Func)Round_To_Grid;
|
| -
|
| -
|
| -#define DO_RTDG \
|
| - CUR.GS.round_state = TT_Round_To_Double_Grid; \
|
| - CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
|
| -
|
| -
|
| -#define DO_RUTG \
|
| - CUR.GS.round_state = TT_Round_Up_To_Grid; \
|
| - CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
|
| -
|
| -
|
| -#define DO_RDTG \
|
| - CUR.GS.round_state = TT_Round_Down_To_Grid; \
|
| - CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
|
| -
|
| -
|
| -#define DO_ROFF \
|
| - CUR.GS.round_state = TT_Round_Off; \
|
| - CUR.func_round = (TT_Round_Func)Round_None;
|
| -
|
| -
|
| -#define DO_SROUND \
|
| - SET_SuperRound( 0x4000, args[0] ); \
|
| - CUR.GS.round_state = TT_Round_Super; \
|
| - CUR.func_round = (TT_Round_Func)Round_Super;
|
| -
|
| -
|
| -#define DO_S45ROUND \
|
| - SET_SuperRound( 0x2D41, args[0] ); \
|
| - CUR.GS.round_state = TT_Round_Super_45; \
|
| - CUR.func_round = (TT_Round_Func)Round_Super_45;
|
| -
|
| -
|
| -#define DO_SLOOP \
|
| - if ( args[0] < 0 ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - else \
|
| - CUR.GS.loop = args[0];
|
| -
|
| -
|
| -#define DO_SMD \
|
| - CUR.GS.minimum_distance = args[0];
|
| -
|
| -
|
| -#define DO_SCVTCI \
|
| - CUR.GS.control_value_cutin = (FT_F26Dot6)args[0];
|
| -
|
| -
|
| -#define DO_SSWCI \
|
| - CUR.GS.single_width_cutin = (FT_F26Dot6)args[0];
|
| -
|
| -
|
| -#define DO_SSW \
|
| - CUR.GS.single_width_value = FT_MulFix( args[0], \
|
| - CUR.tt_metrics.scale );
|
| -
|
| -
|
| -#define DO_FLIPON \
|
| - CUR.GS.auto_flip = TRUE;
|
| -
|
| -
|
| -#define DO_FLIPOFF \
|
| - CUR.GS.auto_flip = FALSE;
|
| -
|
| -
|
| -#define DO_SDB \
|
| - CUR.GS.delta_base = (FT_Short)args[0];
|
| -
|
| -
|
| -#define DO_SDS \
|
| - CUR.GS.delta_shift = (FT_Short)args[0];
|
| -
|
| -
|
| -#define DO_MD /* nothing */
|
| -
|
| -
|
| -#define DO_MPPEM \
|
| - args[0] = CURRENT_Ppem();
|
| -
|
| -
|
| - /* Note: The pointSize should be irrelevant in a given font program; */
|
| - /* we thus decide to return only the ppem. */
|
| -#if 0
|
| -
|
| -#define DO_MPS \
|
| - args[0] = CUR.metrics.pointSize;
|
| -
|
| -#else
|
| -
|
| -#define DO_MPS \
|
| - args[0] = CURRENT_Ppem();
|
| -
|
| -#endif /* 0 */
|
| -
|
| -
|
| -#define DO_DUP \
|
| - args[1] = args[0];
|
| -
|
| -
|
| -#define DO_CLEAR \
|
| - CUR.new_top = 0;
|
| -
|
| -
|
| -#define DO_SWAP \
|
| - { \
|
| - FT_Long L; \
|
| - \
|
| - \
|
| - L = args[0]; \
|
| - args[0] = args[1]; \
|
| - args[1] = L; \
|
| - }
|
| -
|
| -
|
| -#define DO_DEPTH \
|
| - args[0] = CUR.top;
|
| -
|
| -
|
| -#define DO_CINDEX \
|
| - { \
|
| - FT_Long L; \
|
| - \
|
| - \
|
| - L = args[0]; \
|
| - \
|
| - if ( L <= 0 || L > CUR.args ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - CUR.error = FT_THROW( Invalid_Reference ); \
|
| - args[0] = 0; \
|
| - } \
|
| - else \
|
| - args[0] = CUR.stack[CUR.args - L]; \
|
| - }
|
| -
|
| -
|
| -#define DO_JROT \
|
| - if ( args[1] != 0 ) \
|
| - { \
|
| - if ( args[0] == 0 && CUR.args == 0 ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - CUR.IP += args[0]; \
|
| - if ( CUR.IP < 0 || \
|
| - ( CUR.callTop > 0 && \
|
| - CUR.IP > CUR.callStack[CUR.callTop - 1].Cur_End ) ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - CUR.step_ins = FALSE; \
|
| - }
|
| -
|
| -
|
| -#define DO_JMPR \
|
| - if ( args[0] == 0 && CUR.args == 0 ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - CUR.IP += args[0]; \
|
| - if ( CUR.IP < 0 || \
|
| - ( CUR.callTop > 0 && \
|
| - CUR.IP > CUR.callStack[CUR.callTop - 1].Cur_End ) ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - CUR.step_ins = FALSE;
|
| -
|
| -
|
| -#define DO_JROF \
|
| - if ( args[1] == 0 ) \
|
| - { \
|
| - if ( args[0] == 0 && CUR.args == 0 ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - CUR.IP += args[0]; \
|
| - if ( CUR.IP < 0 || \
|
| - ( CUR.callTop > 0 && \
|
| - CUR.IP > CUR.callStack[CUR.callTop - 1].Cur_End ) ) \
|
| - CUR.error = FT_THROW( Bad_Argument ); \
|
| - CUR.step_ins = FALSE; \
|
| - }
|
| -
|
| -
|
| -#define DO_LT \
|
| - args[0] = ( args[0] < args[1] );
|
| -
|
| -
|
| -#define DO_LTEQ \
|
| - args[0] = ( args[0] <= args[1] );
|
| -
|
| -
|
| -#define DO_GT \
|
| - args[0] = ( args[0] > args[1] );
|
| -
|
| -
|
| -#define DO_GTEQ \
|
| - args[0] = ( args[0] >= args[1] );
|
| -
|
| -
|
| -#define DO_EQ \
|
| - args[0] = ( args[0] == args[1] );
|
| -
|
| -
|
| -#define DO_NEQ \
|
| - args[0] = ( args[0] != args[1] );
|
| -
|
| -
|
| -#define DO_ODD \
|
| - args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 64 );
|
| -
|
| -
|
| -#define DO_EVEN \
|
| - args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 0 );
|
| -
|
| -
|
| -#define DO_AND \
|
| - args[0] = ( args[0] && args[1] );
|
| -
|
| -
|
| -#define DO_OR \
|
| - args[0] = ( args[0] || args[1] );
|
| -
|
| -
|
| -#define DO_NOT \
|
| - args[0] = !args[0];
|
| -
|
| -
|
| -#define DO_ADD \
|
| - args[0] += args[1];
|
| -
|
| -
|
| -#define DO_SUB \
|
| - args[0] -= args[1];
|
| -
|
| -
|
| -#define DO_DIV \
|
| - if ( args[1] == 0 ) \
|
| - CUR.error = FT_THROW( Divide_By_Zero ); \
|
| - else \
|
| - args[0] = FT_MulDiv_No_Round( args[0], 64L, args[1] );
|
| -
|
| -
|
| -#define DO_MUL \
|
| - args[0] = FT_MulDiv( args[0], args[1], 64L );
|
| -
|
| -
|
| -#define DO_ABS \
|
| - args[0] = FT_ABS( args[0] );
|
| -
|
| -
|
| -#define DO_NEG \
|
| - args[0] = -args[0];
|
| -
|
| -
|
| -#define DO_FLOOR \
|
| - args[0] = FT_PIX_FLOOR( args[0] );
|
| -
|
| -
|
| -#define DO_CEILING \
|
| - args[0] = FT_PIX_CEIL( args[0] );
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| -
|
| -#define DO_RS \
|
| - { \
|
| - FT_ULong I = (FT_ULong)args[0]; \
|
| - \
|
| - \
|
| - if ( BOUNDSL( I, CUR.storeSize ) ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - ARRAY_BOUND_ERROR; \
|
| - else \
|
| - args[0] = 0; \
|
| - } \
|
| - else \
|
| - { \
|
| - /* subpixel hinting - avoid Typeman Dstroke and */ \
|
| - /* IStroke and Vacuform rounds */ \
|
| - \
|
| - if ( SUBPIXEL_HINTING && \
|
| - CUR.ignore_x_mode && \
|
| - ( ( I == 24 && \
|
| - ( CUR.face->sph_found_func_flags & \
|
| - ( SPH_FDEF_SPACING_1 | \
|
| - SPH_FDEF_SPACING_2 ) ) ) || \
|
| - ( I == 22 && \
|
| - ( CUR.sph_in_func_flags & \
|
| - SPH_FDEF_TYPEMAN_STROKES ) ) || \
|
| - ( I == 8 && \
|
| - ( CUR.face->sph_found_func_flags & \
|
| - SPH_FDEF_VACUFORM_ROUND_1 ) && \
|
| - CUR.iup_called ) ) ) \
|
| - args[0] = 0; \
|
| - else \
|
| - args[0] = CUR.storage[I]; \
|
| - } \
|
| - }
|
| -
|
| -#else /* !TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -#define DO_RS \
|
| - { \
|
| - FT_ULong I = (FT_ULong)args[0]; \
|
| - \
|
| - \
|
| - if ( BOUNDSL( I, CUR.storeSize ) ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - { \
|
| - ARRAY_BOUND_ERROR; \
|
| - } \
|
| - else \
|
| - args[0] = 0; \
|
| - } \
|
| - else \
|
| - args[0] = CUR.storage[I]; \
|
| - }
|
| -
|
| -#endif /* !TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -
|
| -#define DO_WS \
|
| - { \
|
| - FT_ULong I = (FT_ULong)args[0]; \
|
| - \
|
| - \
|
| - if ( BOUNDSL( I, CUR.storeSize ) ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - { \
|
| - ARRAY_BOUND_ERROR; \
|
| - } \
|
| - } \
|
| - else \
|
| - CUR.storage[I] = args[1]; \
|
| - }
|
| -
|
| -
|
| -#define DO_RCVT \
|
| - { \
|
| - FT_ULong I = (FT_ULong)args[0]; \
|
| - \
|
| - \
|
| - if ( BOUNDSL( I, CUR.cvtSize ) ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - { \
|
| - ARRAY_BOUND_ERROR; \
|
| - } \
|
| - else \
|
| - args[0] = 0; \
|
| - } \
|
| - else \
|
| - args[0] = CUR_Func_read_cvt( I ); \
|
| - }
|
| -
|
| -
|
| -#define DO_WCVTP \
|
| - { \
|
| - FT_ULong I = (FT_ULong)args[0]; \
|
| - \
|
| - \
|
| - if ( BOUNDSL( I, CUR.cvtSize ) ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - { \
|
| - ARRAY_BOUND_ERROR; \
|
| - } \
|
| - } \
|
| - else \
|
| - CUR_Func_write_cvt( I, args[1] ); \
|
| - }
|
| -
|
| -
|
| -#define DO_WCVTF \
|
| - { \
|
| - FT_ULong I = (FT_ULong)args[0]; \
|
| - \
|
| - \
|
| - if ( BOUNDSL( I, CUR.cvtSize ) ) \
|
| - { \
|
| - if ( CUR.pedantic_hinting ) \
|
| - { \
|
| - ARRAY_BOUND_ERROR; \
|
| - } \
|
| - } \
|
| - else \
|
| - CUR.cvt[I] = FT_MulFix( args[1], CUR.tt_metrics.scale ); \
|
| - }
|
| -
|
| -
|
| -#define DO_DEBUG \
|
| - CUR.error = FT_THROW( Debug_OpCode );
|
| -
|
| -
|
| -#define DO_ROUND \
|
| - args[0] = CUR_Func_round( \
|
| - args[0], \
|
| - CUR.tt_metrics.compensations[CUR.opcode - 0x68] );
|
| -
|
| -
|
| -#define DO_NROUND \
|
| - args[0] = ROUND_None( args[0], \
|
| - CUR.tt_metrics.compensations[CUR.opcode - 0x6C] );
|
| -
|
| -
|
| -#define DO_MAX \
|
| - if ( args[1] > args[0] ) \
|
| - args[0] = args[1];
|
| -
|
| -
|
| -#define DO_MIN \
|
| - if ( args[1] < args[0] ) \
|
| - args[0] = args[1];
|
| -
|
| -
|
| -#ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
|
| -
|
| -
|
| -#undef ARRAY_BOUND_ERROR
|
| -#define ARRAY_BOUND_ERROR \
|
| - { \
|
| - CUR.error = FT_THROW( Invalid_Reference ); \
|
| - return; \
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SVTCA[a]: Set (F and P) Vectors to Coordinate Axis */
|
| - /* Opcode range: 0x00-0x01 */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_SVTCA( INS_ARG )
|
| - {
|
| - DO_SVTCA
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SPVTCA[a]: Set PVector to Coordinate Axis */
|
| - /* Opcode range: 0x02-0x03 */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_SPVTCA( INS_ARG )
|
| - {
|
| - DO_SPVTCA
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SFVTCA[a]: Set FVector to Coordinate Axis */
|
| - /* Opcode range: 0x04-0x05 */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_SFVTCA( INS_ARG )
|
| - {
|
| - DO_SFVTCA
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SPVTL[a]: Set PVector To Line */
|
| - /* Opcode range: 0x06-0x07 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SPVTL( INS_ARG )
|
| - {
|
| - DO_SPVTL
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SFVTL[a]: Set FVector To Line */
|
| - /* Opcode range: 0x08-0x09 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SFVTL( INS_ARG )
|
| - {
|
| - DO_SFVTL
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SFVTPV[]: Set FVector To PVector */
|
| - /* Opcode range: 0x0E */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_SFVTPV( INS_ARG )
|
| - {
|
| - DO_SFVTPV
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SPVFS[]: Set PVector From Stack */
|
| - /* Opcode range: 0x0A */
|
| - /* Stack: f2.14 f2.14 --> */
|
| - /* */
|
| - static void
|
| - Ins_SPVFS( INS_ARG )
|
| - {
|
| - DO_SPVFS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SFVFS[]: Set FVector From Stack */
|
| - /* Opcode range: 0x0B */
|
| - /* Stack: f2.14 f2.14 --> */
|
| - /* */
|
| - static void
|
| - Ins_SFVFS( INS_ARG )
|
| - {
|
| - DO_SFVFS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* GPV[]: Get Projection Vector */
|
| - /* Opcode range: 0x0C */
|
| - /* Stack: ef2.14 --> ef2.14 */
|
| - /* */
|
| - static void
|
| - Ins_GPV( INS_ARG )
|
| - {
|
| - DO_GPV
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* GFV[]: Get Freedom Vector */
|
| - /* Opcode range: 0x0D */
|
| - /* Stack: ef2.14 --> ef2.14 */
|
| - /* */
|
| - static void
|
| - Ins_GFV( INS_ARG )
|
| - {
|
| - DO_GFV
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SRP0[]: Set Reference Point 0 */
|
| - /* Opcode range: 0x10 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SRP0( INS_ARG )
|
| - {
|
| - DO_SRP0
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SRP1[]: Set Reference Point 1 */
|
| - /* Opcode range: 0x11 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SRP1( INS_ARG )
|
| - {
|
| - DO_SRP1
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SRP2[]: Set Reference Point 2 */
|
| - /* Opcode range: 0x12 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SRP2( INS_ARG )
|
| - {
|
| - DO_SRP2
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* RTHG[]: Round To Half Grid */
|
| - /* Opcode range: 0x19 */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_RTHG( INS_ARG )
|
| - {
|
| - DO_RTHG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* RTG[]: Round To Grid */
|
| - /* Opcode range: 0x18 */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_RTG( INS_ARG )
|
| - {
|
| - DO_RTG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* RTDG[]: Round To Double Grid */
|
| - /* Opcode range: 0x3D */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_RTDG( INS_ARG )
|
| - {
|
| - DO_RTDG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* RUTG[]: Round Up To Grid */
|
| - /* Opcode range: 0x7C */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_RUTG( INS_ARG )
|
| - {
|
| - DO_RUTG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* RDTG[]: Round Down To Grid */
|
| - /* Opcode range: 0x7D */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_RDTG( INS_ARG )
|
| - {
|
| - DO_RDTG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ROFF[]: Round OFF */
|
| - /* Opcode range: 0x7A */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_ROFF( INS_ARG )
|
| - {
|
| - DO_ROFF
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SROUND[]: Super ROUND */
|
| - /* Opcode range: 0x76 */
|
| - /* Stack: Eint8 --> */
|
| - /* */
|
| - static void
|
| - Ins_SROUND( INS_ARG )
|
| - {
|
| - DO_SROUND
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* S45ROUND[]: Super ROUND 45 degrees */
|
| - /* Opcode range: 0x77 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_S45ROUND( INS_ARG )
|
| - {
|
| - DO_S45ROUND
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SLOOP[]: Set LOOP variable */
|
| - /* Opcode range: 0x17 */
|
| - /* Stack: int32? --> */
|
| - /* */
|
| - static void
|
| - Ins_SLOOP( INS_ARG )
|
| - {
|
| - DO_SLOOP
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SMD[]: Set Minimum Distance */
|
| - /* Opcode range: 0x1A */
|
| - /* Stack: f26.6 --> */
|
| - /* */
|
| - static void
|
| - Ins_SMD( INS_ARG )
|
| - {
|
| - DO_SMD
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SCVTCI[]: Set Control Value Table Cut In */
|
| - /* Opcode range: 0x1D */
|
| - /* Stack: f26.6 --> */
|
| - /* */
|
| - static void
|
| - Ins_SCVTCI( INS_ARG )
|
| - {
|
| - DO_SCVTCI
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SSWCI[]: Set Single Width Cut In */
|
| - /* Opcode range: 0x1E */
|
| - /* Stack: f26.6 --> */
|
| - /* */
|
| - static void
|
| - Ins_SSWCI( INS_ARG )
|
| - {
|
| - DO_SSWCI
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SSW[]: Set Single Width */
|
| - /* Opcode range: 0x1F */
|
| - /* Stack: int32? --> */
|
| - /* */
|
| - static void
|
| - Ins_SSW( INS_ARG )
|
| - {
|
| - DO_SSW
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FLIPON[]: Set auto-FLIP to ON */
|
| - /* Opcode range: 0x4D */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_FLIPON( INS_ARG )
|
| - {
|
| - DO_FLIPON
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FLIPOFF[]: Set auto-FLIP to OFF */
|
| - /* Opcode range: 0x4E */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_FLIPOFF( INS_ARG )
|
| - {
|
| - DO_FLIPOFF
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SANGW[]: Set ANGle Weight */
|
| - /* Opcode range: 0x7E */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SANGW( INS_ARG )
|
| - {
|
| - /* instruction not supported anymore */
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SDB[]: Set Delta Base */
|
| - /* Opcode range: 0x5E */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SDB( INS_ARG )
|
| - {
|
| - DO_SDB
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SDS[]: Set Delta Shift */
|
| - /* Opcode range: 0x5F */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SDS( INS_ARG )
|
| - {
|
| - DO_SDS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MPPEM[]: Measure Pixel Per EM */
|
| - /* Opcode range: 0x4B */
|
| - /* Stack: --> Euint16 */
|
| - /* */
|
| - static void
|
| - Ins_MPPEM( INS_ARG )
|
| - {
|
| - DO_MPPEM
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MPS[]: Measure Point Size */
|
| - /* Opcode range: 0x4C */
|
| - /* Stack: --> Euint16 */
|
| - /* */
|
| - static void
|
| - Ins_MPS( INS_ARG )
|
| - {
|
| - DO_MPS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* DUP[]: DUPlicate the top stack's element */
|
| - /* Opcode range: 0x20 */
|
| - /* Stack: StkElt --> StkElt StkElt */
|
| - /* */
|
| - static void
|
| - Ins_DUP( INS_ARG )
|
| - {
|
| - DO_DUP
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* POP[]: POP the stack's top element */
|
| - /* Opcode range: 0x21 */
|
| - /* Stack: StkElt --> */
|
| - /* */
|
| - static void
|
| - Ins_POP( INS_ARG )
|
| - {
|
| - /* nothing to do */
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* CLEAR[]: CLEAR the entire stack */
|
| - /* Opcode range: 0x22 */
|
| - /* Stack: StkElt... --> */
|
| - /* */
|
| - static void
|
| - Ins_CLEAR( INS_ARG )
|
| - {
|
| - DO_CLEAR
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SWAP[]: SWAP the stack's top two elements */
|
| - /* Opcode range: 0x23 */
|
| - /* Stack: 2 * StkElt --> 2 * StkElt */
|
| - /* */
|
| - static void
|
| - Ins_SWAP( INS_ARG )
|
| - {
|
| - DO_SWAP
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* DEPTH[]: return the stack DEPTH */
|
| - /* Opcode range: 0x24 */
|
| - /* Stack: --> uint32 */
|
| - /* */
|
| - static void
|
| - Ins_DEPTH( INS_ARG )
|
| - {
|
| - DO_DEPTH
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* CINDEX[]: Copy INDEXed element */
|
| - /* Opcode range: 0x25 */
|
| - /* Stack: int32 --> StkElt */
|
| - /* */
|
| - static void
|
| - Ins_CINDEX( INS_ARG )
|
| - {
|
| - DO_CINDEX
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* EIF[]: End IF */
|
| - /* Opcode range: 0x59 */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_EIF( INS_ARG )
|
| - {
|
| - /* nothing to do */
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* JROT[]: Jump Relative On True */
|
| - /* Opcode range: 0x78 */
|
| - /* Stack: StkElt int32 --> */
|
| - /* */
|
| - static void
|
| - Ins_JROT( INS_ARG )
|
| - {
|
| - DO_JROT
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* JMPR[]: JuMP Relative */
|
| - /* Opcode range: 0x1C */
|
| - /* Stack: int32 --> */
|
| - /* */
|
| - static void
|
| - Ins_JMPR( INS_ARG )
|
| - {
|
| - DO_JMPR
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* JROF[]: Jump Relative On False */
|
| - /* Opcode range: 0x79 */
|
| - /* Stack: StkElt int32 --> */
|
| - /* */
|
| - static void
|
| - Ins_JROF( INS_ARG )
|
| - {
|
| - DO_JROF
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* LT[]: Less Than */
|
| - /* Opcode range: 0x50 */
|
| - /* Stack: int32? int32? --> bool */
|
| - /* */
|
| - static void
|
| - Ins_LT( INS_ARG )
|
| - {
|
| - DO_LT
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* LTEQ[]: Less Than or EQual */
|
| - /* Opcode range: 0x51 */
|
| - /* Stack: int32? int32? --> bool */
|
| - /* */
|
| - static void
|
| - Ins_LTEQ( INS_ARG )
|
| - {
|
| - DO_LTEQ
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* GT[]: Greater Than */
|
| - /* Opcode range: 0x52 */
|
| - /* Stack: int32? int32? --> bool */
|
| - /* */
|
| - static void
|
| - Ins_GT( INS_ARG )
|
| - {
|
| - DO_GT
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* GTEQ[]: Greater Than or EQual */
|
| - /* Opcode range: 0x53 */
|
| - /* Stack: int32? int32? --> bool */
|
| - /* */
|
| - static void
|
| - Ins_GTEQ( INS_ARG )
|
| - {
|
| - DO_GTEQ
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* EQ[]: EQual */
|
| - /* Opcode range: 0x54 */
|
| - /* Stack: StkElt StkElt --> bool */
|
| - /* */
|
| - static void
|
| - Ins_EQ( INS_ARG )
|
| - {
|
| - DO_EQ
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* NEQ[]: Not EQual */
|
| - /* Opcode range: 0x55 */
|
| - /* Stack: StkElt StkElt --> bool */
|
| - /* */
|
| - static void
|
| - Ins_NEQ( INS_ARG )
|
| - {
|
| - DO_NEQ
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ODD[]: Is ODD */
|
| - /* Opcode range: 0x56 */
|
| - /* Stack: f26.6 --> bool */
|
| - /* */
|
| - static void
|
| - Ins_ODD( INS_ARG )
|
| - {
|
| - DO_ODD
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* EVEN[]: Is EVEN */
|
| - /* Opcode range: 0x57 */
|
| - /* Stack: f26.6 --> bool */
|
| - /* */
|
| - static void
|
| - Ins_EVEN( INS_ARG )
|
| - {
|
| - DO_EVEN
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* AND[]: logical AND */
|
| - /* Opcode range: 0x5A */
|
| - /* Stack: uint32 uint32 --> uint32 */
|
| - /* */
|
| - static void
|
| - Ins_AND( INS_ARG )
|
| - {
|
| - DO_AND
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* OR[]: logical OR */
|
| - /* Opcode range: 0x5B */
|
| - /* Stack: uint32 uint32 --> uint32 */
|
| - /* */
|
| - static void
|
| - Ins_OR( INS_ARG )
|
| - {
|
| - DO_OR
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* NOT[]: logical NOT */
|
| - /* Opcode range: 0x5C */
|
| - /* Stack: StkElt --> uint32 */
|
| - /* */
|
| - static void
|
| - Ins_NOT( INS_ARG )
|
| - {
|
| - DO_NOT
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ADD[]: ADD */
|
| - /* Opcode range: 0x60 */
|
| - /* Stack: f26.6 f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_ADD( INS_ARG )
|
| - {
|
| - DO_ADD
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SUB[]: SUBtract */
|
| - /* Opcode range: 0x61 */
|
| - /* Stack: f26.6 f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_SUB( INS_ARG )
|
| - {
|
| - DO_SUB
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* DIV[]: DIVide */
|
| - /* Opcode range: 0x62 */
|
| - /* Stack: f26.6 f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_DIV( INS_ARG )
|
| - {
|
| - DO_DIV
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MUL[]: MULtiply */
|
| - /* Opcode range: 0x63 */
|
| - /* Stack: f26.6 f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_MUL( INS_ARG )
|
| - {
|
| - DO_MUL
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ABS[]: ABSolute value */
|
| - /* Opcode range: 0x64 */
|
| - /* Stack: f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_ABS( INS_ARG )
|
| - {
|
| - DO_ABS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* NEG[]: NEGate */
|
| - /* Opcode range: 0x65 */
|
| - /* Stack: f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_NEG( INS_ARG )
|
| - {
|
| - DO_NEG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FLOOR[]: FLOOR */
|
| - /* Opcode range: 0x66 */
|
| - /* Stack: f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_FLOOR( INS_ARG )
|
| - {
|
| - DO_FLOOR
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* CEILING[]: CEILING */
|
| - /* Opcode range: 0x67 */
|
| - /* Stack: f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_CEILING( INS_ARG )
|
| - {
|
| - DO_CEILING
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* RS[]: Read Store */
|
| - /* Opcode range: 0x43 */
|
| - /* Stack: uint32 --> uint32 */
|
| - /* */
|
| - static void
|
| - Ins_RS( INS_ARG )
|
| - {
|
| - DO_RS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* WS[]: Write Store */
|
| - /* Opcode range: 0x42 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_WS( INS_ARG )
|
| - {
|
| - DO_WS
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* WCVTP[]: Write CVT in Pixel units */
|
| - /* Opcode range: 0x44 */
|
| - /* Stack: f26.6 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_WCVTP( INS_ARG )
|
| - {
|
| - DO_WCVTP
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* WCVTF[]: Write CVT in Funits */
|
| - /* Opcode range: 0x70 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_WCVTF( INS_ARG )
|
| - {
|
| - DO_WCVTF
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* RCVT[]: Read CVT */
|
| - /* Opcode range: 0x45 */
|
| - /* Stack: uint32 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_RCVT( INS_ARG )
|
| - {
|
| - DO_RCVT
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* AA[]: Adjust Angle */
|
| - /* Opcode range: 0x7F */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_AA( INS_ARG )
|
| - {
|
| - /* 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( INS_ARG )
|
| - {
|
| - DO_DEBUG
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ROUND[ab]: ROUND value */
|
| - /* Opcode range: 0x68-0x6B */
|
| - /* Stack: f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_ROUND( INS_ARG )
|
| - {
|
| - DO_ROUND
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* NROUND[ab]: No ROUNDing of value */
|
| - /* Opcode range: 0x6C-0x6F */
|
| - /* Stack: f26.6 --> f26.6 */
|
| - /* */
|
| - static void
|
| - Ins_NROUND( INS_ARG )
|
| - {
|
| - DO_NROUND
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MAX[]: MAXimum */
|
| - /* Opcode range: 0x68 */
|
| - /* Stack: int32? int32? --> int32 */
|
| - /* */
|
| - static void
|
| - Ins_MAX( INS_ARG )
|
| - {
|
| - DO_MAX
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MIN[]: MINimum */
|
| - /* Opcode range: 0x69 */
|
| - /* Stack: int32? int32? --> int32 */
|
| - /* */
|
| - static void
|
| - Ins_MIN( INS_ARG )
|
| - {
|
| - DO_MIN
|
| - }
|
| -
|
| -
|
| -#endif /* !TT_CONFIG_OPTION_INTERPRETER_SWITCH */
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* The following functions are called as is within the switch statement. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MINDEX[]: Move INDEXed element */
|
| - /* Opcode range: 0x26 */
|
| - /* Stack: int32? --> StkElt */
|
| - /* */
|
| - static void
|
| - Ins_MINDEX( INS_ARG )
|
| - {
|
| - FT_Long L, K;
|
| -
|
| -
|
| - L = args[0];
|
| -
|
| - if ( L <= 0 || L > CUR.args )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - }
|
| - else
|
| - {
|
| - K = CUR.stack[CUR.args - L];
|
| -
|
| - FT_ARRAY_MOVE( &CUR.stack[CUR.args - L ],
|
| - &CUR.stack[CUR.args - L + 1],
|
| - ( L - 1 ) );
|
| -
|
| - CUR.stack[CUR.args - 1] = K;
|
| - }
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ROLL[]: ROLL top three elements */
|
| - /* Opcode range: 0x8A */
|
| - /* Stack: 3 * StkElt --> 3 * StkElt */
|
| - /* */
|
| - static void
|
| - Ins_ROLL( INS_ARG )
|
| - {
|
| - FT_Long A, B, C;
|
| -
|
| - FT_UNUSED_EXEC;
|
| -
|
| -
|
| - A = args[2];
|
| - B = args[1];
|
| - C = args[0];
|
| -
|
| - args[2] = C;
|
| - args[1] = A;
|
| - args[0] = B;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MANAGING THE FLOW OF CONTROL */
|
| - /* */
|
| - /* Instructions appear in the specification's order. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - static FT_Bool
|
| - SkipCode( EXEC_OP )
|
| - {
|
| - CUR.IP += CUR.length;
|
| -
|
| - if ( CUR.IP < CUR.codeSize )
|
| - {
|
| - CUR.opcode = CUR.code[CUR.IP];
|
| -
|
| - CUR.length = opcode_length[CUR.opcode];
|
| - if ( CUR.length < 0 )
|
| - {
|
| - if ( CUR.IP + 1 >= CUR.codeSize )
|
| - goto Fail_Overflow;
|
| - CUR.length = 2 - CUR.length * CUR.code[CUR.IP + 1];
|
| - }
|
| -
|
| - if ( CUR.IP + CUR.length <= CUR.codeSize )
|
| - return SUCCESS;
|
| - }
|
| -
|
| - Fail_Overflow:
|
| - CUR.error = FT_THROW( Code_Overflow );
|
| - return FAILURE;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* IF[]: IF test */
|
| - /* Opcode range: 0x58 */
|
| - /* Stack: StkElt --> */
|
| - /* */
|
| - static void
|
| - Ins_IF( INS_ARG )
|
| - {
|
| - FT_Int nIfs;
|
| - FT_Bool Out;
|
| -
|
| -
|
| - if ( args[0] != 0 )
|
| - return;
|
| -
|
| - nIfs = 1;
|
| - Out = 0;
|
| -
|
| - do
|
| - {
|
| - if ( SKIP_Code() == FAILURE )
|
| - return;
|
| -
|
| - switch ( CUR.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( INS_ARG )
|
| - {
|
| - FT_Int nIfs;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| - nIfs = 1;
|
| -
|
| - do
|
| - {
|
| - if ( SKIP_Code() == FAILURE )
|
| - return;
|
| -
|
| - switch ( CUR.opcode )
|
| - {
|
| - case 0x58: /* IF */
|
| - nIfs++;
|
| - break;
|
| -
|
| - case 0x59: /* EIF */
|
| - nIfs--;
|
| - break;
|
| - }
|
| - } while ( nIfs != 0 );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* DEFINING AND USING FUNCTIONS AND INSTRUCTIONS */
|
| - /* */
|
| - /* Instructions appear in the specification's order. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FDEF[]: Function DEFinition */
|
| - /* Opcode range: 0x2C */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_FDEF( INS_ARG )
|
| - {
|
| - FT_ULong n;
|
| - TT_DefRecord* rec;
|
| - TT_DefRecord* limit;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* 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_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -
|
| - /* some font programs are broken enough to redefine functions! */
|
| - /* We will then parse the current table. */
|
| -
|
| - rec = CUR.FDefs;
|
| - limit = rec + CUR.numFDefs;
|
| - n = args[0];
|
| -
|
| - for ( ; rec < limit; rec++ )
|
| - {
|
| - if ( rec->opc == n )
|
| - break;
|
| - }
|
| -
|
| - if ( rec == limit )
|
| - {
|
| - /* check that there is enough room for new functions */
|
| - if ( CUR.numFDefs >= CUR.maxFDefs )
|
| - {
|
| - CUR.error = FT_THROW( Too_Many_Function_Defs );
|
| - return;
|
| - }
|
| - CUR.numFDefs++;
|
| - }
|
| -
|
| - /* Although FDEF takes unsigned 32-bit integer, */
|
| - /* func # must be within unsigned 16-bit integer */
|
| - if ( n > 0xFFFFU )
|
| - {
|
| - CUR.error = FT_THROW( Too_Many_Function_Defs );
|
| - return;
|
| - }
|
| -
|
| - rec->range = CUR.curRange;
|
| - rec->opc = (FT_UInt16)n;
|
| - rec->start = CUR.IP + 1;
|
| - rec->active = TRUE;
|
| - rec->inline_delta = FALSE;
|
| - rec->sph_fdef_flags = 0x0000;
|
| -
|
| - if ( n > CUR.maxFunc )
|
| - CUR.maxFunc = (FT_UInt16)n;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* 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 ( SKIP_Code() == SUCCESS )
|
| - {
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| -
|
| - if ( SUBPIXEL_HINTING )
|
| - {
|
| - for ( i = 0; i < opcode_patterns; i++ )
|
| - {
|
| - if ( opcode_pointer[i] < opcode_size[i] &&
|
| - CUR.opcode == opcode_pattern[i][opcode_pointer[i]] )
|
| - {
|
| - opcode_pointer[i] += 1;
|
| -
|
| - if ( opcode_pointer[i] == opcode_size[i] )
|
| - {
|
| - FT_TRACE7(( "sph: Function %d, opcode ptrn: %d, %s %s\n",
|
| - i, n,
|
| - CUR.face->root.family_name,
|
| - CUR.face->root.style_name ));
|
| -
|
| - switch ( i )
|
| - {
|
| - case 0:
|
| - rec->sph_fdef_flags |= SPH_FDEF_INLINE_DELTA_1;
|
| - CUR.face->sph_found_func_flags |= SPH_FDEF_INLINE_DELTA_1;
|
| - break;
|
| -
|
| - case 1:
|
| - rec->sph_fdef_flags |= SPH_FDEF_INLINE_DELTA_2;
|
| - CUR.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;
|
| - CUR.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;
|
| - CUR.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;
|
| - CUR.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;
|
| - CUR.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;
|
| - CUR.face->sph_found_func_flags |= SPH_FDEF_SPACING_2;
|
| - }
|
| - break;
|
| -
|
| - case 7:
|
| - rec->sph_fdef_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL;
|
| - CUR.face->sph_found_func_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL;
|
| - break;
|
| -
|
| - case 8:
|
| -#if 0
|
| - rec->sph_fdef_flags |= SPH_FDEF_TYPEMAN_DIAGENDCTRL;
|
| - CUR.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 */
|
| - CUR.face->sph_compatibility_mode =
|
| - ( ( CUR.face->sph_found_func_flags & SPH_FDEF_INLINE_DELTA_1 ) |
|
| - ( CUR.face->sph_found_func_flags & SPH_FDEF_INLINE_DELTA_2 ) );
|
| - }
|
| -
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - switch ( CUR.opcode )
|
| - {
|
| - case 0x89: /* IDEF */
|
| - case 0x2C: /* FDEF */
|
| - CUR.error = FT_THROW( Nested_DEFS );
|
| - return;
|
| -
|
| - case 0x2D: /* ENDF */
|
| - rec->end = CUR.IP;
|
| - return;
|
| - }
|
| - }
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ENDF[]: END Function definition */
|
| - /* Opcode range: 0x2D */
|
| - /* Stack: --> */
|
| - /* */
|
| - static void
|
| - Ins_ENDF( INS_ARG )
|
| - {
|
| - TT_CallRec* pRec;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - CUR.sph_in_func_flags = 0x0000;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - if ( CUR.callTop <= 0 ) /* We encountered an ENDF without a call */
|
| - {
|
| - CUR.error = FT_THROW( ENDF_In_Exec_Stream );
|
| - return;
|
| - }
|
| -
|
| - CUR.callTop--;
|
| -
|
| - pRec = &CUR.callStack[CUR.callTop];
|
| -
|
| - pRec->Cur_Count--;
|
| -
|
| - CUR.step_ins = FALSE;
|
| -
|
| - if ( pRec->Cur_Count > 0 )
|
| - {
|
| - CUR.callTop++;
|
| - CUR.IP = pRec->Cur_Restart;
|
| - }
|
| - else
|
| - /* Loop through the current function */
|
| - INS_Goto_CodeRange( 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( INS_ARG )
|
| - {
|
| - FT_ULong F;
|
| - TT_CallRec* pCrec;
|
| - TT_DefRecord* def;
|
| -
|
| -
|
| - /* first of all, check the index */
|
| -
|
| - F = args[0];
|
| - if ( BOUNDSL( F, CUR.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 */
|
| - /* */
|
| - /* CUR.maxFunc+1 == CUR.numFDefs */
|
| - /* CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc */
|
| - /* */
|
| - /* If this isn't true, we need to look up the function table. */
|
| -
|
| - def = CUR.FDefs + F;
|
| - if ( CUR.maxFunc + 1 != CUR.numFDefs || def->opc != F )
|
| - {
|
| - /* look up the FDefs table */
|
| - TT_DefRecord* limit;
|
| -
|
| -
|
| - def = CUR.FDefs;
|
| - limit = def + CUR.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_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - ( ( CUR.iup_called &&
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_NO_CALL_AFTER_IUP ) ) ||
|
| - ( def->sph_fdef_flags & SPH_FDEF_VACUFORM_ROUND_1 ) ) )
|
| - goto Fail;
|
| - else
|
| - CUR.sph_in_func_flags = def->sph_fdef_flags;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - /* check the call stack */
|
| - if ( CUR.callTop >= CUR.callSize )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - pCrec = CUR.callStack + CUR.callTop;
|
| -
|
| - pCrec->Caller_Range = CUR.curRange;
|
| - pCrec->Caller_IP = CUR.IP + 1;
|
| - pCrec->Cur_Count = 1;
|
| - pCrec->Cur_Restart = def->start;
|
| - pCrec->Cur_End = def->end;
|
| -
|
| - CUR.callTop++;
|
| -
|
| - INS_Goto_CodeRange( def->range,
|
| - def->start );
|
| -
|
| - CUR.step_ins = FALSE;
|
| -
|
| - return;
|
| -
|
| - Fail:
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* LOOPCALL[]: LOOP and CALL function */
|
| - /* Opcode range: 0x2A */
|
| - /* Stack: uint32? Eint16? --> */
|
| - /* */
|
| - static void
|
| - Ins_LOOPCALL( INS_ARG )
|
| - {
|
| - FT_ULong F;
|
| - TT_CallRec* pCrec;
|
| - TT_DefRecord* def;
|
| -
|
| -
|
| - /* first of all, check the index */
|
| - F = args[1];
|
| - if ( BOUNDSL( F, CUR.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 */
|
| - /* */
|
| - /* CUR.maxFunc+1 == CUR.numFDefs */
|
| - /* CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc */
|
| - /* */
|
| - /* If this isn't true, we need to look up the function table. */
|
| -
|
| - def = CUR.FDefs + F;
|
| - if ( CUR.maxFunc + 1 != CUR.numFDefs || def->opc != F )
|
| - {
|
| - /* look up the FDefs table */
|
| - TT_DefRecord* limit;
|
| -
|
| -
|
| - def = CUR.FDefs;
|
| - limit = def + CUR.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_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - ( def->sph_fdef_flags & SPH_FDEF_VACUFORM_ROUND_1 ) )
|
| - goto Fail;
|
| - else
|
| - CUR.sph_in_func_flags = def->sph_fdef_flags;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - /* check stack */
|
| - if ( CUR.callTop >= CUR.callSize )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - if ( args[0] > 0 )
|
| - {
|
| - pCrec = CUR.callStack + CUR.callTop;
|
| -
|
| - pCrec->Caller_Range = CUR.curRange;
|
| - pCrec->Caller_IP = CUR.IP + 1;
|
| - pCrec->Cur_Count = (FT_Int)args[0];
|
| - pCrec->Cur_Restart = def->start;
|
| - pCrec->Cur_End = def->end;
|
| -
|
| - CUR.callTop++;
|
| -
|
| - INS_Goto_CodeRange( def->range, def->start );
|
| -
|
| - CUR.step_ins = FALSE;
|
| - }
|
| -
|
| - return;
|
| -
|
| - Fail:
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* IDEF[]: Instruction DEFinition */
|
| - /* Opcode range: 0x89 */
|
| - /* Stack: Eint8 --> */
|
| - /* */
|
| - static void
|
| - Ins_IDEF( INS_ARG )
|
| - {
|
| - TT_DefRecord* def;
|
| - TT_DefRecord* limit;
|
| -
|
| -
|
| - /* First of all, look for the same function in our table */
|
| -
|
| - def = CUR.IDefs;
|
| - limit = def + CUR.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 ( CUR.numIDefs >= CUR.maxIDefs )
|
| - {
|
| - CUR.error = FT_THROW( Too_Many_Instruction_Defs );
|
| - return;
|
| - }
|
| - CUR.numIDefs++;
|
| - }
|
| -
|
| - /* opcode must be unsigned 8-bit integer */
|
| - if ( 0 > args[0] || args[0] > 0x00FF )
|
| - {
|
| - CUR.error = FT_THROW( Too_Many_Instruction_Defs );
|
| - return;
|
| - }
|
| -
|
| - def->opc = (FT_Byte)args[0];
|
| - def->start = CUR.IP + 1;
|
| - def->range = CUR.curRange;
|
| - def->active = TRUE;
|
| -
|
| - if ( (FT_ULong)args[0] > CUR.maxIns )
|
| - CUR.maxIns = (FT_Byte)args[0];
|
| -
|
| - /* Now skip the whole function definition. */
|
| - /* We don't allow nested IDEFs & FDEFs. */
|
| -
|
| - while ( SKIP_Code() == SUCCESS )
|
| - {
|
| - switch ( CUR.opcode )
|
| - {
|
| - case 0x89: /* IDEF */
|
| - case 0x2C: /* FDEF */
|
| - CUR.error = FT_THROW( Nested_DEFS );
|
| - return;
|
| - case 0x2D: /* ENDF */
|
| - return;
|
| - }
|
| - }
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* PUSHING DATA ONTO THE INTERPRETER STACK */
|
| - /* */
|
| - /* Instructions appear in the specification's order. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* NPUSHB[]: PUSH N Bytes */
|
| - /* Opcode range: 0x40 */
|
| - /* Stack: --> uint32... */
|
| - /* */
|
| - static void
|
| - Ins_NPUSHB( INS_ARG )
|
| - {
|
| - FT_UShort L, K;
|
| -
|
| -
|
| - L = (FT_UShort)CUR.code[CUR.IP + 1];
|
| -
|
| - if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - for ( K = 1; K <= L; K++ )
|
| - args[K - 1] = CUR.code[CUR.IP + K + 1];
|
| -
|
| - CUR.new_top += L;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* NPUSHW[]: PUSH N Words */
|
| - /* Opcode range: 0x41 */
|
| - /* Stack: --> int32... */
|
| - /* */
|
| - static void
|
| - Ins_NPUSHW( INS_ARG )
|
| - {
|
| - FT_UShort L, K;
|
| -
|
| -
|
| - L = (FT_UShort)CUR.code[CUR.IP + 1];
|
| -
|
| - if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - CUR.IP += 2;
|
| -
|
| - for ( K = 0; K < L; K++ )
|
| - args[K] = GET_ShortIns();
|
| -
|
| - CUR.step_ins = FALSE;
|
| - CUR.new_top += L;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* PUSHB[abc]: PUSH Bytes */
|
| - /* Opcode range: 0xB0-0xB7 */
|
| - /* Stack: --> uint32... */
|
| - /* */
|
| - static void
|
| - Ins_PUSHB( INS_ARG )
|
| - {
|
| - FT_UShort L, K;
|
| -
|
| -
|
| - L = (FT_UShort)( CUR.opcode - 0xB0 + 1 );
|
| -
|
| - if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - for ( K = 1; K <= L; K++ )
|
| - args[K - 1] = CUR.code[CUR.IP + K];
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* PUSHW[abc]: PUSH Words */
|
| - /* Opcode range: 0xB8-0xBF */
|
| - /* Stack: --> int32... */
|
| - /* */
|
| - static void
|
| - Ins_PUSHW( INS_ARG )
|
| - {
|
| - FT_UShort L, K;
|
| -
|
| -
|
| - L = (FT_UShort)( CUR.opcode - 0xB8 + 1 );
|
| -
|
| - if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - CUR.IP++;
|
| -
|
| - for ( K = 0; K < L; K++ )
|
| - args[K] = GET_ShortIns();
|
| -
|
| - CUR.step_ins = FALSE;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MANAGING THE GRAPHICS STATE */
|
| - /* */
|
| - /* Instructions appear in the specs' order. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* 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( INS_ARG )
|
| - {
|
| - FT_ULong L;
|
| - FT_F26Dot6 R;
|
| -
|
| -
|
| - L = (FT_ULong)args[0];
|
| -
|
| - if ( BOUNDSL( L, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - R = 0;
|
| - }
|
| - else
|
| - {
|
| - if ( CUR.opcode & 1 )
|
| - R = CUR_fast_dualproj( &CUR.zp2.org[L] );
|
| - else
|
| - R = CUR_fast_project( &CUR.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( INS_ARG )
|
| - {
|
| - FT_Long K;
|
| - FT_UShort L;
|
| -
|
| -
|
| - L = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( L, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - K = CUR_fast_project( &CUR.zp2.cur[L] );
|
| -
|
| - CUR_Func_move( &CUR.zp2, L, args[1] - K );
|
| -
|
| - /* UNDOCUMENTED! The MS rasterizer does that with */
|
| - /* twilight points (confirmed by Greg Hitchcock) */
|
| - if ( CUR.GS.gep2 == 0 )
|
| - CUR.zp2.org[L] = CUR.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( INS_ARG )
|
| - {
|
| - FT_UShort K, L;
|
| - FT_F26Dot6 D;
|
| -
|
| -
|
| - K = (FT_UShort)args[1];
|
| - L = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( L, CUR.zp0.n_points ) ||
|
| - BOUNDS( K, CUR.zp1.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - D = 0;
|
| - }
|
| - else
|
| - {
|
| - if ( CUR.opcode & 1 )
|
| - D = CUR_Func_project( CUR.zp0.cur + L, CUR.zp1.cur + K );
|
| - else
|
| - {
|
| - /* XXX: UNDOCUMENTED: twilight zone special case */
|
| -
|
| - if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
|
| - {
|
| - FT_Vector* vec1 = CUR.zp0.org + L;
|
| - FT_Vector* vec2 = CUR.zp1.org + K;
|
| -
|
| -
|
| - D = CUR_Func_dualproj( vec1, vec2 );
|
| - }
|
| - else
|
| - {
|
| - FT_Vector* vec1 = CUR.zp0.orus + L;
|
| - FT_Vector* vec2 = CUR.zp1.orus + K;
|
| -
|
| -
|
| - if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
|
| - {
|
| - /* this should be faster */
|
| - D = CUR_Func_dualproj( vec1, vec2 );
|
| - D = FT_MulFix( D, CUR.metrics.x_scale );
|
| - }
|
| - else
|
| - {
|
| - FT_Vector vec;
|
| -
|
| -
|
| - vec.x = FT_MulFix( vec1->x - vec2->x, CUR.metrics.x_scale );
|
| - vec.y = FT_MulFix( vec1->y - vec2->y, CUR.metrics.y_scale );
|
| -
|
| - D = CUR_fast_dualproj( &vec );
|
| - }
|
| - }
|
| - }
|
| - }
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* Disable Type 2 Vacuform Rounds - e.g. Arial Narrow */
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode && FT_ABS( D ) == 64 )
|
| - D += 1;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - args[0] = D;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SDPVTL[a]: Set Dual PVector to Line */
|
| - /* Opcode range: 0x86-0x87 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SDPVTL( INS_ARG )
|
| - {
|
| - FT_Long A, B, C;
|
| - FT_UShort p1, p2; /* was FT_Int in pas type ERROR */
|
| - FT_Int aOpc = CUR.opcode;
|
| -
|
| -
|
| - p1 = (FT_UShort)args[1];
|
| - p2 = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( p2, CUR.zp1.n_points ) ||
|
| - BOUNDS( p1, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - {
|
| - FT_Vector* v1 = CUR.zp1.org + p2;
|
| - FT_Vector* v2 = CUR.zp2.org + p1;
|
| -
|
| -
|
| - A = v1->x - v2->x;
|
| - B = 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;
|
| - aOpc = 0;
|
| - }
|
| - }
|
| -
|
| - if ( ( aOpc & 1 ) != 0 )
|
| - {
|
| - C = B; /* counter clockwise rotation */
|
| - B = A;
|
| - A = -C;
|
| - }
|
| -
|
| - NORMalize( A, B, &CUR.GS.dualVector );
|
| -
|
| - {
|
| - FT_Vector* v1 = CUR.zp1.cur + p2;
|
| - FT_Vector* v2 = CUR.zp2.cur + p1;
|
| -
|
| -
|
| - A = v1->x - v2->x;
|
| - B = v1->y - v2->y;
|
| -
|
| - if ( A == 0 && B == 0 )
|
| - {
|
| - A = 0x4000;
|
| - aOpc = 0;
|
| - }
|
| - }
|
| -
|
| - if ( ( aOpc & 1 ) != 0 )
|
| - {
|
| - C = B; /* counter clockwise rotation */
|
| - B = A;
|
| - A = -C;
|
| - }
|
| -
|
| - NORMalize( A, B, &CUR.GS.projVector );
|
| -
|
| - GUESS_VECTOR( freeVector );
|
| -
|
| - COMPUTE_Funcs();
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SZP0[]: Set Zone Pointer 0 */
|
| - /* Opcode range: 0x13 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SZP0( INS_ARG )
|
| - {
|
| - switch ( (FT_Int)args[0] )
|
| - {
|
| - case 0:
|
| - CUR.zp0 = CUR.twilight;
|
| - break;
|
| -
|
| - case 1:
|
| - CUR.zp0 = CUR.pts;
|
| - break;
|
| -
|
| - default:
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - CUR.GS.gep0 = (FT_UShort)args[0];
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SZP1[]: Set Zone Pointer 1 */
|
| - /* Opcode range: 0x14 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SZP1( INS_ARG )
|
| - {
|
| - switch ( (FT_Int)args[0] )
|
| - {
|
| - case 0:
|
| - CUR.zp1 = CUR.twilight;
|
| - break;
|
| -
|
| - case 1:
|
| - CUR.zp1 = CUR.pts;
|
| - break;
|
| -
|
| - default:
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - CUR.GS.gep1 = (FT_UShort)args[0];
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SZP2[]: Set Zone Pointer 2 */
|
| - /* Opcode range: 0x15 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SZP2( INS_ARG )
|
| - {
|
| - switch ( (FT_Int)args[0] )
|
| - {
|
| - case 0:
|
| - CUR.zp2 = CUR.twilight;
|
| - break;
|
| -
|
| - case 1:
|
| - CUR.zp2 = CUR.pts;
|
| - break;
|
| -
|
| - default:
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - CUR.GS.gep2 = (FT_UShort)args[0];
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SZPS[]: Set Zone PointerS */
|
| - /* Opcode range: 0x16 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SZPS( INS_ARG )
|
| - {
|
| - switch ( (FT_Int)args[0] )
|
| - {
|
| - case 0:
|
| - CUR.zp0 = CUR.twilight;
|
| - break;
|
| -
|
| - case 1:
|
| - CUR.zp0 = CUR.pts;
|
| - break;
|
| -
|
| - default:
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - CUR.zp1 = CUR.zp0;
|
| - CUR.zp2 = CUR.zp0;
|
| -
|
| - CUR.GS.gep0 = (FT_UShort)args[0];
|
| - CUR.GS.gep1 = (FT_UShort)args[0];
|
| - CUR.GS.gep2 = (FT_UShort)args[0];
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* INSTCTRL[]: INSTruction ConTRoL */
|
| - /* Opcode range: 0x8e */
|
| - /* Stack: int32 int32 --> */
|
| - /* */
|
| - static void
|
| - Ins_INSTCTRL( INS_ARG )
|
| - {
|
| - FT_Long K, L;
|
| -
|
| -
|
| - K = args[1];
|
| - L = args[0];
|
| -
|
| - if ( K < 1 || K > 2 )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - if ( L != 0 )
|
| - L = K;
|
| -
|
| - CUR.GS.instruct_control = FT_BOOL(
|
| - ( (FT_Byte)CUR.GS.instruct_control & ~(FT_Byte)K ) | (FT_Byte)L );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SCANCTRL[]: SCAN ConTRoL */
|
| - /* Opcode range: 0x85 */
|
| - /* Stack: uint32? --> */
|
| - /* */
|
| - static void
|
| - Ins_SCANCTRL( INS_ARG )
|
| - {
|
| - FT_Int A;
|
| -
|
| -
|
| - /* Get Threshold */
|
| - A = (FT_Int)( args[0] & 0xFF );
|
| -
|
| - if ( A == 0xFF )
|
| - {
|
| - CUR.GS.scan_control = TRUE;
|
| - return;
|
| - }
|
| - else if ( A == 0 )
|
| - {
|
| - CUR.GS.scan_control = FALSE;
|
| - return;
|
| - }
|
| -
|
| - if ( ( args[0] & 0x100 ) != 0 && CUR.tt_metrics.ppem <= A )
|
| - CUR.GS.scan_control = TRUE;
|
| -
|
| - if ( ( args[0] & 0x200 ) != 0 && CUR.tt_metrics.rotated )
|
| - CUR.GS.scan_control = TRUE;
|
| -
|
| - if ( ( args[0] & 0x400 ) != 0 && CUR.tt_metrics.stretched )
|
| - CUR.GS.scan_control = TRUE;
|
| -
|
| - if ( ( args[0] & 0x800 ) != 0 && CUR.tt_metrics.ppem > A )
|
| - CUR.GS.scan_control = FALSE;
|
| -
|
| - if ( ( args[0] & 0x1000 ) != 0 && CUR.tt_metrics.rotated )
|
| - CUR.GS.scan_control = FALSE;
|
| -
|
| - if ( ( args[0] & 0x2000 ) != 0 && CUR.tt_metrics.stretched )
|
| - CUR.GS.scan_control = FALSE;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SCANTYPE[]: SCAN TYPE */
|
| - /* Opcode range: 0x8D */
|
| - /* Stack: uint32? --> */
|
| - /* */
|
| - static void
|
| - Ins_SCANTYPE( INS_ARG )
|
| - {
|
| - if ( args[0] >= 0 )
|
| - CUR.GS.scan_type = (FT_Int)args[0];
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MANAGING OUTLINES */
|
| - /* */
|
| - /* Instructions appear in the specification's order. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FLIPPT[]: FLIP PoinT */
|
| - /* Opcode range: 0x80 */
|
| - /* Stack: uint32... --> */
|
| - /* */
|
| - static void
|
| - Ins_FLIPPT( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| - if ( CUR.top < CUR.GS.loop )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Too_Few_Arguments );
|
| - goto Fail;
|
| - }
|
| -
|
| - while ( CUR.GS.loop > 0 )
|
| - {
|
| - CUR.args--;
|
| -
|
| - point = (FT_UShort)CUR.stack[CUR.args];
|
| -
|
| - if ( BOUNDS( point, CUR.pts.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| - }
|
| - else
|
| - CUR.pts.tags[point] ^= FT_CURVE_TAG_ON;
|
| -
|
| - CUR.GS.loop--;
|
| - }
|
| -
|
| - Fail:
|
| - CUR.GS.loop = 1;
|
| - CUR.new_top = CUR.args;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FLIPRGON[]: FLIP RanGe ON */
|
| - /* Opcode range: 0x81 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_FLIPRGON( INS_ARG )
|
| - {
|
| - FT_UShort I, K, L;
|
| -
|
| -
|
| - K = (FT_UShort)args[1];
|
| - L = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( K, CUR.pts.n_points ) ||
|
| - BOUNDS( L, CUR.pts.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - for ( I = L; I <= K; I++ )
|
| - CUR.pts.tags[I] |= FT_CURVE_TAG_ON;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* FLIPRGOFF: FLIP RanGe OFF */
|
| - /* Opcode range: 0x82 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_FLIPRGOFF( INS_ARG )
|
| - {
|
| - FT_UShort I, K, L;
|
| -
|
| -
|
| - K = (FT_UShort)args[1];
|
| - L = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( K, CUR.pts.n_points ) ||
|
| - BOUNDS( L, CUR.pts.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - for ( I = L; I <= K; I++ )
|
| - CUR.pts.tags[I] &= ~FT_CURVE_TAG_ON;
|
| - }
|
| -
|
| -
|
| - static FT_Bool
|
| - Compute_Point_Displacement( EXEC_OP_ FT_F26Dot6* x,
|
| - FT_F26Dot6* y,
|
| - TT_GlyphZone zone,
|
| - FT_UShort* refp )
|
| - {
|
| - TT_GlyphZoneRec zp;
|
| - FT_UShort p;
|
| - FT_F26Dot6 d;
|
| -
|
| -
|
| - if ( CUR.opcode & 1 )
|
| - {
|
| - zp = CUR.zp0;
|
| - p = CUR.GS.rp1;
|
| - }
|
| - else
|
| - {
|
| - zp = CUR.zp1;
|
| - p = CUR.GS.rp2;
|
| - }
|
| -
|
| - if ( BOUNDS( p, zp.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - *refp = 0;
|
| - return FAILURE;
|
| - }
|
| -
|
| - *zone = zp;
|
| - *refp = p;
|
| -
|
| - d = CUR_Func_project( zp.cur + p, zp.org + p );
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - if ( CUR.GS.both_x_axis )
|
| - {
|
| - *x = d;
|
| - *y = 0;
|
| - }
|
| - else
|
| - {
|
| - *x = 0;
|
| - *y = d;
|
| - }
|
| - }
|
| - else
|
| -#endif
|
| - {
|
| - *x = FT_MulDiv( d, (FT_Long)CUR.GS.freeVector.x, CUR.F_dot_P );
|
| - *y = FT_MulDiv( d, (FT_Long)CUR.GS.freeVector.y, CUR.F_dot_P );
|
| - }
|
| -
|
| - return SUCCESS;
|
| - }
|
| -
|
| -
|
| - static void
|
| - Move_Zp2_Point( EXEC_OP_ FT_UShort point,
|
| - FT_F26Dot6 dx,
|
| - FT_F26Dot6 dy,
|
| - FT_Bool touch )
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - if ( CUR.GS.both_x_axis )
|
| - {
|
| - CUR.zp2.cur[point].x += dx;
|
| - if ( touch )
|
| - CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
|
| - }
|
| - else
|
| - {
|
| - CUR.zp2.cur[point].y += dy;
|
| - if ( touch )
|
| - CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
|
| - }
|
| - return;
|
| - }
|
| -#endif
|
| -
|
| - if (CUR.zp2.cur == NULL) return; /* Security fix: Google Chris6 ufuzz109.pdf page #1 */
|
| - if ( CUR.GS.freeVector.x != 0 )
|
| - {
|
| - CUR.zp2.cur[point].x += dx;
|
| - if ( touch )
|
| - CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
|
| - }
|
| -
|
| - if ( CUR.GS.freeVector.y != 0 )
|
| - {
|
| - CUR.zp2.cur[point].y += dy;
|
| - if ( touch )
|
| - CUR.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( INS_ARG )
|
| - {
|
| - TT_GlyphZoneRec zp;
|
| - FT_UShort refp;
|
| -
|
| - FT_F26Dot6 dx,
|
| - dy;
|
| - FT_UShort point;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| - if ( CUR.top < CUR.GS.loop )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto Fail;
|
| - }
|
| -
|
| - if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
|
| - return;
|
| -
|
| - while ( CUR.GS.loop > 0 )
|
| - {
|
| - CUR.args--;
|
| - point = (FT_UShort)CUR.stack[CUR.args];
|
| -
|
| - if ( BOUNDS( point, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| - }
|
| - else
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* doesn't follow Cleartype spec but produces better result */
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode )
|
| - MOVE_Zp2_Point( point, 0, dy, TRUE );
|
| - else
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| - MOVE_Zp2_Point( point, dx, dy, TRUE );
|
| -
|
| - CUR.GS.loop--;
|
| - }
|
| -
|
| - Fail:
|
| - CUR.GS.loop = 1;
|
| - CUR.new_top = CUR.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( INS_ARG )
|
| - {
|
| - TT_GlyphZoneRec zp;
|
| - FT_UShort refp;
|
| - FT_F26Dot6 dx, dy;
|
| -
|
| - FT_Short contour, bounds;
|
| - FT_UShort start, limit, i;
|
| -
|
| -
|
| - contour = (FT_UShort)args[0];
|
| - bounds = ( CUR.GS.gep2 == 0 ) ? 1 : CUR.zp2.n_contours;
|
| -
|
| - if ( BOUNDS( contour, bounds ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
|
| - return;
|
| -
|
| - if ( contour == 0 )
|
| - start = 0;
|
| - else
|
| - start = (FT_UShort)( CUR.zp2.contours[contour - 1] + 1 -
|
| - CUR.zp2.first_point );
|
| -
|
| - /* we use the number of points if in the twilight zone */
|
| - if ( CUR.GS.gep2 == 0 )
|
| - limit = CUR.zp2.n_points;
|
| - else
|
| - limit = (FT_UShort)( CUR.zp2.contours[contour] -
|
| - CUR.zp2.first_point + 1 );
|
| -
|
| - for ( i = start; i < limit; i++ )
|
| - {
|
| - if ( zp.cur != CUR.zp2.cur || refp != i )
|
| - MOVE_Zp2_Point( i, dx, dy, TRUE );
|
| - }
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SHZ[a]: SHift Zone */
|
| - /* Opcode range: 0x36-37 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_SHZ( INS_ARG )
|
| - {
|
| - TT_GlyphZoneRec zp;
|
| - FT_UShort refp;
|
| - FT_F26Dot6 dx,
|
| - dy;
|
| -
|
| - FT_UShort limit, i;
|
| -
|
| -
|
| - if ( BOUNDS( args[0], 2 ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - if ( COMPUTE_Point_Displacement( &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 ( CUR.GS.gep2 == 0 )
|
| - limit = (FT_UShort)CUR.zp2.n_points;
|
| - else if ( CUR.GS.gep2 == 1 && CUR.zp2.n_contours > 0 ) {
|
| - limit = (FT_UShort)( CUR.zp2.contours[CUR.zp2.n_contours - 1] + 1 );
|
| - if (limit >= CUR.zp2.n_points) /* XYQ 2010-10-01: security fix: validate last point index */
|
| - limit = CUR.zp2.n_points - 1;
|
| - }
|
| - else
|
| - limit = 0;
|
| -
|
| - /* XXX: UNDOCUMENTED! SHZ doesn't touch the points */
|
| - for ( i = 0; i < limit; i++ )
|
| - {
|
| - if ( zp.cur != CUR.zp2.cur || refp != i )
|
| - MOVE_Zp2_Point( i, dx, dy, FALSE );
|
| - }
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* SHPIX[]: SHift points by a PIXel amount */
|
| - /* Opcode range: 0x38 */
|
| - /* Stack: f26.6 uint32... --> */
|
| - /* */
|
| - static void
|
| - Ins_SHPIX( INS_ARG )
|
| - {
|
| - FT_F26Dot6 dx, dy;
|
| - FT_UShort point;
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - FT_Int B1, B2;
|
| -#endif
|
| -
|
| -
|
| - if ( CUR.top < CUR.GS.loop + 1 )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto Fail;
|
| - }
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - if ( CUR.GS.both_x_axis )
|
| - {
|
| - dx = (FT_UInt32)args[0];
|
| - dy = 0;
|
| - }
|
| - else
|
| - {
|
| - dx = 0;
|
| - dy = (FT_UInt32)args[0];
|
| - }
|
| - }
|
| - else
|
| -#endif
|
| - {
|
| - dx = TT_MulFix14( (FT_UInt32)args[0], CUR.GS.freeVector.x );
|
| - dy = TT_MulFix14( (FT_UInt32)args[0], CUR.GS.freeVector.y );
|
| - }
|
| -
|
| - while ( CUR.GS.loop > 0 )
|
| - {
|
| - CUR.args--;
|
| -
|
| - point = (FT_UShort)CUR.stack[CUR.args];
|
| -
|
| - if ( BOUNDS( point, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| - }
|
| - else
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - {
|
| - /* 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 ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode )
|
| - {
|
| - /* save point for later comparison */
|
| - if ( CUR.GS.freeVector.y != 0 )
|
| - B1 = CUR.zp2.cur[point].y;
|
| - else
|
| - B1 = CUR.zp2.cur[point].x;
|
| -
|
| - if ( !CUR.face->sph_compatibility_mode &&
|
| - CUR.GS.freeVector.y != 0 )
|
| - {
|
| - MOVE_Zp2_Point( point, dx, dy, TRUE );
|
| -
|
| - /* save new point */
|
| - if ( CUR.GS.freeVector.y != 0 )
|
| - {
|
| - B2 = CUR.zp2.cur[point].y;
|
| -
|
| - /* reverse any disallowed moves */
|
| - if ( ( CUR.sph_tweak_flags & SPH_TWEAK_SKIP_NONPIXEL_Y_MOVES ) &&
|
| - ( B1 & 63 ) != 0 &&
|
| - ( B2 & 63 ) != 0 &&
|
| - B1 != B2 )
|
| - MOVE_Zp2_Point( point, -dx, -dy, TRUE );
|
| - }
|
| - }
|
| - else if ( CUR.face->sph_compatibility_mode )
|
| - {
|
| - if ( CUR.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 ( CUR.iup_called &&
|
| - ( ( CUR.sph_in_func_flags & SPH_FDEF_INLINE_DELTA_1 ) ||
|
| - ( CUR.sph_in_func_flags & SPH_FDEF_INLINE_DELTA_2 ) ) )
|
| - goto Skip;
|
| -
|
| - if ( !( CUR.sph_tweak_flags & SPH_TWEAK_ALWAYS_SKIP_DELTAP ) &&
|
| - ( ( CUR.is_composite && CUR.GS.freeVector.y != 0 ) ||
|
| - ( CUR.zp2.tags[point] & FT_CURVE_TAG_TOUCH_Y ) ||
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_DO_SHPIX ) ) )
|
| - MOVE_Zp2_Point( point, 0, dy, TRUE );
|
| -
|
| - /* save new point */
|
| - if ( CUR.GS.freeVector.y != 0 )
|
| - {
|
| - B2 = CUR.zp2.cur[point].y;
|
| -
|
| - /* reverse any disallowed moves */
|
| - if ( ( B1 & 63 ) == 0 &&
|
| - ( B2 & 63 ) != 0 &&
|
| - B1 != B2 )
|
| - MOVE_Zp2_Point( point, 0, -dy, TRUE );
|
| - }
|
| - }
|
| - else if ( CUR.sph_in_func_flags & SPH_FDEF_TYPEMAN_DIAGENDCTRL )
|
| - MOVE_Zp2_Point( point, dx, dy, TRUE );
|
| - }
|
| - else
|
| - MOVE_Zp2_Point( point, dx, dy, TRUE );
|
| - }
|
| -
|
| - Skip:
|
| -
|
| -#else /* !TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - MOVE_Zp2_Point( point, dx, dy, TRUE );
|
| -
|
| -#endif /* !TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - CUR.GS.loop--;
|
| - }
|
| -
|
| - Fail:
|
| - CUR.GS.loop = 1;
|
| - CUR.new_top = CUR.args;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MSIRP[a]: Move Stack Indirect Relative Position */
|
| - /* Opcode range: 0x3A-0x3B */
|
| - /* Stack: f26.6 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_MSIRP( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| - FT_F26Dot6 distance;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - FT_F26Dot6 control_value_cutin = 0; /* pacify compiler */
|
| -
|
| -
|
| - if ( SUBPIXEL_HINTING )
|
| - {
|
| - control_value_cutin = CUR.GS.control_value_cutin;
|
| -
|
| - if ( CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 &&
|
| - !( CUR.sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) )
|
| - control_value_cutin = 0;
|
| - }
|
| -
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - point = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( point, CUR.zp1.n_points ) ||
|
| - BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - /* UNDOCUMENTED! The MS rasterizer does that with */
|
| - /* twilight points (confirmed by Greg Hitchcock) */
|
| - if ( CUR.GS.gep1 == 0 )
|
| - {
|
| - CUR.zp1.org[point] = CUR.zp0.org[CUR.GS.rp0];
|
| - CUR_Func_move_orig( &CUR.zp1, point, args[1] );
|
| - CUR.zp1.cur[point] = CUR.zp1.org[point];
|
| - }
|
| -
|
| - distance = CUR_Func_project( CUR.zp1.cur + point,
|
| - CUR.zp0.cur + CUR.GS.rp0 );
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* subpixel hinting - make MSIRP respect CVT cut-in; */
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 &&
|
| - FT_ABS( distance - args[1] ) >= control_value_cutin )
|
| - distance = args[1];
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - CUR_Func_move( &CUR.zp1, point, args[1] - distance );
|
| -
|
| - CUR.GS.rp1 = CUR.GS.rp0;
|
| - CUR.GS.rp2 = point;
|
| -
|
| - if ( ( CUR.opcode & 1 ) != 0 )
|
| - CUR.GS.rp0 = point;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MDAP[a]: Move Direct Absolute Point */
|
| - /* Opcode range: 0x2E-0x2F */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_MDAP( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| - FT_F26Dot6 cur_dist;
|
| - FT_F26Dot6 distance;
|
| -
|
| -
|
| - point = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( point, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - if ( ( CUR.opcode & 1 ) != 0 )
|
| - {
|
| - cur_dist = CUR_fast_project( &CUR.zp0.cur[point] );
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 )
|
| - distance = ROUND_None(
|
| - cur_dist,
|
| - CUR.tt_metrics.compensations[0] ) - cur_dist;
|
| - else
|
| -#endif
|
| - distance = CUR_Func_round(
|
| - cur_dist,
|
| - CUR.tt_metrics.compensations[0] ) - cur_dist;
|
| - }
|
| - else
|
| - distance = 0;
|
| -
|
| - CUR_Func_move( &CUR.zp0, point, distance );
|
| -
|
| - CUR.GS.rp0 = point;
|
| - CUR.GS.rp1 = point;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MIAP[a]: Move Indirect Absolute Point */
|
| - /* Opcode range: 0x3E-0x3F */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_MIAP( INS_ARG )
|
| - {
|
| - FT_ULong cvtEntry;
|
| - FT_UShort point;
|
| - FT_F26Dot6 distance;
|
| - FT_F26Dot6 org_dist;
|
| - FT_F26Dot6 control_value_cutin;
|
| -
|
| -
|
| - control_value_cutin = CUR.GS.control_value_cutin;
|
| - cvtEntry = (FT_ULong)args[1];
|
| - point = (FT_UShort)args[0];
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 &&
|
| - CUR.GS.freeVector.y == 0 &&
|
| - !( CUR.sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) )
|
| - control_value_cutin = 0;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - if ( BOUNDS( point, CUR.zp0.n_points ) ||
|
| - BOUNDSL( cvtEntry, CUR.cvtSize ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.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 = CUR_Func_read_cvt( cvtEntry );
|
| -
|
| - if ( CUR.GS.gep0 == 0 ) /* If in twilight zone */
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* Only adjust if not in sph_compatibility_mode or ignore_x_mode. */
|
| - /* Determined via experimentation and may be incorrect... */
|
| - if ( !SUBPIXEL_HINTING ||
|
| - ( !CUR.ignore_x_mode ||
|
| - !CUR.face->sph_compatibility_mode ) )
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| - CUR.zp0.org[point].x = TT_MulFix14( (FT_UInt32)distance,
|
| - CUR.GS.freeVector.x );
|
| - CUR.zp0.org[point].y = TT_MulFix14( (FT_UInt32)distance,
|
| - CUR.GS.freeVector.y ),
|
| - CUR.zp0.cur[point] = CUR.zp0.org[point];
|
| - }
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_MIAP_HACK ) &&
|
| - distance > 0 &&
|
| - CUR.GS.freeVector.y != 0 )
|
| - distance = 0;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - org_dist = CUR_fast_project( &CUR.zp0.cur[point] );
|
| -
|
| - if ( ( CUR.opcode & 1 ) != 0 ) /* rounding and control cut-in flag */
|
| - {
|
| - if ( FT_ABS( distance - org_dist ) > control_value_cutin )
|
| - distance = org_dist;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 )
|
| - distance = ROUND_None( distance,
|
| - CUR.tt_metrics.compensations[0] );
|
| - else
|
| -#endif
|
| - distance = CUR_Func_round( distance,
|
| - CUR.tt_metrics.compensations[0] );
|
| - }
|
| -
|
| - CUR_Func_move( &CUR.zp0, point, distance - org_dist );
|
| -
|
| - Fail:
|
| - CUR.GS.rp0 = point;
|
| - CUR.GS.rp1 = point;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MDRP[abcde]: Move Direct Relative Point */
|
| - /* Opcode range: 0xC0-0xDF */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_MDRP( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| - FT_F26Dot6 org_dist, distance, minimum_distance;
|
| -
|
| -
|
| - minimum_distance = CUR.GS.minimum_distance;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 &&
|
| - !( CUR.sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) )
|
| - minimum_distance = 0;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - point = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( point, CUR.zp1.n_points ) ||
|
| - BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.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 ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
|
| - {
|
| - FT_Vector* vec1 = &CUR.zp1.org[point];
|
| - FT_Vector* vec2 = &CUR.zp0.org[CUR.GS.rp0];
|
| -
|
| -
|
| - org_dist = CUR_Func_dualproj( vec1, vec2 );
|
| - }
|
| - else
|
| - {
|
| - FT_Vector* vec1 = &CUR.zp1.orus[point];
|
| - FT_Vector* vec2 = &CUR.zp0.orus[CUR.GS.rp0];
|
| -
|
| -
|
| - if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
|
| - {
|
| - /* this should be faster */
|
| - org_dist = CUR_Func_dualproj( vec1, vec2 );
|
| - org_dist = FT_MulFix( org_dist, CUR.metrics.x_scale );
|
| - }
|
| - else
|
| - {
|
| - FT_Vector vec;
|
| -
|
| -
|
| - vec.x = FT_MulFix( vec1->x - vec2->x, CUR.metrics.x_scale );
|
| - vec.y = FT_MulFix( vec1->y - vec2->y, CUR.metrics.y_scale );
|
| -
|
| - org_dist = CUR_fast_dualproj( &vec );
|
| - }
|
| - }
|
| -
|
| - /* single width cut-in test */
|
| -
|
| - if ( FT_ABS( org_dist - CUR.GS.single_width_value ) <
|
| - CUR.GS.single_width_cutin )
|
| - {
|
| - if ( org_dist >= 0 )
|
| - org_dist = CUR.GS.single_width_value;
|
| - else
|
| - org_dist = -CUR.GS.single_width_value;
|
| - }
|
| -
|
| - /* round flag */
|
| -
|
| - if ( ( CUR.opcode & 4 ) != 0 )
|
| - {
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 )
|
| - distance = ROUND_None(
|
| - org_dist,
|
| - CUR.tt_metrics.compensations[CUR.opcode & 3] );
|
| - else
|
| -#endif
|
| - distance = CUR_Func_round(
|
| - org_dist,
|
| - CUR.tt_metrics.compensations[CUR.opcode & 3] );
|
| - }
|
| - else
|
| - distance = ROUND_None(
|
| - org_dist,
|
| - CUR.tt_metrics.compensations[CUR.opcode & 3] );
|
| -
|
| - /* minimum distance flag */
|
| -
|
| - if ( ( CUR.opcode & 8 ) != 0 )
|
| - {
|
| - if ( org_dist >= 0 )
|
| - {
|
| - if ( distance < minimum_distance )
|
| - distance = minimum_distance;
|
| - }
|
| - else
|
| - {
|
| - if ( distance > -minimum_distance )
|
| - distance = -minimum_distance;
|
| - }
|
| - }
|
| -
|
| - /* now move the point */
|
| -
|
| - org_dist = CUR_Func_project( CUR.zp1.cur + point,
|
| - CUR.zp0.cur + CUR.GS.rp0 );
|
| -
|
| - CUR_Func_move( &CUR.zp1, point, distance - org_dist );
|
| -
|
| - Fail:
|
| - CUR.GS.rp1 = CUR.GS.rp0;
|
| - CUR.GS.rp2 = point;
|
| -
|
| - if ( ( CUR.opcode & 16 ) != 0 )
|
| - CUR.GS.rp0 = point;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MIRP[abcde]: Move Indirect Relative Point */
|
| - /* Opcode range: 0xE0-0xFF */
|
| - /* Stack: int32? uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_MIRP( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| - FT_ULong cvtEntry;
|
| -
|
| - FT_F26Dot6 cvt_dist,
|
| - distance,
|
| - cur_dist,
|
| - org_dist,
|
| - control_value_cutin,
|
| - minimum_distance;
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - FT_Int B1 = 0; /* pacify compiler */
|
| - FT_Int B2 = 0;
|
| - FT_Bool reverse_move = FALSE;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -
|
| - minimum_distance = CUR.GS.minimum_distance;
|
| - control_value_cutin = CUR.GS.control_value_cutin;
|
| - point = (FT_UShort)args[0];
|
| - cvtEntry = (FT_ULong)( args[1] + 1 );
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.x != 0 &&
|
| - !( CUR.sph_tweak_flags & SPH_TWEAK_NORMAL_ROUND ) )
|
| - control_value_cutin = minimum_distance = 0;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - /* XXX: UNDOCUMENTED! cvt[-1] = 0 always */
|
| - /* Security fix: Google 07_oobread4.pdf page #1, cvtEntry > CUR.cvtSize + 1 will cause array index oob. */
|
| - if ( BOUNDS( point, CUR.zp1.n_points ) ||
|
| - BOUNDS( cvtEntry, CUR.cvtSize + 1 ) ||
|
| - BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto Fail;
|
| - }
|
| -
|
| - if ( !cvtEntry )
|
| - cvt_dist = 0;
|
| - else
|
| - cvt_dist = CUR_Func_read_cvt( cvtEntry - 1 );
|
| -
|
| - /* single width test */
|
| -
|
| - if ( FT_ABS( cvt_dist - CUR.GS.single_width_value ) <
|
| - CUR.GS.single_width_cutin )
|
| - {
|
| - if ( cvt_dist >= 0 )
|
| - cvt_dist = CUR.GS.single_width_value;
|
| - else
|
| - cvt_dist = -CUR.GS.single_width_value;
|
| - }
|
| -
|
| - /* UNDOCUMENTED! The MS rasterizer does that with */
|
| - /* twilight points (confirmed by Greg Hitchcock) */
|
| - if ( CUR.GS.gep1 == 0 )
|
| - {
|
| - CUR.zp1.org[point].x = CUR.zp0.org[CUR.GS.rp0].x +
|
| - TT_MulFix14( (FT_UInt32)cvt_dist,
|
| - CUR.GS.freeVector.x );
|
| - CUR.zp1.org[point].y = CUR.zp0.org[CUR.GS.rp0].y +
|
| - TT_MulFix14( (FT_UInt32)cvt_dist,
|
| - CUR.GS.freeVector.y );
|
| - CUR.zp1.cur[point] = CUR.zp1.org[point];
|
| - }
|
| -
|
| - org_dist = CUR_Func_dualproj( &CUR.zp1.org[point],
|
| - &CUR.zp0.org[CUR.GS.rp0] );
|
| - cur_dist = CUR_Func_project ( &CUR.zp1.cur[point],
|
| - &CUR.zp0.cur[CUR.GS.rp0] );
|
| -
|
| - /* auto-flip test */
|
| -
|
| - if ( CUR.GS.auto_flip )
|
| - {
|
| - if ( ( org_dist ^ cvt_dist ) < 0 )
|
| - cvt_dist = -cvt_dist;
|
| - }
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.y != 0 &&
|
| - ( CUR.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_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - /* control value cut-in and round */
|
| -
|
| - if ( ( CUR.opcode & 4 ) != 0 )
|
| - {
|
| - /* XXX: UNDOCUMENTED! Only perform cut-in test when both points */
|
| - /* refer to the same zone. */
|
| -
|
| - if ( CUR.GS.gep0 == CUR.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 `>'. */
|
| -
|
| - if ( FT_ABS( cvt_dist - org_dist ) > control_value_cutin )
|
| - cvt_dist = org_dist;
|
| - }
|
| -
|
| - distance = CUR_Func_round(
|
| - cvt_dist,
|
| - CUR.tt_metrics.compensations[CUR.opcode & 3] );
|
| - }
|
| - else
|
| - {
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /* do cvt cut-in always in MIRP for sph */
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.GS.gep0 == CUR.GS.gep1 )
|
| - {
|
| - if ( FT_ABS( cvt_dist - org_dist ) > control_value_cutin )
|
| - cvt_dist = org_dist;
|
| - }
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - distance = ROUND_None(
|
| - cvt_dist,
|
| - CUR.tt_metrics.compensations[CUR.opcode & 3] );
|
| - }
|
| -
|
| - /* minimum distance test */
|
| -
|
| - if ( ( CUR.opcode & 8 ) != 0 )
|
| - {
|
| - if ( org_dist >= 0 )
|
| - {
|
| - if ( distance < minimum_distance )
|
| - distance = minimum_distance;
|
| - }
|
| - else
|
| - {
|
| - if ( distance > -minimum_distance )
|
| - distance = -minimum_distance;
|
| - }
|
| - }
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING )
|
| - {
|
| - B1 = CUR.zp1.cur[point].y;
|
| -
|
| - /* Round moves if necessary */
|
| - if ( CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.y != 0 &&
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_ROUND_NONPIXEL_Y_MOVES ) )
|
| - distance = FT_PIX_ROUND( B1 + distance - cur_dist ) - B1 + cur_dist;
|
| -
|
| - if ( CUR.ignore_x_mode &&
|
| - CUR.GS.freeVector.y != 0 &&
|
| - ( CUR.opcode & 16 ) == 0 &&
|
| - ( CUR.opcode & 8 ) == 0 &&
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_COURIER_NEW_2_HACK ) )
|
| - distance += 64;
|
| - }
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - CUR_Func_move( &CUR.zp1, point, distance - cur_dist );
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING )
|
| - {
|
| - B2 = CUR.zp1.cur[point].y;
|
| -
|
| - /* Reverse move if necessary */
|
| - if ( CUR.ignore_x_mode )
|
| - {
|
| - if ( CUR.face->sph_compatibility_mode &&
|
| - CUR.GS.freeVector.y != 0 &&
|
| - ( B1 & 63 ) == 0 &&
|
| - ( B2 & 63 ) != 0 )
|
| - reverse_move = TRUE;
|
| -
|
| - if ( ( CUR.sph_tweak_flags & SPH_TWEAK_SKIP_NONPIXEL_Y_MOVES ) &&
|
| - CUR.GS.freeVector.y != 0 &&
|
| - ( B2 & 63 ) != 0 &&
|
| - ( B1 & 63 ) != 0 )
|
| - reverse_move = TRUE;
|
| - }
|
| -
|
| - if ( reverse_move )
|
| - CUR_Func_move( &CUR.zp1, point, -( distance - cur_dist ) );
|
| - }
|
| -
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - Fail:
|
| - CUR.GS.rp1 = CUR.GS.rp0;
|
| -
|
| - if ( ( CUR.opcode & 16 ) != 0 )
|
| - CUR.GS.rp0 = point;
|
| -
|
| - CUR.GS.rp2 = point;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ALIGNRP[]: ALIGN Relative Point */
|
| - /* Opcode range: 0x3C */
|
| - /* Stack: uint32 uint32... --> */
|
| - /* */
|
| - static void
|
| - Ins_ALIGNRP( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| - FT_F26Dot6 distance;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.iup_called &&
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_NO_ALIGNRP_AFTER_IUP ) )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto Fail;
|
| - }
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - if ( CUR.top < CUR.GS.loop ||
|
| - BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto Fail;
|
| - }
|
| -
|
| - while ( CUR.GS.loop > 0 )
|
| - {
|
| - CUR.args--;
|
| -
|
| - point = (FT_UShort)CUR.stack[CUR.args];
|
| -
|
| - if ( BOUNDS( point, CUR.zp1.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| - }
|
| - else
|
| - {
|
| - distance = CUR_Func_project( CUR.zp1.cur + point,
|
| - CUR.zp0.cur + CUR.GS.rp0 );
|
| -
|
| - CUR_Func_move( &CUR.zp1, point, -distance );
|
| - }
|
| -
|
| - CUR.GS.loop--;
|
| - }
|
| -
|
| - Fail:
|
| - CUR.GS.loop = 1;
|
| - CUR.new_top = CUR.args;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ISECT[]: moves point to InterSECTion */
|
| - /* Opcode range: 0x0F */
|
| - /* Stack: 5 * uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_ISECT( INS_ARG )
|
| - {
|
| - 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, CUR.zp0.n_points ) ||
|
| - BOUNDS( b1, CUR.zp0.n_points ) ||
|
| - BOUNDS( a0, CUR.zp1.n_points ) ||
|
| - BOUNDS( a1, CUR.zp1.n_points ) ||
|
| - BOUNDS( point, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - /* Cramer's rule */
|
| -
|
| - dbx = CUR.zp0.cur[b1].x - CUR.zp0.cur[b0].x;
|
| - dby = CUR.zp0.cur[b1].y - CUR.zp0.cur[b0].y;
|
| -
|
| - dax = CUR.zp1.cur[a1].x - CUR.zp1.cur[a0].x;
|
| - day = CUR.zp1.cur[a1].y - CUR.zp1.cur[a0].y;
|
| -
|
| - dx = CUR.zp0.cur[b0].x - CUR.zp1.cur[a0].x;
|
| - dy = CUR.zp0.cur[b0].y - CUR.zp1.cur[a0].y;
|
| -
|
| - CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_BOTH;
|
| -
|
| - discriminant = FT_MulDiv( dax, -dby, 0x40 ) +
|
| - FT_MulDiv( day, dbx, 0x40 );
|
| - dotproduct = 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 ( 19 * FT_ABS( discriminant ) > FT_ABS( dotproduct ) )
|
| - {
|
| - val = FT_MulDiv( dx, -dby, 0x40 ) + FT_MulDiv( dy, dbx, 0x40 );
|
| -
|
| - R.x = FT_MulDiv( val, dax, discriminant );
|
| - R.y = FT_MulDiv( val, day, discriminant );
|
| -
|
| - CUR.zp2.cur[point].x = CUR.zp1.cur[a0].x + R.x;
|
| - CUR.zp2.cur[point].y = CUR.zp1.cur[a0].y + R.y;
|
| - }
|
| - else
|
| - {
|
| - /* else, take the middle of the middles of A and B */
|
| -
|
| - CUR.zp2.cur[point].x = ( CUR.zp1.cur[a0].x +
|
| - CUR.zp1.cur[a1].x +
|
| - CUR.zp0.cur[b0].x +
|
| - CUR.zp0.cur[b1].x ) / 4;
|
| - CUR.zp2.cur[point].y = ( CUR.zp1.cur[a0].y +
|
| - CUR.zp1.cur[a1].y +
|
| - CUR.zp0.cur[b0].y +
|
| - CUR.zp0.cur[b1].y ) / 4;
|
| - }
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* ALIGNPTS[]: ALIGN PoinTS */
|
| - /* Opcode range: 0x27 */
|
| - /* Stack: uint32 uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_ALIGNPTS( INS_ARG )
|
| - {
|
| - FT_UShort p1, p2;
|
| - FT_F26Dot6 distance;
|
| -
|
| -
|
| - p1 = (FT_UShort)args[0];
|
| - p2 = (FT_UShort)args[1];
|
| -
|
| - if ( BOUNDS( p1, CUR.zp1.n_points ) ||
|
| - BOUNDS( p2, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - distance = CUR_Func_project( CUR.zp0.cur + p2,
|
| - CUR.zp1.cur + p1 ) / 2;
|
| -
|
| - CUR_Func_move( &CUR.zp1, p1, distance );
|
| - CUR_Func_move( &CUR.zp0, p2, -distance );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* IP[]: Interpolate Point */
|
| - /* Opcode range: 0x39 */
|
| - /* Stack: uint32... --> */
|
| - /* */
|
| -
|
| - /* SOMETIMES, DUMBER CODE IS BETTER CODE */
|
| -
|
| - static void
|
| - Ins_IP( INS_ARG )
|
| - {
|
| - FT_F26Dot6 old_range, cur_range;
|
| - FT_Vector* orus_base;
|
| - FT_Vector* cur_base;
|
| - FT_Int twilight;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| - if ( CUR.top < CUR.GS.loop )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.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 CUR.twilight.orus[n] is (0,0),
|
| - * for every n.
|
| - */
|
| - twilight = CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 || CUR.GS.gep2 == 0;
|
| -
|
| - if ( BOUNDS( CUR.GS.rp1, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto Fail;
|
| - }
|
| -
|
| - if ( twilight )
|
| - orus_base = &CUR.zp0.org[CUR.GS.rp1];
|
| - else
|
| - orus_base = &CUR.zp0.orus[CUR.GS.rp1];
|
| -
|
| - cur_base = &CUR.zp0.cur[CUR.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( CUR.GS.rp1, CUR.zp0.n_points ) ||
|
| - BOUNDS( CUR.GS.rp2, CUR.zp1.n_points ) )
|
| - {
|
| - old_range = 0;
|
| - cur_range = 0;
|
| - }
|
| - else
|
| - {
|
| - if ( twilight )
|
| - old_range = CUR_Func_dualproj( &CUR.zp1.org[CUR.GS.rp2],
|
| - orus_base );
|
| - else if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
|
| - old_range = CUR_Func_dualproj( &CUR.zp1.orus[CUR.GS.rp2],
|
| - orus_base );
|
| - else
|
| - {
|
| - FT_Vector vec;
|
| -
|
| -
|
| - vec.x = FT_MulFix( CUR.zp1.orus[CUR.GS.rp2].x - orus_base->x,
|
| - CUR.metrics.x_scale );
|
| - vec.y = FT_MulFix( CUR.zp1.orus[CUR.GS.rp2].y - orus_base->y,
|
| - CUR.metrics.y_scale );
|
| -
|
| - old_range = CUR_fast_dualproj( &vec );
|
| - }
|
| -
|
| - cur_range = CUR_Func_project ( &CUR.zp1.cur[CUR.GS.rp2], cur_base );
|
| - }
|
| -
|
| - for ( ; CUR.GS.loop > 0; --CUR.GS.loop )
|
| - {
|
| - FT_UInt point = (FT_UInt)CUR.stack[--CUR.args];
|
| - FT_F26Dot6 org_dist, cur_dist, new_dist;
|
| -
|
| -
|
| - /* check point bounds */
|
| - if ( BOUNDS( point, CUR.zp2.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| - continue;
|
| - }
|
| -
|
| - if ( twilight )
|
| - org_dist = CUR_Func_dualproj( &CUR.zp2.org[point], orus_base );
|
| - else if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
|
| - org_dist = CUR_Func_dualproj( &CUR.zp2.orus[point], orus_base );
|
| - else
|
| - {
|
| - FT_Vector vec;
|
| -
|
| -
|
| - vec.x = FT_MulFix( CUR.zp2.orus[point].x - orus_base->x,
|
| - CUR.metrics.x_scale );
|
| - vec.y = FT_MulFix( CUR.zp2.orus[point].y - orus_base->y,
|
| - CUR.metrics.y_scale );
|
| -
|
| - org_dist = CUR_fast_dualproj( &vec );
|
| - }
|
| -
|
| - cur_dist = CUR_Func_project ( &CUR.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: */
|
| - /* */
|
| - /* new_dist = cur_dist - */
|
| - /* org_dist - cur_dist; */
|
| -
|
| - new_dist = -org_dist;
|
| - }
|
| - }
|
| - else
|
| - new_dist = 0;
|
| -
|
| - CUR_Func_move( &CUR.zp2, (FT_UShort)point, new_dist - cur_dist );
|
| - }
|
| -
|
| - Fail:
|
| - CUR.GS.loop = 1;
|
| - CUR.new_top = CUR.args;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* UTP[a]: UnTouch Point */
|
| - /* Opcode range: 0x29 */
|
| - /* Stack: uint32 --> */
|
| - /* */
|
| - static void
|
| - Ins_UTP( INS_ARG )
|
| - {
|
| - FT_UShort point;
|
| - FT_Byte mask;
|
| -
|
| -
|
| - point = (FT_UShort)args[0];
|
| -
|
| - if ( BOUNDS( point, CUR.zp0.n_points ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| -
|
| - mask = 0xFF;
|
| -
|
| - if ( CUR.GS.freeVector.x != 0 )
|
| - mask &= ~FT_CURVE_TAG_TOUCH_X;
|
| -
|
| - if ( CUR.GS.freeVector.y != 0 )
|
| - mask &= ~FT_CURVE_TAG_TOUCH_Y;
|
| -
|
| - CUR.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 = worker->curs[p].x - worker->orgs[p].x;
|
| - if ( dx != 0 )
|
| - {
|
| - for ( i = p1; i < p; i++ )
|
| - worker->curs[i].x += dx;
|
| -
|
| - for ( i = p + 1; i <= p2; i++ )
|
| - 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, 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;
|
| - delta1 = worker->curs[ref1].x - org1;
|
| - delta2 = worker->curs[ref2].x - org2;
|
| -
|
| - if ( orus1 == orus2 )
|
| - {
|
| - /* simple shift of untouched points */
|
| - for ( i = p1; i <= p2; i++ )
|
| - {
|
| - FT_F26Dot6 x = worker->orgs[i].x;
|
| -
|
| -
|
| - if ( x <= org1 )
|
| - x += delta1;
|
| - else
|
| - x += delta2;
|
| -
|
| - 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 += delta1;
|
| -
|
| - else if ( x >= org2 )
|
| - x += delta2;
|
| -
|
| - else
|
| - {
|
| - if ( !scale_valid )
|
| - {
|
| - scale_valid = 1;
|
| - scale = FT_DivFix( org2 + delta2 - ( org1 + delta1 ),
|
| - orus2 - orus1 );
|
| - }
|
| -
|
| - x = ( org1 + delta1 ) +
|
| - FT_MulFix( 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( INS_ARG )
|
| - {
|
| - 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 */
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| - /* ignore empty outlines */
|
| - if ( CUR.pts.n_contours == 0 )
|
| - return;
|
| -
|
| - if ( CUR.opcode & 1 )
|
| - {
|
| - mask = FT_CURVE_TAG_TOUCH_X;
|
| - V.orgs = CUR.pts.org;
|
| - V.curs = CUR.pts.cur;
|
| - V.orus = CUR.pts.orus;
|
| - }
|
| - else
|
| - {
|
| - mask = FT_CURVE_TAG_TOUCH_Y;
|
| - V.orgs = (FT_Vector*)( (FT_Pos*)CUR.pts.org + 1 );
|
| - V.curs = (FT_Vector*)( (FT_Pos*)CUR.pts.cur + 1 );
|
| - V.orus = (FT_Vector*)( (FT_Pos*)CUR.pts.orus + 1 );
|
| - }
|
| - V.max_points = CUR.pts.n_points;
|
| -
|
| - contour = 0;
|
| - point = 0;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode )
|
| - {
|
| - CUR.iup_called = TRUE;
|
| - if ( CUR.sph_tweak_flags & SPH_TWEAK_SKIP_IUP )
|
| - return;
|
| - }
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - do
|
| - {
|
| - end_point = CUR.pts.contours[contour] - CUR.pts.first_point;
|
| - first_point = point;
|
| -
|
| - if ( BOUNDS ( end_point, CUR.pts.n_points ) )
|
| - end_point = CUR.pts.n_points - 1;
|
| -
|
| - while ( point <= end_point && ( CUR.pts.tags[point] & mask ) == 0 )
|
| - point++;
|
| -
|
| - if ( point <= end_point )
|
| - {
|
| - first_touched = point;
|
| - cur_touched = point;
|
| -
|
| - point++;
|
| -
|
| - while ( point <= end_point )
|
| - {
|
| - if ( ( CUR.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 < CUR.pts.n_contours );
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* DELTAPn[]: DELTA exceptions P1, P2, P3 */
|
| - /* Opcode range: 0x5D,0x71,0x72 */
|
| - /* Stack: uint32 (2 * uint32)... --> */
|
| - /* */
|
| - static void
|
| - Ins_DELTAP( INS_ARG )
|
| - {
|
| - FT_ULong k, nump;
|
| - FT_UShort A;
|
| - FT_ULong C;
|
| - FT_Long B;
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - FT_UShort B1, B2;
|
| -
|
| -
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.iup_called &&
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_NO_DELTAP_AFTER_IUP ) )
|
| - goto Fail;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - /* Delta hinting is covered by US Patent 5159668. */
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - FT_Long n = args[0] * 2;
|
| -
|
| -
|
| - if ( CUR.args < n )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Too_Few_Arguments );
|
| - n = CUR.args;
|
| - }
|
| -
|
| - CUR.args -= n;
|
| - CUR.new_top = CUR.args;
|
| - return;
|
| - }
|
| -#endif
|
| -
|
| - 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 ( CUR.args < 2 )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Too_Few_Arguments );
|
| - CUR.args = 0;
|
| - goto Fail;
|
| - }
|
| -
|
| - CUR.args -= 2;
|
| -
|
| - A = (FT_UShort)CUR.stack[CUR.args + 1];
|
| - B = CUR.stack[CUR.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, CUR.zp0.n_points ) )
|
| - {
|
| - C = ( (FT_ULong)B & 0xF0 ) >> 4;
|
| -
|
| - switch ( CUR.opcode )
|
| - {
|
| - case 0x5D:
|
| - break;
|
| -
|
| - case 0x71:
|
| - C += 16;
|
| - break;
|
| -
|
| - case 0x72:
|
| - C += 32;
|
| - break;
|
| - }
|
| -
|
| - C += CUR.GS.delta_base;
|
| -
|
| - if ( CURRENT_Ppem() == (FT_Long)C )
|
| - {
|
| - B = ( (FT_ULong)B & 0xF ) - 8;
|
| - if ( B >= 0 )
|
| - B++;
|
| - B = B * 64 / ( 1L << CUR.GS.delta_shift );
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| -
|
| - if ( SUBPIXEL_HINTING )
|
| - {
|
| - /*
|
| - * Allow delta move if
|
| - *
|
| - * - not using ignore_x_mode rendering
|
| - * - glyph is specifically set to allow it
|
| - * - glyph is composite and freedom vector is not subpixel
|
| - * vector
|
| - */
|
| - if ( !CUR.ignore_x_mode ||
|
| - ( CUR.sph_tweak_flags & SPH_TWEAK_ALWAYS_DO_DELTAP ) ||
|
| - ( CUR.is_composite && CUR.GS.freeVector.y != 0 ) )
|
| - CUR_Func_move( &CUR.zp0, A, B );
|
| -
|
| - /* Otherwise apply subpixel hinting and */
|
| - /* compatibility mode rules */
|
| - else if ( CUR.ignore_x_mode )
|
| - {
|
| - if ( CUR.GS.freeVector.y != 0 )
|
| - B1 = CUR.zp0.cur[A].y;
|
| - else
|
| - B1 = CUR.zp0.cur[A].x;
|
| -
|
| -#if 0
|
| - /* Standard Subpixel Hinting: Allow y move. */
|
| - /* This messes up dejavu and may not be needed... */
|
| - if ( !CUR.face->sph_compatibility_mode &&
|
| - CUR.GS.freeVector.y != 0 )
|
| - CUR_Func_move( &CUR.zp0, A, B );
|
| - else
|
| -#endif /* 0 */
|
| -
|
| - /* Compatibility Mode: Allow x or y move if point touched in */
|
| - /* Y direction. */
|
| - if ( CUR.face->sph_compatibility_mode &&
|
| - !( CUR.sph_tweak_flags & SPH_TWEAK_ALWAYS_SKIP_DELTAP ) )
|
| - {
|
| - /* save the y value of the point now; compare after move */
|
| - B1 = CUR.zp0.cur[A].y;
|
| -
|
| - if ( CUR.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 ( !CUR.iup_called &&
|
| - ( CUR.zp0.tags[A] & FT_CURVE_TAG_TOUCH_Y ) )
|
| - CUR_Func_move( &CUR.zp0, A, B );
|
| - }
|
| -
|
| - B2 = CUR.zp0.cur[A].y;
|
| -
|
| - /* Reverse this move if it results in a disallowed move */
|
| - if ( CUR.GS.freeVector.y != 0 &&
|
| - ( ( CUR.face->sph_compatibility_mode &&
|
| - ( B1 & 63 ) == 0 &&
|
| - ( B2 & 63 ) != 0 ) ||
|
| - ( ( CUR.sph_tweak_flags &
|
| - SPH_TWEAK_SKIP_NONPIXEL_Y_MOVES_DELTAP ) &&
|
| - ( B1 & 63 ) != 0 &&
|
| - ( B2 & 63 ) != 0 ) ) )
|
| - CUR_Func_move( &CUR.zp0, A, -B );
|
| - }
|
| - }
|
| - else
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - CUR_Func_move( &CUR.zp0, A, B );
|
| - }
|
| - }
|
| - else
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - }
|
| -
|
| - Fail:
|
| - CUR.new_top = CUR.args;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* DELTACn[]: DELTA exceptions C1, C2, C3 */
|
| - /* Opcode range: 0x73,0x74,0x75 */
|
| - /* Stack: uint32 (2 * uint32)... --> */
|
| - /* */
|
| - static void
|
| - Ins_DELTAC( INS_ARG )
|
| - {
|
| - FT_ULong nump, k;
|
| - FT_ULong A, C;
|
| - FT_Long B;
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
|
| - /* Delta hinting is covered by US Patent 5159668. */
|
| - if ( CUR.face->unpatented_hinting )
|
| - {
|
| - FT_Long n = args[0] * 2;
|
| -
|
| -
|
| - if ( CUR.args < n )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Too_Few_Arguments );
|
| - n = CUR.args;
|
| - }
|
| -
|
| - CUR.args -= n;
|
| - CUR.new_top = CUR.args;
|
| - return;
|
| - }
|
| -#endif
|
| -
|
| - nump = (FT_ULong)args[0];
|
| -
|
| - for ( k = 1; k <= nump; k++ )
|
| - {
|
| - if ( CUR.args < 2 )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - CUR.error = FT_THROW( Too_Few_Arguments );
|
| - CUR.args = 0;
|
| - goto Fail;
|
| - }
|
| -
|
| - CUR.args -= 2;
|
| -
|
| - A = (FT_ULong)CUR.stack[CUR.args + 1];
|
| - B = CUR.stack[CUR.args];
|
| -
|
| - if ( BOUNDSL( A, CUR.cvtSize ) )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - return;
|
| - }
|
| - }
|
| - else
|
| - {
|
| - C = ( (FT_ULong)B & 0xF0 ) >> 4;
|
| -
|
| - switch ( CUR.opcode )
|
| - {
|
| - case 0x73:
|
| - break;
|
| -
|
| - case 0x74:
|
| - C += 16;
|
| - break;
|
| -
|
| - case 0x75:
|
| - C += 32;
|
| - break;
|
| - }
|
| -
|
| - C += CUR.GS.delta_base;
|
| -
|
| - if ( CURRENT_Ppem() == (FT_Long)C )
|
| - {
|
| - B = ( (FT_ULong)B & 0xF ) - 8;
|
| - if ( B >= 0 )
|
| - B++;
|
| - B = B * 64 / ( 1L << CUR.GS.delta_shift );
|
| -
|
| - CUR_Func_move_cvt( A, B );
|
| - }
|
| - }
|
| - }
|
| -
|
| - Fail:
|
| - CUR.new_top = CUR.args;
|
| - }
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* MISC. INSTRUCTIONS */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* GETINFO[]: GET INFOrmation */
|
| - /* Opcode range: 0x88 */
|
| - /* Stack: uint32 --> uint32 */
|
| - /* */
|
| - static void
|
| - Ins_GETINFO( INS_ARG )
|
| - {
|
| - FT_Long K;
|
| -
|
| -
|
| - K = 0;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - /********************************/
|
| - /* RASTERIZER VERSION */
|
| - /* Selector Bit: 0 */
|
| - /* Return Bit(s): 0-7 */
|
| - /* */
|
| - if ( SUBPIXEL_HINTING &&
|
| - ( args[0] & 1 ) != 0 &&
|
| - CUR.ignore_x_mode )
|
| - {
|
| - K = CUR.rasterizer_version;
|
| - FT_TRACE7(( "Setting rasterizer version %d\n",
|
| - CUR.rasterizer_version ));
|
| - }
|
| - else
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| - if ( ( args[0] & 1 ) != 0 )
|
| - K = TT_INTERPRETER_VERSION_35;
|
| -
|
| - /********************************/
|
| - /* GLYPH ROTATED */
|
| - /* Selector Bit: 1 */
|
| - /* Return Bit(s): 8 */
|
| - /* */
|
| - if ( ( args[0] & 2 ) != 0 && CUR.tt_metrics.rotated )
|
| - K |= 0x80;
|
| -
|
| - /********************************/
|
| - /* GLYPH STRETCHED */
|
| - /* Selector Bit: 2 */
|
| - /* Return Bit(s): 9 */
|
| - /* */
|
| - if ( ( args[0] & 4 ) != 0 && CUR.tt_metrics.stretched )
|
| - K |= 1 << 8;
|
| -
|
| - /********************************/
|
| - /* HINTING FOR GRAYSCALE */
|
| - /* Selector Bit: 5 */
|
| - /* Return Bit(s): 12 */
|
| - /* */
|
| - if ( ( args[0] & 32 ) != 0 && CUR.grayscale )
|
| - K |= 1 << 12;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| -
|
| - if ( SUBPIXEL_HINTING &&
|
| - CUR.ignore_x_mode &&
|
| - CUR.rasterizer_version >= TT_INTERPRETER_VERSION_35 )
|
| - {
|
| - /********************************/
|
| - /* HINTING FOR GRAYSCALE */
|
| - /* Selector Bit: 5 */
|
| - /* Return Bit(s): 12 */
|
| - /* */
|
| - if ( ( args[0] & 32 ) != 0 && CUR.grayscale_hinting )
|
| - K |= 1 << 12;
|
| -
|
| - /********************************/
|
| - /* HINTING FOR SUBPIXEL */
|
| - /* Selector Bit: 6 */
|
| - /* Return Bit(s): 13 */
|
| - /* */
|
| - if ( ( args[0] & 64 ) != 0 &&
|
| - CUR.subpixel_hinting &&
|
| - CUR.rasterizer_version >= 37 )
|
| - {
|
| - K |= 1 << 13;
|
| -
|
| - /* the stuff below is irrelevant if subpixel_hinting is not set */
|
| -
|
| - /********************************/
|
| - /* COMPATIBLE WIDTHS ENABLED */
|
| - /* Selector Bit: 7 */
|
| - /* Return Bit(s): 14 */
|
| - /* */
|
| - /* Functionality still needs to be added */
|
| - if ( ( args[0] & 128 ) != 0 && CUR.compatible_widths )
|
| - K |= 1 << 14;
|
| -
|
| - /********************************/
|
| - /* SYMMETRICAL SMOOTHING */
|
| - /* Selector Bit: 8 */
|
| - /* Return Bit(s): 15 */
|
| - /* */
|
| - /* Functionality still needs to be added */
|
| - if ( ( args[0] & 256 ) != 0 && CUR.symmetrical_smoothing )
|
| - K |= 1 << 15;
|
| -
|
| - /********************************/
|
| - /* HINTING FOR BGR? */
|
| - /* Selector Bit: 9 */
|
| - /* Return Bit(s): 16 */
|
| - /* */
|
| - /* Functionality still needs to be added */
|
| - if ( ( args[0] & 512 ) != 0 && CUR.bgr )
|
| - K |= 1 << 16;
|
| -
|
| - if ( CUR.rasterizer_version >= 38 )
|
| - {
|
| - /********************************/
|
| - /* SUBPIXEL POSITIONED? */
|
| - /* Selector Bit: 10 */
|
| - /* Return Bit(s): 17 */
|
| - /* */
|
| - /* Functionality still needs to be added */
|
| - if ( ( args[0] & 1024 ) != 0 && CUR.subpixel_positioned )
|
| - K |= 1 << 17;
|
| - }
|
| - }
|
| - }
|
| -
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - args[0] = K;
|
| - }
|
| -
|
| -
|
| - static void
|
| - Ins_UNKNOWN( INS_ARG )
|
| - {
|
| - TT_DefRecord* def = CUR.IDefs;
|
| - TT_DefRecord* limit = def + CUR.numIDefs;
|
| -
|
| - FT_UNUSED_ARG;
|
| -
|
| -
|
| - for ( ; def < limit; def++ )
|
| - {
|
| - if ( (FT_Byte)def->opc == CUR.opcode && def->active )
|
| - {
|
| - TT_CallRec* call;
|
| -
|
| -
|
| - if ( CUR.callTop >= CUR.callSize )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - return;
|
| - }
|
| -
|
| - call = CUR.callStack + CUR.callTop++;
|
| -
|
| - call->Caller_Range = CUR.curRange;
|
| - call->Caller_IP = CUR.IP + 1;
|
| - call->Cur_Count = 1;
|
| - call->Cur_Restart = def->start;
|
| - call->Cur_End = def->end;
|
| -
|
| - INS_Goto_CodeRange( def->range, def->start );
|
| -
|
| - CUR.step_ins = FALSE;
|
| - return;
|
| - }
|
| - }
|
| -
|
| - CUR.error = FT_THROW( Invalid_Opcode );
|
| - }
|
| -
|
| -
|
| -#ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
|
| -
|
| -
|
| - static
|
| - TInstruction_Function Instruct_Dispatch[256] =
|
| - {
|
| - /* Opcodes are gathered in groups of 16. */
|
| - /* Please keep the spaces as they are. */
|
| -
|
| - /* SVTCA y */ Ins_SVTCA,
|
| - /* SVTCA x */ Ins_SVTCA,
|
| - /* SPvTCA y */ Ins_SPVTCA,
|
| - /* SPvTCA x */ Ins_SPVTCA,
|
| - /* SFvTCA y */ Ins_SFVTCA,
|
| - /* SFvTCA x */ Ins_SFVTCA,
|
| - /* SPvTL // */ Ins_SPVTL,
|
| - /* SPvTL + */ Ins_SPVTL,
|
| - /* SFvTL // */ Ins_SFVTL,
|
| - /* SFvTL + */ Ins_SFVTL,
|
| - /* SPvFS */ Ins_SPVFS,
|
| - /* SFvFS */ Ins_SFVFS,
|
| - /* GPV */ Ins_GPV,
|
| - /* GFV */ Ins_GFV,
|
| - /* SFvTPv */ Ins_SFVTPV,
|
| - /* ISECT */ Ins_ISECT,
|
| -
|
| - /* SRP0 */ Ins_SRP0,
|
| - /* SRP1 */ Ins_SRP1,
|
| - /* SRP2 */ Ins_SRP2,
|
| - /* SZP0 */ Ins_SZP0,
|
| - /* SZP1 */ Ins_SZP1,
|
| - /* SZP2 */ Ins_SZP2,
|
| - /* SZPS */ Ins_SZPS,
|
| - /* SLOOP */ Ins_SLOOP,
|
| - /* RTG */ Ins_RTG,
|
| - /* RTHG */ Ins_RTHG,
|
| - /* SMD */ Ins_SMD,
|
| - /* ELSE */ Ins_ELSE,
|
| - /* JMPR */ Ins_JMPR,
|
| - /* SCvTCi */ Ins_SCVTCI,
|
| - /* SSwCi */ Ins_SSWCI,
|
| - /* SSW */ Ins_SSW,
|
| -
|
| - /* DUP */ Ins_DUP,
|
| - /* POP */ Ins_POP,
|
| - /* CLEAR */ Ins_CLEAR,
|
| - /* SWAP */ Ins_SWAP,
|
| - /* DEPTH */ Ins_DEPTH,
|
| - /* CINDEX */ Ins_CINDEX,
|
| - /* MINDEX */ Ins_MINDEX,
|
| - /* AlignPTS */ Ins_ALIGNPTS,
|
| - /* INS_0x28 */ Ins_UNKNOWN,
|
| - /* UTP */ Ins_UTP,
|
| - /* LOOPCALL */ Ins_LOOPCALL,
|
| - /* CALL */ Ins_CALL,
|
| - /* FDEF */ Ins_FDEF,
|
| - /* ENDF */ Ins_ENDF,
|
| - /* MDAP[0] */ Ins_MDAP,
|
| - /* MDAP[1] */ Ins_MDAP,
|
| -
|
| - /* IUP[0] */ Ins_IUP,
|
| - /* IUP[1] */ Ins_IUP,
|
| - /* SHP[0] */ Ins_SHP,
|
| - /* SHP[1] */ Ins_SHP,
|
| - /* SHC[0] */ Ins_SHC,
|
| - /* SHC[1] */ Ins_SHC,
|
| - /* SHZ[0] */ Ins_SHZ,
|
| - /* SHZ[1] */ Ins_SHZ,
|
| - /* SHPIX */ Ins_SHPIX,
|
| - /* IP */ Ins_IP,
|
| - /* MSIRP[0] */ Ins_MSIRP,
|
| - /* MSIRP[1] */ Ins_MSIRP,
|
| - /* AlignRP */ Ins_ALIGNRP,
|
| - /* RTDG */ Ins_RTDG,
|
| - /* MIAP[0] */ Ins_MIAP,
|
| - /* MIAP[1] */ Ins_MIAP,
|
| -
|
| - /* NPushB */ Ins_NPUSHB,
|
| - /* NPushW */ Ins_NPUSHW,
|
| - /* WS */ Ins_WS,
|
| - /* RS */ Ins_RS,
|
| - /* WCvtP */ Ins_WCVTP,
|
| - /* RCvt */ Ins_RCVT,
|
| - /* GC[0] */ Ins_GC,
|
| - /* GC[1] */ Ins_GC,
|
| - /* SCFS */ Ins_SCFS,
|
| - /* MD[0] */ Ins_MD,
|
| - /* MD[1] */ Ins_MD,
|
| - /* MPPEM */ Ins_MPPEM,
|
| - /* MPS */ Ins_MPS,
|
| - /* FlipON */ Ins_FLIPON,
|
| - /* FlipOFF */ Ins_FLIPOFF,
|
| - /* DEBUG */ Ins_DEBUG,
|
| -
|
| - /* LT */ Ins_LT,
|
| - /* LTEQ */ Ins_LTEQ,
|
| - /* GT */ Ins_GT,
|
| - /* GTEQ */ Ins_GTEQ,
|
| - /* EQ */ Ins_EQ,
|
| - /* NEQ */ Ins_NEQ,
|
| - /* ODD */ Ins_ODD,
|
| - /* EVEN */ Ins_EVEN,
|
| - /* IF */ Ins_IF,
|
| - /* EIF */ Ins_EIF,
|
| - /* AND */ Ins_AND,
|
| - /* OR */ Ins_OR,
|
| - /* NOT */ Ins_NOT,
|
| - /* DeltaP1 */ Ins_DELTAP,
|
| - /* SDB */ Ins_SDB,
|
| - /* SDS */ Ins_SDS,
|
| -
|
| - /* ADD */ Ins_ADD,
|
| - /* SUB */ Ins_SUB,
|
| - /* DIV */ Ins_DIV,
|
| - /* MUL */ Ins_MUL,
|
| - /* ABS */ Ins_ABS,
|
| - /* NEG */ Ins_NEG,
|
| - /* FLOOR */ Ins_FLOOR,
|
| - /* CEILING */ Ins_CEILING,
|
| - /* ROUND[0] */ Ins_ROUND,
|
| - /* ROUND[1] */ Ins_ROUND,
|
| - /* ROUND[2] */ Ins_ROUND,
|
| - /* ROUND[3] */ Ins_ROUND,
|
| - /* NROUND[0] */ Ins_NROUND,
|
| - /* NROUND[1] */ Ins_NROUND,
|
| - /* NROUND[2] */ Ins_NROUND,
|
| - /* NROUND[3] */ Ins_NROUND,
|
| -
|
| - /* WCvtF */ Ins_WCVTF,
|
| - /* DeltaP2 */ Ins_DELTAP,
|
| - /* DeltaP3 */ Ins_DELTAP,
|
| - /* DeltaCn[0] */ Ins_DELTAC,
|
| - /* DeltaCn[1] */ Ins_DELTAC,
|
| - /* DeltaCn[2] */ Ins_DELTAC,
|
| - /* SROUND */ Ins_SROUND,
|
| - /* S45Round */ Ins_S45ROUND,
|
| - /* JROT */ Ins_JROT,
|
| - /* JROF */ Ins_JROF,
|
| - /* ROFF */ Ins_ROFF,
|
| - /* INS_0x7B */ Ins_UNKNOWN,
|
| - /* RUTG */ Ins_RUTG,
|
| - /* RDTG */ Ins_RDTG,
|
| - /* SANGW */ Ins_SANGW,
|
| - /* AA */ Ins_AA,
|
| -
|
| - /* FlipPT */ Ins_FLIPPT,
|
| - /* FlipRgON */ Ins_FLIPRGON,
|
| - /* FlipRgOFF */ Ins_FLIPRGOFF,
|
| - /* INS_0x83 */ Ins_UNKNOWN,
|
| - /* INS_0x84 */ Ins_UNKNOWN,
|
| - /* ScanCTRL */ Ins_SCANCTRL,
|
| - /* SDPVTL[0] */ Ins_SDPVTL,
|
| - /* SDPVTL[1] */ Ins_SDPVTL,
|
| - /* GetINFO */ Ins_GETINFO,
|
| - /* IDEF */ Ins_IDEF,
|
| - /* ROLL */ Ins_ROLL,
|
| - /* MAX */ Ins_MAX,
|
| - /* MIN */ Ins_MIN,
|
| - /* ScanTYPE */ Ins_SCANTYPE,
|
| - /* InstCTRL */ Ins_INSTCTRL,
|
| - /* INS_0x8F */ Ins_UNKNOWN,
|
| -
|
| - /* INS_0x90 */ Ins_UNKNOWN,
|
| - /* INS_0x91 */ Ins_UNKNOWN,
|
| - /* INS_0x92 */ Ins_UNKNOWN,
|
| - /* INS_0x93 */ Ins_UNKNOWN,
|
| - /* INS_0x94 */ Ins_UNKNOWN,
|
| - /* INS_0x95 */ Ins_UNKNOWN,
|
| - /* INS_0x96 */ Ins_UNKNOWN,
|
| - /* INS_0x97 */ Ins_UNKNOWN,
|
| - /* INS_0x98 */ Ins_UNKNOWN,
|
| - /* INS_0x99 */ Ins_UNKNOWN,
|
| - /* INS_0x9A */ Ins_UNKNOWN,
|
| - /* INS_0x9B */ Ins_UNKNOWN,
|
| - /* INS_0x9C */ Ins_UNKNOWN,
|
| - /* INS_0x9D */ Ins_UNKNOWN,
|
| - /* INS_0x9E */ Ins_UNKNOWN,
|
| - /* INS_0x9F */ Ins_UNKNOWN,
|
| -
|
| - /* INS_0xA0 */ Ins_UNKNOWN,
|
| - /* INS_0xA1 */ Ins_UNKNOWN,
|
| - /* INS_0xA2 */ Ins_UNKNOWN,
|
| - /* INS_0xA3 */ Ins_UNKNOWN,
|
| - /* INS_0xA4 */ Ins_UNKNOWN,
|
| - /* INS_0xA5 */ Ins_UNKNOWN,
|
| - /* INS_0xA6 */ Ins_UNKNOWN,
|
| - /* INS_0xA7 */ Ins_UNKNOWN,
|
| - /* INS_0xA8 */ Ins_UNKNOWN,
|
| - /* INS_0xA9 */ Ins_UNKNOWN,
|
| - /* INS_0xAA */ Ins_UNKNOWN,
|
| - /* INS_0xAB */ Ins_UNKNOWN,
|
| - /* INS_0xAC */ Ins_UNKNOWN,
|
| - /* INS_0xAD */ Ins_UNKNOWN,
|
| - /* INS_0xAE */ Ins_UNKNOWN,
|
| - /* INS_0xAF */ Ins_UNKNOWN,
|
| -
|
| - /* PushB[0] */ Ins_PUSHB,
|
| - /* PushB[1] */ Ins_PUSHB,
|
| - /* PushB[2] */ Ins_PUSHB,
|
| - /* PushB[3] */ Ins_PUSHB,
|
| - /* PushB[4] */ Ins_PUSHB,
|
| - /* PushB[5] */ Ins_PUSHB,
|
| - /* PushB[6] */ Ins_PUSHB,
|
| - /* PushB[7] */ Ins_PUSHB,
|
| - /* PushW[0] */ Ins_PUSHW,
|
| - /* PushW[1] */ Ins_PUSHW,
|
| - /* PushW[2] */ Ins_PUSHW,
|
| - /* PushW[3] */ Ins_PUSHW,
|
| - /* PushW[4] */ Ins_PUSHW,
|
| - /* PushW[5] */ Ins_PUSHW,
|
| - /* PushW[6] */ Ins_PUSHW,
|
| - /* PushW[7] */ Ins_PUSHW,
|
| -
|
| - /* MDRP[00] */ Ins_MDRP,
|
| - /* MDRP[01] */ Ins_MDRP,
|
| - /* MDRP[02] */ Ins_MDRP,
|
| - /* MDRP[03] */ Ins_MDRP,
|
| - /* MDRP[04] */ Ins_MDRP,
|
| - /* MDRP[05] */ Ins_MDRP,
|
| - /* MDRP[06] */ Ins_MDRP,
|
| - /* MDRP[07] */ Ins_MDRP,
|
| - /* MDRP[08] */ Ins_MDRP,
|
| - /* MDRP[09] */ Ins_MDRP,
|
| - /* MDRP[10] */ Ins_MDRP,
|
| - /* MDRP[11] */ Ins_MDRP,
|
| - /* MDRP[12] */ Ins_MDRP,
|
| - /* MDRP[13] */ Ins_MDRP,
|
| - /* MDRP[14] */ Ins_MDRP,
|
| - /* MDRP[15] */ Ins_MDRP,
|
| -
|
| - /* MDRP[16] */ Ins_MDRP,
|
| - /* MDRP[17] */ Ins_MDRP,
|
| - /* MDRP[18] */ Ins_MDRP,
|
| - /* MDRP[19] */ Ins_MDRP,
|
| - /* MDRP[20] */ Ins_MDRP,
|
| - /* MDRP[21] */ Ins_MDRP,
|
| - /* MDRP[22] */ Ins_MDRP,
|
| - /* MDRP[23] */ Ins_MDRP,
|
| - /* MDRP[24] */ Ins_MDRP,
|
| - /* MDRP[25] */ Ins_MDRP,
|
| - /* MDRP[26] */ Ins_MDRP,
|
| - /* MDRP[27] */ Ins_MDRP,
|
| - /* MDRP[28] */ Ins_MDRP,
|
| - /* MDRP[29] */ Ins_MDRP,
|
| - /* MDRP[30] */ Ins_MDRP,
|
| - /* MDRP[31] */ Ins_MDRP,
|
| -
|
| - /* MIRP[00] */ Ins_MIRP,
|
| - /* MIRP[01] */ Ins_MIRP,
|
| - /* MIRP[02] */ Ins_MIRP,
|
| - /* MIRP[03] */ Ins_MIRP,
|
| - /* MIRP[04] */ Ins_MIRP,
|
| - /* MIRP[05] */ Ins_MIRP,
|
| - /* MIRP[06] */ Ins_MIRP,
|
| - /* MIRP[07] */ Ins_MIRP,
|
| - /* MIRP[08] */ Ins_MIRP,
|
| - /* MIRP[09] */ Ins_MIRP,
|
| - /* MIRP[10] */ Ins_MIRP,
|
| - /* MIRP[11] */ Ins_MIRP,
|
| - /* MIRP[12] */ Ins_MIRP,
|
| - /* MIRP[13] */ Ins_MIRP,
|
| - /* MIRP[14] */ Ins_MIRP,
|
| - /* MIRP[15] */ Ins_MIRP,
|
| -
|
| - /* MIRP[16] */ Ins_MIRP,
|
| - /* MIRP[17] */ Ins_MIRP,
|
| - /* MIRP[18] */ Ins_MIRP,
|
| - /* MIRP[19] */ Ins_MIRP,
|
| - /* MIRP[20] */ Ins_MIRP,
|
| - /* MIRP[21] */ Ins_MIRP,
|
| - /* MIRP[22] */ Ins_MIRP,
|
| - /* MIRP[23] */ Ins_MIRP,
|
| - /* MIRP[24] */ Ins_MIRP,
|
| - /* MIRP[25] */ Ins_MIRP,
|
| - /* MIRP[26] */ Ins_MIRP,
|
| - /* MIRP[27] */ Ins_MIRP,
|
| - /* MIRP[28] */ Ins_MIRP,
|
| - /* MIRP[29] */ Ins_MIRP,
|
| - /* MIRP[30] */ Ins_MIRP,
|
| - /* MIRP[31] */ Ins_MIRP
|
| - };
|
| -
|
| -
|
| -#endif /* !TT_CONFIG_OPTION_INTERPRETER_SWITCH */
|
| -
|
| -
|
| - /*************************************************************************/
|
| - /* */
|
| - /* 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. */
|
| - /* */
|
| - /* Instructions appear in the specification's order. */
|
| - /* */
|
| - /*************************************************************************/
|
| -
|
| -
|
| - /* documentation is in ttinterp.h */
|
| -
|
| - FT_EXPORT_DEF( FT_Error )
|
| - TT_RunIns( TT_ExecContext exc )
|
| - {
|
| - FT_Long ins_counter = 0; /* executed instructions counter */
|
| - FT_UShort i;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - 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_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -
|
| -#ifdef TT_CONFIG_OPTION_STATIC_RASTER
|
| - cur = *exc;
|
| -#endif
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| - CUR.iup_called = FALSE;
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| - /* set CVT functions */
|
| - CUR.tt_metrics.ratio = 0;
|
| - if ( CUR.metrics.x_ppem != CUR.metrics.y_ppem )
|
| - {
|
| - /* non-square pixels, use the stretched routines */
|
| - CUR.func_read_cvt = Read_CVT_Stretched;
|
| - CUR.func_write_cvt = Write_CVT_Stretched;
|
| - CUR.func_move_cvt = Move_CVT_Stretched;
|
| - }
|
| - else
|
| - {
|
| - /* square pixels, use normal routines */
|
| - CUR.func_read_cvt = Read_CVT;
|
| - CUR.func_write_cvt = Write_CVT;
|
| - CUR.func_move_cvt = Move_CVT;
|
| - }
|
| -
|
| - COMPUTE_Funcs();
|
| - COMPUTE_Round( (FT_Byte)exc->GS.round_state );
|
| -
|
| - do
|
| - {
|
| - CUR.opcode = CUR.code[CUR.IP];
|
| -
|
| - FT_TRACE7(( " " ));
|
| - FT_TRACE7(( opcode_name[CUR.opcode] ));
|
| - FT_TRACE7(( "\n" ));
|
| -
|
| - if ( ( CUR.length = opcode_length[CUR.opcode] ) < 0 )
|
| - {
|
| - if ( CUR.IP + 1 >= CUR.codeSize )
|
| - goto LErrorCodeOverflow_;
|
| -
|
| - CUR.length = 2 - CUR.length * CUR.code[CUR.IP + 1];
|
| - }
|
| -
|
| - if ( CUR.IP + CUR.length > CUR.codeSize )
|
| - goto LErrorCodeOverflow_;
|
| -
|
| - /* First, let's check for empty stack and overflow */
|
| - CUR.args = CUR.top - ( Pop_Push_Count[CUR.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 ( CUR.args < 0 )
|
| - {
|
| - if ( CUR.pedantic_hinting )
|
| - {
|
| - CUR.error = FT_THROW( Too_Few_Arguments );
|
| - goto LErrorLabel_;
|
| - }
|
| -
|
| - /* push zeroes onto the stack */
|
| - for ( i = 0; i < Pop_Push_Count[CUR.opcode] >> 4; i++ )
|
| - CUR.stack[i] = 0;
|
| - CUR.args = 0;
|
| - }
|
| -
|
| - CUR.new_top = CUR.args + ( Pop_Push_Count[CUR.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 ( CUR.new_top > CUR.stackSize )
|
| - {
|
| - CUR.error = FT_THROW( Stack_Overflow );
|
| - goto LErrorLabel_;
|
| - }
|
| -
|
| - CUR.step_ins = TRUE;
|
| - CUR.error = FT_Err_Ok;
|
| -
|
| -#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
|
| -
|
| - if ( SUBPIXEL_HINTING )
|
| - {
|
| - for ( i = 0; i < opcode_patterns; i++ )
|
| - {
|
| - if ( opcode_pointer[i] < opcode_size[i] &&
|
| - CUR.opcode == opcode_pattern[i][opcode_pointer[i]] )
|
| - {
|
| - opcode_pointer[i] += 1;
|
| -
|
| - if ( opcode_pointer[i] == opcode_size[i] )
|
| - {
|
| - FT_TRACE7(( "sph: opcode ptrn: %d, %s %s\n",
|
| - i,
|
| - CUR.face->root.family_name,
|
| - CUR.face->root.style_name ));
|
| -
|
| - switch ( i )
|
| - {
|
| - case 0:
|
| - break;
|
| - }
|
| - opcode_pointer[i] = 0;
|
| - }
|
| - }
|
| - else
|
| - opcode_pointer[i] = 0;
|
| - }
|
| - }
|
| -
|
| -#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
|
| -
|
| -#ifdef TT_CONFIG_OPTION_INTERPRETER_SWITCH
|
| -
|
| - {
|
| - FT_Long* args = CUR.stack + CUR.args;
|
| - FT_Byte opcode = CUR.opcode;
|
| -
|
| -
|
| -#undef ARRAY_BOUND_ERROR
|
| -#define ARRAY_BOUND_ERROR goto Set_Invalid_Ref
|
| -
|
| -
|
| - 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 */
|
| - {
|
| - FT_Short AA, BB;
|
| -
|
| -
|
| - AA = (FT_Short)( ( opcode & 1 ) << 14 );
|
| - BB = (FT_Short)( AA ^ 0x4000 );
|
| -
|
| - if ( opcode < 4 )
|
| - {
|
| - CUR.GS.projVector.x = AA;
|
| - CUR.GS.projVector.y = BB;
|
| -
|
| - CUR.GS.dualVector.x = AA;
|
| - CUR.GS.dualVector.y = BB;
|
| - }
|
| - else
|
| - {
|
| - GUESS_VECTOR( projVector );
|
| - }
|
| -
|
| - if ( ( opcode & 2 ) == 0 )
|
| - {
|
| - CUR.GS.freeVector.x = AA;
|
| - CUR.GS.freeVector.y = BB;
|
| - }
|
| - else
|
| - {
|
| - GUESS_VECTOR( freeVector );
|
| - }
|
| -
|
| - COMPUTE_Funcs();
|
| - }
|
| - break;
|
| -
|
| - case 0x06: /* SPvTL // */
|
| - case 0x07: /* SPvTL + */
|
| - DO_SPVTL
|
| - break;
|
| -
|
| - case 0x08: /* SFvTL // */
|
| - case 0x09: /* SFvTL + */
|
| - DO_SFVTL
|
| - break;
|
| -
|
| - case 0x0A: /* SPvFS */
|
| - DO_SPVFS
|
| - break;
|
| -
|
| - case 0x0B: /* SFvFS */
|
| - DO_SFVFS
|
| - break;
|
| -
|
| - case 0x0C: /* GPV */
|
| - DO_GPV
|
| - break;
|
| -
|
| - case 0x0D: /* GFV */
|
| - DO_GFV
|
| - break;
|
| -
|
| - case 0x0E: /* SFvTPv */
|
| - DO_SFVTPV
|
| - break;
|
| -
|
| - case 0x0F: /* ISECT */
|
| - Ins_ISECT( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x10: /* SRP0 */
|
| - DO_SRP0
|
| - break;
|
| -
|
| - case 0x11: /* SRP1 */
|
| - DO_SRP1
|
| - break;
|
| -
|
| - case 0x12: /* SRP2 */
|
| - DO_SRP2
|
| - break;
|
| -
|
| - case 0x13: /* SZP0 */
|
| - Ins_SZP0( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x14: /* SZP1 */
|
| - Ins_SZP1( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x15: /* SZP2 */
|
| - Ins_SZP2( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x16: /* SZPS */
|
| - Ins_SZPS( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x17: /* SLOOP */
|
| - DO_SLOOP
|
| - break;
|
| -
|
| - case 0x18: /* RTG */
|
| - DO_RTG
|
| - break;
|
| -
|
| - case 0x19: /* RTHG */
|
| - DO_RTHG
|
| - break;
|
| -
|
| - case 0x1A: /* SMD */
|
| - DO_SMD
|
| - break;
|
| -
|
| - case 0x1B: /* ELSE */
|
| - Ins_ELSE( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x1C: /* JMPR */
|
| - DO_JMPR
|
| - break;
|
| -
|
| - case 0x1D: /* SCVTCI */
|
| - DO_SCVTCI
|
| - break;
|
| -
|
| - case 0x1E: /* SSWCI */
|
| - DO_SSWCI
|
| - break;
|
| -
|
| - case 0x1F: /* SSW */
|
| - DO_SSW
|
| - break;
|
| -
|
| - case 0x20: /* DUP */
|
| - DO_DUP
|
| - break;
|
| -
|
| - case 0x21: /* POP */
|
| - /* nothing :-) */
|
| - break;
|
| -
|
| - case 0x22: /* CLEAR */
|
| - DO_CLEAR
|
| - break;
|
| -
|
| - case 0x23: /* SWAP */
|
| - DO_SWAP
|
| - break;
|
| -
|
| - case 0x24: /* DEPTH */
|
| - DO_DEPTH
|
| - break;
|
| -
|
| - case 0x25: /* CINDEX */
|
| - DO_CINDEX
|
| - break;
|
| -
|
| - case 0x26: /* MINDEX */
|
| - Ins_MINDEX( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x27: /* ALIGNPTS */
|
| - Ins_ALIGNPTS( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x28: /* ???? */
|
| - Ins_UNKNOWN( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x29: /* UTP */
|
| - Ins_UTP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x2A: /* LOOPCALL */
|
| - Ins_LOOPCALL( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x2B: /* CALL */
|
| - Ins_CALL( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x2C: /* FDEF */
|
| - Ins_FDEF( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x2D: /* ENDF */
|
| - Ins_ENDF( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x2E: /* MDAP */
|
| - case 0x2F: /* MDAP */
|
| - Ins_MDAP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x30: /* IUP */
|
| - case 0x31: /* IUP */
|
| - Ins_IUP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x32: /* SHP */
|
| - case 0x33: /* SHP */
|
| - Ins_SHP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x34: /* SHC */
|
| - case 0x35: /* SHC */
|
| - Ins_SHC( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x36: /* SHZ */
|
| - case 0x37: /* SHZ */
|
| - Ins_SHZ( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x38: /* SHPIX */
|
| - Ins_SHPIX( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x39: /* IP */
|
| - Ins_IP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x3A: /* MSIRP */
|
| - case 0x3B: /* MSIRP */
|
| - Ins_MSIRP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x3C: /* AlignRP */
|
| - Ins_ALIGNRP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x3D: /* RTDG */
|
| - DO_RTDG
|
| - break;
|
| -
|
| - case 0x3E: /* MIAP */
|
| - case 0x3F: /* MIAP */
|
| - Ins_MIAP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x40: /* NPUSHB */
|
| - Ins_NPUSHB( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x41: /* NPUSHW */
|
| - Ins_NPUSHW( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x42: /* WS */
|
| - DO_WS
|
| - break;
|
| -
|
| - Set_Invalid_Ref:
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - break;
|
| -
|
| - case 0x43: /* RS */
|
| - DO_RS
|
| - break;
|
| -
|
| - case 0x44: /* WCVTP */
|
| - DO_WCVTP
|
| - break;
|
| -
|
| - case 0x45: /* RCVT */
|
| - DO_RCVT
|
| - break;
|
| -
|
| - case 0x46: /* GC */
|
| - case 0x47: /* GC */
|
| - Ins_GC( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x48: /* SCFS */
|
| - Ins_SCFS( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x49: /* MD */
|
| - case 0x4A: /* MD */
|
| - Ins_MD( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x4B: /* MPPEM */
|
| - DO_MPPEM
|
| - break;
|
| -
|
| - case 0x4C: /* MPS */
|
| - DO_MPS
|
| - break;
|
| -
|
| - case 0x4D: /* FLIPON */
|
| - DO_FLIPON
|
| - break;
|
| -
|
| - case 0x4E: /* FLIPOFF */
|
| - DO_FLIPOFF
|
| - break;
|
| -
|
| - case 0x4F: /* DEBUG */
|
| - DO_DEBUG
|
| - break;
|
| -
|
| - case 0x50: /* LT */
|
| - DO_LT
|
| - break;
|
| -
|
| - case 0x51: /* LTEQ */
|
| - DO_LTEQ
|
| - break;
|
| -
|
| - case 0x52: /* GT */
|
| - DO_GT
|
| - break;
|
| -
|
| - case 0x53: /* GTEQ */
|
| - DO_GTEQ
|
| - break;
|
| -
|
| - case 0x54: /* EQ */
|
| - DO_EQ
|
| - break;
|
| -
|
| - case 0x55: /* NEQ */
|
| - DO_NEQ
|
| - break;
|
| -
|
| - case 0x56: /* ODD */
|
| - DO_ODD
|
| - break;
|
| -
|
| - case 0x57: /* EVEN */
|
| - DO_EVEN
|
| - break;
|
| -
|
| - case 0x58: /* IF */
|
| - Ins_IF( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x59: /* EIF */
|
| - /* do nothing */
|
| - break;
|
| -
|
| - case 0x5A: /* AND */
|
| - DO_AND
|
| - break;
|
| -
|
| - case 0x5B: /* OR */
|
| - DO_OR
|
| - break;
|
| -
|
| - case 0x5C: /* NOT */
|
| - DO_NOT
|
| - break;
|
| -
|
| - case 0x5D: /* DELTAP1 */
|
| - Ins_DELTAP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x5E: /* SDB */
|
| - DO_SDB
|
| - break;
|
| -
|
| - case 0x5F: /* SDS */
|
| - DO_SDS
|
| - break;
|
| -
|
| - case 0x60: /* ADD */
|
| - DO_ADD
|
| - break;
|
| -
|
| - case 0x61: /* SUB */
|
| - DO_SUB
|
| - break;
|
| -
|
| - case 0x62: /* DIV */
|
| - DO_DIV
|
| - break;
|
| -
|
| - case 0x63: /* MUL */
|
| - DO_MUL
|
| - break;
|
| -
|
| - case 0x64: /* ABS */
|
| - DO_ABS
|
| - break;
|
| -
|
| - case 0x65: /* NEG */
|
| - DO_NEG
|
| - break;
|
| -
|
| - case 0x66: /* FLOOR */
|
| - DO_FLOOR
|
| - break;
|
| -
|
| - case 0x67: /* CEILING */
|
| - DO_CEILING
|
| - break;
|
| -
|
| - case 0x68: /* ROUND */
|
| - case 0x69: /* ROUND */
|
| - case 0x6A: /* ROUND */
|
| - case 0x6B: /* ROUND */
|
| - DO_ROUND
|
| - break;
|
| -
|
| - case 0x6C: /* NROUND */
|
| - case 0x6D: /* NROUND */
|
| - case 0x6E: /* NRRUND */
|
| - case 0x6F: /* NROUND */
|
| - DO_NROUND
|
| - break;
|
| -
|
| - case 0x70: /* WCVTF */
|
| - DO_WCVTF
|
| - break;
|
| -
|
| - case 0x71: /* DELTAP2 */
|
| - case 0x72: /* DELTAP3 */
|
| - Ins_DELTAP( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x73: /* DELTAC0 */
|
| - case 0x74: /* DELTAC1 */
|
| - case 0x75: /* DELTAC2 */
|
| - Ins_DELTAC( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x76: /* SROUND */
|
| - DO_SROUND
|
| - break;
|
| -
|
| - case 0x77: /* S45Round */
|
| - DO_S45ROUND
|
| - break;
|
| -
|
| - case 0x78: /* JROT */
|
| - DO_JROT
|
| - break;
|
| -
|
| - case 0x79: /* JROF */
|
| - DO_JROF
|
| - break;
|
| -
|
| - case 0x7A: /* ROFF */
|
| - DO_ROFF
|
| - break;
|
| -
|
| - case 0x7B: /* ???? */
|
| - Ins_UNKNOWN( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x7C: /* RUTG */
|
| - DO_RUTG
|
| - break;
|
| -
|
| - case 0x7D: /* RDTG */
|
| - DO_RDTG
|
| - break;
|
| -
|
| - case 0x7E: /* SANGW */
|
| - case 0x7F: /* AA */
|
| - /* nothing - obsolete */
|
| - break;
|
| -
|
| - case 0x80: /* FLIPPT */
|
| - Ins_FLIPPT( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x81: /* FLIPRGON */
|
| - Ins_FLIPRGON( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x82: /* FLIPRGOFF */
|
| - Ins_FLIPRGOFF( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x83: /* UNKNOWN */
|
| - case 0x84: /* UNKNOWN */
|
| - Ins_UNKNOWN( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x85: /* SCANCTRL */
|
| - Ins_SCANCTRL( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x86: /* SDPVTL */
|
| - case 0x87: /* SDPVTL */
|
| - Ins_SDPVTL( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x88: /* GETINFO */
|
| - Ins_GETINFO( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x89: /* IDEF */
|
| - Ins_IDEF( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x8A: /* ROLL */
|
| - Ins_ROLL( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x8B: /* MAX */
|
| - DO_MAX
|
| - break;
|
| -
|
| - case 0x8C: /* MIN */
|
| - DO_MIN
|
| - break;
|
| -
|
| - case 0x8D: /* SCANTYPE */
|
| - Ins_SCANTYPE( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x8E: /* INSTCTRL */
|
| - Ins_INSTCTRL( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - case 0x8F:
|
| - Ins_UNKNOWN( EXEC_ARG_ args );
|
| - break;
|
| -
|
| - default:
|
| - if ( opcode >= 0xE0 )
|
| - Ins_MIRP( EXEC_ARG_ args );
|
| - else if ( opcode >= 0xC0 )
|
| - Ins_MDRP( EXEC_ARG_ args );
|
| - else if ( opcode >= 0xB8 )
|
| - Ins_PUSHW( EXEC_ARG_ args );
|
| - else if ( opcode >= 0xB0 )
|
| - Ins_PUSHB( EXEC_ARG_ args );
|
| - else
|
| - Ins_UNKNOWN( EXEC_ARG_ args );
|
| - }
|
| -
|
| - }
|
| -
|
| -#else
|
| -
|
| - Instruct_Dispatch[CUR.opcode]( EXEC_ARG_ &CUR.stack[CUR.args] );
|
| -
|
| -#endif /* TT_CONFIG_OPTION_INTERPRETER_SWITCH */
|
| -
|
| - if ( CUR.error )
|
| - {
|
| - switch ( CUR.error )
|
| - {
|
| - /* looking for redefined instructions */
|
| - case FT_ERR( Invalid_Opcode ):
|
| - {
|
| - TT_DefRecord* def = CUR.IDefs;
|
| - TT_DefRecord* limit = def + CUR.numIDefs;
|
| -
|
| -
|
| - for ( ; def < limit; def++ )
|
| - {
|
| - if ( def->active && CUR.opcode == (FT_Byte)def->opc )
|
| - {
|
| - TT_CallRec* callrec;
|
| -
|
| -
|
| - if ( CUR.callTop >= CUR.callSize )
|
| - {
|
| - CUR.error = FT_THROW( Invalid_Reference );
|
| - goto LErrorLabel_;
|
| - }
|
| -
|
| - callrec = &CUR.callStack[CUR.callTop];
|
| -
|
| - callrec->Caller_Range = CUR.curRange;
|
| - callrec->Caller_IP = CUR.IP + 1;
|
| - callrec->Cur_Count = 1;
|
| - callrec->Cur_Restart = def->start;
|
| - callrec->Cur_End = def->end;
|
| -
|
| - if ( INS_Goto_CodeRange( def->range, def->start ) == FAILURE )
|
| - goto LErrorLabel_;
|
| -
|
| - goto LSuiteLabel_;
|
| - }
|
| - }
|
| - }
|
| -
|
| - CUR.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
|
| - }
|
| - }
|
| -
|
| - CUR.top = CUR.new_top;
|
| -
|
| - if ( CUR.step_ins )
|
| - CUR.IP += CUR.length;
|
| -
|
| - /* increment instruction counter and check if we didn't */
|
| - /* run this program for too long (e.g. infinite loops). */
|
| - if ( ++ins_counter > MAX_RUNNABLE_OPCODES )
|
| - return FT_THROW( Execution_Too_Long );
|
| -
|
| - LSuiteLabel_:
|
| - if ( CUR.IP >= CUR.codeSize )
|
| - {
|
| - if ( CUR.callTop > 0 )
|
| - {
|
| - CUR.error = FT_THROW( Code_Overflow );
|
| - goto LErrorLabel_;
|
| - }
|
| - else
|
| - goto LNo_Error_;
|
| - }
|
| - } while ( !CUR.instruction_trap );
|
| -
|
| - LNo_Error_:
|
| -
|
| -#ifdef TT_CONFIG_OPTION_STATIC_RASTER
|
| - *exc = cur;
|
| -#endif
|
| -
|
| - return FT_Err_Ok;
|
| -
|
| - LErrorCodeOverflow_:
|
| - CUR.error = FT_THROW( Code_Overflow );
|
| -
|
| - LErrorLabel_:
|
| -
|
| -#ifdef TT_CONFIG_OPTION_STATIC_RASTER
|
| - *exc = cur;
|
| -#endif
|
| -
|
| - /* If any errors have occurred, function tables may be broken. */
|
| - /* Force a re-execution of `prep' and `fpgm' tables if no */
|
| - /* bytecode debugger is run. */
|
| - if ( CUR.error && !CUR.instruction_trap )
|
| - {
|
| - FT_TRACE1(( " The interpreter returned error 0x%x\n", CUR.error ));
|
| - exc->size->cvt_ready = FALSE;
|
| - }
|
| -
|
| - return CUR.error;
|
| - }
|
| -
|
| -
|
| -#endif /* TT_USE_BYTECODE_INTERPRETER */
|
| -
|
| -
|
| -/* END */
|
|
|
Chromium Code Reviews
Issue 815103002:
Update freetype to 2.5.4. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master