src/truetype/ttinterp.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ttinterp.c                                                             */
   4 /*                                                                         */
   5 /*    TrueType bytecode interpreter (body).                                */
   6 /*                                                                         */
   7 /*  Copyright 1996-2012                                                    */
   8 /*  by David Turner, Robert Wilhelm, and Werner Lemberg.                   */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 /* Greg Hitchcock from Microsoft has helped a lot in resolving unclear */
  20 /* issues; many thanks!                                                */
  21
  22
  23 #include <ft2build.h>
  24 #include FT_INTERNAL_DEBUG_H
  25 #include FT_INTERNAL_CALC_H
  26 #include FT_TRIGONOMETRY_H
  27 #include FT_SYSTEM_H
  28
  29 #include "ttinterp.h"
  30
  31 #include "tterrors.h"
  32
  33
  34 #ifdef TT_USE_BYTECODE_INTERPRETER
  35
  36
  37 #define TT_MULFIX           FT_MulFix
  38 #define TT_MULDIV           FT_MulDiv
  39 #define TT_MULDIV_NO_ROUND  FT_MulDiv_No_Round
  40
  41
  42   /*************************************************************************/
  43   /*                                                                       */
  44   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  45   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  46   /* messages during execution.                                            */
  47   /*                                                                       */
  48 #undef  FT_COMPONENT
  49 #define FT_COMPONENT  trace_ttinterp
  50
  51   /*************************************************************************/
  52   /*                                                                       */
  53   /* In order to detect infinite loops in the code, we set up a counter    */
  54   /* within the run loop.  A single stroke of interpretation is now        */
  55   /* limited to a maximal number of opcodes defined below.                 */
  56   /*                                                                       */
  57 #define MAX_RUNNABLE_OPCODES  1000000L
  58
  59
  60   /*************************************************************************/
  61   /*                                                                       */
  62   /* There are two kinds of implementations:                               */
  63   /*                                                                       */
  64   /* a. static implementation                                              */
  65   /*                                                                       */
  66   /*    The current execution context is a static variable, which fields   */
  67   /*    are accessed directly by the interpreter during execution.  The    */
  68   /*    context is named `cur'.                                            */
  69   /*                                                                       */
  70   /*    This version is non-reentrant, of course.                          */
  71   /*                                                                       */
  72   /* b. indirect implementation                                            */
  73   /*                                                                       */
  74   /*    The current execution context is passed to _each_ function as its  */
  75   /*    first argument, and each field is thus accessed indirectly.        */
  76   /*                                                                       */
  77   /*    This version is fully re-entrant.                                  */
  78   /*                                                                       */
  79   /* The idea is that an indirect implementation may be slower to execute  */
  80   /* on low-end processors that are used in some systems (like 386s or     */
  81   /* even 486s).                                                           */
  82   /*                                                                       */
  83   /* As a consequence, the indirect implementation is now the default, as  */
  84   /* its performance costs can be considered negligible in our context.    */
  85   /* Note, however, that we kept the same source with macros because:      */
  86   /*                                                                       */
  87   /* - The code is kept very close in design to the Pascal code used for   */
  88   /*   development.                                                        */
  89   /*                                                                       */
  90   /* - It's much more readable that way!                                   */
  91   /*                                                                       */
  92   /* - It's still open to experimentation and tuning.                      */
  93   /*                                                                       */
  94   /*************************************************************************/
  95
  96
  97 #ifndef TT_CONFIG_OPTION_STATIC_INTERPRETER     /* indirect implementation */
  98
  99 #define CUR  (*exc)                             /* see ttobjs.h */
 100
 101   /*************************************************************************/
 102   /*                                                                       */
 103   /* This macro is used whenever `exec' is unused in a function, to avoid  */
 104   /* stupid warnings from pedantic compilers.                              */
 105   /*                                                                       */
 106 #define FT_UNUSED_EXEC  FT_UNUSED( exc )
 107
 108 #else                                           /* static implementation */
 109
 110 #define CUR  cur
 111
 112 #define FT_UNUSED_EXEC  int  __dummy = __dummy
 113
 114   static
 115   TT_ExecContextRec  cur;   /* static exec. context variable */
 116
 117   /* apparently, we have a _lot_ of direct indexing when accessing  */
 118   /* the static `cur', which makes the code bigger (due to all the  */
 119   /* four bytes addresses).                                         */
 120
 121 #endif /* TT_CONFIG_OPTION_STATIC_INTERPRETER */
 122
 123
 124   /*************************************************************************/
 125   /*                                                                       */
 126   /* The instruction argument stack.                                       */
 127   /*                                                                       */
 128 #define INS_ARG  EXEC_OP_ FT_Long*  args    /* see ttobjs.h for EXEC_OP_ */
 129
 130
 131   /*************************************************************************/
 132   /*                                                                       */
 133   /* This macro is used whenever `args' is unused in a function, to avoid  */
 134   /* stupid warnings from pedantic compilers.                              */
 135   /*                                                                       */
 136 #define FT_UNUSED_ARG  FT_UNUSED_EXEC; FT_UNUSED( args )
 137
 138
 139   /*************************************************************************/
 140   /*                                                                       */
 141   /* The following macros hide the use of EXEC_ARG and EXEC_ARG_ to        */
 142   /* increase readability of the code.                                     */
 143   /*                                                                       */
 144   /*************************************************************************/
 145
 146
 147 #define SKIP_Code() \
 148           SkipCode( EXEC_ARG )
 149
 150 #define GET_ShortIns() \
 151           GetShortIns( EXEC_ARG )
 152
 153 #define NORMalize( x, y, v ) \
 154           Normalize( EXEC_ARG_ x, y, v )
 155
 156 #define SET_SuperRound( scale, flags ) \
 157           SetSuperRound( EXEC_ARG_ scale, flags )
 158
 159 #define ROUND_None( d, c ) \
 160           Round_None( EXEC_ARG_ d, c )
 161
 162 #define INS_Goto_CodeRange( range, ip ) \
 163           Ins_Goto_CodeRange( EXEC_ARG_ range, ip )
 164
 165 #define CUR_Func_move( z, p, d ) \
 166           CUR.func_move( EXEC_ARG_ z, p, d )
 167
 168 #define CUR_Func_move_orig( z, p, d ) \
 169           CUR.func_move_orig( EXEC_ARG_ z, p, d )
 170
 171 #define CUR_Func_round( d, c ) \
 172           CUR.func_round( EXEC_ARG_ d, c )
 173
 174 #define CUR_Func_read_cvt( index ) \
 175           CUR.func_read_cvt( EXEC_ARG_ index )
 176
 177 #define CUR_Func_write_cvt( index, val ) \
 178           CUR.func_write_cvt( EXEC_ARG_ index, val )
 179
 180 #define CUR_Func_move_cvt( index, val ) \
 181           CUR.func_move_cvt( EXEC_ARG_ index, val )
 182
 183 #define CURRENT_Ratio() \
 184           Current_Ratio( EXEC_ARG )
 185
 186 #define CURRENT_Ppem() \
 187           Current_Ppem( EXEC_ARG )
 188
 189 #define CUR_Ppem() \
 190           Cur_PPEM( EXEC_ARG )
 191
 192 #define INS_SxVTL( a, b, c, d ) \
 193           Ins_SxVTL( EXEC_ARG_ a, b, c, d )
 194
 195 #define COMPUTE_Funcs() \
 196           Compute_Funcs( EXEC_ARG )
 197
 198 #define COMPUTE_Round( a ) \
 199           Compute_Round( EXEC_ARG_ a )
 200
 201 #define COMPUTE_Point_Displacement( a, b, c, d ) \
 202           Compute_Point_Displacement( EXEC_ARG_ a, b, c, d )
 203
 204 #define MOVE_Zp2_Point( a, b, c, t ) \
 205           Move_Zp2_Point( EXEC_ARG_ a, b, c, t )
 206
 207
 208 #define CUR_Func_project( v1, v2 )  \
 209           CUR.func_project( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
 210
 211 #define CUR_Func_dualproj( v1, v2 )  \
 212           CUR.func_dualproj( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
 213
 214 #define CUR_fast_project( v ) \
 215           CUR.func_project( EXEC_ARG_ (v)->x, (v)->y )
 216
 217 #define CUR_fast_dualproj( v ) \
 218           CUR.func_dualproj( EXEC_ARG_ (v)->x, (v)->y )
 219
 220
 221   /*************************************************************************/
 222   /*                                                                       */
 223   /* Instruction dispatch function, as used by the interpreter.            */
 224   /*                                                                       */
 225   typedef void  (*TInstruction_Function)( INS_ARG );
 226
 227
 228   /*************************************************************************/
 229   /*                                                                       */
 230   /* Two simple bounds-checking macros.                                    */
 231   /*                                                                       */
 232 #define BOUNDS( x, n )   ( (FT_UInt)(x)  >= (FT_UInt)(n)  )
 233 #define BOUNDSL( x, n )  ( (FT_ULong)(x) >= (FT_ULong)(n) )
 234
 235 #undef  SUCCESS
 236 #define SUCCESS  0
 237
 238 #undef  FAILURE
 239 #define FAILURE  1
 240
 241 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
 242 #define GUESS_VECTOR( V )                                         \
 243   if ( CUR.face->unpatented_hinting )                             \
 244   {                                                               \
 245     CUR.GS.V.x = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0x4000 : 0 ); \
 246     CUR.GS.V.y = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0 : 0x4000 ); \
 247   }
 248 #else
 249 #define GUESS_VECTOR( V )
 250 #endif
 251
 252   /*************************************************************************/
 253   /*                                                                       */
 254   /*                        CODERANGE FUNCTIONS                            */
 255   /*                                                                       */
 256   /*************************************************************************/
 257
 258
 259   /*************************************************************************/
 260   /*                                                                       */
 261   /* <Function>                                                            */
 262   /*    TT_Goto_CodeRange                                                  */
 263   /*                                                                       */
 264   /* <Description>                                                         */
 265   /*    Switches to a new code range (updates the code related elements in */
 266   /*    `exec', and `IP').                                                 */
 267   /*                                                                       */
 268   /* <Input>                                                               */
 269   /*    range :: The new execution code range.                             */
 270   /*                                                                       */
 271   /*    IP    :: The new IP in the new code range.                         */
 272   /*                                                                       */
 273   /* <InOut>                                                               */
 274   /*    exec  :: The target execution context.                             */
 275   /*                                                                       */
 276   /* <Return>                                                              */
 277   /*    FreeType error code.  0 means success.                             */
 278   /*                                                                       */
 279   FT_LOCAL_DEF( FT_Error )
 280   TT_Goto_CodeRange( TT_ExecContext  exec,
 281                      FT_Int          range,
 282                      FT_Long         IP )
 283   {
 284     TT_CodeRange*  coderange;
 285
 286
 287     FT_ASSERT( range >= 1 && range <= 3 );
 288
 289     coderange = &exec->codeRangeTable[range - 1];
 290
 291     FT_ASSERT( coderange->base != NULL );
 292
 293     /* NOTE: Because the last instruction of a program may be a CALL */
 294     /*       which will return to the first byte *after* the code    */
 295     /*       range, we test for IP <= Size instead of IP < Size.     */
 296     /*                                                               */
 297     FT_ASSERT( (FT_ULong)IP <= coderange->size );
 298
 299     exec->code     = coderange->base;
 300     exec->codeSize = coderange->size;
 301     exec->IP       = IP;
 302     exec->curRange = range;
 303
 304     return TT_Err_Ok;
 305   }
 306
 307
 308   /*************************************************************************/
 309   /*                                                                       */
 310   /* <Function>                                                            */
 311   /*    TT_Set_CodeRange                                                   */
 312   /*                                                                       */
 313   /* <Description>                                                         */
 314   /*    Sets a code range.                                                 */
 315   /*                                                                       */
 316   /* <Input>                                                               */
 317   /*    range  :: The code range index.                                    */
 318   /*                                                                       */
 319   /*    base   :: The new code base.                                       */
 320   /*                                                                       */
 321   /*    length :: The range size in bytes.                                 */
 322   /*                                                                       */
 323   /* <InOut>                                                               */
 324   /*    exec   :: The target execution context.                            */
 325   /*                                                                       */
 326   /* <Return>                                                              */
 327   /*    FreeType error code.  0 means success.                             */
 328   /*                                                                       */
 329   FT_LOCAL_DEF( FT_Error )
 330   TT_Set_CodeRange( TT_ExecContext  exec,
 331                     FT_Int          range,
 332                     void*           base,
 333                     FT_Long         length )
 334   {
 335     FT_ASSERT( range >= 1 && range <= 3 );
 336
 337     exec->codeRangeTable[range - 1].base = (FT_Byte*)base;
 338     exec->codeRangeTable[range - 1].size = length;
 339
 340     return TT_Err_Ok;
 341   }
 342
 343
 344   /*************************************************************************/
 345   /*                                                                       */
 346   /* <Function>                                                            */
 347   /*    TT_Clear_CodeRange                                                 */
 348   /*                                                                       */
 349   /* <Description>                                                         */
 350   /*    Clears a code range.                                               */
 351   /*                                                                       */
 352   /* <Input>                                                               */
 353   /*    range :: The code range index.                                     */
 354   /*                                                                       */
 355   /* <InOut>                                                               */
 356   /*    exec  :: The target execution context.                             */
 357   /*                                                                       */
 358   /* <Return>                                                              */
 359   /*    FreeType error code.  0 means success.                             */
 360   /*                                                                       */
 361   /* <Note>                                                                */
 362   /*    Does not set the Error variable.                                   */
 363   /*                                                                       */
 364   FT_LOCAL_DEF( FT_Error )
 365   TT_Clear_CodeRange( TT_ExecContext  exec,
 366                       FT_Int          range )
 367   {
 368     FT_ASSERT( range >= 1 && range <= 3 );
 369
 370     exec->codeRangeTable[range - 1].base = NULL;
 371     exec->codeRangeTable[range - 1].size = 0;
 372
 373     return TT_Err_Ok;
 374   }
 375
 376
 377   /*************************************************************************/
 378   /*                                                                       */
 379   /*                   EXECUTION CONTEXT ROUTINES                          */
 380   /*                                                                       */
 381   /*************************************************************************/
 382
 383
 384   /*************************************************************************/
 385   /*                                                                       */
 386   /* <Function>                                                            */
 387   /*    TT_Done_Context                                                    */
 388   /*                                                                       */
 389   /* <Description>                                                         */
 390   /*    Destroys a given context.                                          */
 391   /*                                                                       */
 392   /* <Input>                                                               */
 393   /*    exec   :: A handle to the target execution context.                */
 394   /*                                                                       */
 395   /*    memory :: A handle to the parent memory object.                    */
 396   /*                                                                       */
 397   /* <Return>                                                              */
 398   /*    FreeType error code.  0 means success.                             */
 399   /*                                                                       */
 400   /* <Note>                                                                */
 401   /*    Only the glyph loader and debugger should call this function.      */
 402   /*                                                                       */
 403   FT_LOCAL_DEF( FT_Error )
 404   TT_Done_Context( TT_ExecContext  exec )
 405   {
 406     FT_Memory  memory = exec->memory;
 407
 408
 409     /* points zone */
 410     exec->maxPoints   = 0;
 411     exec->maxContours = 0;
 412
 413     /* free stack */
 414     FT_FREE( exec->stack );
 415     exec->stackSize = 0;
 416
 417     /* free call stack */
 418     FT_FREE( exec->callStack );
 419     exec->callSize = 0;
 420     exec->callTop  = 0;
 421
 422     /* free glyph code range */
 423     FT_FREE( exec->glyphIns );
 424     exec->glyphSize = 0;
 425
 426     exec->size = NULL;
 427     exec->face = NULL;
 428
 429     FT_FREE( exec );
 430
 431     return TT_Err_Ok;
 432   }
 433
 434
 435   /*************************************************************************/
 436   /*                                                                       */
 437   /* <Function>                                                            */
 438   /*    Init_Context                                                       */
 439   /*                                                                       */
 440   /* <Description>                                                         */
 441   /*    Initializes a context object.                                      */
 442   /*                                                                       */
 443   /* <Input>                                                               */
 444   /*    memory :: A handle to the parent memory object.                    */
 445   /*                                                                       */
 446   /* <InOut>                                                               */
 447   /*    exec   :: A handle to the target execution context.                */
 448   /*                                                                       */
 449   /* <Return>                                                              */
 450   /*    FreeType error code.  0 means success.                             */
 451   /*                                                                       */
 452   static FT_Error
 453   Init_Context( TT_ExecContext  exec,
 454                 FT_Memory       memory )
 455   {
 456     FT_Error  error;
 457
 458
 459     FT_TRACE1(( "Init_Context: new object at 0x%08p\n", exec ));
 460
 461     exec->memory   = memory;
 462     exec->callSize = 32;
 463
 464     if ( FT_NEW_ARRAY( exec->callStack, exec->callSize ) )
 465       goto Fail_Memory;
 466
 467     /* all values in the context are set to 0 already, but this is */
 468     /* here as a remainder                                         */
 469     exec->maxPoints   = 0;
 470     exec->maxContours = 0;
 471
 472     exec->stackSize = 0;
 473     exec->glyphSize = 0;
 474
 475     exec->stack     = NULL;
 476     exec->glyphIns  = NULL;
 477
 478     exec->face = NULL;
 479     exec->size = NULL;
 480
 481     return TT_Err_Ok;
 482
 483   Fail_Memory:
 484     FT_ERROR(( "Init_Context: not enough memory for %p\n", exec ));
 485     TT_Done_Context( exec );
 486
 487     return error;
 488  }
 489
 490
 491   /*************************************************************************/
 492   /*                                                                       */
 493   /* <Function>                                                            */
 494   /*    Update_Max                                                         */
 495   /*                                                                       */
 496   /* <Description>                                                         */
 497   /*    Checks the size of a buffer and reallocates it if necessary.       */
 498   /*                                                                       */
 499   /* <Input>                                                               */
 500   /*    memory     :: A handle to the parent memory object.                */
 501   /*                                                                       */
 502   /*    multiplier :: The size in bytes of each element in the buffer.     */
 503   /*                                                                       */
 504   /*    new_max    :: The new capacity (size) of the buffer.               */
 505   /*                                                                       */
 506   /* <InOut>                                                               */
 507   /*    size       :: The address of the buffer's current size expressed   */
 508   /*                  in elements.                                         */
 509   /*                                                                       */
 510   /*    buff       :: The address of the buffer base pointer.              */
 511   /*                                                                       */
 512   /* <Return>                                                              */
 513   /*    FreeType error code.  0 means success.                             */
 514   /*                                                                       */
 515   FT_LOCAL_DEF( FT_Error )
 516   Update_Max( FT_Memory  memory,
 517               FT_ULong*  size,
 518               FT_Long    multiplier,
 519               void*      _pbuff,
 520               FT_ULong   new_max )
 521   {
 522     FT_Error  error;
 523     void**    pbuff = (void**)_pbuff;
 524
 525
 526     if ( *size < new_max )
 527     {
 528       if ( FT_REALLOC( *pbuff, *size * multiplier, new_max * multiplier ) )
 529         return error;
 530       *size = new_max;
 531     }
 532
 533     return TT_Err_Ok;
 534   }
 535
 536
 537   /*************************************************************************/
 538   /*                                                                       */
 539   /* <Function>                                                            */
 540   /*    TT_Load_Context                                                    */
 541   /*                                                                       */
 542   /* <Description>                                                         */
 543   /*    Prepare an execution context for glyph hinting.                    */
 544   /*                                                                       */
 545   /* <Input>                                                               */
 546   /*    face :: A handle to the source face object.                        */
 547   /*                                                                       */
 548   /*    size :: A handle to the source size object.                        */
 549   /*                                                                       */
 550   /* <InOut>                                                               */
 551   /*    exec :: A handle to the target execution context.                  */
 552   /*                                                                       */
 553   /* <Return>                                                              */
 554   /*    FreeType error code.  0 means success.                             */
 555   /*                                                                       */
 556   /* <Note>                                                                */
 557   /*    Only the glyph loader and debugger should call this function.      */
 558   /*                                                                       */
 559   FT_LOCAL_DEF( FT_Error )
 560   TT_Load_Context( TT_ExecContext  exec,
 561                    TT_Face         face,
 562                    TT_Size         size )
 563   {
 564     FT_Int          i;
 565     FT_ULong        tmp;
 566     TT_MaxProfile*  maxp;
 567     FT_Error        error;
 568
 569
 570     exec->face = face;
 571     maxp       = &face->max_profile;
 572     exec->size = size;
 573
 574     if ( size )
 575     {
 576       exec->numFDefs   = size->num_function_defs;
 577       exec->maxFDefs   = size->max_function_defs;
 578       exec->numIDefs   = size->num_instruction_defs;
 579       exec->maxIDefs   = size->max_instruction_defs;
 580       exec->FDefs      = size->function_defs;
 581       exec->IDefs      = size->instruction_defs;
 582       exec->tt_metrics = size->ttmetrics;
 583       exec->metrics    = size->metrics;
 584
 585       exec->maxFunc    = size->max_func;
 586       exec->maxIns     = size->max_ins;
 587
 588       for ( i = 0; i < TT_MAX_CODE_RANGES; i++ )
 589         exec->codeRangeTable[i] = size->codeRangeTable[i];
 590
 591       /* set graphics state */
 592       exec->GS = size->GS;
 593
 594       exec->cvtSize = size->cvt_size;
 595       exec->cvt     = size->cvt;
 596
 597       exec->storeSize = size->storage_size;
 598       exec->storage   = size->storage;
 599
 600       exec->twilight  = size->twilight;
 601
 602       /* In case of multi-threading it can happen that the old size object */
 603       /* no longer exists, thus we must clear all glyph zone references.   */
 604       ft_memset( &exec->zp0, 0, sizeof ( exec->zp0 ) );
 605       exec->zp1 = exec->zp0;
 606       exec->zp2 = exec->zp0;
 607     }
 608
 609     /* XXX: We reserve a little more elements on the stack to deal safely */
 610     /*      with broken fonts like arialbs, courbs, timesbs, etc.         */
 611     tmp = exec->stackSize;
 612     error = Update_Max( exec->memory,
 613                         &tmp,
 614                         sizeof ( FT_F26Dot6 ),
 615                         (void*)&exec->stack,
 616                         maxp->maxStackElements + 32 );
 617     exec->stackSize = (FT_UInt)tmp;
 618     if ( error )
 619       return error;
 620
 621     tmp = exec->glyphSize;
 622     error = Update_Max( exec->memory,
 623                         &tmp,
 624                         sizeof ( FT_Byte ),
 625                         (void*)&exec->glyphIns,
 626                         maxp->maxSizeOfInstructions );
 627     exec->glyphSize = (FT_UShort)tmp;
 628     if ( error )
 629       return error;
 630
 631     exec->pts.n_points   = 0;
 632     exec->pts.n_contours = 0;
 633
 634     exec->zp1 = exec->pts;
 635     exec->zp2 = exec->pts;
 636     exec->zp0 = exec->pts;
 637
 638     exec->instruction_trap = FALSE;
 639
 640     return TT_Err_Ok;
 641   }
 642
 643
 644   /*************************************************************************/
 645   /*                                                                       */
 646   /* <Function>                                                            */
 647   /*    TT_Save_Context                                                    */
 648   /*                                                                       */
 649   /* <Description>                                                         */
 650   /*    Saves the code ranges in a `size' object.                          */
 651   /*                                                                       */
 652   /* <Input>                                                               */
 653   /*    exec :: A handle to the source execution context.                  */
 654   /*                                                                       */
 655   /* <InOut>                                                               */
 656   /*    size :: A handle to the target size object.                        */
 657   /*                                                                       */
 658   /* <Return>                                                              */
 659   /*    FreeType error code.  0 means success.                             */
 660   /*                                                                       */
 661   /* <Note>                                                                */
 662   /*    Only the glyph loader and debugger should call this function.      */
 663   /*                                                                       */
 664   FT_LOCAL_DEF( FT_Error )
 665   TT_Save_Context( TT_ExecContext  exec,
 666                    TT_Size         size )
 667   {
 668     FT_Int  i;
 669
 670
 671     /* XXX: Will probably disappear soon with all the code range */
 672     /*      management, which is now rather obsolete.            */
 673     /*                                                           */
 674     size->num_function_defs    = exec->numFDefs;
 675     size->num_instruction_defs = exec->numIDefs;
 676
 677     size->max_func = exec->maxFunc;
 678     size->max_ins  = exec->maxIns;
 679
 680     for ( i = 0; i < TT_MAX_CODE_RANGES; i++ )
 681       size->codeRangeTable[i] = exec->codeRangeTable[i];
 682
 683     return TT_Err_Ok;
 684   }
 685
 686
 687   /*************************************************************************/
 688   /*                                                                       */
 689   /* <Function>                                                            */
 690   /*    TT_Run_Context                                                     */
 691   /*                                                                       */
 692   /* <Description>                                                         */
 693   /*    Executes one or more instructions in the execution context.        */
 694   /*                                                                       */
 695   /* <Input>                                                               */
 696   /*    debug :: A Boolean flag.  If set, the function sets some internal  */
 697   /*             variables and returns immediately, otherwise TT_RunIns()  */
 698   /*             is called.                                                */
 699   /*                                                                       */
 700   /*             This is commented out currently.                          */
 701   /*                                                                       */
 702   /* <Input>                                                               */
 703   /*    exec  :: A handle to the target execution context.                 */
 704   /*                                                                       */
 705   /* <Return>                                                              */
 706   /*    TrueType error code.  0 means success.                             */
 707   /*                                                                       */
 708   /* <Note>                                                                */
 709   /*    Only the glyph loader and debugger should call this function.      */
 710   /*                                                                       */
 711   FT_LOCAL_DEF( FT_Error )
 712   TT_Run_Context( TT_ExecContext  exec,
 713                   FT_Bool         debug )
 714   {
 715     FT_Error  error;
 716
 717
 718     if ( ( error = TT_Goto_CodeRange( exec, tt_coderange_glyph, 0 ) )
 719            != TT_Err_Ok )
 720       return error;
 721
 722     exec->zp0 = exec->pts;
 723     exec->zp1 = exec->pts;
 724     exec->zp2 = exec->pts;
 725
 726     exec->GS.gep0 = 1;
 727     exec->GS.gep1 = 1;
 728     exec->GS.gep2 = 1;
 729
 730     exec->GS.projVector.x = 0x4000;
 731     exec->GS.projVector.y = 0x0000;
 732
 733     exec->GS.freeVector = exec->GS.projVector;
 734     exec->GS.dualVector = exec->GS.projVector;
 735
 736 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
 737     exec->GS.both_x_axis = TRUE;
 738 #endif
 739
 740     exec->GS.round_state = 1;
 741     exec->GS.loop        = 1;
 742
 743     /* some glyphs leave something on the stack. so we clean it */
 744     /* before a new execution.                                  */
 745     exec->top     = 0;
 746     exec->callTop = 0;
 747
 748 #if 1
 749     FT_UNUSED( debug );
 750
 751     return exec->face->interpreter( exec );
 752 #else
 753     if ( !debug )
 754       return TT_RunIns( exec );
 755     else
 756       return TT_Err_Ok;
 757 #endif
 758   }
 759
 760
 761   /* The default value for `scan_control' is documented as FALSE in the */
 762   /* TrueType specification.  This is confusing since it implies a      */
 763   /* Boolean value.  However, this is not the case, thus both the       */
 764   /* default values of our `scan_type' and `scan_control' fields (which */
 765   /* the documentation's `scan_control' variable is split into) are     */
 766   /* zero.                                                              */
 767
 768   const TT_GraphicsState  tt_default_graphics_state =
 769   {
 770     0, 0, 0,
 771     { 0x4000, 0 },
 772     { 0x4000, 0 },
 773     { 0x4000, 0 },
 774
 775 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
 776     TRUE,
 777 #endif
 778
 779     1, 64, 1,
 780     TRUE, 68, 0, 0, 9, 3,
 781     0, FALSE, 0, 1, 1, 1
 782   };
 783
 784
 785   /* documentation is in ttinterp.h */
 786
 787   FT_EXPORT_DEF( TT_ExecContext )
 788   TT_New_Context( TT_Driver  driver )
 789   {
 790     TT_ExecContext  exec;
 791     FT_Memory       memory;
 792
 793
 794     memory = driver->root.root.memory;
 795     exec   = driver->context;
 796
 797     if ( !driver->context )
 798     {
 799       FT_Error  error;
 800
 801
 802       /* allocate object */
 803       if ( FT_NEW( exec ) )
 804         goto Fail;
 805
 806       /* initialize it; in case of error this deallocates `exec' too */
 807       error = Init_Context( exec, memory );
 808       if ( error )
 809         goto Fail;
 810
 811       /* store it into the driver */
 812       driver->context = exec;
 813     }
 814
 815     return driver->context;
 816
 817   Fail:
 818     return NULL;
 819   }
 820
 821
 822   /*************************************************************************/
 823   /*                                                                       */
 824   /* Before an opcode is executed, the interpreter verifies that there are */
 825   /* enough arguments on the stack, with the help of the `Pop_Push_Count'  */
 826   /* table.                                                                */
 827   /*                                                                       */
 828   /* For each opcode, the first column gives the number of arguments that  */
 829   /* are popped from the stack; the second one gives the number of those   */
 830   /* that are pushed in result.                                            */
 831   /*                                                                       */
 832   /* Opcodes which have a varying number of parameters in the data stream  */
 833   /* (NPUSHB, NPUSHW) are handled specially; they have a negative value in */
 834   /* the `opcode_length' table, and the value in `Pop_Push_Count' is set   */
 835   /* to zero.                                                              */
 836   /*                                                                       */
 837   /*************************************************************************/
 838
 839
 840 #undef  PACK
 841 #define PACK( x, y )  ( ( x << 4 ) | y )
 842
 843
 844   static
 845   const FT_Byte  Pop_Push_Count[256] =
 846   {
 847     /* opcodes are gathered in groups of 16 */
 848     /* please keep the spaces as they are   */
 849
 850     /*  SVTCA  y  */  PACK( 0, 0 ),
 851     /*  SVTCA  x  */  PACK( 0, 0 ),
 852     /*  SPvTCA y  */  PACK( 0, 0 ),
 853     /*  SPvTCA x  */  PACK( 0, 0 ),
 854     /*  SFvTCA y  */  PACK( 0, 0 ),
 855     /*  SFvTCA x  */  PACK( 0, 0 ),
 856     /*  SPvTL //  */  PACK( 2, 0 ),
 857     /*  SPvTL +   */  PACK( 2, 0 ),
 858     /*  SFvTL //  */  PACK( 2, 0 ),
 859     /*  SFvTL +   */  PACK( 2, 0 ),
 860     /*  SPvFS     */  PACK( 2, 0 ),
 861     /*  SFvFS     */  PACK( 2, 0 ),
 862     /*  GPV       */  PACK( 0, 2 ),
 863     /*  GFV       */  PACK( 0, 2 ),
 864     /*  SFvTPv    */  PACK( 0, 0 ),
 865     /*  ISECT     */  PACK( 5, 0 ),
 866
 867     /*  SRP0      */  PACK( 1, 0 ),
 868     /*  SRP1      */  PACK( 1, 0 ),
 869     /*  SRP2      */  PACK( 1, 0 ),
 870     /*  SZP0      */  PACK( 1, 0 ),
 871     /*  SZP1      */  PACK( 1, 0 ),
 872     /*  SZP2      */  PACK( 1, 0 ),
 873     /*  SZPS      */  PACK( 1, 0 ),
 874     /*  SLOOP     */  PACK( 1, 0 ),
 875     /*  RTG       */  PACK( 0, 0 ),
 876     /*  RTHG      */  PACK( 0, 0 ),
 877     /*  SMD       */  PACK( 1, 0 ),
 878     /*  ELSE      */  PACK( 0, 0 ),
 879     /*  JMPR      */  PACK( 1, 0 ),
 880     /*  SCvTCi    */  PACK( 1, 0 ),
 881     /*  SSwCi     */  PACK( 1, 0 ),
 882     /*  SSW       */  PACK( 1, 0 ),
 883
 884     /*  DUP       */  PACK( 1, 2 ),
 885     /*  POP       */  PACK( 1, 0 ),
 886     /*  CLEAR     */  PACK( 0, 0 ),
 887     /*  SWAP      */  PACK( 2, 2 ),
 888     /*  DEPTH     */  PACK( 0, 1 ),
 889     /*  CINDEX    */  PACK( 1, 1 ),
 890     /*  MINDEX    */  PACK( 1, 0 ),
 891     /*  AlignPTS  */  PACK( 2, 0 ),
 892     /*  INS_$28   */  PACK( 0, 0 ),
 893     /*  UTP       */  PACK( 1, 0 ),
 894     /*  LOOPCALL  */  PACK( 2, 0 ),
 895     /*  CALL      */  PACK( 1, 0 ),
 896     /*  FDEF      */  PACK( 1, 0 ),
 897     /*  ENDF      */  PACK( 0, 0 ),
 898     /*  MDAP[0]   */  PACK( 1, 0 ),
 899     /*  MDAP[1]   */  PACK( 1, 0 ),
 900
 901     /*  IUP[0]    */  PACK( 0, 0 ),
 902     /*  IUP[1]    */  PACK( 0, 0 ),
 903     /*  SHP[0]    */  PACK( 0, 0 ),
 904     /*  SHP[1]    */  PACK( 0, 0 ),
 905     /*  SHC[0]    */  PACK( 1, 0 ),
 906     /*  SHC[1]    */  PACK( 1, 0 ),
 907     /*  SHZ[0]    */  PACK( 1, 0 ),
 908     /*  SHZ[1]    */  PACK( 1, 0 ),
 909     /*  SHPIX     */  PACK( 1, 0 ),
 910     /*  IP        */  PACK( 0, 0 ),
 911     /*  MSIRP[0]  */  PACK( 2, 0 ),
 912     /*  MSIRP[1]  */  PACK( 2, 0 ),
 913     /*  AlignRP   */  PACK( 0, 0 ),
 914     /*  RTDG      */  PACK( 0, 0 ),
 915     /*  MIAP[0]   */  PACK( 2, 0 ),
 916     /*  MIAP[1]   */  PACK( 2, 0 ),
 917
 918     /*  NPushB    */  PACK( 0, 0 ),
 919     /*  NPushW    */  PACK( 0, 0 ),
 920     /*  WS        */  PACK( 2, 0 ),
 921     /*  RS        */  PACK( 1, 1 ),
 922     /*  WCvtP     */  PACK( 2, 0 ),
 923     /*  RCvt      */  PACK( 1, 1 ),
 924     /*  GC[0]     */  PACK( 1, 1 ),
 925     /*  GC[1]     */  PACK( 1, 1 ),
 926     /*  SCFS      */  PACK( 2, 0 ),
 927     /*  MD[0]     */  PACK( 2, 1 ),
 928     /*  MD[1]     */  PACK( 2, 1 ),
 929     /*  MPPEM     */  PACK( 0, 1 ),
 930     /*  MPS       */  PACK( 0, 1 ),
 931     /*  FlipON    */  PACK( 0, 0 ),
 932     /*  FlipOFF   */  PACK( 0, 0 ),
 933     /*  DEBUG     */  PACK( 1, 0 ),
 934
 935     /*  LT        */  PACK( 2, 1 ),
 936     /*  LTEQ      */  PACK( 2, 1 ),
 937     /*  GT        */  PACK( 2, 1 ),
 938     /*  GTEQ      */  PACK( 2, 1 ),
 939     /*  EQ        */  PACK( 2, 1 ),
 940     /*  NEQ       */  PACK( 2, 1 ),
 941     /*  ODD       */  PACK( 1, 1 ),
 942     /*  EVEN      */  PACK( 1, 1 ),
 943     /*  IF        */  PACK( 1, 0 ),
 944     /*  EIF       */  PACK( 0, 0 ),
 945     /*  AND       */  PACK( 2, 1 ),
 946     /*  OR        */  PACK( 2, 1 ),
 947     /*  NOT       */  PACK( 1, 1 ),
 948     /*  DeltaP1   */  PACK( 1, 0 ),
 949     /*  SDB       */  PACK( 1, 0 ),
 950     /*  SDS       */  PACK( 1, 0 ),
 951
 952     /*  ADD       */  PACK( 2, 1 ),
 953     /*  SUB       */  PACK( 2, 1 ),
 954     /*  DIV       */  PACK( 2, 1 ),
 955     /*  MUL       */  PACK( 2, 1 ),
 956     /*  ABS       */  PACK( 1, 1 ),
 957     /*  NEG       */  PACK( 1, 1 ),
 958     /*  FLOOR     */  PACK( 1, 1 ),
 959     /*  CEILING   */  PACK( 1, 1 ),
 960     /*  ROUND[0]  */  PACK( 1, 1 ),
 961     /*  ROUND[1]  */  PACK( 1, 1 ),
 962     /*  ROUND[2]  */  PACK( 1, 1 ),
 963     /*  ROUND[3]  */  PACK( 1, 1 ),
 964     /*  NROUND[0] */  PACK( 1, 1 ),
 965     /*  NROUND[1] */  PACK( 1, 1 ),
 966     /*  NROUND[2] */  PACK( 1, 1 ),
 967     /*  NROUND[3] */  PACK( 1, 1 ),
 968
 969     /*  WCvtF     */  PACK( 2, 0 ),
 970     /*  DeltaP2   */  PACK( 1, 0 ),
 971     /*  DeltaP3   */  PACK( 1, 0 ),
 972     /*  DeltaCn[0] */ PACK( 1, 0 ),
 973     /*  DeltaCn[1] */ PACK( 1, 0 ),
 974     /*  DeltaCn[2] */ PACK( 1, 0 ),
 975     /*  SROUND    */  PACK( 1, 0 ),
 976     /*  S45Round  */  PACK( 1, 0 ),
 977     /*  JROT      */  PACK( 2, 0 ),
 978     /*  JROF      */  PACK( 2, 0 ),
 979     /*  ROFF      */  PACK( 0, 0 ),
 980     /*  INS_$7B   */  PACK( 0, 0 ),
 981     /*  RUTG      */  PACK( 0, 0 ),
 982     /*  RDTG      */  PACK( 0, 0 ),
 983     /*  SANGW     */  PACK( 1, 0 ),
 984     /*  AA        */  PACK( 1, 0 ),
 985
 986     /*  FlipPT    */  PACK( 0, 0 ),
 987     /*  FlipRgON  */  PACK( 2, 0 ),
 988     /*  FlipRgOFF */  PACK( 2, 0 ),
 989     /*  INS_$83   */  PACK( 0, 0 ),
 990     /*  INS_$84   */  PACK( 0, 0 ),
 991     /*  ScanCTRL  */  PACK( 1, 0 ),
 992     /*  SDPVTL[0] */  PACK( 2, 0 ),
 993     /*  SDPVTL[1] */  PACK( 2, 0 ),
 994     /*  GetINFO   */  PACK( 1, 1 ),
 995     /*  IDEF      */  PACK( 1, 0 ),
 996     /*  ROLL      */  PACK( 3, 3 ),
 997     /*  MAX       */  PACK( 2, 1 ),
 998     /*  MIN       */  PACK( 2, 1 ),
 999     /*  ScanTYPE  */  PACK( 1, 0 ),
1000     /*  InstCTRL  */  PACK( 2, 0 ),
1001     /*  INS_$8F   */  PACK( 0, 0 ),
1002
1003     /*  INS_$90  */   PACK( 0, 0 ),
1004     /*  INS_$91  */   PACK( 0, 0 ),
1005     /*  INS_$92  */   PACK( 0, 0 ),
1006     /*  INS_$93  */   PACK( 0, 0 ),
1007     /*  INS_$94  */   PACK( 0, 0 ),
1008     /*  INS_$95  */   PACK( 0, 0 ),
1009     /*  INS_$96  */   PACK( 0, 0 ),
1010     /*  INS_$97  */   PACK( 0, 0 ),
1011     /*  INS_$98  */   PACK( 0, 0 ),
1012     /*  INS_$99  */   PACK( 0, 0 ),
1013     /*  INS_$9A  */   PACK( 0, 0 ),
1014     /*  INS_$9B  */   PACK( 0, 0 ),
1015     /*  INS_$9C  */   PACK( 0, 0 ),
1016     /*  INS_$9D  */   PACK( 0, 0 ),
1017     /*  INS_$9E  */   PACK( 0, 0 ),
1018     /*  INS_$9F  */   PACK( 0, 0 ),
1019
1020     /*  INS_$A0  */   PACK( 0, 0 ),
1021     /*  INS_$A1  */   PACK( 0, 0 ),
1022     /*  INS_$A2  */   PACK( 0, 0 ),
1023     /*  INS_$A3  */   PACK( 0, 0 ),
1024     /*  INS_$A4  */   PACK( 0, 0 ),
1025     /*  INS_$A5  */   PACK( 0, 0 ),
1026     /*  INS_$A6  */   PACK( 0, 0 ),
1027     /*  INS_$A7  */   PACK( 0, 0 ),
1028     /*  INS_$A8  */   PACK( 0, 0 ),
1029     /*  INS_$A9  */   PACK( 0, 0 ),
1030     /*  INS_$AA  */   PACK( 0, 0 ),
1031     /*  INS_$AB  */   PACK( 0, 0 ),
1032     /*  INS_$AC  */   PACK( 0, 0 ),
1033     /*  INS_$AD  */   PACK( 0, 0 ),
1034     /*  INS_$AE  */   PACK( 0, 0 ),
1035     /*  INS_$AF  */   PACK( 0, 0 ),
1036
1037     /*  PushB[0]  */  PACK( 0, 1 ),
1038     /*  PushB[1]  */  PACK( 0, 2 ),
1039     /*  PushB[2]  */  PACK( 0, 3 ),
1040     /*  PushB[3]  */  PACK( 0, 4 ),
1041     /*  PushB[4]  */  PACK( 0, 5 ),
1042     /*  PushB[5]  */  PACK( 0, 6 ),
1043     /*  PushB[6]  */  PACK( 0, 7 ),
1044     /*  PushB[7]  */  PACK( 0, 8 ),
1045     /*  PushW[0]  */  PACK( 0, 1 ),
1046     /*  PushW[1]  */  PACK( 0, 2 ),
1047     /*  PushW[2]  */  PACK( 0, 3 ),
1048     /*  PushW[3]  */  PACK( 0, 4 ),
1049     /*  PushW[4]  */  PACK( 0, 5 ),
1050     /*  PushW[5]  */  PACK( 0, 6 ),
1051     /*  PushW[6]  */  PACK( 0, 7 ),
1052     /*  PushW[7]  */  PACK( 0, 8 ),
1053
1054     /*  MDRP[00]  */  PACK( 1, 0 ),
1055     /*  MDRP[01]  */  PACK( 1, 0 ),
1056     /*  MDRP[02]  */  PACK( 1, 0 ),
1057     /*  MDRP[03]  */  PACK( 1, 0 ),
1058     /*  MDRP[04]  */  PACK( 1, 0 ),
1059     /*  MDRP[05]  */  PACK( 1, 0 ),
1060     /*  MDRP[06]  */  PACK( 1, 0 ),
1061     /*  MDRP[07]  */  PACK( 1, 0 ),
1062     /*  MDRP[08]  */  PACK( 1, 0 ),
1063     /*  MDRP[09]  */  PACK( 1, 0 ),
1064     /*  MDRP[10]  */  PACK( 1, 0 ),
1065     /*  MDRP[11]  */  PACK( 1, 0 ),
1066     /*  MDRP[12]  */  PACK( 1, 0 ),
1067     /*  MDRP[13]  */  PACK( 1, 0 ),
1068     /*  MDRP[14]  */  PACK( 1, 0 ),
1069     /*  MDRP[15]  */  PACK( 1, 0 ),
1070
1071     /*  MDRP[16]  */  PACK( 1, 0 ),
1072     /*  MDRP[17]  */  PACK( 1, 0 ),
1073     /*  MDRP[18]  */  PACK( 1, 0 ),
1074     /*  MDRP[19]  */  PACK( 1, 0 ),
1075     /*  MDRP[20]  */  PACK( 1, 0 ),
1076     /*  MDRP[21]  */  PACK( 1, 0 ),
1077     /*  MDRP[22]  */  PACK( 1, 0 ),
1078     /*  MDRP[23]  */  PACK( 1, 0 ),
1079     /*  MDRP[24]  */  PACK( 1, 0 ),
1080     /*  MDRP[25]  */  PACK( 1, 0 ),
1081     /*  MDRP[26]  */  PACK( 1, 0 ),
1082     /*  MDRP[27]  */  PACK( 1, 0 ),
1083     /*  MDRP[28]  */  PACK( 1, 0 ),
1084     /*  MDRP[29]  */  PACK( 1, 0 ),
1085     /*  MDRP[30]  */  PACK( 1, 0 ),
1086     /*  MDRP[31]  */  PACK( 1, 0 ),
1087
1088     /*  MIRP[00]  */  PACK( 2, 0 ),
1089     /*  MIRP[01]  */  PACK( 2, 0 ),
1090     /*  MIRP[02]  */  PACK( 2, 0 ),
1091     /*  MIRP[03]  */  PACK( 2, 0 ),
1092     /*  MIRP[04]  */  PACK( 2, 0 ),
1093     /*  MIRP[05]  */  PACK( 2, 0 ),
1094     /*  MIRP[06]  */  PACK( 2, 0 ),
1095     /*  MIRP[07]  */  PACK( 2, 0 ),
1096     /*  MIRP[08]  */  PACK( 2, 0 ),
1097     /*  MIRP[09]  */  PACK( 2, 0 ),
1098     /*  MIRP[10]  */  PACK( 2, 0 ),
1099     /*  MIRP[11]  */  PACK( 2, 0 ),
1100     /*  MIRP[12]  */  PACK( 2, 0 ),
1101     /*  MIRP[13]  */  PACK( 2, 0 ),
1102     /*  MIRP[14]  */  PACK( 2, 0 ),
1103     /*  MIRP[15]  */  PACK( 2, 0 ),
1104
1105     /*  MIRP[16]  */  PACK( 2, 0 ),
1106     /*  MIRP[17]  */  PACK( 2, 0 ),
1107     /*  MIRP[18]  */  PACK( 2, 0 ),
1108     /*  MIRP[19]  */  PACK( 2, 0 ),
1109     /*  MIRP[20]  */  PACK( 2, 0 ),
1110     /*  MIRP[21]  */  PACK( 2, 0 ),
1111     /*  MIRP[22]  */  PACK( 2, 0 ),
1112     /*  MIRP[23]  */  PACK( 2, 0 ),
1113     /*  MIRP[24]  */  PACK( 2, 0 ),
1114     /*  MIRP[25]  */  PACK( 2, 0 ),
1115     /*  MIRP[26]  */  PACK( 2, 0 ),
1116     /*  MIRP[27]  */  PACK( 2, 0 ),
1117     /*  MIRP[28]  */  PACK( 2, 0 ),
1118     /*  MIRP[29]  */  PACK( 2, 0 ),
1119     /*  MIRP[30]  */  PACK( 2, 0 ),
1120     /*  MIRP[31]  */  PACK( 2, 0 )
1121   };
1122
1123
1124 #ifdef FT_DEBUG_LEVEL_TRACE
1125
1126   static
1127   const char*  const opcode_name[256] =
1128   {
1129     "SVTCA y",
1130     "SVTCA x",
1131     "SPvTCA y",
1132     "SPvTCA x",
1133     "SFvTCA y",
1134     "SFvTCA x",
1135     "SPvTL ||",
1136     "SPvTL +",
1137     "SFvTL ||",
1138     "SFvTL +",
1139     "SPvFS",
1140     "SFvFS",
1141     "GPV",
1142     "GFV",
1143     "SFvTPv",
1144     "ISECT",
1145
1146     "SRP0",
1147     "SRP1",
1148     "SRP2",
1149     "SZP0",
1150     "SZP1",
1151     "SZP2",
1152     "SZPS",
1153     "SLOOP",
1154     "RTG",
1155     "RTHG",
1156     "SMD",
1157     "ELSE",
1158     "JMPR",
1159     "SCvTCi",
1160     "SSwCi",
1161     "SSW",
1162
1163     "DUP",
1164     "POP",
1165     "CLEAR",
1166     "SWAP",
1167     "DEPTH",
1168     "CINDEX",
1169     "MINDEX",
1170     "AlignPTS",
1171     "INS_$28",
1172     "UTP",
1173     "LOOPCALL",
1174     "CALL",
1175     "FDEF",
1176     "ENDF",
1177     "MDAP[0]",
1178     "MDAP[1]",
1179
1180     "IUP[0]",
1181     "IUP[1]",
1182     "SHP[0]",
1183     "SHP[1]",
1184     "SHC[0]",
1185     "SHC[1]",
1186     "SHZ[0]",
1187     "SHZ[1]",
1188     "SHPIX",
1189     "IP",
1190     "MSIRP[0]",
1191     "MSIRP[1]",
1192     "AlignRP",
1193     "RTDG",
1194     "MIAP[0]",
1195     "MIAP[1]",
1196
1197     "NPushB",
1198     "NPushW",
1199     "WS",
1200     "RS",
1201     "WCvtP",
1202     "RCvt",
1203     "GC[0]",
1204     "GC[1]",
1205     "SCFS",
1206     "MD[0]",
1207     "MD[1]",
1208     "MPPEM",
1209     "MPS",
1210     "FlipON",
1211     "FlipOFF",
1212     "DEBUG",
1213
1214     "LT",
1215     "LTEQ",
1216     "GT",
1217     "GTEQ",
1218     "EQ",
1219     "NEQ",
1220     "ODD",
1221     "EVEN",
1222     "IF",
1223     "EIF",
1224     "AND",
1225     "OR",
1226     "NOT",
1227     "DeltaP1",
1228     "SDB",
1229     "SDS",
1230
1231     "ADD",
1232     "SUB",
1233     "DIV",
1234     "MUL",
1235     "ABS",
1236     "NEG",
1237     "FLOOR",
1238     "CEILING",
1239     "ROUND[0]",
1240     "ROUND[1]",
1241     "ROUND[2]",
1242     "ROUND[3]",
1243     "NROUND[0]",
1244     "NROUND[1]",
1245     "NROUND[2]",
1246     "NROUND[3]",
1247
1248     "WCvtF",
1249     "DeltaP2",
1250     "DeltaP3",
1251     "DeltaCn[0]",
1252     "DeltaCn[1]",
1253     "DeltaCn[2]",
1254     "SROUND",
1255     "S45Round",
1256     "JROT",
1257     "JROF",
1258     "ROFF",
1259     "INS_$7B",
1260     "RUTG",
1261     "RDTG",
1262     "SANGW",
1263     "AA",
1264
1265     "FlipPT",
1266     "FlipRgON",
1267     "FlipRgOFF",
1268     "INS_$83",
1269     "INS_$84",
1270     "ScanCTRL",
1271     "SDVPTL[0]",
1272     "SDVPTL[1]",
1273     "GetINFO",
1274     "IDEF",
1275     "ROLL",
1276     "MAX",
1277     "MIN",
1278     "ScanTYPE",
1279     "InstCTRL",
1280     "INS_$8F",
1281
1282     "INS_$90",
1283     "INS_$91",
1284     "INS_$92",
1285     "INS_$93",
1286     "INS_$94",
1287     "INS_$95",
1288     "INS_$96",
1289     "INS_$97",
1290     "INS_$98",
1291     "INS_$99",
1292     "INS_$9A",
1293     "INS_$9B",
1294     "INS_$9C",
1295     "INS_$9D",
1296     "INS_$9E",
1297     "INS_$9F",
1298
1299     "INS_$A0",
1300     "INS_$A1",
1301     "INS_$A2",
1302     "INS_$A3",
1303     "INS_$A4",
1304     "INS_$A5",
1305     "INS_$A6",
1306     "INS_$A7",
1307     "INS_$A8",
1308     "INS_$A9",
1309     "INS_$AA",
1310     "INS_$AB",
1311     "INS_$AC",
1312     "INS_$AD",
1313     "INS_$AE",
1314     "INS_$AF",
1315
1316     "PushB[0]",
1317     "PushB[1]",
1318     "PushB[2]",
1319     "PushB[3]",
1320     "PushB[4]",
1321     "PushB[5]",
1322     "PushB[6]",
1323     "PushB[7]",
1324     "PushW[0]",
1325     "PushW[1]",
1326     "PushW[2]",
1327     "PushW[3]",
1328     "PushW[4]",
1329     "PushW[5]",
1330     "PushW[6]",
1331     "PushW[7]",
1332
1333     "MDRP[00]",
1334     "MDRP[01]",
1335     "MDRP[02]",
1336     "MDRP[03]",
1337     "MDRP[04]",
1338     "MDRP[05]",
1339     "MDRP[06]",
1340     "MDRP[07]",
1341     "MDRP[08]",
1342     "MDRP[09]",
1343     "MDRP[10]",
1344     "MDRP[11]",
1345     "MDRP[12]",
1346     "MDRP[13]",
1347     "MDRP[14]",
1348     "MDRP[15]",
1349
1350     "MDRP[16]",
1351     "MDRP[17]",
1352     "MDRP[18]",
1353     "MDRP[19]",
1354     "MDRP[20]",
1355     "MDRP[21]",
1356     "MDRP[22]",
1357     "MDRP[23]",
1358     "MDRP[24]",
1359     "MDRP[25]",
1360     "MDRP[26]",
1361     "MDRP[27]",
1362     "MDRP[28]",
1363     "MDRP[29]",
1364     "MDRP[30]",
1365     "MDRP[31]",
1366
1367     "MIRP[00]",
1368     "MIRP[01]",
1369     "MIRP[02]",
1370     "MIRP[03]",
1371     "MIRP[04]",
1372     "MIRP[05]",
1373     "MIRP[06]",
1374     "MIRP[07]",
1375     "MIRP[08]",
1376     "MIRP[09]",
1377     "MIRP[10]",
1378     "MIRP[11]",
1379     "MIRP[12]",
1380     "MIRP[13]",
1381     "MIRP[14]",
1382     "MIRP[15]",
1383
1384     "MIRP[16]",
1385     "MIRP[17]",
1386     "MIRP[18]",
1387     "MIRP[19]",
1388     "MIRP[20]",
1389     "MIRP[21]",
1390     "MIRP[22]",
1391     "MIRP[23]",
1392     "MIRP[24]",
1393     "MIRP[25]",
1394     "MIRP[26]",
1395     "MIRP[27]",
1396     "MIRP[28]",
1397     "MIRP[29]",
1398     "MIRP[30]",
1399     "MIRP[31]"
1400   };
1401
1402 #endif /* FT_DEBUG_LEVEL_TRACE */
1403
1404
1405   static
1406   const FT_Char  opcode_length[256] =
1407   {
1408     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1409     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1410     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1411     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1412
1413    -1,-2, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1414     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1415     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1416     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1417
1418     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1419     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1420     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1421     2, 3, 4, 5,  6, 7, 8, 9,  3, 5, 7, 9, 11,13,15,17,
1422
1423     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1424     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1425     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
1426     1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1
1427   };
1428
1429 #undef PACK
1430
1431 #if 1
1432
1433   static FT_Int32
1434   TT_MulFix14( FT_Int32  a,
1435                FT_Int    b )
1436   {
1437     FT_Int32   sign;
1438     FT_UInt32  ah, al, mid, lo, hi;
1439
1440
1441     sign = a ^ b;
1442
1443     if ( a < 0 )
1444       a = -a;
1445     if ( b < 0 )
1446       b = -b;
1447
1448     ah = (FT_UInt32)( ( a >> 16 ) & 0xFFFFU );
1449     al = (FT_UInt32)( a & 0xFFFFU );
1450
1451     lo    = al * b;
1452     mid   = ah * b;
1453     hi    = mid >> 16;
1454     mid   = ( mid << 16 ) + ( 1 << 13 ); /* rounding */
1455     lo   += mid;
1456     if ( lo < mid )
1457       hi += 1;
1458
1459     mid = ( lo >> 14 ) | ( hi << 18 );
1460
1461     return sign >= 0 ? (FT_Int32)mid : -(FT_Int32)mid;
1462   }
1463
1464 #else
1465
1466   /* compute (a*b)/2^14 with maximal accuracy and rounding */
1467   static FT_Int32
1468   TT_MulFix14( FT_Int32  a,
1469                FT_Int    b )
1470   {
1471     FT_Int32   m, s, hi;
1472     FT_UInt32  l, lo;
1473
1474
1475     /* compute ax*bx as 64-bit value */
1476     l  = (FT_UInt32)( ( a & 0xFFFFU ) * b );
1477     m  = ( a >> 16 ) * b;
1478
1479     lo = l + (FT_UInt32)( m << 16 );
1480     hi = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo < l );
1481
1482     /* divide the result by 2^14 with rounding */
1483     s   = hi >> 31;
1484     l   = lo + (FT_UInt32)s;
1485     hi += s + ( l < lo );
1486     lo  = l;
1487
1488     l   = lo + 0x2000U;
1489     hi += l < lo;
1490
1491     return ( hi << 18 ) | ( l >> 14 );
1492   }
1493 #endif
1494
1495
1496   /* compute (ax*bx+ay*by)/2^14 with maximal accuracy and rounding */
1497   static FT_Int32
1498   TT_DotFix14( FT_Int32  ax,
1499                FT_Int32  ay,
1500                FT_Int    bx,
1501                FT_Int    by )
1502   {
1503     FT_Int32   m, s, hi1, hi2, hi;
1504     FT_UInt32  l, lo1, lo2, lo;
1505
1506
1507     /* compute ax*bx as 64-bit value */
1508     l = (FT_UInt32)( ( ax & 0xFFFFU ) * bx );
1509     m = ( ax >> 16 ) * bx;
1510
1511     lo1 = l + (FT_UInt32)( m << 16 );
1512     hi1 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo1 < l );
1513
1514     /* compute ay*by as 64-bit value */
1515     l = (FT_UInt32)( ( ay & 0xFFFFU ) * by );
1516     m = ( ay >> 16 ) * by;
1517
1518     lo2 = l + (FT_UInt32)( m << 16 );
1519     hi2 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo2 < l );
1520
1521     /* add them */
1522     lo = lo1 + lo2;
1523     hi = hi1 + hi2 + ( lo < lo1 );
1524
1525     /* divide the result by 2^14 with rounding */
1526     s   = hi >> 31;
1527     l   = lo + (FT_UInt32)s;
1528     hi += s + ( l < lo );
1529     lo  = l;
1530
1531     l   = lo + 0x2000U;
1532     hi += ( l < lo );
1533
1534     return ( hi << 18 ) | ( l >> 14 );
1535   }
1536
1537
1538   /* return length of given vector */
1539
1540 #if 0
1541
1542   static FT_Int32
1543   TT_VecLen( FT_Int32  x,
1544              FT_Int32  y )
1545   {
1546     FT_Int32   m, hi1, hi2, hi;
1547     FT_UInt32  l, lo1, lo2, lo;
1548
1549
1550     /* compute x*x as 64-bit value */
1551     lo = (FT_UInt32)( x & 0xFFFFU );
1552     hi = x >> 16;
1553
1554     l  = lo * lo;
1555     m  = hi * lo;
1556     hi = hi * hi;
1557
1558     lo1 = l + (FT_UInt32)( m << 17 );
1559     hi1 = hi + ( m >> 15 ) + ( lo1 < l );
1560
1561     /* compute y*y as 64-bit value */
1562     lo = (FT_UInt32)( y & 0xFFFFU );
1563     hi = y >> 16;
1564
1565     l  = lo * lo;
1566     m  = hi * lo;
1567     hi = hi * hi;
1568
1569     lo2 = l + (FT_UInt32)( m << 17 );
1570     hi2 = hi + ( m >> 15 ) + ( lo2 < l );
1571
1572     /* add them to get 'x*x+y*y' as 64-bit value */
1573     lo = lo1 + lo2;
1574     hi = hi1 + hi2 + ( lo < lo1 );
1575
1576     /* compute the square root of this value */
1577     {
1578       FT_UInt32  root, rem, test_div;
1579       FT_Int     count;
1580
1581
1582       root = 0;
1583
1584       {
1585         rem   = 0;
1586         count = 32;
1587         do
1588         {
1589           rem      = ( rem << 2 ) | ( (FT_UInt32)hi >> 30 );
1590           hi       = (  hi << 2 ) | (            lo >> 30 );
1591           lo     <<= 2;
1592           root   <<= 1;
1593           test_div = ( root << 1 ) + 1;
1594
1595           if ( rem >= test_div )
1596           {
1597             rem  -= test_div;
1598             root += 1;
1599           }
1600         } while ( --count );
1601       }
1602
1603       return (FT_Int32)root;
1604     }
1605   }
1606
1607 #else
1608
1609   /* this version uses FT_Vector_Length which computes the same value */
1610   /* much, much faster..                                              */
1611   /*                                                                  */
1612   static FT_F26Dot6
1613   TT_VecLen( FT_F26Dot6  X,
1614              FT_F26Dot6  Y )
1615   {
1616     FT_Vector  v;
1617
1618
1619     v.x = X;
1620     v.y = Y;
1621
1622     return FT_Vector_Length( &v );
1623   }
1624
1625 #endif
1626
1627
1628   /*************************************************************************/
1629   /*                                                                       */
1630   /* <Function>                                                            */
1631   /*    Current_Ratio                                                      */
1632   /*                                                                       */
1633   /* <Description>                                                         */
1634   /*    Returns the current aspect ratio scaling factor depending on the   */
1635   /*    projection vector's state and device resolutions.                  */
1636   /*                                                                       */
1637   /* <Return>                                                              */
1638   /*    The aspect ratio in 16.16 format, always <= 1.0 .                  */
1639   /*                                                                       */
1640   static FT_Long
1641   Current_Ratio( EXEC_OP )
1642   {
1643     if ( !CUR.tt_metrics.ratio )
1644     {
1645 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
1646       if ( CUR.face->unpatented_hinting )
1647       {
1648         if ( CUR.GS.both_x_axis )
1649           CUR.tt_metrics.ratio = CUR.tt_metrics.x_ratio;
1650         else
1651           CUR.tt_metrics.ratio = CUR.tt_metrics.y_ratio;
1652       }
1653       else
1654 #endif
1655       {
1656         if ( CUR.GS.projVector.y == 0 )
1657           CUR.tt_metrics.ratio = CUR.tt_metrics.x_ratio;
1658
1659         else if ( CUR.GS.projVector.x == 0 )
1660           CUR.tt_metrics.ratio = CUR.tt_metrics.y_ratio;
1661
1662         else
1663         {
1664           FT_Long  x, y;
1665
1666
1667           x = TT_MULDIV( CUR.GS.projVector.x,
1668                          CUR.tt_metrics.x_ratio, 0x4000 );
1669           y = TT_MULDIV( CUR.GS.projVector.y,
1670                          CUR.tt_metrics.y_ratio, 0x4000 );
1671           CUR.tt_metrics.ratio = TT_VecLen( x, y );
1672         }
1673       }
1674     }
1675     return CUR.tt_metrics.ratio;
1676   }
1677
1678
1679   static FT_Long
1680   Current_Ppem( EXEC_OP )
1681   {
1682     return TT_MULFIX( CUR.tt_metrics.ppem, CURRENT_Ratio() );
1683   }
1684
1685
1686   /*************************************************************************/
1687   /*                                                                       */
1688   /* Functions related to the control value table (CVT).                   */
1689   /*                                                                       */
1690   /*************************************************************************/
1691
1692
1693   FT_CALLBACK_DEF( FT_F26Dot6 )
1694   Read_CVT( EXEC_OP_ FT_ULong  idx )
1695   {
1696     return CUR.cvt[idx];
1697   }
1698
1699
1700   FT_CALLBACK_DEF( FT_F26Dot6 )
1701   Read_CVT_Stretched( EXEC_OP_ FT_ULong  idx )
1702   {
1703     return TT_MULFIX( CUR.cvt[idx], CURRENT_Ratio() );
1704   }
1705
1706
1707   FT_CALLBACK_DEF( void )
1708   Write_CVT( EXEC_OP_ FT_ULong    idx,
1709                       FT_F26Dot6  value )
1710   {
1711     CUR.cvt[idx] = value;
1712   }
1713
1714
1715   FT_CALLBACK_DEF( void )
1716   Write_CVT_Stretched( EXEC_OP_ FT_ULong    idx,
1717                                 FT_F26Dot6  value )
1718   {
1719     CUR.cvt[idx] = FT_DivFix( value, CURRENT_Ratio() );
1720   }
1721
1722
1723   FT_CALLBACK_DEF( void )
1724   Move_CVT( EXEC_OP_ FT_ULong    idx,
1725                      FT_F26Dot6  value )
1726   {
1727     CUR.cvt[idx] += value;
1728   }
1729
1730
1731   FT_CALLBACK_DEF( void )
1732   Move_CVT_Stretched( EXEC_OP_ FT_ULong    idx,
1733                                FT_F26Dot6  value )
1734   {
1735     CUR.cvt[idx] += FT_DivFix( value, CURRENT_Ratio() );
1736   }
1737
1738
1739   /*************************************************************************/
1740   /*                                                                       */
1741   /* <Function>                                                            */
1742   /*    GetShortIns                                                        */
1743   /*                                                                       */
1744   /* <Description>                                                         */
1745   /*    Returns a short integer taken from the instruction stream at       */
1746   /*    address IP.                                                        */
1747   /*                                                                       */
1748   /* <Return>                                                              */
1749   /*    Short read at code[IP].                                            */
1750   /*                                                                       */
1751   /* <Note>                                                                */
1752   /*    This one could become a macro.                                     */
1753   /*                                                                       */
1754   static FT_Short
1755   GetShortIns( EXEC_OP )
1756   {
1757     /* Reading a byte stream so there is no endianess (DaveP) */
1758     CUR.IP += 2;
1759     return (FT_Short)( ( CUR.code[CUR.IP - 2] << 8 ) +
1760                          CUR.code[CUR.IP - 1]      );
1761   }
1762
1763
1764   /*************************************************************************/
1765   /*                                                                       */
1766   /* <Function>                                                            */
1767   /*    Ins_Goto_CodeRange                                                 */
1768   /*                                                                       */
1769   /* <Description>                                                         */
1770   /*    Goes to a certain code range in the instruction stream.            */
1771   /*                                                                       */
1772   /* <Input>                                                               */
1773   /*    aRange :: The index of the code range.                             */
1774   /*                                                                       */
1775   /*    aIP    :: The new IP address in the code range.                    */
1776   /*                                                                       */
1777   /* <Return>                                                              */
1778   /*    SUCCESS or FAILURE.                                                */
1779   /*                                                                       */
1780   static FT_Bool
1781   Ins_Goto_CodeRange( EXEC_OP_ FT_Int    aRange,
1782                                FT_ULong  aIP )
1783   {
1784     TT_CodeRange*  range;
1785
1786
1787     if ( aRange < 1 || aRange > 3 )
1788     {
1789       CUR.error = TT_Err_Bad_Argument;
1790       return FAILURE;
1791     }
1792
1793     range = &CUR.codeRangeTable[aRange - 1];
1794
1795     if ( range->base == NULL )     /* invalid coderange */
1796     {
1797       CUR.error = TT_Err_Invalid_CodeRange;
1798       return FAILURE;
1799     }
1800
1801     /* NOTE: Because the last instruction of a program may be a CALL */
1802     /*       which will return to the first byte *after* the code    */
1803     /*       range, we test for aIP <= Size, instead of aIP < Size.  */
1804
1805     if ( aIP > range->size )
1806     {
1807       CUR.error = TT_Err_Code_Overflow;
1808       return FAILURE;
1809     }
1810
1811     CUR.code     = range->base;
1812     CUR.codeSize = range->size;
1813     CUR.IP       = aIP;
1814     CUR.curRange = aRange;
1815
1816     return SUCCESS;
1817   }
1818
1819
1820   /*************************************************************************/
1821   /*                                                                       */
1822   /* <Function>                                                            */
1823   /*    Direct_Move                                                        */
1824   /*                                                                       */
1825   /* <Description>                                                         */
1826   /*    Moves a point by a given distance along the freedom vector.  The   */
1827   /*    point will be `touched'.                                           */
1828   /*                                                                       */
1829   /* <Input>                                                               */
1830   /*    point    :: The index of the point to move.                        */
1831   /*                                                                       */
1832   /*    distance :: The distance to apply.                                 */
1833   /*                                                                       */
1834   /* <InOut>                                                               */
1835   /*    zone     :: The affected glyph zone.                               */
1836   /*                                                                       */
1837   static void
1838   Direct_Move( EXEC_OP_ TT_GlyphZone  zone,
1839                         FT_UShort     point,
1840                         FT_F26Dot6    distance )
1841   {
1842     FT_F26Dot6  v;
1843
1844
1845 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
1846     FT_ASSERT( !CUR.face->unpatented_hinting );
1847 #endif
1848
1849     v = CUR.GS.freeVector.x;
1850
1851     if ( v != 0 )
1852     {
1853       zone->cur[point].x += TT_MULDIV( distance,
1854                                        v * 0x10000L,
1855                                        CUR.F_dot_P );
1856
1857       zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
1858     }
1859
1860     v = CUR.GS.freeVector.y;
1861
1862     if ( v != 0 )
1863     {
1864       zone->cur[point].y += TT_MULDIV( distance,
1865                                        v * 0x10000L,
1866                                        CUR.F_dot_P );
1867
1868       zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y;
1869     }
1870   }
1871
1872
1873   /*************************************************************************/
1874   /*                                                                       */
1875   /* <Function>                                                            */
1876   /*    Direct_Move_Orig                                                   */
1877   /*                                                                       */
1878   /* <Description>                                                         */
1879   /*    Moves the *original* position of a point by a given distance along */
1880   /*    the freedom vector.  Obviously, the point will not be `touched'.   */
1881   /*                                                                       */
1882   /* <Input>                                                               */
1883   /*    point    :: The index of the point to move.                        */
1884   /*                                                                       */
1885   /*    distance :: The distance to apply.                                 */
1886   /*                                                                       */
1887   /* <InOut>                                                               */
1888   /*    zone     :: The affected glyph zone.                               */
1889   /*                                                                       */
1890   static void
1891   Direct_Move_Orig( EXEC_OP_ TT_GlyphZone  zone,
1892                              FT_UShort     point,
1893                              FT_F26Dot6    distance )
1894   {
1895     FT_F26Dot6  v;
1896
1897
1898 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
1899     FT_ASSERT( !CUR.face->unpatented_hinting );
1900 #endif
1901
1902     v = CUR.GS.freeVector.x;
1903
1904     if ( v != 0 )
1905       zone->org[point].x += TT_MULDIV( distance,
1906                                        v * 0x10000L,
1907                                        CUR.F_dot_P );
1908
1909     v = CUR.GS.freeVector.y;
1910
1911     if ( v != 0 )
1912       zone->org[point].y += TT_MULDIV( distance,
1913                                        v * 0x10000L,
1914                                        CUR.F_dot_P );
1915   }
1916
1917
1918   /*************************************************************************/
1919   /*                                                                       */
1920   /* Special versions of Direct_Move()                                     */
1921   /*                                                                       */
1922   /*   The following versions are used whenever both vectors are both      */
1923   /*   along one of the coordinate unit vectors, i.e. in 90% of the cases. */
1924   /*                                                                       */
1925   /*************************************************************************/
1926
1927
1928   static void
1929   Direct_Move_X( EXEC_OP_ TT_GlyphZone  zone,
1930                           FT_UShort     point,
1931                           FT_F26Dot6    distance )
1932   {
1933     FT_UNUSED_EXEC;
1934
1935     zone->cur[point].x += distance;
1936     zone->tags[point]  |= FT_CURVE_TAG_TOUCH_X;
1937   }
1938
1939
1940   static void
1941   Direct_Move_Y( EXEC_OP_ TT_GlyphZone  zone,
1942                           FT_UShort     point,
1943                           FT_F26Dot6    distance )
1944   {
1945     FT_UNUSED_EXEC;
1946
1947     zone->cur[point].y += distance;
1948     zone->tags[point]  |= FT_CURVE_TAG_TOUCH_Y;
1949   }
1950
1951
1952   /*************************************************************************/
1953   /*                                                                       */
1954   /* Special versions of Direct_Move_Orig()                                */
1955   /*                                                                       */
1956   /*   The following versions are used whenever both vectors are both      */
1957   /*   along one of the coordinate unit vectors, i.e. in 90% of the cases. */
1958   /*                                                                       */
1959   /*************************************************************************/
1960
1961
1962   static void
1963   Direct_Move_Orig_X( EXEC_OP_ TT_GlyphZone  zone,
1964                                FT_UShort     point,
1965                                FT_F26Dot6    distance )
1966   {
1967     FT_UNUSED_EXEC;
1968
1969     zone->org[point].x += distance;
1970   }
1971
1972
1973   static void
1974   Direct_Move_Orig_Y( EXEC_OP_ TT_GlyphZone  zone,
1975                                FT_UShort     point,
1976                                FT_F26Dot6    distance )
1977   {
1978     FT_UNUSED_EXEC;
1979
1980     zone->org[point].y += distance;
1981   }
1982
1983
1984   /*************************************************************************/
1985   /*                                                                       */
1986   /* <Function>                                                            */
1987   /*    Round_None                                                         */
1988   /*                                                                       */
1989   /* <Description>                                                         */
1990   /*    Does not round, but adds engine compensation.                      */
1991   /*                                                                       */
1992   /* <Input>                                                               */
1993   /*    distance     :: The distance (not) to round.                       */
1994   /*                                                                       */
1995   /*    compensation :: The engine compensation.                           */
1996   /*                                                                       */
1997   /* <Return>                                                              */
1998   /*    The compensated distance.                                          */
1999   /*                                                                       */
2000   /* <Note>                                                                */
2001   /*    The TrueType specification says very few about the relationship    */
2002   /*    between rounding and engine compensation.  However, it seems from  */
2003   /*    the description of super round that we should add the compensation */
2004   /*    before rounding.                                                   */
2005   /*                                                                       */
2006   static FT_F26Dot6
2007   Round_None( EXEC_OP_ FT_F26Dot6  distance,
2008                        FT_F26Dot6  compensation )
2009   {
2010     FT_F26Dot6  val;
2011
2012     FT_UNUSED_EXEC;
2013
2014
2015     if ( distance >= 0 )
2016     {
2017       val = distance + compensation;
2018       if ( distance && val < 0 )
2019         val = 0;
2020     }
2021     else
2022     {
2023       val = distance - compensation;
2024       if ( val > 0 )
2025         val = 0;
2026     }
2027     return val;
2028   }
2029
2030
2031   /*************************************************************************/
2032   /*                                                                       */
2033   /* <Function>                                                            */
2034   /*    Round_To_Grid                                                      */
2035   /*                                                                       */
2036   /* <Description>                                                         */
2037   /*    Rounds value to grid after adding engine compensation.             */
2038   /*                                                                       */
2039   /* <Input>                                                               */
2040   /*    distance     :: The distance to round.                             */
2041   /*                                                                       */
2042   /*    compensation :: The engine compensation.                           */
2043   /*                                                                       */
2044   /* <Return>                                                              */
2045   /*    Rounded distance.                                                  */
2046   /*                                                                       */
2047   static FT_F26Dot6
2048   Round_To_Grid( EXEC_OP_ FT_F26Dot6  distance,
2049                           FT_F26Dot6  compensation )
2050   {
2051     FT_F26Dot6  val;
2052
2053     FT_UNUSED_EXEC;
2054
2055
2056     if ( distance >= 0 )
2057     {
2058       val = distance + compensation + 32;
2059       if ( distance && val > 0 )
2060         val &= ~63;
2061       else
2062         val = 0;
2063     }
2064     else
2065     {
2066       val = -FT_PIX_ROUND( compensation - distance );
2067       if ( val > 0 )
2068         val = 0;
2069     }
2070
2071     return  val;
2072   }
2073
2074
2075   /*************************************************************************/
2076   /*                                                                       */
2077   /* <Function>                                                            */
2078   /*    Round_To_Half_Grid                                                 */
2079   /*                                                                       */
2080   /* <Description>                                                         */
2081   /*    Rounds value to half grid after adding engine compensation.        */
2082   /*                                                                       */
2083   /* <Input>                                                               */
2084   /*    distance     :: The distance to round.                             */
2085   /*                                                                       */
2086   /*    compensation :: The engine compensation.                           */
2087   /*                                                                       */
2088   /* <Return>                                                              */
2089   /*    Rounded distance.                                                  */
2090   /*                                                                       */
2091   static FT_F26Dot6
2092   Round_To_Half_Grid( EXEC_OP_ FT_F26Dot6  distance,
2093                                FT_F26Dot6  compensation )
2094   {
2095     FT_F26Dot6  val;
2096
2097     FT_UNUSED_EXEC;
2098
2099
2100     if ( distance >= 0 )
2101     {
2102       val = FT_PIX_FLOOR( distance + compensation ) + 32;
2103       if ( distance && val < 0 )
2104         val = 0;
2105     }
2106     else
2107     {
2108       val = -( FT_PIX_FLOOR( compensation - distance ) + 32 );
2109       if ( val > 0 )
2110         val = 0;
2111     }
2112
2113     return val;
2114   }
2115
2116
2117   /*************************************************************************/
2118   /*                                                                       */
2119   /* <Function>                                                            */
2120   /*    Round_Down_To_Grid                                                 */
2121   /*                                                                       */
2122   /* <Description>                                                         */
2123   /*    Rounds value down to grid after adding engine compensation.        */
2124   /*                                                                       */
2125   /* <Input>                                                               */
2126   /*    distance     :: The distance to round.                             */
2127   /*                                                                       */
2128   /*    compensation :: The engine compensation.                           */
2129   /*                                                                       */
2130   /* <Return>                                                              */
2131   /*    Rounded distance.                                                  */
2132   /*                                                                       */
2133   static FT_F26Dot6
2134   Round_Down_To_Grid( EXEC_OP_ FT_F26Dot6  distance,
2135                                FT_F26Dot6  compensation )
2136   {
2137     FT_F26Dot6  val;
2138
2139     FT_UNUSED_EXEC;
2140
2141
2142     if ( distance >= 0 )
2143     {
2144       val = distance + compensation;
2145       if ( distance && val > 0 )
2146         val &= ~63;
2147       else
2148         val = 0;
2149     }
2150     else
2151     {
2152       val = -( ( compensation - distance ) & -64 );
2153       if ( val > 0 )
2154         val = 0;
2155     }
2156
2157     return val;
2158   }
2159
2160
2161   /*************************************************************************/
2162   /*                                                                       */
2163   /* <Function>                                                            */
2164   /*    Round_Up_To_Grid                                                   */
2165   /*                                                                       */
2166   /* <Description>                                                         */
2167   /*    Rounds value up to grid after adding engine compensation.          */
2168   /*                                                                       */
2169   /* <Input>                                                               */
2170   /*    distance     :: The distance to round.                             */
2171   /*                                                                       */
2172   /*    compensation :: The engine compensation.                           */
2173   /*                                                                       */
2174   /* <Return>                                                              */
2175   /*    Rounded distance.                                                  */
2176   /*                                                                       */
2177   static FT_F26Dot6
2178   Round_Up_To_Grid( EXEC_OP_ FT_F26Dot6  distance,
2179                              FT_F26Dot6  compensation )
2180   {
2181     FT_F26Dot6  val;
2182
2183     FT_UNUSED_EXEC;
2184
2185
2186     if ( distance >= 0 )
2187     {
2188       val = distance + compensation + 63;
2189       if ( distance && val > 0 )
2190         val &= ~63;
2191       else
2192         val = 0;
2193     }
2194     else
2195     {
2196       val = - FT_PIX_CEIL( compensation - distance );
2197       if ( val > 0 )
2198         val = 0;
2199     }
2200
2201     return val;
2202   }
2203
2204
2205   /*************************************************************************/
2206   /*                                                                       */
2207   /* <Function>                                                            */
2208   /*    Round_To_Double_Grid                                               */
2209   /*                                                                       */
2210   /* <Description>                                                         */
2211   /*    Rounds value to double grid after adding engine compensation.      */
2212   /*                                                                       */
2213   /* <Input>                                                               */
2214   /*    distance     :: The distance to round.                             */
2215   /*                                                                       */
2216   /*    compensation :: The engine compensation.                           */
2217   /*                                                                       */
2218   /* <Return>                                                              */
2219   /*    Rounded distance.                                                  */
2220   /*                                                                       */
2221   static FT_F26Dot6
2222   Round_To_Double_Grid( EXEC_OP_ FT_F26Dot6  distance,
2223                                  FT_F26Dot6  compensation )
2224   {
2225     FT_F26Dot6 val;
2226
2227     FT_UNUSED_EXEC;
2228
2229
2230     if ( distance >= 0 )
2231     {
2232       val = distance + compensation + 16;
2233       if ( distance && val > 0 )
2234         val &= ~31;
2235       else
2236         val = 0;
2237     }
2238     else
2239     {
2240       val = -FT_PAD_ROUND( compensation - distance, 32 );
2241       if ( val > 0 )
2242         val = 0;
2243     }
2244
2245     return val;
2246   }
2247
2248
2249   /*************************************************************************/
2250   /*                                                                       */
2251   /* <Function>                                                            */
2252   /*    Round_Super                                                        */
2253   /*                                                                       */
2254   /* <Description>                                                         */
2255   /*    Super-rounds value to grid after adding engine compensation.       */
2256   /*                                                                       */
2257   /* <Input>                                                               */
2258   /*    distance     :: The distance to round.                             */
2259   /*                                                                       */
2260   /*    compensation :: The engine compensation.                           */
2261   /*                                                                       */
2262   /* <Return>                                                              */
2263   /*    Rounded distance.                                                  */
2264   /*                                                                       */
2265   /* <Note>                                                                */
2266   /*    The TrueType specification says very few about the relationship    */
2267   /*    between rounding and engine compensation.  However, it seems from  */
2268   /*    the description of super round that we should add the compensation */
2269   /*    before rounding.                                                   */
2270   /*                                                                       */
2271   static FT_F26Dot6
2272   Round_Super( EXEC_OP_ FT_F26Dot6  distance,
2273                         FT_F26Dot6  compensation )
2274   {
2275     FT_F26Dot6  val;
2276
2277
2278     if ( distance >= 0 )
2279     {
2280       val = ( distance - CUR.phase + CUR.threshold + compensation ) &
2281               -CUR.period;
2282       if ( distance && val < 0 )
2283         val = 0;
2284       val += CUR.phase;
2285     }
2286     else
2287     {
2288       val = -( ( CUR.threshold - CUR.phase - distance + compensation ) &
2289                -CUR.period );
2290       if ( val > 0 )
2291         val = 0;
2292       val -= CUR.phase;
2293     }
2294
2295     return val;
2296   }
2297
2298
2299   /*************************************************************************/
2300   /*                                                                       */
2301   /* <Function>                                                            */
2302   /*    Round_Super_45                                                     */
2303   /*                                                                       */
2304   /* <Description>                                                         */
2305   /*    Super-rounds value to grid after adding engine compensation.       */
2306   /*                                                                       */
2307   /* <Input>                                                               */
2308   /*    distance     :: The distance to round.                             */
2309   /*                                                                       */
2310   /*    compensation :: The engine compensation.                           */
2311   /*                                                                       */
2312   /* <Return>                                                              */
2313   /*    Rounded distance.                                                  */
2314   /*                                                                       */
2315   /* <Note>                                                                */
2316   /*    There is a separate function for Round_Super_45() as we may need   */
2317   /*    greater precision.                                                 */
2318   /*                                                                       */
2319   static FT_F26Dot6
2320   Round_Super_45( EXEC_OP_ FT_F26Dot6  distance,
2321                            FT_F26Dot6  compensation )
2322   {
2323     FT_F26Dot6  val;
2324
2325
2326     if ( distance >= 0 )
2327     {
2328       val = ( ( distance - CUR.phase + CUR.threshold + compensation ) /
2329                 CUR.period ) * CUR.period;
2330       if ( distance && val < 0 )
2331         val = 0;
2332       val += CUR.phase;
2333     }
2334     else
2335     {
2336       val = -( ( ( CUR.threshold - CUR.phase - distance + compensation ) /
2337                    CUR.period ) * CUR.period );
2338       if ( val > 0 )
2339         val = 0;
2340       val -= CUR.phase;
2341     }
2342
2343     return val;
2344   }
2345
2346
2347   /*************************************************************************/
2348   /*                                                                       */
2349   /* <Function>                                                            */
2350   /*    Compute_Round                                                      */
2351   /*                                                                       */
2352   /* <Description>                                                         */
2353   /*    Sets the rounding mode.                                            */
2354   /*                                                                       */
2355   /* <Input>                                                               */
2356   /*    round_mode :: The rounding mode to be used.                        */
2357   /*                                                                       */
2358   static void
2359   Compute_Round( EXEC_OP_ FT_Byte  round_mode )
2360   {
2361     switch ( round_mode )
2362     {
2363     case TT_Round_Off:
2364       CUR.func_round = (TT_Round_Func)Round_None;
2365       break;
2366
2367     case TT_Round_To_Grid:
2368       CUR.func_round = (TT_Round_Func)Round_To_Grid;
2369       break;
2370
2371     case TT_Round_Up_To_Grid:
2372       CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
2373       break;
2374
2375     case TT_Round_Down_To_Grid:
2376       CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
2377       break;
2378
2379     case TT_Round_To_Half_Grid:
2380       CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
2381       break;
2382
2383     case TT_Round_To_Double_Grid:
2384       CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
2385       break;
2386
2387     case TT_Round_Super:
2388       CUR.func_round = (TT_Round_Func)Round_Super;
2389       break;
2390
2391     case TT_Round_Super_45:
2392       CUR.func_round = (TT_Round_Func)Round_Super_45;
2393       break;
2394     }
2395   }
2396
2397
2398   /*************************************************************************/
2399   /*                                                                       */
2400   /* <Function>                                                            */
2401   /*    SetSuperRound                                                      */
2402   /*                                                                       */
2403   /* <Description>                                                         */
2404   /*    Sets Super Round parameters.                                       */
2405   /*                                                                       */
2406   /* <Input>                                                               */
2407   /*    GridPeriod :: Grid period                                          */
2408   /*    selector   :: SROUND opcode                                        */
2409   /*                                                                       */
2410   static void
2411   SetSuperRound( EXEC_OP_ FT_F26Dot6  GridPeriod,
2412                           FT_Long     selector )
2413   {
2414     switch ( (FT_Int)( selector & 0xC0 ) )
2415     {
2416       case 0:
2417         CUR.period = GridPeriod / 2;
2418         break;
2419
2420       case 0x40:
2421         CUR.period = GridPeriod;
2422         break;
2423
2424       case 0x80:
2425         CUR.period = GridPeriod * 2;
2426         break;
2427
2428       /* This opcode is reserved, but... */
2429
2430       case 0xC0:
2431         CUR.period = GridPeriod;
2432         break;
2433     }
2434
2435     switch ( (FT_Int)( selector & 0x30 ) )
2436     {
2437     case 0:
2438       CUR.phase = 0;
2439       break;
2440
2441     case 0x10:
2442       CUR.phase = CUR.period / 4;
2443       break;
2444
2445     case 0x20:
2446       CUR.phase = CUR.period / 2;
2447       break;
2448
2449     case 0x30:
2450       CUR.phase = CUR.period * 3 / 4;
2451       break;
2452     }
2453
2454     if ( ( selector & 0x0F ) == 0 )
2455       CUR.threshold = CUR.period - 1;
2456     else
2457       CUR.threshold = ( (FT_Int)( selector & 0x0F ) - 4 ) * CUR.period / 8;
2458
2459     CUR.period    /= 256;
2460     CUR.phase     /= 256;
2461     CUR.threshold /= 256;
2462   }
2463
2464
2465   /*************************************************************************/
2466   /*                                                                       */
2467   /* <Function>                                                            */
2468   /*    Project                                                            */
2469   /*                                                                       */
2470   /* <Description>                                                         */
2471   /*    Computes the projection of vector given by (v2-v1) along the       */
2472   /*    current projection vector.                                         */
2473   /*                                                                       */
2474   /* <Input>                                                               */
2475   /*    v1 :: First input vector.                                          */
2476   /*    v2 :: Second input vector.                                         */
2477   /*                                                                       */
2478   /* <Return>                                                              */
2479   /*    The distance in F26dot6 format.                                    */
2480   /*                                                                       */
2481   static FT_F26Dot6
2482   Project( EXEC_OP_ FT_Pos  dx,
2483                     FT_Pos  dy )
2484   {
2485 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
2486     FT_ASSERT( !CUR.face->unpatented_hinting );
2487 #endif
2488
2489     return TT_DotFix14( (FT_UInt32)dx, (FT_UInt32)dy,
2490                         CUR.GS.projVector.x,
2491                         CUR.GS.projVector.y );
2492   }
2493
2494
2495   /*************************************************************************/
2496   /*                                                                       */
2497   /* <Function>                                                            */
2498   /*    Dual_Project                                                       */
2499   /*                                                                       */
2500   /* <Description>                                                         */
2501   /*    Computes the projection of the vector given by (v2-v1) along the   */
2502   /*    current dual vector.                                               */
2503   /*                                                                       */
2504   /* <Input>                                                               */
2505   /*    v1 :: First input vector.                                          */
2506   /*    v2 :: Second input vector.                                         */
2507   /*                                                                       */
2508   /* <Return>                                                              */
2509   /*    The distance in F26dot6 format.                                    */
2510   /*                                                                       */
2511   static FT_F26Dot6
2512   Dual_Project( EXEC_OP_ FT_Pos  dx,
2513                          FT_Pos  dy )
2514   {
2515     return TT_DotFix14( (FT_UInt32)dx, (FT_UInt32)dy,
2516                         CUR.GS.dualVector.x,
2517                         CUR.GS.dualVector.y );
2518   }
2519
2520
2521   /*************************************************************************/
2522   /*                                                                       */
2523   /* <Function>                                                            */
2524   /*    Project_x                                                          */
2525   /*                                                                       */
2526   /* <Description>                                                         */
2527   /*    Computes the projection of the vector given by (v2-v1) along the   */
2528   /*    horizontal axis.                                                   */
2529   /*                                                                       */
2530   /* <Input>                                                               */
2531   /*    v1 :: First input vector.                                          */
2532   /*    v2 :: Second input vector.                                         */
2533   /*                                                                       */
2534   /* <Return>                                                              */
2535   /*    The distance in F26dot6 format.                                    */
2536   /*                                                                       */
2537   static FT_F26Dot6
2538   Project_x( EXEC_OP_ FT_Pos  dx,
2539                       FT_Pos  dy )
2540   {
2541     FT_UNUSED_EXEC;
2542     FT_UNUSED( dy );
2543
2544     return dx;
2545   }
2546
2547
2548   /*************************************************************************/
2549   /*                                                                       */
2550   /* <Function>                                                            */
2551   /*    Project_y                                                          */
2552   /*                                                                       */
2553   /* <Description>                                                         */
2554   /*    Computes the projection of the vector given by (v2-v1) along the   */
2555   /*    vertical axis.                                                     */
2556   /*                                                                       */
2557   /* <Input>                                                               */
2558   /*    v1 :: First input vector.                                          */
2559   /*    v2 :: Second input vector.                                         */
2560   /*                                                                       */
2561   /* <Return>                                                              */
2562   /*    The distance in F26dot6 format.                                    */
2563   /*                                                                       */
2564   static FT_F26Dot6
2565   Project_y( EXEC_OP_ FT_Pos  dx,
2566                       FT_Pos  dy )
2567   {
2568     FT_UNUSED_EXEC;
2569     FT_UNUSED( dx );
2570
2571     return dy;
2572   }
2573
2574
2575   /*************************************************************************/
2576   /*                                                                       */
2577   /* <Function>                                                            */
2578   /*    Compute_Funcs                                                      */
2579   /*                                                                       */
2580   /* <Description>                                                         */
2581   /*    Computes the projection and movement function pointers according   */
2582   /*    to the current graphics state.                                     */
2583   /*                                                                       */
2584   static void
2585   Compute_Funcs( EXEC_OP )
2586   {
2587 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
2588     if ( CUR.face->unpatented_hinting )
2589     {
2590       /* If both vectors point rightwards along the x axis, set             */
2591       /* `both-x-axis' true, otherwise set it false.  The x values only     */
2592       /* need be tested because the vector has been normalised to a unit    */
2593       /* vector of length 0x4000 = unity.                                   */
2594       CUR.GS.both_x_axis = (FT_Bool)( CUR.GS.projVector.x == 0x4000 &&
2595                                       CUR.GS.freeVector.x == 0x4000 );
2596
2597       /* Throw away projection and freedom vector information */
2598       /* because the patents don't allow them to be stored.   */
2599       /* The relevant US Patents are 5155805 and 5325479.     */
2600       CUR.GS.projVector.x = 0;
2601       CUR.GS.projVector.y = 0;
2602       CUR.GS.freeVector.x = 0;
2603       CUR.GS.freeVector.y = 0;
2604
2605       if ( CUR.GS.both_x_axis )
2606       {
2607         CUR.func_project   = Project_x;
2608         CUR.func_move      = Direct_Move_X;
2609         CUR.func_move_orig = Direct_Move_Orig_X;
2610       }
2611       else
2612       {
2613         CUR.func_project   = Project_y;
2614         CUR.func_move      = Direct_Move_Y;
2615         CUR.func_move_orig = Direct_Move_Orig_Y;
2616       }
2617
2618       if ( CUR.GS.dualVector.x == 0x4000 )
2619         CUR.func_dualproj = Project_x;
2620       else
2621       {
2622         if ( CUR.GS.dualVector.y == 0x4000 )
2623           CUR.func_dualproj = Project_y;
2624         else
2625           CUR.func_dualproj = Dual_Project;
2626       }
2627
2628       /* Force recalculation of cached aspect ratio */
2629       CUR.tt_metrics.ratio = 0;
2630
2631       return;
2632     }
2633 #endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING */
2634
2635     if ( CUR.GS.freeVector.x == 0x4000 )
2636       CUR.F_dot_P       = CUR.GS.projVector.x * 0x10000L;
2637     else
2638     {
2639       if ( CUR.GS.freeVector.y == 0x4000 )
2640         CUR.F_dot_P       = CUR.GS.projVector.y * 0x10000L;
2641       else
2642         CUR.F_dot_P = (FT_Long)CUR.GS.projVector.x * CUR.GS.freeVector.x * 4 +
2643                       (FT_Long)CUR.GS.projVector.y * CUR.GS.freeVector.y * 4;
2644     }
2645
2646     if ( CUR.GS.projVector.x == 0x4000 )
2647       CUR.func_project = (TT_Project_Func)Project_x;
2648     else
2649     {
2650       if ( CUR.GS.projVector.y == 0x4000 )
2651         CUR.func_project = (TT_Project_Func)Project_y;
2652       else
2653         CUR.func_project = (TT_Project_Func)Project;
2654     }
2655
2656     if ( CUR.GS.dualVector.x == 0x4000 )
2657       CUR.func_dualproj = (TT_Project_Func)Project_x;
2658     else
2659     {
2660       if ( CUR.GS.dualVector.y == 0x4000 )
2661         CUR.func_dualproj = (TT_Project_Func)Project_y;
2662       else
2663         CUR.func_dualproj = (TT_Project_Func)Dual_Project;
2664     }
2665
2666     CUR.func_move      = (TT_Move_Func)Direct_Move;
2667     CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig;
2668
2669     if ( CUR.F_dot_P == 0x40000000L )
2670     {
2671       if ( CUR.GS.freeVector.x == 0x4000 )
2672       {
2673         CUR.func_move      = (TT_Move_Func)Direct_Move_X;
2674         CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig_X;
2675       }
2676       else
2677       {
2678         if ( CUR.GS.freeVector.y == 0x4000 )
2679         {
2680           CUR.func_move      = (TT_Move_Func)Direct_Move_Y;
2681           CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig_Y;
2682         }
2683       }
2684     }
2685
2686     /* at small sizes, F_dot_P can become too small, resulting   */
2687     /* in overflows and `spikes' in a number of glyphs like `w'. */
2688
2689     if ( FT_ABS( CUR.F_dot_P ) < 0x4000000L )
2690       CUR.F_dot_P = 0x40000000L;
2691
2692     /* Disable cached aspect ratio */
2693     CUR.tt_metrics.ratio = 0;
2694   }
2695
2696
2697   /*************************************************************************/
2698   /*                                                                       */
2699   /* <Function>                                                            */
2700   /*    Normalize                                                          */
2701   /*                                                                       */
2702   /* <Description>                                                         */
2703   /*    Norms a vector.                                                    */
2704   /*                                                                       */
2705   /* <Input>                                                               */
2706   /*    Vx :: The horizontal input vector coordinate.                      */
2707   /*    Vy :: The vertical input vector coordinate.                        */
2708   /*                                                                       */
2709   /* <Output>                                                              */
2710   /*    R  :: The normed unit vector.                                      */
2711   /*                                                                       */
2712   /* <Return>                                                              */
2713   /*    Returns FAILURE if a vector parameter is zero.                     */
2714   /*                                                                       */
2715   /* <Note>                                                                */
2716   /*    In case Vx and Vy are both zero, Normalize() returns SUCCESS, and  */
2717   /*    R is undefined.                                                    */
2718   /*                                                                       */
2719
2720
2721   static FT_Bool
2722   Normalize( EXEC_OP_ FT_F26Dot6      Vx,
2723                       FT_F26Dot6      Vy,
2724                       FT_UnitVector*  R )
2725   {
2726     FT_F26Dot6  W;
2727     FT_Bool     S1, S2;
2728
2729     FT_UNUSED_EXEC;
2730
2731
2732     if ( FT_ABS( Vx ) < 0x10000L && FT_ABS( Vy ) < 0x10000L )
2733     {
2734       Vx *= 0x100;
2735       Vy *= 0x100;
2736
2737       W = TT_VecLen( Vx, Vy );
2738
2739       if ( W == 0 )
2740       {
2741         /* XXX: UNDOCUMENTED! It seems that it is possible to try   */
2742         /*      to normalize the vector (0,0).  Return immediately. */
2743         return SUCCESS;
2744       }
2745
2746       R->x = (FT_F2Dot14)FT_MulDiv( Vx, 0x4000L, W );
2747       R->y = (FT_F2Dot14)FT_MulDiv( Vy, 0x4000L, W );
2748
2749       return SUCCESS;
2750     }
2751
2752     W = TT_VecLen( Vx, Vy );
2753
2754     Vx = FT_MulDiv( Vx, 0x4000L, W );
2755     Vy = FT_MulDiv( Vy, 0x4000L, W );
2756
2757     W = Vx * Vx + Vy * Vy;
2758
2759     /* Now, we want that Sqrt( W ) = 0x4000 */
2760     /* Or 0x10000000 <= W < 0x10004000      */
2761
2762     if ( Vx < 0 )
2763     {
2764       Vx = -Vx;
2765       S1 = TRUE;
2766     }
2767     else
2768       S1 = FALSE;
2769
2770     if ( Vy < 0 )
2771     {
2772       Vy = -Vy;
2773       S2 = TRUE;
2774     }
2775     else
2776       S2 = FALSE;
2777
2778     while ( W < 0x10000000L )
2779     {
2780       /* We need to increase W by a minimal amount */
2781       if ( Vx < Vy )
2782         Vx++;
2783       else
2784         Vy++;
2785
2786       W = Vx * Vx + Vy * Vy;
2787     }
2788
2789     while ( W >= 0x10004000L )
2790     {
2791       /* We need to decrease W by a minimal amount */
2792       if ( Vx < Vy )
2793         Vx--;
2794       else
2795         Vy--;
2796
2797       W = Vx * Vx + Vy * Vy;
2798     }
2799
2800     /* Note that in various cases, we can only  */
2801     /* compute a Sqrt(W) of 0x3FFF, eg. Vx = Vy */
2802
2803     if ( S1 )
2804       Vx = -Vx;
2805
2806     if ( S2 )
2807       Vy = -Vy;
2808
2809     R->x = (FT_F2Dot14)Vx;   /* Type conversion */
2810     R->y = (FT_F2Dot14)Vy;   /* Type conversion */
2811
2812     return SUCCESS;
2813   }
2814
2815
2816   /*************************************************************************/
2817   /*                                                                       */
2818   /* Here we start with the implementation of the various opcodes.         */
2819   /*                                                                       */
2820   /*************************************************************************/
2821
2822
2823   static FT_Bool
2824   Ins_SxVTL( EXEC_OP_ FT_UShort       aIdx1,
2825                       FT_UShort       aIdx2,
2826                       FT_Int          aOpc,
2827                       FT_UnitVector*  Vec )
2828   {
2829     FT_Long     A, B, C;
2830     FT_Vector*  p1;
2831     FT_Vector*  p2;
2832
2833
2834     if ( BOUNDS( aIdx1, CUR.zp2.n_points ) ||
2835          BOUNDS( aIdx2, CUR.zp1.n_points ) )
2836     {
2837       if ( CUR.pedantic_hinting )
2838         CUR.error = TT_Err_Invalid_Reference;
2839       return FAILURE;
2840     }
2841
2842     p1 = CUR.zp1.cur + aIdx2;
2843     p2 = CUR.zp2.cur + aIdx1;
2844
2845     A = p1->x - p2->x;
2846     B = p1->y - p2->y;
2847
2848     /* If p1 == p2, SPVTL and SFVTL behave the same as */
2849     /* SPVTCA[X] and SFVTCA[X], respectively.          */
2850     /*                                                 */
2851     /* Confirmed by Greg Hitchcock.                    */
2852
2853     if ( A == 0 && B == 0 )
2854     {
2855       A    = 0x4000;
2856       aOpc = 0;
2857     }
2858
2859     if ( ( aOpc & 1 ) != 0 )
2860     {
2861       C =  B;   /* counter clockwise rotation */
2862       B =  A;
2863       A = -C;
2864     }
2865
2866     NORMalize( A, B, Vec );
2867
2868     return SUCCESS;
2869   }
2870
2871
2872   /* When not using the big switch statements, the interpreter uses a */
2873   /* call table defined later below in this source.  Each opcode must */
2874   /* thus have a corresponding function, even trivial ones.           */
2875   /*                                                                  */
2876   /* They are all defined there.                                      */
2877
2878 #define DO_SVTCA                            \
2879   {                                         \
2880     FT_Short  A, B;                         \
2881                                             \
2882                                             \
2883     A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2884     B = A ^ (FT_Short)0x4000;               \
2885                                             \
2886     CUR.GS.freeVector.x = A;                \
2887     CUR.GS.projVector.x = A;                \
2888     CUR.GS.dualVector.x = A;                \
2889                                             \
2890     CUR.GS.freeVector.y = B;                \
2891     CUR.GS.projVector.y = B;                \
2892     CUR.GS.dualVector.y = B;                \
2893                                             \
2894     COMPUTE_Funcs();                        \
2895   }
2896
2897
2898 #define DO_SPVTCA                           \
2899   {                                         \
2900     FT_Short  A, B;                         \
2901                                             \
2902                                             \
2903     A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2904     B = A ^ (FT_Short)0x4000;               \
2905                                             \
2906     CUR.GS.projVector.x = A;                \
2907     CUR.GS.dualVector.x = A;                \
2908                                             \
2909     CUR.GS.projVector.y = B;                \
2910     CUR.GS.dualVector.y = B;                \
2911                                             \
2912     GUESS_VECTOR( freeVector );             \
2913                                             \
2914     COMPUTE_Funcs();                        \
2915   }
2916
2917
2918 #define DO_SFVTCA                           \
2919   {                                         \
2920     FT_Short  A, B;                         \
2921                                             \
2922                                             \
2923     A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2924     B = A ^ (FT_Short)0x4000;               \
2925                                             \
2926     CUR.GS.freeVector.x = A;                \
2927     CUR.GS.freeVector.y = B;                \
2928                                             \
2929     GUESS_VECTOR( projVector );             \
2930                                             \
2931     COMPUTE_Funcs();                        \
2932   }
2933
2934
2935 #define DO_SPVTL                                      \
2936     if ( INS_SxVTL( (FT_UShort)args[1],               \
2937                     (FT_UShort)args[0],               \
2938                     CUR.opcode,                       \
2939                     &CUR.GS.projVector ) == SUCCESS ) \
2940     {                                                 \
2941       CUR.GS.dualVector = CUR.GS.projVector;          \
2942       GUESS_VECTOR( freeVector );                     \
2943       COMPUTE_Funcs();                                \
2944     }
2945
2946
2947 #define DO_SFVTL                                      \
2948     if ( INS_SxVTL( (FT_UShort)args[1],               \
2949                     (FT_UShort)args[0],               \
2950                     CUR.opcode,                       \
2951                     &CUR.GS.freeVector ) == SUCCESS ) \
2952     {                                                 \
2953       GUESS_VECTOR( projVector );                     \
2954       COMPUTE_Funcs();                                \
2955     }
2956
2957
2958 #define DO_SFVTPV                          \
2959     GUESS_VECTOR( projVector );            \
2960     CUR.GS.freeVector = CUR.GS.projVector; \
2961     COMPUTE_Funcs();
2962
2963
2964 #define DO_SPVFS                                \
2965   {                                             \
2966     FT_Short  S;                                \
2967     FT_Long   X, Y;                             \
2968                                                 \
2969                                                 \
2970     /* Only use low 16bits, then sign extend */ \
2971     S = (FT_Short)args[1];                      \
2972     Y = (FT_Long)S;                             \
2973     S = (FT_Short)args[0];                      \
2974     X = (FT_Long)S;                             \
2975                                                 \
2976     NORMalize( X, Y, &CUR.GS.projVector );      \
2977                                                 \
2978     CUR.GS.dualVector = CUR.GS.projVector;      \
2979     GUESS_VECTOR( freeVector );                 \
2980     COMPUTE_Funcs();                            \
2981   }
2982
2983
2984 #define DO_SFVFS                                \
2985   {                                             \
2986     FT_Short  S;                                \
2987     FT_Long   X, Y;                             \
2988                                                 \
2989                                                 \
2990     /* Only use low 16bits, then sign extend */ \
2991     S = (FT_Short)args[1];                      \
2992     Y = (FT_Long)S;                             \
2993     S = (FT_Short)args[0];                      \
2994     X = S;                                      \
2995                                                 \
2996     NORMalize( X, Y, &CUR.GS.freeVector );      \
2997     GUESS_VECTOR( projVector );                 \
2998     COMPUTE_Funcs();                            \
2999   }
3000
3001
3002 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
3003 #define DO_GPV                                   \
3004     if ( CUR.face->unpatented_hinting )          \
3005     {                                            \
3006       args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
3007       args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
3008     }                                            \
3009     else                                         \
3010     {                                            \
3011       args[0] = CUR.GS.projVector.x;             \
3012       args[1] = CUR.GS.projVector.y;             \
3013     }
3014 #else
3015 #define DO_GPV                                   \
3016     args[0] = CUR.GS.projVector.x;               \
3017     args[1] = CUR.GS.projVector.y;
3018 #endif
3019
3020
3021 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
3022 #define DO_GFV                                   \
3023     if ( CUR.face->unpatented_hinting )          \
3024     {                                            \
3025       args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
3026       args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
3027     }                                            \
3028     else                                         \
3029     {                                            \
3030       args[0] = CUR.GS.freeVector.x;             \
3031       args[1] = CUR.GS.freeVector.y;             \
3032     }
3033 #else
3034 #define DO_GFV                                   \
3035     args[0] = CUR.GS.freeVector.x;               \
3036     args[1] = CUR.GS.freeVector.y;
3037 #endif
3038
3039
3040 #define DO_SRP0                      \
3041     CUR.GS.rp0 = (FT_UShort)args[0];
3042
3043
3044 #define DO_SRP1                      \
3045     CUR.GS.rp1 = (FT_UShort)args[0];
3046
3047
3048 #define DO_SRP2                      \
3049     CUR.GS.rp2 = (FT_UShort)args[0];
3050
3051
3052 #define DO_RTHG                                         \
3053     CUR.GS.round_state = TT_Round_To_Half_Grid;         \
3054     CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
3055
3056
3057 #define DO_RTG                                     \
3058     CUR.GS.round_state = TT_Round_To_Grid;         \
3059     CUR.func_round = (TT_Round_Func)Round_To_Grid;
3060
3061
3062 #define DO_RTDG                                           \
3063     CUR.GS.round_state = TT_Round_To_Double_Grid;         \
3064     CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
3065
3066
3067 #define DO_RUTG                                       \
3068     CUR.GS.round_state = TT_Round_Up_To_Grid;         \
3069     CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
3070
3071
3072 #define DO_RDTG                                         \
3073     CUR.GS.round_state = TT_Round_Down_To_Grid;         \
3074     CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
3075
3076
3077 #define DO_ROFF                                 \
3078     CUR.GS.round_state = TT_Round_Off;          \
3079     CUR.func_round = (TT_Round_Func)Round_None;
3080
3081
3082 #define DO_SROUND                                \
3083     SET_SuperRound( 0x4000, args[0] );           \
3084     CUR.GS.round_state = TT_Round_Super;         \
3085     CUR.func_round = (TT_Round_Func)Round_Super;
3086
3087
3088 #define DO_S45ROUND                                 \
3089     SET_SuperRound( 0x2D41, args[0] );              \
3090     CUR.GS.round_state = TT_Round_Super_45;         \
3091     CUR.func_round = (TT_Round_Func)Round_Super_45;
3092
3093
3094 #define DO_SLOOP                       \
3095     if ( args[0] < 0 )                 \
3096       CUR.error = TT_Err_Bad_Argument; \
3097     else                               \
3098       CUR.GS.loop = args[0];
3099
3100
3101 #define DO_SMD                         \
3102     CUR.GS.minimum_distance = args[0];
3103
3104
3105 #define DO_SCVTCI                                     \
3106     CUR.GS.control_value_cutin = (FT_F26Dot6)args[0];
3107
3108
3109 #define DO_SSWCI                                     \
3110     CUR.GS.single_width_cutin = (FT_F26Dot6)args[0];
3111
3112
3113     /* XXX: UNDOCUMENTED! or bug in the Windows engine?   */
3114     /*                                                    */
3115     /*      It seems that the value that is read here is  */
3116     /*      expressed in 16.16 format rather than in font */
3117     /*      units.                                        */
3118     /*                                                    */
3119 #define DO_SSW                                                 \
3120     CUR.GS.single_width_value = (FT_F26Dot6)( args[0] >> 10 );
3121
3122
3123 #define DO_FLIPON            \
3124     CUR.GS.auto_flip = TRUE;
3125
3126
3127 #define DO_FLIPOFF            \
3128     CUR.GS.auto_flip = FALSE;
3129
3130
3131 #define DO_SDB                             \
3132     CUR.GS.delta_base = (FT_Short)args[0];
3133
3134
3135 #define DO_SDS                              \
3136     CUR.GS.delta_shift = (FT_Short)args[0];
3137
3138
3139 #define DO_MD  /* nothing */
3140
3141
3142 #define DO_MPPEM              \
3143     args[0] = CURRENT_Ppem();
3144
3145
3146   /* Note: The pointSize should be irrelevant in a given font program; */
3147   /*       we thus decide to return only the ppem.                     */
3148 #if 0
3149
3150 #define DO_MPS                       \
3151     args[0] = CUR.metrics.pointSize;
3152
3153 #else
3154
3155 #define DO_MPS                \
3156     args[0] = CURRENT_Ppem();
3157
3158 #endif /* 0 */
3159
3160
3161 #define DO_DUP         \
3162     args[1] = args[0];
3163
3164
3165 #define DO_CLEAR     \
3166     CUR.new_top = 0;
3167
3168
3169 #define DO_SWAP        \
3170   {                    \
3171     FT_Long  L;        \
3172                        \
3173                        \
3174     L       = args[0]; \
3175     args[0] = args[1]; \
3176     args[1] = L;       \
3177   }
3178
3179
3180 #define DO_DEPTH       \
3181     args[0] = CUR.top;
3182
3183
3184 #define DO_CINDEX                             \
3185   {                                           \
3186     FT_Long  L;                               \
3187                                               \
3188                                               \
3189     L = args[0];                              \
3190                                               \
3191     if ( L <= 0 || L > CUR.args )             \
3192     {                                         \
3193       if ( CUR.pedantic_hinting )             \
3194         CUR.error = TT_Err_Invalid_Reference; \
3195       args[0] = 0;                            \
3196     }                                         \
3197     else                                      \
3198       args[0] = CUR.stack[CUR.args - L];      \
3199   }
3200
3201
3202 #define DO_JROT                                                   \
3203     if ( args[1] != 0 )                                           \
3204     {                                                             \
3205       if ( args[0] == 0 && CUR.args == 0 )                        \
3206         CUR.error = TT_Err_Bad_Argument;                          \
3207       CUR.IP += args[0];                                          \
3208       if ( CUR.IP < 0                                          || \
3209            ( CUR.callTop > 0                                 &&   \
3210              CUR.IP > CUR.callStack[CUR.callTop - 1].Cur_End ) )  \
3211         CUR.error = TT_Err_Bad_Argument;                          \
3212       CUR.step_ins = FALSE;                                       \
3213     }
3214
3215
3216 #define DO_JMPR                                                 \
3217     if ( args[0] == 0 && CUR.args == 0 )                        \
3218       CUR.error = TT_Err_Bad_Argument;                          \
3219     CUR.IP += args[0];                                          \
3220     if ( CUR.IP < 0                                          || \
3221          ( CUR.callTop > 0                                 &&   \
3222            CUR.IP > CUR.callStack[CUR.callTop - 1].Cur_End ) )  \
3223       CUR.error = TT_Err_Bad_Argument;                          \
3224     CUR.step_ins = FALSE;
3225
3226
3227 #define DO_JROF                                                   \
3228     if ( args[1] == 0 )                                           \
3229     {                                                             \
3230       if ( args[0] == 0 && CUR.args == 0 )                        \
3231         CUR.error = TT_Err_Bad_Argument;                          \
3232       CUR.IP += args[0];                                          \
3233       if ( CUR.IP < 0                                          || \
3234            ( CUR.callTop > 0                                 &&   \
3235              CUR.IP > CUR.callStack[CUR.callTop - 1].Cur_End ) )  \
3236         CUR.error = TT_Err_Bad_Argument;                          \
3237       CUR.step_ins = FALSE;                                       \
3238     }
3239
3240
3241 #define DO_LT                        \
3242     args[0] = ( args[0] < args[1] );
3243
3244
3245 #define DO_LTEQ                       \
3246     args[0] = ( args[0] <= args[1] );
3247
3248
3249 #define DO_GT                        \
3250     args[0] = ( args[0] > args[1] );
3251
3252
3253 #define DO_GTEQ                       \
3254     args[0] = ( args[0] >= args[1] );
3255
3256
3257 #define DO_EQ                         \
3258     args[0] = ( args[0] == args[1] );
3259
3260
3261 #define DO_NEQ                        \
3262     args[0] = ( args[0] != args[1] );
3263
3264
3265 #define DO_ODD                                                  \
3266     args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 64 );
3267
3268
3269 #define DO_EVEN                                                \
3270     args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 0 );
3271
3272
3273 #define DO_AND                        \
3274     args[0] = ( args[0] && args[1] );
3275
3276
3277 #define DO_OR                         \
3278     args[0] = ( args[0] || args[1] );
3279
3280
3281 #define DO_NOT          \
3282     args[0] = !args[0];
3283
3284
3285 #define DO_ADD          \
3286     args[0] += args[1];
3287
3288
3289 #define DO_SUB          \
3290     args[0] -= args[1];
3291
3292
3293 #define DO_DIV                                               \
3294     if ( args[1] == 0 )                                      \
3295       CUR.error = TT_Err_Divide_By_Zero;                     \
3296     else                                                     \
3297       args[0] = TT_MULDIV_NO_ROUND( args[0], 64L, args[1] );
3298
3299
3300 #define DO_MUL                                    \
3301     args[0] = TT_MULDIV( args[0], args[1], 64L );
3302
3303
3304 #define DO_ABS                   \
3305     args[0] = FT_ABS( args[0] );
3306
3307
3308 #define DO_NEG          \
3309     args[0] = -args[0];
3310
3311
3312 #define DO_FLOOR    \
3313     args[0] = FT_PIX_FLOOR( args[0] );
3314
3315
3316 #define DO_CEILING                    \
3317     args[0] = FT_PIX_CEIL( args[0] );
3318
3319
3320 #define DO_RS                           \
3321    {                                    \
3322      FT_ULong  I = (FT_ULong)args[0];   \
3323                                         \
3324                                         \
3325      if ( BOUNDSL( I, CUR.storeSize ) ) \
3326      {                                  \
3327        if ( CUR.pedantic_hinting )      \
3328        {                                \
3329          ARRAY_BOUND_ERROR;             \
3330        }                                \
3331        else                             \
3332          args[0] = 0;                   \
3333      }                                  \
3334      else                               \
3335        args[0] = CUR.storage[I];        \
3336    }
3337
3338
3339 #define DO_WS                           \
3340    {                                    \
3341      FT_ULong  I = (FT_ULong)args[0];   \
3342                                         \
3343                                         \
3344      if ( BOUNDSL( I, CUR.storeSize ) ) \
3345      {                                  \
3346        if ( CUR.pedantic_hinting )      \
3347        {                                \
3348          ARRAY_BOUND_ERROR;             \
3349        }                                \
3350      }                                  \
3351      else                               \
3352        CUR.storage[I] = args[1];        \
3353    }
3354
3355
3356 #define DO_RCVT                          \
3357    {                                     \
3358      FT_ULong  I = (FT_ULong)args[0];    \
3359                                          \
3360                                          \
3361      if ( BOUNDSL( I, CUR.cvtSize ) )    \
3362      {                                   \
3363        if ( CUR.pedantic_hinting )       \
3364        {                                 \
3365          ARRAY_BOUND_ERROR;              \
3366        }                                 \
3367        else                              \
3368          args[0] = 0;                    \
3369      }                                   \
3370      else                                \
3371        args[0] = CUR_Func_read_cvt( I ); \
3372    }
3373
3374
3375 #define DO_WCVTP                         \
3376    {                                     \
3377      FT_ULong  I = (FT_ULong)args[0];    \
3378                                          \
3379                                          \
3380      if ( BOUNDSL( I, CUR.cvtSize ) )    \
3381      {                                   \
3382        if ( CUR.pedantic_hinting )       \
3383        {                                 \
3384          ARRAY_BOUND_ERROR;              \
3385        }                                 \
3386      }                                   \
3387      else                                \
3388        CUR_Func_write_cvt( I, args[1] ); \
3389    }
3390
3391
3392 #define DO_WCVTF                                                \
3393    {                                                            \
3394      FT_ULong  I = (FT_ULong)args[0];                           \
3395                                                                 \
3396                                                                 \
3397      if ( BOUNDSL( I, CUR.cvtSize ) )                           \
3398      {                                                          \
3399        if ( CUR.pedantic_hinting )                              \
3400        {                                                        \
3401          ARRAY_BOUND_ERROR;                                     \
3402        }                                                        \
3403      }                                                          \
3404      else                                                       \
3405        CUR.cvt[I] = TT_MULFIX( args[1], CUR.tt_metrics.scale ); \
3406    }
3407
3408
3409 #define DO_DEBUG                     \
3410     CUR.error = TT_Err_Debug_OpCode;
3411
3412
3413 #define DO_ROUND                                                   \
3414     args[0] = CUR_Func_round(                                      \
3415                 args[0],                                           \
3416                 CUR.tt_metrics.compensations[CUR.opcode - 0x68] );
3417
3418
3419 #define DO_NROUND                                                            \
3420     args[0] = ROUND_None( args[0],                                           \
3421                           CUR.tt_metrics.compensations[CUR.opcode - 0x6C] );
3422
3423
3424 #define DO_MAX               \
3425     if ( args[1] > args[0] ) \
3426       args[0] = args[1];
3427
3428
3429 #define DO_MIN               \
3430     if ( args[1] < args[0] ) \
3431       args[0] = args[1];
3432
3433
3434 #ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
3435
3436
3437 #undef  ARRAY_BOUND_ERROR
3438 #define ARRAY_BOUND_ERROR                   \
3439     {                                       \
3440       CUR.error = TT_Err_Invalid_Reference; \
3441       return;                               \
3442     }
3443
3444
3445   /*************************************************************************/
3446   /*                                                                       */
3447   /* SVTCA[a]:     Set (F and P) Vectors to Coordinate Axis                */
3448   /* Opcode range: 0x00-0x01                                               */
3449   /* Stack:        -->                                                     */
3450   /*                                                                       */
3451   static void
3452   Ins_SVTCA( INS_ARG )
3453   {
3454     DO_SVTCA
3455   }
3456
3457
3458   /*************************************************************************/
3459   /*                                                                       */
3460   /* SPVTCA[a]:    Set PVector to Coordinate Axis                          */
3461   /* Opcode range: 0x02-0x03                                               */
3462   /* Stack:        -->                                                     */
3463   /*                                                                       */
3464   static void
3465   Ins_SPVTCA( INS_ARG )
3466   {
3467     DO_SPVTCA
3468   }
3469
3470
3471   /*************************************************************************/
3472   /*                                                                       */
3473   /* SFVTCA[a]:    Set FVector to Coordinate Axis                          */
3474   /* Opcode range: 0x04-0x05                                               */
3475   /* Stack:        -->                                                     */
3476   /*                                                                       */
3477   static void
3478   Ins_SFVTCA( INS_ARG )
3479   {
3480     DO_SFVTCA
3481   }
3482
3483
3484   /*************************************************************************/
3485   /*                                                                       */
3486   /* SPVTL[a]:     Set PVector To Line                                     */
3487   /* Opcode range: 0x06-0x07                                               */
3488   /* Stack:        uint32 uint32 -->                                       */
3489   /*                                                                       */
3490   static void
3491   Ins_SPVTL( INS_ARG )
3492   {
3493     DO_SPVTL
3494   }
3495
3496
3497   /*************************************************************************/
3498   /*                                                                       */
3499   /* SFVTL[a]:     Set FVector To Line                                     */
3500   /* Opcode range: 0x08-0x09                                               */
3501   /* Stack:        uint32 uint32 -->                                       */
3502   /*                                                                       */
3503   static void
3504   Ins_SFVTL( INS_ARG )
3505   {
3506     DO_SFVTL
3507   }
3508
3509
3510   /*************************************************************************/
3511   /*                                                                       */
3512   /* SFVTPV[]:     Set FVector To PVector                                  */
3513   /* Opcode range: 0x0E                                                    */
3514   /* Stack:        -->                                                     */
3515   /*                                                                       */
3516   static void
3517   Ins_SFVTPV( INS_ARG )
3518   {
3519     DO_SFVTPV
3520   }
3521
3522
3523   /*************************************************************************/
3524   /*                                                                       */
3525   /* SPVFS[]:      Set PVector From Stack                                  */
3526   /* Opcode range: 0x0A                                                    */
3527   /* Stack:        f2.14 f2.14 -->                                         */
3528   /*                                                                       */
3529   static void
3530   Ins_SPVFS( INS_ARG )
3531   {
3532     DO_SPVFS
3533   }
3534
3535
3536   /*************************************************************************/
3537   /*                                                                       */
3538   /* SFVFS[]:      Set FVector From Stack                                  */
3539   /* Opcode range: 0x0B                                                    */
3540   /* Stack:        f2.14 f2.14 -->                                         */
3541   /*                                                                       */
3542   static void
3543   Ins_SFVFS( INS_ARG )
3544   {
3545     DO_SFVFS
3546   }
3547
3548
3549   /*************************************************************************/
3550   /*                                                                       */
3551   /* GPV[]:        Get Projection Vector                                   */
3552   /* Opcode range: 0x0C                                                    */
3553   /* Stack:        ef2.14 --> ef2.14                                       */
3554   /*                                                                       */
3555   static void
3556   Ins_GPV( INS_ARG )
3557   {
3558     DO_GPV
3559   }
3560
3561
3562   /*************************************************************************/
3563   /* GFV[]:        Get Freedom Vector                                      */
3564   /* Opcode range: 0x0D                                                    */
3565   /* Stack:        ef2.14 --> ef2.14                                       */
3566   /*                                                                       */
3567   static void
3568   Ins_GFV( INS_ARG )
3569   {
3570     DO_GFV
3571   }
3572
3573
3574   /*************************************************************************/
3575   /*                                                                       */
3576   /* SRP0[]:       Set Reference Point 0                                   */
3577   /* Opcode range: 0x10                                                    */
3578   /* Stack:        uint32 -->                                              */
3579   /*                                                                       */
3580   static void
3581   Ins_SRP0( INS_ARG )
3582   {
3583     DO_SRP0
3584   }
3585
3586
3587   /*************************************************************************/
3588   /*                                                                       */
3589   /* SRP1[]:       Set Reference Point 1                                   */
3590   /* Opcode range: 0x11                                                    */
3591   /* Stack:        uint32 -->                                              */
3592   /*                                                                       */
3593   static void
3594   Ins_SRP1( INS_ARG )
3595   {
3596     DO_SRP1
3597   }
3598
3599
3600   /*************************************************************************/
3601   /*                                                                       */
3602   /* SRP2[]:       Set Reference Point 2                                   */
3603   /* Opcode range: 0x12                                                    */
3604   /* Stack:        uint32 -->                                              */
3605   /*                                                                       */
3606   static void
3607   Ins_SRP2( INS_ARG )
3608   {
3609     DO_SRP2
3610   }
3611
3612
3613   /*************************************************************************/
3614   /*                                                                       */
3615   /* RTHG[]:       Round To Half Grid                                      */
3616   /* Opcode range: 0x19                                                    */
3617   /* Stack:        -->                                                     */
3618   /*                                                                       */
3619   static void
3620   Ins_RTHG( INS_ARG )
3621   {
3622     DO_RTHG
3623   }
3624
3625
3626   /*************************************************************************/
3627   /*                                                                       */
3628   /* RTG[]:        Round To Grid                                           */
3629   /* Opcode range: 0x18                                                    */
3630   /* Stack:        -->                                                     */
3631   /*                                                                       */
3632   static void
3633   Ins_RTG( INS_ARG )
3634   {
3635     DO_RTG
3636   }
3637
3638
3639   /*************************************************************************/
3640   /* RTDG[]:       Round To Double Grid                                    */
3641   /* Opcode range: 0x3D                                                    */
3642   /* Stack:        -->                                                     */
3643   /*                                                                       */
3644   static void
3645   Ins_RTDG( INS_ARG )
3646   {
3647     DO_RTDG
3648   }
3649
3650
3651   /*************************************************************************/
3652   /* RUTG[]:       Round Up To Grid                                        */
3653   /* Opcode range: 0x7C                                                    */
3654   /* Stack:        -->                                                     */
3655   /*                                                                       */
3656   static void
3657   Ins_RUTG( INS_ARG )
3658   {
3659     DO_RUTG
3660   }
3661
3662
3663   /*************************************************************************/
3664   /*                                                                       */
3665   /* RDTG[]:       Round Down To Grid                                      */
3666   /* Opcode range: 0x7D                                                    */
3667   /* Stack:        -->                                                     */
3668   /*                                                                       */
3669   static void
3670   Ins_RDTG( INS_ARG )
3671   {
3672     DO_RDTG
3673   }
3674
3675
3676   /*************************************************************************/
3677   /*                                                                       */
3678   /* ROFF[]:       Round OFF                                               */
3679   /* Opcode range: 0x7A                                                    */
3680   /* Stack:        -->                                                     */
3681   /*                                                                       */
3682   static void
3683   Ins_ROFF( INS_ARG )
3684   {
3685     DO_ROFF
3686   }
3687
3688
3689   /*************************************************************************/
3690   /*                                                                       */
3691   /* SROUND[]:     Super ROUND                                             */
3692   /* Opcode range: 0x76                                                    */
3693   /* Stack:        Eint8 -->                                               */
3694   /*                                                                       */
3695   static void
3696   Ins_SROUND( INS_ARG )
3697   {
3698     DO_SROUND
3699   }
3700
3701
3702   /*************************************************************************/
3703   /*                                                                       */
3704   /* S45ROUND[]:   Super ROUND 45 degrees                                  */
3705   /* Opcode range: 0x77                                                    */
3706   /* Stack:        uint32 -->                                              */
3707   /*                                                                       */
3708   static void
3709   Ins_S45ROUND( INS_ARG )
3710   {
3711     DO_S45ROUND
3712   }
3713
3714
3715   /*************************************************************************/
3716   /*                                                                       */
3717   /* SLOOP[]:      Set LOOP variable                                       */
3718   /* Opcode range: 0x17                                                    */
3719   /* Stack:        int32? -->                                              */
3720   /*                                                                       */
3721   static void
3722   Ins_SLOOP( INS_ARG )
3723   {
3724     DO_SLOOP
3725   }
3726
3727
3728   /*************************************************************************/
3729   /*                                                                       */
3730   /* SMD[]:        Set Minimum Distance                                    */
3731   /* Opcode range: 0x1A                                                    */
3732   /* Stack:        f26.6 -->                                               */
3733   /*                                                                       */
3734   static void
3735   Ins_SMD( INS_ARG )
3736   {
3737     DO_SMD
3738   }
3739
3740
3741   /*************************************************************************/
3742   /*                                                                       */
3743   /* SCVTCI[]:     Set Control Value Table Cut In                          */
3744   /* Opcode range: 0x1D                                                    */
3745   /* Stack:        f26.6 -->                                               */
3746   /*                                                                       */
3747   static void
3748   Ins_SCVTCI( INS_ARG )
3749   {
3750     DO_SCVTCI
3751   }
3752
3753
3754   /*************************************************************************/
3755   /*                                                                       */
3756   /* SSWCI[]:      Set Single Width Cut In                                 */
3757   /* Opcode range: 0x1E                                                    */
3758   /* Stack:        f26.6 -->                                               */
3759   /*                                                                       */
3760   static void
3761   Ins_SSWCI( INS_ARG )
3762   {
3763     DO_SSWCI
3764   }
3765
3766
3767   /*************************************************************************/
3768   /*                                                                       */
3769   /* SSW[]:        Set Single Width                                        */
3770   /* Opcode range: 0x1F                                                    */
3771   /* Stack:        int32? -->                                              */
3772   /*                                                                       */
3773   static void
3774   Ins_SSW( INS_ARG )
3775   {
3776     DO_SSW
3777   }
3778
3779
3780   /*************************************************************************/
3781   /*                                                                       */
3782   /* FLIPON[]:     Set auto-FLIP to ON                                     */
3783   /* Opcode range: 0x4D                                                    */
3784   /* Stack:        -->                                                     */
3785   /*                                                                       */
3786   static void
3787   Ins_FLIPON( INS_ARG )
3788   {
3789     DO_FLIPON
3790   }
3791
3792
3793   /*************************************************************************/
3794   /*                                                                       */
3795   /* FLIPOFF[]:    Set auto-FLIP to OFF                                    */
3796   /* Opcode range: 0x4E                                                    */
3797   /* Stack: -->                                                            */
3798   /*                                                                       */
3799   static void
3800   Ins_FLIPOFF( INS_ARG )
3801   {
3802     DO_FLIPOFF
3803   }
3804
3805
3806   /*************************************************************************/
3807   /*                                                                       */
3808   /* SANGW[]:      Set ANGle Weight                                        */
3809   /* Opcode range: 0x7E                                                    */
3810   /* Stack:        uint32 -->                                              */
3811   /*                                                                       */
3812   static void
3813   Ins_SANGW( INS_ARG )
3814   {
3815     /* instruction not supported anymore */
3816   }
3817
3818
3819   /*************************************************************************/
3820   /*                                                                       */
3821   /* SDB[]:        Set Delta Base                                          */
3822   /* Opcode range: 0x5E                                                    */
3823   /* Stack:        uint32 -->                                              */
3824   /*                                                                       */
3825   static void
3826   Ins_SDB( INS_ARG )
3827   {
3828     DO_SDB
3829   }
3830
3831
3832   /*************************************************************************/
3833   /*                                                                       */
3834   /* SDS[]:        Set Delta Shift                                         */
3835   /* Opcode range: 0x5F                                                    */
3836   /* Stack:        uint32 -->                                              */
3837   /*                                                                       */
3838   static void
3839   Ins_SDS( INS_ARG )
3840   {
3841     DO_SDS
3842   }
3843
3844
3845   /*************************************************************************/
3846   /*                                                                       */
3847   /* MPPEM[]:      Measure Pixel Per EM                                    */
3848   /* Opcode range: 0x4B                                                    */
3849   /* Stack:        --> Euint16                                             */
3850   /*                                                                       */
3851   static void
3852   Ins_MPPEM( INS_ARG )
3853   {
3854     DO_MPPEM
3855   }
3856
3857
3858   /*************************************************************************/
3859   /*                                                                       */
3860   /* MPS[]:        Measure Point Size                                      */
3861   /* Opcode range: 0x4C                                                    */
3862   /* Stack:        --> Euint16                                             */
3863   /*                                                                       */
3864   static void
3865   Ins_MPS( INS_ARG )
3866   {
3867     DO_MPS
3868   }
3869
3870
3871   /*************************************************************************/
3872   /*                                                                       */
3873   /* DUP[]:        DUPlicate the top stack's element                       */
3874   /* Opcode range: 0x20                                                    */
3875   /* Stack:        StkElt --> StkElt StkElt                                */
3876   /*                                                                       */
3877   static void
3878   Ins_DUP( INS_ARG )
3879   {
3880     DO_DUP
3881   }
3882
3883
3884   /*************************************************************************/
3885   /*                                                                       */
3886   /* POP[]:        POP the stack's top element                             */
3887   /* Opcode range: 0x21                                                    */
3888   /* Stack:        StkElt -->                                              */
3889   /*                                                                       */
3890   static void
3891   Ins_POP( INS_ARG )
3892   {
3893     /* nothing to do */
3894   }
3895
3896
3897   /*************************************************************************/
3898   /*                                                                       */
3899   /* CLEAR[]:      CLEAR the entire stack                                  */
3900   /* Opcode range: 0x22                                                    */
3901   /* Stack:        StkElt... -->                                           */
3902   /*                                                                       */
3903   static void
3904   Ins_CLEAR( INS_ARG )
3905   {
3906     DO_CLEAR
3907   }
3908
3909
3910   /*************************************************************************/
3911   /*                                                                       */
3912   /* SWAP[]:       SWAP the stack's top two elements                       */
3913   /* Opcode range: 0x23                                                    */
3914   /* Stack:        2 * StkElt --> 2 * StkElt                               */
3915   /*                                                                       */
3916   static void
3917   Ins_SWAP( INS_ARG )
3918   {
3919     DO_SWAP
3920   }
3921
3922
3923   /*************************************************************************/
3924   /*                                                                       */
3925   /* DEPTH[]:      return the stack DEPTH                                  */
3926   /* Opcode range: 0x24                                                    */
3927   /* Stack:        --> uint32                                              */
3928   /*                                                                       */
3929   static void
3930   Ins_DEPTH( INS_ARG )
3931   {
3932     DO_DEPTH
3933   }
3934
3935
3936   /*************************************************************************/
3937   /*                                                                       */
3938   /* CINDEX[]:     Copy INDEXed element                                    */
3939   /* Opcode range: 0x25                                                    */
3940   /* Stack:        int32 --> StkElt                                        */
3941   /*                                                                       */
3942   static void
3943   Ins_CINDEX( INS_ARG )
3944   {
3945     DO_CINDEX
3946   }
3947
3948
3949   /*************************************************************************/
3950   /*                                                                       */
3951   /* EIF[]:        End IF                                                  */
3952   /* Opcode range: 0x59                                                    */
3953   /* Stack:        -->                                                     */
3954   /*                                                                       */
3955   static void
3956   Ins_EIF( INS_ARG )
3957   {
3958     /* nothing to do */
3959   }
3960
3961
3962   /*************************************************************************/
3963   /*                                                                       */
3964   /* JROT[]:       Jump Relative On True                                   */
3965   /* Opcode range: 0x78                                                    */
3966   /* Stack:        StkElt int32 -->                                        */
3967   /*                                                                       */
3968   static void
3969   Ins_JROT( INS_ARG )
3970   {
3971     DO_JROT
3972   }
3973
3974
3975   /*************************************************************************/
3976   /*                                                                       */
3977   /* JMPR[]:       JuMP Relative                                           */
3978   /* Opcode range: 0x1C                                                    */
3979   /* Stack:        int32 -->                                               */
3980   /*                                                                       */
3981   static void
3982   Ins_JMPR( INS_ARG )
3983   {
3984     DO_JMPR
3985   }
3986
3987
3988   /*************************************************************************/
3989   /*                                                                       */
3990   /* JROF[]:       Jump Relative On False                                  */
3991   /* Opcode range: 0x79                                                    */
3992   /* Stack:        StkElt int32 -->                                        */
3993   /*                                                                       */
3994   static void
3995   Ins_JROF( INS_ARG )
3996   {
3997     DO_JROF
3998   }
3999
4000
4001   /*************************************************************************/
4002   /*                                                                       */
4003   /* LT[]:         Less Than                                               */
4004   /* Opcode range: 0x50                                                    */
4005   /* Stack:        int32? int32? --> bool                                  */
4006   /*                                                                       */
4007   static void
4008   Ins_LT( INS_ARG )
4009   {
4010     DO_LT
4011   }
4012
4013
4014   /*************************************************************************/
4015   /*                                                                       */
4016   /* LTEQ[]:       Less Than or EQual                                      */
4017   /* Opcode range: 0x51                                                    */
4018   /* Stack:        int32? int32? --> bool                                  */
4019   /*                                                                       */
4020   static void
4021   Ins_LTEQ( INS_ARG )
4022   {
4023     DO_LTEQ
4024   }
4025
4026
4027   /*************************************************************************/
4028   /*                                                                       */
4029   /* GT[]:         Greater Than                                            */
4030   /* Opcode range: 0x52                                                    */
4031   /* Stack:        int32? int32? --> bool                                  */
4032   /*                                                                       */
4033   static void
4034   Ins_GT( INS_ARG )
4035   {
4036     DO_GT
4037   }
4038
4039
4040   /*************************************************************************/
4041   /*                                                                       */
4042   /* GTEQ[]:       Greater Than or EQual                                   */
4043   /* Opcode range: 0x53                                                    */
4044   /* Stack:        int32? int32? --> bool                                  */
4045   /*                                                                       */
4046   static void
4047   Ins_GTEQ( INS_ARG )
4048   {
4049     DO_GTEQ
4050   }
4051
4052
4053   /*************************************************************************/
4054   /*                                                                       */
4055   /* EQ[]:         EQual                                                   */
4056   /* Opcode range: 0x54                                                    */
4057   /* Stack:        StkElt StkElt --> bool                                  */
4058   /*                                                                       */
4059   static void
4060   Ins_EQ( INS_ARG )
4061   {
4062     DO_EQ
4063   }
4064
4065
4066   /*************************************************************************/
4067   /*                                                                       */
4068   /* NEQ[]:        Not EQual                                               */
4069   /* Opcode range: 0x55                                                    */
4070   /* Stack:        StkElt StkElt --> bool                                  */
4071   /*                                                                       */
4072   static void
4073   Ins_NEQ( INS_ARG )
4074   {
4075     DO_NEQ
4076   }
4077
4078
4079   /*************************************************************************/
4080   /*                                                                       */
4081   /* ODD[]:        Is ODD                                                  */
4082   /* Opcode range: 0x56                                                    */
4083   /* Stack:        f26.6 --> bool                                          */
4084   /*                                                                       */
4085   static void
4086   Ins_ODD( INS_ARG )
4087   {
4088     DO_ODD
4089   }
4090
4091
4092   /*************************************************************************/
4093   /*                                                                       */
4094   /* EVEN[]:       Is EVEN                                                 */
4095   /* Opcode range: 0x57                                                    */
4096   /* Stack:        f26.6 --> bool                                          */
4097   /*                                                                       */
4098   static void
4099   Ins_EVEN( INS_ARG )
4100   {
4101     DO_EVEN
4102   }
4103
4104
4105   /*************************************************************************/
4106   /*                                                                       */
4107   /* AND[]:        logical AND                                             */
4108   /* Opcode range: 0x5A                                                    */
4109   /* Stack:        uint32 uint32 --> uint32                                */
4110   /*                                                                       */
4111   static void
4112   Ins_AND( INS_ARG )
4113   {
4114     DO_AND
4115   }
4116
4117
4118   /*************************************************************************/
4119   /*                                                                       */
4120   /* OR[]:         logical OR                                              */
4121   /* Opcode range: 0x5B                                                    */
4122   /* Stack:        uint32 uint32 --> uint32                                */
4123   /*                                                                       */
4124   static void
4125   Ins_OR( INS_ARG )
4126   {
4127     DO_OR
4128   }
4129
4130
4131   /*************************************************************************/
4132   /*                                                                       */
4133   /* NOT[]:        logical NOT                                             */
4134   /* Opcode range: 0x5C                                                    */
4135   /* Stack:        StkElt --> uint32                                       */
4136   /*                                                                       */
4137   static void
4138   Ins_NOT( INS_ARG )
4139   {
4140     DO_NOT
4141   }
4142
4143
4144   /*************************************************************************/
4145   /*                                                                       */
4146   /* ADD[]:        ADD                                                     */
4147   /* Opcode range: 0x60                                                    */
4148   /* Stack:        f26.6 f26.6 --> f26.6                                   */
4149   /*                                                                       */
4150   static void
4151   Ins_ADD( INS_ARG )
4152   {
4153     DO_ADD
4154   }
4155
4156
4157   /*************************************************************************/
4158   /*                                                                       */
4159   /* SUB[]:        SUBtract                                                */
4160   /* Opcode range: 0x61                                                    */
4161   /* Stack:        f26.6 f26.6 --> f26.6                                   */
4162   /*                                                                       */
4163   static void
4164   Ins_SUB( INS_ARG )
4165   {
4166     DO_SUB
4167   }
4168
4169
4170   /*************************************************************************/
4171   /*                                                                       */
4172   /* DIV[]:        DIVide                                                  */
4173   /* Opcode range: 0x62                                                    */
4174   /* Stack:        f26.6 f26.6 --> f26.6                                   */
4175   /*                                                                       */
4176   static void
4177   Ins_DIV( INS_ARG )
4178   {
4179     DO_DIV
4180   }
4181
4182
4183   /*************************************************************************/
4184   /*                                                                       */
4185   /* MUL[]:        MULtiply                                                */
4186   /* Opcode range: 0x63                                                    */
4187   /* Stack:        f26.6 f26.6 --> f26.6                                   */
4188   /*                                                                       */
4189   static void
4190   Ins_MUL( INS_ARG )
4191   {
4192     DO_MUL
4193   }
4194
4195
4196   /*************************************************************************/
4197   /*                                                                       */
4198   /* ABS[]:        ABSolute value                                          */
4199   /* Opcode range: 0x64                                                    */
4200   /* Stack:        f26.6 --> f26.6                                         */
4201   /*                                                                       */
4202   static void
4203   Ins_ABS( INS_ARG )
4204   {
4205     DO_ABS
4206   }
4207
4208
4209   /*************************************************************************/
4210   /*                                                                       */
4211   /* NEG[]:        NEGate                                                  */
4212   /* Opcode range: 0x65                                                    */
4213   /* Stack: f26.6 --> f26.6                                                */
4214   /*                                                                       */
4215   static void
4216   Ins_NEG( INS_ARG )
4217   {
4218     DO_NEG
4219   }
4220
4221
4222   /*************************************************************************/
4223   /*                                                                       */
4224   /* FLOOR[]:      FLOOR                                                   */
4225   /* Opcode range: 0x66                                                    */
4226   /* Stack:        f26.6 --> f26.6                                         */
4227   /*                                                                       */
4228   static void
4229   Ins_FLOOR( INS_ARG )
4230   {
4231     DO_FLOOR
4232   }
4233
4234
4235   /*************************************************************************/
4236   /*                                                                       */
4237   /* CEILING[]:    CEILING                                                 */
4238   /* Opcode range: 0x67                                                    */
4239   /* Stack:        f26.6 --> f26.6                                         */
4240   /*                                                                       */
4241   static void
4242   Ins_CEILING( INS_ARG )
4243   {
4244     DO_CEILING
4245   }
4246
4247
4248   /*************************************************************************/
4249   /*                                                                       */
4250   /* RS[]:         Read Store                                              */
4251   /* Opcode range: 0x43                                                    */
4252   /* Stack:        uint32 --> uint32                                       */
4253   /*                                                                       */
4254   static void
4255   Ins_RS( INS_ARG )
4256   {
4257     DO_RS
4258   }
4259
4260
4261   /*************************************************************************/
4262   /*                                                                       */
4263   /* WS[]:         Write Store                                             */
4264   /* Opcode range: 0x42                                                    */
4265   /* Stack:        uint32 uint32 -->                                       */
4266   /*                                                                       */
4267   static void
4268   Ins_WS( INS_ARG )
4269   {
4270     DO_WS
4271   }
4272
4273
4274   /*************************************************************************/
4275   /*                                                                       */
4276   /* WCVTP[]:      Write CVT in Pixel units                                */
4277   /* Opcode range: 0x44                                                    */
4278   /* Stack:        f26.6 uint32 -->                                        */
4279   /*                                                                       */
4280   static void
4281   Ins_WCVTP( INS_ARG )
4282   {
4283     DO_WCVTP
4284   }
4285
4286
4287   /*************************************************************************/
4288   /*                                                                       */
4289   /* WCVTF[]:      Write CVT in Funits                                     */
4290   /* Opcode range: 0x70                                                    */
4291   /* Stack:        uint32 uint32 -->                                       */
4292   /*                                                                       */
4293   static void
4294   Ins_WCVTF( INS_ARG )
4295   {
4296     DO_WCVTF
4297   }
4298
4299
4300   /*************************************************************************/
4301   /*                                                                       */
4302   /* RCVT[]:       Read CVT                                                */
4303   /* Opcode range: 0x45                                                    */
4304   /* Stack:        uint32 --> f26.6                                        */
4305   /*                                                                       */
4306   static void
4307   Ins_RCVT( INS_ARG )
4308   {
4309     DO_RCVT
4310   }
4311
4312
4313   /*************************************************************************/
4314   /*                                                                       */
4315   /* AA[]:         Adjust Angle                                            */
4316   /* Opcode range: 0x7F                                                    */
4317   /* Stack:        uint32 -->                                              */
4318   /*                                                                       */
4319   static void
4320   Ins_AA( INS_ARG )
4321   {
4322     /* intentionally no longer supported */
4323   }
4324
4325
4326   /*************************************************************************/
4327   /*                                                                       */
4328   /* DEBUG[]:      DEBUG.  Unsupported.                                    */
4329   /* Opcode range: 0x4F                                                    */
4330   /* Stack:        uint32 -->                                              */
4331   /*                                                                       */
4332   /* Note: The original instruction pops a value from the stack.           */
4333   /*                                                                       */
4334   static void
4335   Ins_DEBUG( INS_ARG )
4336   {
4337     DO_DEBUG
4338   }
4339
4340
4341   /*************************************************************************/
4342   /*                                                                       */
4343   /* ROUND[ab]:    ROUND value                                             */
4344   /* Opcode range: 0x68-0x6B                                               */
4345   /* Stack:        f26.6 --> f26.6                                         */
4346   /*                                                                       */
4347   static void
4348   Ins_ROUND( INS_ARG )
4349   {
4350     DO_ROUND
4351   }
4352
4353
4354   /*************************************************************************/
4355   /*                                                                       */
4356   /* NROUND[ab]:   No ROUNDing of value                                    */
4357   /* Opcode range: 0x6C-0x6F                                               */
4358   /* Stack:        f26.6 --> f26.6                                         */
4359   /*                                                                       */
4360   static void
4361   Ins_NROUND( INS_ARG )
4362   {
4363     DO_NROUND
4364   }
4365
4366
4367   /*************************************************************************/
4368   /*                                                                       */
4369   /* MAX[]:        MAXimum                                                 */
4370   /* Opcode range: 0x68                                                    */
4371   /* Stack:        int32? int32? --> int32                                 */
4372   /*                                                                       */
4373   static void
4374   Ins_MAX( INS_ARG )
4375   {
4376     DO_MAX
4377   }
4378
4379
4380   /*************************************************************************/
4381   /*                                                                       */
4382   /* MIN[]:        MINimum                                                 */
4383   /* Opcode range: 0x69                                                    */
4384   /* Stack:        int32? int32? --> int32                                 */
4385   /*                                                                       */
4386   static void
4387   Ins_MIN( INS_ARG )
4388   {
4389     DO_MIN
4390   }
4391
4392
4393 #endif  /* !TT_CONFIG_OPTION_INTERPRETER_SWITCH */
4394
4395
4396   /*************************************************************************/
4397   /*                                                                       */
4398   /* The following functions are called as is within the switch statement. */
4399   /*                                                                       */
4400   /*************************************************************************/
4401
4402
4403   /*************************************************************************/
4404   /*                                                                       */
4405   /* MINDEX[]:     Move INDEXed element                                    */
4406   /* Opcode range: 0x26                                                    */
4407   /* Stack:        int32? --> StkElt                                       */
4408   /*                                                                       */
4409   static void
4410   Ins_MINDEX( INS_ARG )
4411   {
4412     FT_Long  L, K;
4413
4414
4415     L = args[0];
4416
4417     if ( L <= 0 || L > CUR.args )
4418     {
4419       if ( CUR.pedantic_hinting )
4420         CUR.error = TT_Err_Invalid_Reference;
4421     }
4422     else
4423     {
4424       K = CUR.stack[CUR.args - L];
4425
4426       FT_ARRAY_MOVE( &CUR.stack[CUR.args - L    ],
4427                      &CUR.stack[CUR.args - L + 1],
4428                      ( L - 1 ) );
4429
4430       CUR.stack[CUR.args - 1] = K;
4431     }
4432   }
4433
4434
4435   /*************************************************************************/
4436   /*                                                                       */
4437   /* ROLL[]:       ROLL top three elements                                 */
4438   /* Opcode range: 0x8A                                                    */
4439   /* Stack:        3 * StkElt --> 3 * StkElt                               */
4440   /*                                                                       */
4441   static void
4442   Ins_ROLL( INS_ARG )
4443   {
4444     FT_Long  A, B, C;
4445
4446     FT_UNUSED_EXEC;
4447
4448
4449     A = args[2];
4450     B = args[1];
4451     C = args[0];
4452
4453     args[2] = C;
4454     args[1] = A;
4455     args[0] = B;
4456   }
4457
4458
4459   /*************************************************************************/
4460   /*                                                                       */
4461   /* MANAGING THE FLOW OF CONTROL                                          */
4462   /*                                                                       */
4463   /*   Instructions appear in the specification's order.                   */
4464   /*                                                                       */
4465   /*************************************************************************/
4466
4467
4468   static FT_Bool
4469   SkipCode( EXEC_OP )
4470   {
4471     CUR.IP += CUR.length;
4472
4473     if ( CUR.IP < CUR.codeSize )
4474     {
4475       CUR.opcode = CUR.code[CUR.IP];
4476
4477       CUR.length = opcode_length[CUR.opcode];
4478       if ( CUR.length < 0 )
4479       {
4480         if ( CUR.IP + 1 >= CUR.codeSize )
4481           goto Fail_Overflow;
4482         CUR.length = 2 - CUR.length * CUR.code[CUR.IP + 1];
4483       }
4484
4485       if ( CUR.IP + CUR.length <= CUR.codeSize )
4486         return SUCCESS;
4487     }
4488
4489   Fail_Overflow:
4490     CUR.error = TT_Err_Code_Overflow;
4491     return FAILURE;
4492   }
4493
4494
4495   /*************************************************************************/
4496   /*                                                                       */
4497   /* IF[]:         IF test                                                 */
4498   /* Opcode range: 0x58                                                    */
4499   /* Stack:        StkElt -->                                              */
4500   /*                                                                       */
4501   static void
4502   Ins_IF( INS_ARG )
4503   {
4504     FT_Int   nIfs;
4505     FT_Bool  Out;
4506
4507
4508     if ( args[0] != 0 )
4509       return;
4510
4511     nIfs = 1;
4512     Out = 0;
4513
4514     do
4515     {
4516       if ( SKIP_Code() == FAILURE )
4517         return;
4518
4519       switch ( CUR.opcode )
4520       {
4521       case 0x58:      /* IF */
4522         nIfs++;
4523         break;
4524
4525       case 0x1B:      /* ELSE */
4526         Out = FT_BOOL( nIfs == 1 );
4527         break;
4528
4529       case 0x59:      /* EIF */
4530         nIfs--;
4531         Out = FT_BOOL( nIfs == 0 );
4532         break;
4533       }
4534     } while ( Out == 0 );
4535   }
4536
4537
4538   /*************************************************************************/
4539   /*                                                                       */
4540   /* ELSE[]:       ELSE                                                    */
4541   /* Opcode range: 0x1B                                                    */
4542   /* Stack:        -->                                                     */
4543   /*                                                                       */
4544   static void
4545   Ins_ELSE( INS_ARG )
4546   {
4547     FT_Int  nIfs;
4548
4549     FT_UNUSED_ARG;
4550
4551
4552     nIfs = 1;
4553
4554     do
4555     {
4556       if ( SKIP_Code() == FAILURE )
4557         return;
4558
4559       switch ( CUR.opcode )
4560       {
4561       case 0x58:    /* IF */
4562         nIfs++;
4563         break;
4564
4565       case 0x59:    /* EIF */
4566         nIfs--;
4567         break;
4568       }
4569     } while ( nIfs != 0 );
4570   }
4571
4572
4573   /*************************************************************************/
4574   /*                                                                       */
4575   /* DEFINING AND USING FUNCTIONS AND INSTRUCTIONS                         */
4576   /*                                                                       */
4577   /*   Instructions appear in the specification's order.                   */
4578   /*                                                                       */
4579   /*************************************************************************/
4580
4581
4582   /*************************************************************************/
4583   /*                                                                       */
4584   /* FDEF[]:       Function DEFinition                                     */
4585   /* Opcode range: 0x2C                                                    */
4586   /* Stack:        uint32 -->                                              */
4587   /*                                                                       */
4588   static void
4589   Ins_FDEF( INS_ARG )
4590   {
4591     FT_ULong       n;
4592     TT_DefRecord*  rec;
4593     TT_DefRecord*  limit;
4594
4595
4596     /* some font programs are broken enough to redefine functions! */
4597     /* We will then parse the current table.                       */
4598
4599     rec   = CUR.FDefs;
4600     limit = rec + CUR.numFDefs;
4601     n     = args[0];
4602
4603     for ( ; rec < limit; rec++ )
4604     {
4605       if ( rec->opc == n )
4606         break;
4607     }
4608
4609     if ( rec == limit )
4610     {
4611       /* check that there is enough room for new functions */
4612       if ( CUR.numFDefs >= CUR.maxFDefs )
4613       {
4614         CUR.error = TT_Err_Too_Many_Function_Defs;
4615         return;
4616       }
4617       CUR.numFDefs++;
4618     }
4619
4620     /* Although FDEF takes unsigned 32-bit integer,  */
4621     /* func # must be within unsigned 16-bit integer */
4622     if ( n > 0xFFFFU )
4623     {
4624       CUR.error = TT_Err_Too_Many_Function_Defs;
4625       return;
4626     }
4627
4628     rec->range  = CUR.curRange;
4629     rec->opc    = (FT_UInt16)n;
4630     rec->start  = CUR.IP + 1;
4631     rec->active = TRUE;
4632
4633     if ( n > CUR.maxFunc )
4634       CUR.maxFunc = (FT_UInt16)n;
4635
4636     /* Now skip the whole function definition. */
4637     /* We don't allow nested IDEFS & FDEFs.    */
4638
4639     while ( SKIP_Code() == SUCCESS )
4640     {
4641       switch ( CUR.opcode )
4642       {
4643       case 0x89:    /* IDEF */
4644       case 0x2C:    /* FDEF */
4645         CUR.error = TT_Err_Nested_DEFS;
4646         return;
4647
4648       case 0x2D:   /* ENDF */
4649         rec->end = CUR.IP;
4650         return;
4651       }
4652     }
4653   }
4654
4655
4656   /*************************************************************************/
4657   /*                                                                       */
4658   /* ENDF[]:       END Function definition                                 */
4659   /* Opcode range: 0x2D                                                    */
4660   /* Stack:        -->                                                     */
4661   /*                                                                       */
4662   static void
4663   Ins_ENDF( INS_ARG )
4664   {
4665     TT_CallRec*  pRec;
4666
4667     FT_UNUSED_ARG;
4668
4669
4670     if ( CUR.callTop <= 0 )     /* We encountered an ENDF without a call */
4671     {
4672       CUR.error = TT_Err_ENDF_In_Exec_Stream;
4673       return;
4674     }
4675
4676     CUR.callTop--;
4677
4678     pRec = &CUR.callStack[CUR.callTop];
4679
4680     pRec->Cur_Count--;
4681
4682     CUR.step_ins = FALSE;
4683
4684     if ( pRec->Cur_Count > 0 )
4685     {
4686       CUR.callTop++;
4687       CUR.IP = pRec->Cur_Restart;
4688     }
4689     else
4690       /* Loop through the current function */
4691       INS_Goto_CodeRange( pRec->Caller_Range,
4692                           pRec->Caller_IP );
4693
4694     /* Exit the current call frame.                      */
4695
4696     /* NOTE: If the last instruction of a program is a   */
4697     /*       CALL or LOOPCALL, the return address is     */
4698     /*       always out of the code range.  This is a    */
4699     /*       valid address, and it is why we do not test */
4700     /*       the result of Ins_Goto_CodeRange() here!    */
4701   }
4702
4703
4704   /*************************************************************************/
4705   /*                                                                       */
4706   /* CALL[]:       CALL function                                           */
4707   /* Opcode range: 0x2B                                                    */
4708   /* Stack:        uint32? -->                                             */
4709   /*                                                                       */
4710   static void
4711   Ins_CALL( INS_ARG )
4712   {
4713     FT_ULong       F;
4714     TT_CallRec*    pCrec;
4715     TT_DefRecord*  def;
4716
4717
4718     /* first of all, check the index */
4719
4720     F = args[0];
4721     if ( BOUNDSL( F, CUR.maxFunc + 1 ) )
4722       goto Fail;
4723
4724     /* Except for some old Apple fonts, all functions in a TrueType */
4725     /* font are defined in increasing order, starting from 0.  This */
4726     /* means that we normally have                                  */
4727     /*                                                              */
4728     /*    CUR.maxFunc+1 == CUR.numFDefs                             */
4729     /*    CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc             */
4730     /*                                                              */
4731     /* If this isn't true, we need to look up the function table.   */
4732
4733     def = CUR.FDefs + F;
4734     if ( CUR.maxFunc + 1 != CUR.numFDefs || def->opc != F )
4735     {
4736       /* look up the FDefs table */
4737       TT_DefRecord*  limit;
4738
4739
4740       def   = CUR.FDefs;
4741       limit = def + CUR.numFDefs;
4742
4743       while ( def < limit && def->opc != F )
4744         def++;
4745
4746       if ( def == limit )
4747         goto Fail;
4748     }
4749
4750     /* check that the function is active */
4751     if ( !def->active )
4752       goto Fail;
4753
4754     /* check the call stack */
4755     if ( CUR.callTop >= CUR.callSize )
4756     {
4757       CUR.error = TT_Err_Stack_Overflow;
4758       return;
4759     }
4760
4761     pCrec = CUR.callStack + CUR.callTop;
4762
4763     pCrec->Caller_Range = CUR.curRange;
4764     pCrec->Caller_IP    = CUR.IP + 1;
4765     pCrec->Cur_Count    = 1;
4766     pCrec->Cur_Restart  = def->start;
4767     pCrec->Cur_End      = def->end;
4768
4769     CUR.callTop++;
4770
4771     INS_Goto_CodeRange( def->range,
4772                         def->start );
4773
4774     CUR.step_ins = FALSE;
4775     return;
4776
4777   Fail:
4778     CUR.error = TT_Err_Invalid_Reference;
4779   }
4780
4781
4782   /*************************************************************************/
4783   /*                                                                       */
4784   /* LOOPCALL[]:   LOOP and CALL function                                  */
4785   /* Opcode range: 0x2A                                                    */
4786   /* Stack:        uint32? Eint16? -->                                     */
4787   /*                                                                       */
4788   static void
4789   Ins_LOOPCALL( INS_ARG )
4790   {
4791     FT_ULong       F;
4792     TT_CallRec*    pCrec;
4793     TT_DefRecord*  def;
4794
4795
4796     /* first of all, check the index */
4797     F = args[1];
4798     if ( BOUNDSL( F, CUR.maxFunc + 1 ) )
4799       goto Fail;
4800
4801     /* Except for some old Apple fonts, all functions in a TrueType */
4802     /* font are defined in increasing order, starting from 0.  This */
4803     /* means that we normally have                                  */
4804     /*                                                              */
4805     /*    CUR.maxFunc+1 == CUR.numFDefs                             */
4806     /*    CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc             */
4807     /*                                                              */
4808     /* If this isn't true, we need to look up the function table.   */
4809
4810     def = CUR.FDefs + F;
4811     if ( CUR.maxFunc + 1 != CUR.numFDefs || def->opc != F )
4812     {
4813       /* look up the FDefs table */
4814       TT_DefRecord*  limit;
4815
4816
4817       def   = CUR.FDefs;
4818       limit = def + CUR.numFDefs;
4819
4820       while ( def < limit && def->opc != F )
4821         def++;
4822
4823       if ( def == limit )
4824         goto Fail;
4825     }
4826
4827     /* check that the function is active */
4828     if ( !def->active )
4829       goto Fail;
4830
4831     /* check stack */
4832     if ( CUR.callTop >= CUR.callSize )
4833     {
4834       CUR.error = TT_Err_Stack_Overflow;
4835       return;
4836     }
4837
4838     if ( args[0] > 0 )
4839     {
4840       pCrec = CUR.callStack + CUR.callTop;
4841
4842       pCrec->Caller_Range = CUR.curRange;
4843       pCrec->Caller_IP    = CUR.IP + 1;
4844       pCrec->Cur_Count    = (FT_Int)args[0];
4845       pCrec->Cur_Restart  = def->start;
4846       pCrec->Cur_End      = def->end;
4847
4848       CUR.callTop++;
4849
4850       INS_Goto_CodeRange( def->range, def->start );
4851
4852       CUR.step_ins = FALSE;
4853     }
4854     return;
4855
4856   Fail:
4857     CUR.error = TT_Err_Invalid_Reference;
4858   }
4859
4860
4861   /*************************************************************************/
4862   /*                                                                       */
4863   /* IDEF[]:       Instruction DEFinition                                  */
4864   /* Opcode range: 0x89                                                    */
4865   /* Stack:        Eint8 -->                                               */
4866   /*                                                                       */
4867   static void
4868   Ins_IDEF( INS_ARG )
4869   {
4870     TT_DefRecord*  def;
4871     TT_DefRecord*  limit;
4872
4873
4874     /*  First of all, look for the same function in our table */
4875
4876     def   = CUR.IDefs;
4877     limit = def + CUR.numIDefs;
4878
4879     for ( ; def < limit; def++ )
4880       if ( def->opc == (FT_ULong)args[0] )
4881         break;
4882
4883     if ( def == limit )
4884     {
4885       /* check that there is enough room for a new instruction */
4886       if ( CUR.numIDefs >= CUR.maxIDefs )
4887       {
4888         CUR.error = TT_Err_Too_Many_Instruction_Defs;
4889         return;
4890       }
4891       CUR.numIDefs++;
4892     }
4893
4894     /* opcode must be unsigned 8-bit integer */
4895     if ( 0 > args[0] || args[0] > 0x00FF )
4896     {
4897       CUR.error = TT_Err_Too_Many_Instruction_Defs;
4898       return;
4899     }
4900
4901     def->opc    = (FT_Byte)args[0];
4902     def->start  = CUR.IP + 1;
4903     def->range  = CUR.curRange;
4904     def->active = TRUE;
4905
4906     if ( (FT_ULong)args[0] > CUR.maxIns )
4907       CUR.maxIns = (FT_Byte)args[0];
4908
4909     /* Now skip the whole function definition. */
4910     /* We don't allow nested IDEFs & FDEFs.    */
4911
4912     while ( SKIP_Code() == SUCCESS )
4913     {
4914       switch ( CUR.opcode )
4915       {
4916       case 0x89:   /* IDEF */
4917       case 0x2C:   /* FDEF */
4918         CUR.error = TT_Err_Nested_DEFS;
4919         return;
4920       case 0x2D:   /* ENDF */
4921         return;
4922       }
4923     }
4924   }
4925
4926
4927   /*************************************************************************/
4928   /*                                                                       */
4929   /* PUSHING DATA ONTO THE INTERPRETER STACK                               */
4930   /*                                                                       */
4931   /*   Instructions appear in the specification's order.                   */
4932   /*                                                                       */
4933   /*************************************************************************/
4934
4935
4936   /*************************************************************************/
4937   /*                                                                       */
4938   /* NPUSHB[]:     PUSH N Bytes                                            */
4939   /* Opcode range: 0x40                                                    */
4940   /* Stack:        --> uint32...                                           */
4941   /*                                                                       */
4942   static void
4943   Ins_NPUSHB( INS_ARG )
4944   {
4945     FT_UShort  L, K;
4946
4947
4948     L = (FT_UShort)CUR.code[CUR.IP + 1];
4949
4950     if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
4951     {
4952       CUR.error = TT_Err_Stack_Overflow;
4953       return;
4954     }
4955
4956     for ( K = 1; K <= L; K++ )
4957       args[K - 1] = CUR.code[CUR.IP + K + 1];
4958
4959     CUR.new_top += L;
4960   }
4961
4962
4963   /*************************************************************************/
4964   /*                                                                       */
4965   /* NPUSHW[]:     PUSH N Words                                            */
4966   /* Opcode range: 0x41                                                    */
4967   /* Stack:        --> int32...                                            */
4968   /*                                                                       */
4969   static void
4970   Ins_NPUSHW( INS_ARG )
4971   {
4972     FT_UShort  L, K;
4973
4974
4975     L = (FT_UShort)CUR.code[CUR.IP + 1];
4976
4977     if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
4978     {
4979       CUR.error = TT_Err_Stack_Overflow;
4980       return;
4981     }
4982
4983     CUR.IP += 2;
4984
4985     for ( K = 0; K < L; K++ )
4986       args[K] = GET_ShortIns();
4987
4988     CUR.step_ins = FALSE;
4989     CUR.new_top += L;
4990   }
4991
4992
4993   /*************************************************************************/
4994   /*                                                                       */
4995   /* PUSHB[abc]:   PUSH Bytes                                              */
4996   /* Opcode range: 0xB0-0xB7                                               */
4997   /* Stack:        --> uint32...                                           */
4998   /*                                                                       */
4999   static void
5000   Ins_PUSHB( INS_ARG )
5001   {
5002     FT_UShort  L, K;
5003
5004
5005     L = (FT_UShort)( CUR.opcode - 0xB0 + 1 );
5006
5007     if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
5008     {
5009       CUR.error = TT_Err_Stack_Overflow;
5010       return;
5011     }
5012
5013     for ( K = 1; K <= L; K++ )
5014       args[K - 1] = CUR.code[CUR.IP + K];
5015   }
5016
5017
5018   /*************************************************************************/
5019   /*                                                                       */
5020   /* PUSHW[abc]:   PUSH Words                                              */
5021   /* Opcode range: 0xB8-0xBF                                               */
5022   /* Stack:        --> int32...                                            */
5023   /*                                                                       */
5024   static void
5025   Ins_PUSHW( INS_ARG )
5026   {
5027     FT_UShort  L, K;
5028
5029
5030     L = (FT_UShort)( CUR.opcode - 0xB8 + 1 );
5031
5032     if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
5033     {
5034       CUR.error = TT_Err_Stack_Overflow;
5035       return;
5036     }
5037
5038     CUR.IP++;
5039
5040     for ( K = 0; K < L; K++ )
5041       args[K] = GET_ShortIns();
5042
5043     CUR.step_ins = FALSE;
5044   }
5045
5046
5047   /*************************************************************************/
5048   /*                                                                       */
5049   /* MANAGING THE GRAPHICS STATE                                           */
5050   /*                                                                       */
5051   /*  Instructions appear in the specs' order.                             */
5052   /*                                                                       */
5053   /*************************************************************************/
5054
5055
5056   /*************************************************************************/
5057   /*                                                                       */
5058   /* GC[a]:        Get Coordinate projected onto                           */
5059   /* Opcode range: 0x46-0x47                                               */
5060   /* Stack:        uint32 --> f26.6                                        */
5061   /*                                                                       */
5062   /* XXX: UNDOCUMENTED: Measures from the original glyph must be taken     */
5063   /*      along the dual projection vector!                                */
5064   /*                                                                       */
5065   static void
5066   Ins_GC( INS_ARG )
5067   {
5068     FT_ULong    L;
5069     FT_F26Dot6  R;
5070
5071
5072     L = (FT_ULong)args[0];
5073
5074     if ( BOUNDSL( L, CUR.zp2.n_points ) )
5075     {
5076       if ( CUR.pedantic_hinting )
5077         CUR.error = TT_Err_Invalid_Reference;
5078       R = 0;
5079     }
5080     else
5081     {
5082       if ( CUR.opcode & 1 )
5083         R = CUR_fast_dualproj( &CUR.zp2.org[L] );
5084       else
5085         R = CUR_fast_project( &CUR.zp2.cur[L] );
5086     }
5087
5088     args[0] = R;
5089   }
5090
5091
5092   /*************************************************************************/
5093   /*                                                                       */
5094   /* SCFS[]:       Set Coordinate From Stack                               */
5095   /* Opcode range: 0x48                                                    */
5096   /* Stack:        f26.6 uint32 -->                                        */
5097   /*                                                                       */
5098   /* Formula:                                                              */
5099   /*                                                                       */
5100   /*   OA := OA + ( value - OA.p )/( f.p ) * f                             */
5101   /*                                                                       */
5102   static void
5103   Ins_SCFS( INS_ARG )
5104   {
5105     FT_Long    K;
5106     FT_UShort  L;
5107
5108
5109     L = (FT_UShort)args[0];
5110
5111     if ( BOUNDS( L, CUR.zp2.n_points ) )
5112     {
5113       if ( CUR.pedantic_hinting )
5114         CUR.error = TT_Err_Invalid_Reference;
5115       return;
5116     }
5117
5118     K = CUR_fast_project( &CUR.zp2.cur[L] );
5119
5120     CUR_Func_move( &CUR.zp2, L, args[1] - K );
5121
5122     /* UNDOCUMENTED!  The MS rasterizer does that with */
5123     /* twilight points (confirmed by Greg Hitchcock)   */
5124     if ( CUR.GS.gep2 == 0 )
5125       CUR.zp2.org[L] = CUR.zp2.cur[L];
5126   }
5127
5128
5129   /*************************************************************************/
5130   /*                                                                       */
5131   /* MD[a]:        Measure Distance                                        */
5132   /* Opcode range: 0x49-0x4A                                               */
5133   /* Stack:        uint32 uint32 --> f26.6                                 */
5134   /*                                                                       */
5135   /* XXX: UNDOCUMENTED: Measure taken in the original glyph must be along  */
5136   /*                    the dual projection vector.                        */
5137   /*                                                                       */
5138   /* XXX: UNDOCUMENTED: Flag attributes are inverted!                      */
5139   /*                      0 => measure distance in original outline        */
5140   /*                      1 => measure distance in grid-fitted outline     */
5141   /*                                                                       */
5142   /* XXX: UNDOCUMENTED: `zp0 - zp1', and not `zp2 - zp1!                   */
5143   /*                                                                       */
5144   static void
5145   Ins_MD( INS_ARG )
5146   {
5147     FT_UShort   K, L;
5148     FT_F26Dot6  D;
5149
5150
5151     K = (FT_UShort)args[1];
5152     L = (FT_UShort)args[0];
5153
5154     if ( BOUNDS( L, CUR.zp0.n_points ) ||
5155          BOUNDS( K, CUR.zp1.n_points ) )
5156     {
5157       if ( CUR.pedantic_hinting )
5158         CUR.error = TT_Err_Invalid_Reference;
5159       D = 0;
5160     }
5161     else
5162     {
5163       if ( CUR.opcode & 1 )
5164         D = CUR_Func_project( CUR.zp0.cur + L, CUR.zp1.cur + K );
5165       else
5166       {
5167         /* XXX: UNDOCUMENTED: twilight zone special case */
5168
5169         if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
5170         {
5171           FT_Vector*  vec1 = CUR.zp0.org + L;
5172           FT_Vector*  vec2 = CUR.zp1.org + K;
5173
5174
5175           D = CUR_Func_dualproj( vec1, vec2 );
5176         }
5177         else
5178         {
5179           FT_Vector*  vec1 = CUR.zp0.orus + L;
5180           FT_Vector*  vec2 = CUR.zp1.orus + K;
5181
5182
5183           if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
5184           {
5185             /* this should be faster */
5186             D = CUR_Func_dualproj( vec1, vec2 );
5187             D = TT_MULFIX( D, CUR.metrics.x_scale );
5188           }
5189           else
5190           {
5191             FT_Vector  vec;
5192
5193
5194             vec.x = TT_MULFIX( vec1->x - vec2->x, CUR.metrics.x_scale );
5195             vec.y = TT_MULFIX( vec1->y - vec2->y, CUR.metrics.y_scale );
5196
5197             D = CUR_fast_dualproj( &vec );
5198           }
5199         }
5200       }
5201     }
5202
5203     args[0] = D;
5204   }
5205
5206
5207   /*************************************************************************/
5208   /*                                                                       */
5209   /* SDPVTL[a]:    Set Dual PVector to Line                                */
5210   /* Opcode range: 0x86-0x87                                               */
5211   /* Stack:        uint32 uint32 -->                                       */
5212   /*                                                                       */
5213   static void
5214   Ins_SDPVTL( INS_ARG )
5215   {
5216     FT_Long    A, B, C;
5217     FT_UShort  p1, p2;            /* was FT_Int in pas type ERROR */
5218     FT_Int     aOpc = CUR.opcode;
5219
5220
5221     p1 = (FT_UShort)args[1];
5222     p2 = (FT_UShort)args[0];
5223
5224     if ( BOUNDS( p2, CUR.zp1.n_points ) ||
5225          BOUNDS( p1, CUR.zp2.n_points ) )
5226     {
5227       if ( CUR.pedantic_hinting )
5228         CUR.error = TT_Err_Invalid_Reference;
5229       return;
5230     }
5231
5232     {
5233       FT_Vector* v1 = CUR.zp1.org + p2;
5234       FT_Vector* v2 = CUR.zp2.org + p1;
5235
5236
5237       A = v1->x - v2->x;
5238       B = v1->y - v2->y;
5239
5240       /* If v1 == v2, SDPVTL behaves the same as */
5241       /* SVTCA[X], respectively.                 */
5242       /*                                         */
5243       /* Confirmed by Greg Hitchcock.            */
5244
5245       if ( A == 0 && B == 0 )
5246       {
5247         A    = 0x4000;
5248         aOpc = 0;
5249       }
5250     }
5251
5252     if ( ( aOpc & 1 ) != 0 )
5253     {
5254       C =  B;   /* counter clockwise rotation */
5255       B =  A;
5256       A = -C;
5257     }
5258
5259     NORMalize( A, B, &CUR.GS.dualVector );
5260
5261     {
5262       FT_Vector*  v1 = CUR.zp1.cur + p2;
5263       FT_Vector*  v2 = CUR.zp2.cur + p1;
5264
5265
5266       A = v1->x - v2->x;
5267       B = v1->y - v2->y;
5268     }
5269
5270     if ( ( aOpc & 1 ) != 0 )
5271     {
5272       C =  B;   /* counter clockwise rotation */
5273       B =  A;
5274       A = -C;
5275     }
5276
5277     NORMalize( A, B, &CUR.GS.projVector );
5278
5279     GUESS_VECTOR( freeVector );
5280
5281     COMPUTE_Funcs();
5282   }
5283
5284
5285   /*************************************************************************/
5286   /*                                                                       */
5287   /* SZP0[]:       Set Zone Pointer 0                                      */
5288   /* Opcode range: 0x13                                                    */
5289   /* Stack:        uint32 -->                                              */
5290   /*                                                                       */
5291   static void
5292   Ins_SZP0( INS_ARG )
5293   {
5294     switch ( (FT_Int)args[0] )
5295     {
5296     case 0:
5297       CUR.zp0 = CUR.twilight;
5298       break;
5299
5300     case 1:
5301       CUR.zp0 = CUR.pts;
5302       break;
5303
5304     default:
5305       if ( CUR.pedantic_hinting )
5306         CUR.error = TT_Err_Invalid_Reference;
5307       return;
5308     }
5309
5310     CUR.GS.gep0 = (FT_UShort)args[0];
5311   }
5312
5313
5314   /*************************************************************************/
5315   /*                                                                       */
5316   /* SZP1[]:       Set Zone Pointer 1                                      */
5317   /* Opcode range: 0x14                                                    */
5318   /* Stack:        uint32 -->                                              */
5319   /*                                                                       */
5320   static void
5321   Ins_SZP1( INS_ARG )
5322   {
5323     switch ( (FT_Int)args[0] )
5324     {
5325     case 0:
5326       CUR.zp1 = CUR.twilight;
5327       break;
5328
5329     case 1:
5330       CUR.zp1 = CUR.pts;
5331       break;
5332
5333     default:
5334       if ( CUR.pedantic_hinting )
5335         CUR.error = TT_Err_Invalid_Reference;
5336       return;
5337     }
5338
5339     CUR.GS.gep1 = (FT_UShort)args[0];
5340   }
5341
5342
5343   /*************************************************************************/
5344   /*                                                                       */
5345   /* SZP2[]:       Set Zone Pointer 2                                      */
5346   /* Opcode range: 0x15                                                    */
5347   /* Stack:        uint32 -->                                              */
5348   /*                                                                       */
5349   static void
5350   Ins_SZP2( INS_ARG )
5351   {
5352     switch ( (FT_Int)args[0] )
5353     {
5354     case 0:
5355       CUR.zp2 = CUR.twilight;
5356       break;
5357
5358     case 1:
5359       CUR.zp2 = CUR.pts;
5360       break;
5361
5362     default:
5363       if ( CUR.pedantic_hinting )
5364         CUR.error = TT_Err_Invalid_Reference;
5365       return;
5366     }
5367
5368     CUR.GS.gep2 = (FT_UShort)args[0];
5369   }
5370
5371
5372   /*************************************************************************/
5373   /*                                                                       */
5374   /* SZPS[]:       Set Zone PointerS                                       */
5375   /* Opcode range: 0x16                                                    */
5376   /* Stack:        uint32 -->                                              */
5377   /*                                                                       */
5378   static void
5379   Ins_SZPS( INS_ARG )
5380   {
5381     switch ( (FT_Int)args[0] )
5382     {
5383     case 0:
5384       CUR.zp0 = CUR.twilight;
5385       break;
5386
5387     case 1:
5388       CUR.zp0 = CUR.pts;
5389       break;
5390
5391     default:
5392       if ( CUR.pedantic_hinting )
5393         CUR.error = TT_Err_Invalid_Reference;
5394       return;
5395     }
5396
5397     CUR.zp1 = CUR.zp0;
5398     CUR.zp2 = CUR.zp0;
5399
5400     CUR.GS.gep0 = (FT_UShort)args[0];
5401     CUR.GS.gep1 = (FT_UShort)args[0];
5402     CUR.GS.gep2 = (FT_UShort)args[0];
5403   }
5404
5405
5406   /*************************************************************************/
5407   /*                                                                       */
5408   /* INSTCTRL[]:   INSTruction ConTRoL                                     */
5409   /* Opcode range: 0x8e                                                    */
5410   /* Stack:        int32 int32 -->                                         */
5411   /*                                                                       */
5412   static void
5413   Ins_INSTCTRL( INS_ARG )
5414   {
5415     FT_Long  K, L;
5416
5417
5418     K = args[1];
5419     L = args[0];
5420
5421     if ( K < 1 || K > 2 )
5422     {
5423       if ( CUR.pedantic_hinting )
5424         CUR.error = TT_Err_Invalid_Reference;
5425       return;
5426     }
5427
5428     if ( L != 0 )
5429         L = K;
5430
5431     CUR.GS.instruct_control = FT_BOOL(
5432       ( (FT_Byte)CUR.GS.instruct_control & ~(FT_Byte)K ) | (FT_Byte)L );
5433   }
5434
5435
5436   /*************************************************************************/
5437   /*                                                                       */
5438   /* SCANCTRL[]:   SCAN ConTRoL                                            */
5439   /* Opcode range: 0x85                                                    */
5440   /* Stack:        uint32? -->                                             */
5441   /*                                                                       */
5442   static void
5443   Ins_SCANCTRL( INS_ARG )
5444   {
5445     FT_Int  A;
5446
5447
5448     /* Get Threshold */
5449     A = (FT_Int)( args[0] & 0xFF );
5450
5451     if ( A == 0xFF )
5452     {
5453       CUR.GS.scan_control = TRUE;
5454       return;
5455     }
5456     else if ( A == 0 )
5457     {
5458       CUR.GS.scan_control = FALSE;
5459       return;
5460     }
5461
5462     if ( ( args[0] & 0x100 ) != 0 && CUR.tt_metrics.ppem <= A )
5463       CUR.GS.scan_control = TRUE;
5464
5465     if ( ( args[0] & 0x200 ) != 0 && CUR.tt_metrics.rotated )
5466       CUR.GS.scan_control = TRUE;
5467
5468     if ( ( args[0] & 0x400 ) != 0 && CUR.tt_metrics.stretched )
5469       CUR.GS.scan_control = TRUE;
5470
5471     if ( ( args[0] & 0x800 ) != 0 && CUR.tt_metrics.ppem > A )
5472       CUR.GS.scan_control = FALSE;
5473
5474     if ( ( args[0] & 0x1000 ) != 0 && CUR.tt_metrics.rotated )
5475       CUR.GS.scan_control = FALSE;
5476
5477     if ( ( args[0] & 0x2000 ) != 0 && CUR.tt_metrics.stretched )
5478       CUR.GS.scan_control = FALSE;
5479   }
5480
5481
5482   /*************************************************************************/
5483   /*                                                                       */
5484   /* SCANTYPE[]:   SCAN TYPE                                               */
5485   /* Opcode range: 0x8D                                                    */
5486   /* Stack:        uint32? -->                                             */
5487   /*                                                                       */
5488   static void
5489   Ins_SCANTYPE( INS_ARG )
5490   {
5491     if ( args[0] >= 0 )
5492       CUR.GS.scan_type = (FT_Int)args[0];
5493   }
5494
5495
5496   /*************************************************************************/
5497   /*                                                                       */
5498   /* MANAGING OUTLINES                                                     */
5499   /*                                                                       */
5500   /*   Instructions appear in the specification's order.                   */
5501   /*                                                                       */
5502   /*************************************************************************/
5503
5504
5505   /*************************************************************************/
5506   /*                                                                       */
5507   /* FLIPPT[]:     FLIP PoinT                                              */
5508   /* Opcode range: 0x80                                                    */
5509   /* Stack:        uint32... -->                                           */
5510   /*                                                                       */
5511   static void
5512   Ins_FLIPPT( INS_ARG )
5513   {
5514     FT_UShort  point;
5515
5516     FT_UNUSED_ARG;
5517
5518
5519     if ( CUR.top < CUR.GS.loop )
5520     {
5521       if ( CUR.pedantic_hinting )
5522         CUR.error = TT_Err_Too_Few_Arguments;
5523       goto Fail;
5524     }
5525
5526     while ( CUR.GS.loop > 0 )
5527     {
5528       CUR.args--;
5529
5530       point = (FT_UShort)CUR.stack[CUR.args];
5531
5532       if ( BOUNDS( point, CUR.pts.n_points ) )
5533       {
5534         if ( CUR.pedantic_hinting )
5535         {
5536           CUR.error = TT_Err_Invalid_Reference;
5537           return;
5538         }
5539       }
5540       else
5541         CUR.pts.tags[point] ^= FT_CURVE_TAG_ON;
5542
5543       CUR.GS.loop--;
5544     }
5545
5546   Fail:
5547     CUR.GS.loop = 1;
5548     CUR.new_top = CUR.args;
5549   }
5550
5551
5552   /*************************************************************************/
5553   /*                                                                       */
5554   /* FLIPRGON[]:   FLIP RanGe ON                                           */
5555   /* Opcode range: 0x81                                                    */
5556   /* Stack:        uint32 uint32 -->                                       */
5557   /*                                                                       */
5558   static void
5559   Ins_FLIPRGON( INS_ARG )
5560   {
5561     FT_UShort  I, K, L;
5562
5563
5564     K = (FT_UShort)args[1];
5565     L = (FT_UShort)args[0];
5566
5567     if ( BOUNDS( K, CUR.pts.n_points ) ||
5568          BOUNDS( L, CUR.pts.n_points ) )
5569     {
5570       if ( CUR.pedantic_hinting )
5571         CUR.error = TT_Err_Invalid_Reference;
5572       return;
5573     }
5574
5575     for ( I = L; I <= K; I++ )
5576       CUR.pts.tags[I] |= FT_CURVE_TAG_ON;
5577   }
5578
5579
5580   /*************************************************************************/
5581   /*                                                                       */
5582   /* FLIPRGOFF:    FLIP RanGe OFF                                          */
5583   /* Opcode range: 0x82                                                    */
5584   /* Stack:        uint32 uint32 -->                                       */
5585   /*                                                                       */
5586   static void
5587   Ins_FLIPRGOFF( INS_ARG )
5588   {
5589     FT_UShort  I, K, L;
5590
5591
5592     K = (FT_UShort)args[1];
5593     L = (FT_UShort)args[0];
5594
5595     if ( BOUNDS( K, CUR.pts.n_points ) ||
5596          BOUNDS( L, CUR.pts.n_points ) )
5597     {
5598       if ( CUR.pedantic_hinting )
5599         CUR.error = TT_Err_Invalid_Reference;
5600       return;
5601     }
5602
5603     for ( I = L; I <= K; I++ )
5604       CUR.pts.tags[I] &= ~FT_CURVE_TAG_ON;
5605   }
5606
5607
5608   static FT_Bool
5609   Compute_Point_Displacement( EXEC_OP_ FT_F26Dot6*   x,
5610                                        FT_F26Dot6*   y,
5611                                        TT_GlyphZone  zone,
5612                                        FT_UShort*    refp )
5613   {
5614     TT_GlyphZoneRec  zp;
5615     FT_UShort        p;
5616     FT_F26Dot6       d;
5617
5618
5619     if ( CUR.opcode & 1 )
5620     {
5621       zp = CUR.zp0;
5622       p  = CUR.GS.rp1;
5623     }
5624     else
5625     {
5626       zp = CUR.zp1;
5627       p  = CUR.GS.rp2;
5628     }
5629
5630     if ( BOUNDS( p, zp.n_points ) )
5631     {
5632       if ( CUR.pedantic_hinting )
5633         CUR.error = TT_Err_Invalid_Reference;
5634       *refp = 0;
5635       return FAILURE;
5636     }
5637
5638     *zone = zp;
5639     *refp = p;
5640
5641     d = CUR_Func_project( zp.cur + p, zp.org + p );
5642
5643 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
5644     if ( CUR.face->unpatented_hinting )
5645     {
5646       if ( CUR.GS.both_x_axis )
5647       {
5648         *x = d;
5649         *y = 0;
5650       }
5651       else
5652       {
5653         *x = 0;
5654         *y = d;
5655       }
5656     }
5657     else
5658 #endif
5659     {
5660       *x = TT_MULDIV( d,
5661                       (FT_Long)CUR.GS.freeVector.x * 0x10000L,
5662                       CUR.F_dot_P );
5663       *y = TT_MULDIV( d,
5664                       (FT_Long)CUR.GS.freeVector.y * 0x10000L,
5665                       CUR.F_dot_P );
5666     }
5667
5668     return SUCCESS;
5669   }
5670
5671
5672   static void
5673   Move_Zp2_Point( EXEC_OP_ FT_UShort   point,
5674                            FT_F26Dot6  dx,
5675                            FT_F26Dot6  dy,
5676                            FT_Bool     touch )
5677   {
5678 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
5679     if ( CUR.face->unpatented_hinting )
5680     {
5681       if ( CUR.GS.both_x_axis )
5682       {
5683         CUR.zp2.cur[point].x += dx;
5684         if ( touch )
5685           CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
5686       }
5687       else
5688       {
5689         CUR.zp2.cur[point].y += dy;
5690         if ( touch )
5691           CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
5692       }
5693       return;
5694     }
5695 #endif
5696
5697     if ( CUR.GS.freeVector.x != 0 )
5698     {
5699       CUR.zp2.cur[point].x += dx;
5700       if ( touch )
5701         CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
5702     }
5703
5704     if ( CUR.GS.freeVector.y != 0 )
5705     {
5706       CUR.zp2.cur[point].y += dy;
5707       if ( touch )
5708         CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
5709     }
5710   }
5711
5712
5713   /*************************************************************************/
5714   /*                                                                       */
5715   /* SHP[a]:       SHift Point by the last point                           */
5716   /* Opcode range: 0x32-0x33                                               */
5717   /* Stack:        uint32... -->                                           */
5718   /*                                                                       */
5719   static void
5720   Ins_SHP( INS_ARG )
5721   {
5722     TT_GlyphZoneRec  zp;
5723     FT_UShort        refp;
5724
5725     FT_F26Dot6       dx,
5726                      dy;
5727     FT_UShort        point;
5728
5729     FT_UNUSED_ARG;
5730
5731
5732     if ( CUR.top < CUR.GS.loop )
5733     {
5734       if ( CUR.pedantic_hinting )
5735         CUR.error = TT_Err_Invalid_Reference;
5736       goto Fail;
5737     }
5738
5739     if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
5740       return;
5741
5742     while ( CUR.GS.loop > 0 )
5743     {
5744       CUR.args--;
5745       point = (FT_UShort)CUR.stack[CUR.args];
5746
5747       if ( BOUNDS( point, CUR.zp2.n_points ) )
5748       {
5749         if ( CUR.pedantic_hinting )
5750         {
5751           CUR.error = TT_Err_Invalid_Reference;
5752           return;
5753         }
5754       }
5755       else
5756         MOVE_Zp2_Point( point, dx, dy, TRUE );
5757
5758       CUR.GS.loop--;
5759     }
5760
5761   Fail:
5762     CUR.GS.loop = 1;
5763     CUR.new_top = CUR.args;
5764   }
5765
5766
5767   /*************************************************************************/
5768   /*                                                                       */
5769   /* SHC[a]:       SHift Contour                                           */
5770   /* Opcode range: 0x34-35                                                 */
5771   /* Stack:        uint32 -->                                              */
5772   /*                                                                       */
5773   /* UNDOCUMENTED: According to Greg Hitchcock, there is one (virtual)     */
5774   /*               contour in the twilight zone, namely contour number     */
5775   /*               zero.                                                   */
5776   /*                                                                       */
5777   static void
5778   Ins_SHC( INS_ARG )
5779   {
5780     TT_GlyphZoneRec  zp;
5781     FT_UShort        refp;
5782     FT_F26Dot6       dx, dy;
5783
5784     FT_Short         contour, bounds;
5785     FT_UShort        start, limit, i;
5786
5787
5788     contour = (FT_UShort)args[0];
5789     bounds  = ( CUR.GS.gep2 == 0 ) ? 1 : CUR.zp2.n_contours;
5790
5791     if ( BOUNDS( contour, bounds ) )
5792     {
5793       if ( CUR.pedantic_hinting )
5794         CUR.error = TT_Err_Invalid_Reference;
5795       return;
5796     }
5797
5798     if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
5799       return;
5800
5801     if ( contour == 0 )
5802       start = 0;
5803     else
5804       start = (FT_UShort)( CUR.zp2.contours[contour - 1] + 1 -
5805                            CUR.zp2.first_point );
5806
5807     /* we use the number of points if in the twilight zone */
5808     if ( CUR.GS.gep2 == 0 )
5809       limit = CUR.zp2.n_points;
5810     else
5811       limit = (FT_UShort)( CUR.zp2.contours[contour] -
5812                            CUR.zp2.first_point + 1 );
5813
5814     for ( i = start; i < limit; i++ )
5815     {
5816       if ( zp.cur != CUR.zp2.cur || refp != i )
5817         MOVE_Zp2_Point( i, dx, dy, TRUE );
5818     }
5819   }
5820
5821
5822   /*************************************************************************/
5823   /*                                                                       */
5824   /* SHZ[a]:       SHift Zone                                              */
5825   /* Opcode range: 0x36-37                                                 */
5826   /* Stack:        uint32 -->                                              */
5827   /*                                                                       */
5828   static void
5829   Ins_SHZ( INS_ARG )
5830   {
5831     TT_GlyphZoneRec  zp;
5832     FT_UShort        refp;
5833     FT_F26Dot6       dx,
5834                      dy;
5835
5836     FT_UShort        limit, i;
5837
5838
5839     if ( BOUNDS( args[0], 2 ) )
5840     {
5841       if ( CUR.pedantic_hinting )
5842         CUR.error = TT_Err_Invalid_Reference;
5843       return;
5844     }
5845
5846     if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
5847       return;
5848
5849     /* XXX: UNDOCUMENTED! SHZ doesn't move the phantom points.     */
5850     /*      Twilight zone has no real contours, so use `n_points'. */
5851     /*      Normal zone's `n_points' includes phantoms, so must    */
5852     /*      use end of last contour.                               */
5853     if ( CUR.GS.gep2 == 0 )
5854       limit = (FT_UShort)CUR.zp2.n_points;
5855     else if ( CUR.GS.gep2 == 1 && CUR.zp2.n_contours > 0 )
5856       limit = (FT_UShort)( CUR.zp2.contours[CUR.zp2.n_contours - 1] + 1 );
5857     else
5858       limit = 0;
5859
5860     /* XXX: UNDOCUMENTED! SHZ doesn't touch the points */
5861     for ( i = 0; i < limit; i++ )
5862     {
5863       if ( zp.cur != CUR.zp2.cur || refp != i )
5864         MOVE_Zp2_Point( i, dx, dy, FALSE );
5865     }
5866   }
5867
5868
5869   /*************************************************************************/
5870   /*                                                                       */
5871   /* SHPIX[]:      SHift points by a PIXel amount                          */
5872   /* Opcode range: 0x38                                                    */
5873   /* Stack:        f26.6 uint32... -->                                     */
5874   /*                                                                       */
5875   static void
5876   Ins_SHPIX( INS_ARG )
5877   {
5878     FT_F26Dot6  dx, dy;
5879     FT_UShort   point;
5880
5881
5882     if ( CUR.top < CUR.GS.loop + 1 )
5883     {
5884       if ( CUR.pedantic_hinting )
5885         CUR.error = TT_Err_Invalid_Reference;
5886       goto Fail;
5887     }
5888
5889 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
5890     if ( CUR.face->unpatented_hinting )
5891     {
5892       if ( CUR.GS.both_x_axis )
5893       {
5894         dx = TT_MulFix14( (FT_UInt32)args[0], 0x4000 );
5895         dy = 0;
5896       }
5897       else
5898       {
5899         dx = 0;
5900         dy = TT_MulFix14( (FT_UInt32)args[0], 0x4000 );
5901       }
5902     }
5903     else
5904 #endif
5905     {
5906       dx = TT_MulFix14( (FT_UInt32)args[0], CUR.GS.freeVector.x );
5907       dy = TT_MulFix14( (FT_UInt32)args[0], CUR.GS.freeVector.y );
5908     }
5909
5910     while ( CUR.GS.loop > 0 )
5911     {
5912       CUR.args--;
5913
5914       point = (FT_UShort)CUR.stack[CUR.args];
5915
5916       if ( BOUNDS( point, CUR.zp2.n_points ) )
5917       {
5918         if ( CUR.pedantic_hinting )
5919         {
5920           CUR.error = TT_Err_Invalid_Reference;
5921           return;
5922         }
5923       }
5924       else
5925         MOVE_Zp2_Point( point, dx, dy, TRUE );
5926
5927       CUR.GS.loop--;
5928     }
5929
5930   Fail:
5931     CUR.GS.loop = 1;
5932     CUR.new_top = CUR.args;
5933   }
5934
5935
5936   /*************************************************************************/
5937   /*                                                                       */
5938   /* MSIRP[a]:     Move Stack Indirect Relative Position                   */
5939   /* Opcode range: 0x3A-0x3B                                               */
5940   /* Stack:        f26.6 uint32 -->                                        */
5941   /*                                                                       */
5942   static void
5943   Ins_MSIRP( INS_ARG )
5944   {
5945     FT_UShort   point;
5946     FT_F26Dot6  distance;
5947
5948
5949     point = (FT_UShort)args[0];
5950
5951     if ( BOUNDS( point,      CUR.zp1.n_points ) ||
5952          BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
5953     {
5954       if ( CUR.pedantic_hinting )
5955         CUR.error = TT_Err_Invalid_Reference;
5956       return;
5957     }
5958
5959     /* UNDOCUMENTED!  The MS rasterizer does that with */
5960     /* twilight points (confirmed by Greg Hitchcock)   */
5961     if ( CUR.GS.gep1 == 0 )
5962     {
5963       CUR.zp1.org[point] = CUR.zp0.org[CUR.GS.rp0];
5964       CUR_Func_move_orig( &CUR.zp1, point, args[1] );
5965       CUR.zp1.cur[point] = CUR.zp1.org[point];
5966     }
5967
5968     distance = CUR_Func_project( CUR.zp1.cur + point,
5969                                  CUR.zp0.cur + CUR.GS.rp0 );
5970
5971     CUR_Func_move( &CUR.zp1, point, args[1] - distance );
5972
5973     CUR.GS.rp1 = CUR.GS.rp0;
5974     CUR.GS.rp2 = point;
5975
5976     if ( ( CUR.opcode & 1 ) != 0 )
5977       CUR.GS.rp0 = point;
5978   }
5979
5980
5981   /*************************************************************************/
5982   /*                                                                       */
5983   /* MDAP[a]:      Move Direct Absolute Point                              */
5984   /* Opcode range: 0x2E-0x2F                                               */
5985   /* Stack:        uint32 -->                                              */
5986   /*                                                                       */
5987   static void
5988   Ins_MDAP( INS_ARG )
5989   {
5990     FT_UShort   point;
5991     FT_F26Dot6  cur_dist,
5992                 distance;
5993
5994
5995     point = (FT_UShort)args[0];
5996
5997     if ( BOUNDS( point, CUR.zp0.n_points ) )
5998     {
5999       if ( CUR.pedantic_hinting )
6000         CUR.error = TT_Err_Invalid_Reference;
6001       return;
6002     }
6003
6004     if ( ( CUR.opcode & 1 ) != 0 )
6005     {
6006       cur_dist = CUR_fast_project( &CUR.zp0.cur[point] );
6007       distance = CUR_Func_round( cur_dist,
6008                                  CUR.tt_metrics.compensations[0] ) - cur_dist;
6009     }
6010     else
6011       distance = 0;
6012
6013     CUR_Func_move( &CUR.zp0, point, distance );
6014
6015     CUR.GS.rp0 = point;
6016     CUR.GS.rp1 = point;
6017   }
6018
6019
6020   /*************************************************************************/
6021   /*                                                                       */
6022   /* MIAP[a]:      Move Indirect Absolute Point                            */
6023   /* Opcode range: 0x3E-0x3F                                               */
6024   /* Stack:        uint32 uint32 -->                                       */
6025   /*                                                                       */
6026   static void
6027   Ins_MIAP( INS_ARG )
6028   {
6029     FT_ULong    cvtEntry;
6030     FT_UShort   point;
6031     FT_F26Dot6  distance,
6032                 org_dist;
6033
6034
6035     cvtEntry = (FT_ULong)args[1];
6036     point    = (FT_UShort)args[0];
6037
6038     if ( BOUNDS( point,     CUR.zp0.n_points ) ||
6039          BOUNDSL( cvtEntry, CUR.cvtSize )      )
6040     {
6041       if ( CUR.pedantic_hinting )
6042         CUR.error = TT_Err_Invalid_Reference;
6043       goto Fail;
6044     }
6045
6046     /* UNDOCUMENTED!                                                      */
6047     /*                                                                    */
6048     /* The behaviour of an MIAP instruction is quite different when used  */
6049     /* in the twilight zone.                                              */
6050     /*                                                                    */
6051     /* First, no control value cut-in test is performed as it would fail  */
6052     /* anyway.  Second, the original point, i.e. (org_x,org_y) of         */
6053     /* zp0.point, is set to the absolute, unrounded distance found in the */
6054     /* CVT.                                                               */
6055     /*                                                                    */
6056     /* This is used in the CVT programs of the Microsoft fonts Arial,     */
6057     /* Times, etc., in order to re-adjust some key font heights.  It      */
6058     /* allows the use of the IP instruction in the twilight zone, which   */
6059     /* otherwise would be invalid according to the specification.         */
6060     /*                                                                    */
6061     /* We implement it with a special sequence for the twilight zone.     */
6062     /* This is a bad hack, but it seems to work.                          */
6063     /*                                                                    */
6064     /* Confirmed by Greg Hitchcock.                                       */
6065
6066     distance = CUR_Func_read_cvt( cvtEntry );
6067
6068     if ( CUR.GS.gep0 == 0 )   /* If in twilight zone */
6069     {
6070       CUR.zp0.org[point].x = TT_MulFix14( (FT_UInt32)distance,
6071                                           CUR.GS.freeVector.x );
6072       CUR.zp0.org[point].y = TT_MulFix14( (FT_UInt32)distance,
6073                                           CUR.GS.freeVector.y ),
6074       CUR.zp0.cur[point]   = CUR.zp0.org[point];
6075     }
6076
6077     org_dist = CUR_fast_project( &CUR.zp0.cur[point] );
6078
6079     if ( ( CUR.opcode & 1 ) != 0 )   /* rounding and control cutin flag */
6080     {
6081       if ( FT_ABS( distance - org_dist ) > CUR.GS.control_value_cutin )
6082         distance = org_dist;
6083
6084       distance = CUR_Func_round( distance, CUR.tt_metrics.compensations[0] );
6085     }
6086
6087     CUR_Func_move( &CUR.zp0, point, distance - org_dist );
6088
6089   Fail:
6090     CUR.GS.rp0 = point;
6091     CUR.GS.rp1 = point;
6092   }
6093
6094
6095   /*************************************************************************/
6096   /*                                                                       */
6097   /* MDRP[abcde]:  Move Direct Relative Point                              */
6098   /* Opcode range: 0xC0-0xDF                                               */
6099   /* Stack:        uint32 -->                                              */
6100   /*                                                                       */
6101   static void
6102   Ins_MDRP( INS_ARG )
6103   {
6104     FT_UShort   point;
6105     FT_F26Dot6  org_dist, distance;
6106
6107
6108     point = (FT_UShort)args[0];
6109
6110     if ( BOUNDS( point,      CUR.zp1.n_points ) ||
6111          BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
6112     {
6113       if ( CUR.pedantic_hinting )
6114         CUR.error = TT_Err_Invalid_Reference;
6115       goto Fail;
6116     }
6117
6118     /* XXX: Is there some undocumented feature while in the */
6119     /*      twilight zone?                                  */
6120
6121     /* XXX: UNDOCUMENTED: twilight zone special case */
6122
6123     if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
6124     {
6125       FT_Vector*  vec1 = &CUR.zp1.org[point];
6126       FT_Vector*  vec2 = &CUR.zp0.org[CUR.GS.rp0];
6127
6128
6129       org_dist = CUR_Func_dualproj( vec1, vec2 );
6130     }
6131     else
6132     {
6133       FT_Vector*  vec1 = &CUR.zp1.orus[point];
6134       FT_Vector*  vec2 = &CUR.zp0.orus[CUR.GS.rp0];
6135
6136
6137       if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
6138       {
6139         /* this should be faster */
6140         org_dist = CUR_Func_dualproj( vec1, vec2 );
6141         org_dist = TT_MULFIX( org_dist, CUR.metrics.x_scale );
6142       }
6143       else
6144       {
6145         FT_Vector  vec;
6146
6147
6148         vec.x = TT_MULFIX( vec1->x - vec2->x, CUR.metrics.x_scale );
6149         vec.y = TT_MULFIX( vec1->y - vec2->y, CUR.metrics.y_scale );
6150
6151         org_dist = CUR_fast_dualproj( &vec );
6152       }
6153     }
6154
6155     /* single width cut-in test */
6156
6157     if ( FT_ABS( org_dist - CUR.GS.single_width_value ) <
6158          CUR.GS.single_width_cutin )
6159     {
6160       if ( org_dist >= 0 )
6161         org_dist = CUR.GS.single_width_value;
6162       else
6163         org_dist = -CUR.GS.single_width_value;
6164     }
6165
6166     /* round flag */
6167
6168     if ( ( CUR.opcode & 4 ) != 0 )
6169       distance = CUR_Func_round(
6170                    org_dist,
6171                    CUR.tt_metrics.compensations[CUR.opcode & 3] );
6172     else
6173       distance = ROUND_None(
6174                    org_dist,
6175                    CUR.tt_metrics.compensations[CUR.opcode & 3] );
6176
6177     /* minimum distance flag */
6178
6179     if ( ( CUR.opcode & 8 ) != 0 )
6180     {
6181       if ( org_dist >= 0 )
6182       {
6183         if ( distance < CUR.GS.minimum_distance )
6184           distance = CUR.GS.minimum_distance;
6185       }
6186       else
6187       {
6188         if ( distance > -CUR.GS.minimum_distance )
6189           distance = -CUR.GS.minimum_distance;
6190       }
6191     }
6192
6193     /* now move the point */
6194
6195     org_dist = CUR_Func_project( CUR.zp1.cur + point,
6196                                  CUR.zp0.cur + CUR.GS.rp0 );
6197
6198     CUR_Func_move( &CUR.zp1, point, distance - org_dist );
6199
6200   Fail:
6201     CUR.GS.rp1 = CUR.GS.rp0;
6202     CUR.GS.rp2 = point;
6203
6204     if ( ( CUR.opcode & 16 ) != 0 )
6205       CUR.GS.rp0 = point;
6206   }
6207
6208
6209   /*************************************************************************/
6210   /*                                                                       */
6211   /* MIRP[abcde]:  Move Indirect Relative Point                            */
6212   /* Opcode range: 0xE0-0xFF                                               */
6213   /* Stack:        int32? uint32 -->                                       */
6214   /*                                                                       */
6215   static void
6216   Ins_MIRP( INS_ARG )
6217   {
6218     FT_UShort   point;
6219     FT_ULong    cvtEntry;
6220
6221     FT_F26Dot6  cvt_dist,
6222                 distance,
6223                 cur_dist,
6224                 org_dist;
6225
6226
6227     point    = (FT_UShort)args[0];
6228     cvtEntry = (FT_ULong)( args[1] + 1 );
6229
6230     /* XXX: UNDOCUMENTED! cvt[-1] = 0 always */
6231
6232     if ( BOUNDS( point,      CUR.zp1.n_points ) ||
6233          BOUNDSL( cvtEntry,  CUR.cvtSize + 1 )  ||
6234          BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
6235     {
6236       if ( CUR.pedantic_hinting )
6237         CUR.error = TT_Err_Invalid_Reference;
6238       goto Fail;
6239     }
6240
6241     if ( !cvtEntry )
6242       cvt_dist = 0;
6243     else
6244       cvt_dist = CUR_Func_read_cvt( cvtEntry - 1 );
6245
6246     /* single width test */
6247
6248     if ( FT_ABS( cvt_dist - CUR.GS.single_width_value ) <
6249          CUR.GS.single_width_cutin )
6250     {
6251       if ( cvt_dist >= 0 )
6252         cvt_dist =  CUR.GS.single_width_value;
6253       else
6254         cvt_dist = -CUR.GS.single_width_value;
6255     }
6256
6257     /* UNDOCUMENTED!  The MS rasterizer does that with */
6258     /* twilight points (confirmed by Greg Hitchcock)   */
6259     if ( CUR.GS.gep1 == 0 )
6260     {
6261       CUR.zp1.org[point].x = CUR.zp0.org[CUR.GS.rp0].x +
6262                              TT_MulFix14( (FT_UInt32)cvt_dist,
6263                                           CUR.GS.freeVector.x );
6264       CUR.zp1.org[point].y = CUR.zp0.org[CUR.GS.rp0].y +
6265                              TT_MulFix14( (FT_UInt32)cvt_dist,
6266                                           CUR.GS.freeVector.y );
6267       CUR.zp1.cur[point]   = CUR.zp1.org[point];
6268     }
6269
6270     org_dist = CUR_Func_dualproj( &CUR.zp1.org[point],
6271                                   &CUR.zp0.org[CUR.GS.rp0] );
6272     cur_dist = CUR_Func_project ( &CUR.zp1.cur[point],
6273                                   &CUR.zp0.cur[CUR.GS.rp0] );
6274
6275     /* auto-flip test */
6276
6277     if ( CUR.GS.auto_flip )
6278     {
6279       if ( ( org_dist ^ cvt_dist ) < 0 )
6280         cvt_dist = -cvt_dist;
6281     }
6282
6283     /* control value cutin and round */
6284
6285     if ( ( CUR.opcode & 4 ) != 0 )
6286     {
6287       /* XXX: UNDOCUMENTED!  Only perform cut-in test when both points */
6288       /*      refer to the same zone.                                  */
6289
6290       if ( CUR.GS.gep0 == CUR.GS.gep1 )
6291       {
6292         /* XXX: According to Greg Hitchcock, the following wording is */
6293         /*      the right one:                                        */
6294         /*                                                            */
6295         /*        When the absolute difference between the value in   */
6296         /*        the table [CVT] and the measurement directly from   */
6297         /*        the outline is _greater_ than the cut_in value, the */
6298         /*        outline measurement is used.                        */
6299         /*                                                            */
6300         /*      This is from `instgly.doc'.  The description in       */
6301         /*      `ttinst2.doc', version 1.66, is thus incorrect since  */
6302         /*      it implies `>=' instead of `>'.                       */
6303
6304         if ( FT_ABS( cvt_dist - org_dist ) > CUR.GS.control_value_cutin )
6305           cvt_dist = org_dist;
6306       }
6307
6308       distance = CUR_Func_round(
6309                    cvt_dist,
6310                    CUR.tt_metrics.compensations[CUR.opcode & 3] );
6311     }
6312     else
6313       distance = ROUND_None(
6314                    cvt_dist,
6315                    CUR.tt_metrics.compensations[CUR.opcode & 3] );
6316
6317     /* minimum distance test */
6318
6319     if ( ( CUR.opcode & 8 ) != 0 )
6320     {
6321       if ( org_dist >= 0 )
6322       {
6323         if ( distance < CUR.GS.minimum_distance )
6324           distance = CUR.GS.minimum_distance;
6325       }
6326       else
6327       {
6328         if ( distance > -CUR.GS.minimum_distance )
6329           distance = -CUR.GS.minimum_distance;
6330       }
6331     }
6332
6333     CUR_Func_move( &CUR.zp1, point, distance - cur_dist );
6334
6335   Fail:
6336     CUR.GS.rp1 = CUR.GS.rp0;
6337
6338     if ( ( CUR.opcode & 16 ) != 0 )
6339       CUR.GS.rp0 = point;
6340
6341     CUR.GS.rp2 = point;
6342   }
6343
6344
6345   /*************************************************************************/
6346   /*                                                                       */
6347   /* ALIGNRP[]:    ALIGN Relative Point                                    */
6348   /* Opcode range: 0x3C                                                    */
6349   /* Stack:        uint32 uint32... -->                                    */
6350   /*                                                                       */
6351   static void
6352   Ins_ALIGNRP( INS_ARG )
6353   {
6354     FT_UShort   point;
6355     FT_F26Dot6  distance;
6356
6357     FT_UNUSED_ARG;
6358
6359
6360     if ( CUR.top < CUR.GS.loop ||
6361          BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
6362     {
6363       if ( CUR.pedantic_hinting )
6364         CUR.error = TT_Err_Invalid_Reference;
6365       goto Fail;
6366     }
6367
6368     while ( CUR.GS.loop > 0 )
6369     {
6370       CUR.args--;
6371
6372       point = (FT_UShort)CUR.stack[CUR.args];
6373
6374       if ( BOUNDS( point, CUR.zp1.n_points ) )
6375       {
6376         if ( CUR.pedantic_hinting )
6377         {
6378           CUR.error = TT_Err_Invalid_Reference;
6379           return;
6380         }
6381       }
6382       else
6383       {
6384         distance = CUR_Func_project( CUR.zp1.cur + point,
6385                                      CUR.zp0.cur + CUR.GS.rp0 );
6386
6387         CUR_Func_move( &CUR.zp1, point, -distance );
6388       }
6389
6390       CUR.GS.loop--;
6391     }
6392
6393   Fail:
6394     CUR.GS.loop = 1;
6395     CUR.new_top = CUR.args;
6396   }
6397
6398
6399   /*************************************************************************/
6400   /*                                                                       */
6401   /* ISECT[]:      moves point to InterSECTion                             */
6402   /* Opcode range: 0x0F                                                    */
6403   /* Stack:        5 * uint32 -->                                          */
6404   /*                                                                       */
6405   static void
6406   Ins_ISECT( INS_ARG )
6407   {
6408     FT_UShort   point,
6409                 a0, a1,
6410                 b0, b1;
6411
6412     FT_F26Dot6  discriminant;
6413
6414     FT_F26Dot6  dx,  dy,
6415                 dax, day,
6416                 dbx, dby;
6417
6418     FT_F26Dot6  val;
6419
6420     FT_Vector   R;
6421
6422
6423     point = (FT_UShort)args[0];
6424
6425     a0 = (FT_UShort)args[1];
6426     a1 = (FT_UShort)args[2];
6427     b0 = (FT_UShort)args[3];
6428     b1 = (FT_UShort)args[4];
6429
6430     if ( BOUNDS( b0, CUR.zp0.n_points )  ||
6431          BOUNDS( b1, CUR.zp0.n_points )  ||
6432          BOUNDS( a0, CUR.zp1.n_points )  ||
6433          BOUNDS( a1, CUR.zp1.n_points )  ||
6434          BOUNDS( point, CUR.zp2.n_points ) )
6435     {
6436       if ( CUR.pedantic_hinting )
6437         CUR.error = TT_Err_Invalid_Reference;
6438       return;
6439     }
6440
6441     dbx = CUR.zp0.cur[b1].x - CUR.zp0.cur[b0].x;
6442     dby = CUR.zp0.cur[b1].y - CUR.zp0.cur[b0].y;
6443
6444     dax = CUR.zp1.cur[a1].x - CUR.zp1.cur[a0].x;
6445     day = CUR.zp1.cur[a1].y - CUR.zp1.cur[a0].y;
6446
6447     dx = CUR.zp0.cur[b0].x - CUR.zp1.cur[a0].x;
6448     dy = CUR.zp0.cur[b0].y - CUR.zp1.cur[a0].y;
6449
6450     CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_BOTH;
6451
6452     discriminant = TT_MULDIV( dax, -dby, 0x40 ) +
6453                    TT_MULDIV( day, dbx, 0x40 );
6454
6455     if ( FT_ABS( discriminant ) >= 0x40 )
6456     {
6457       val = TT_MULDIV( dx, -dby, 0x40 ) + TT_MULDIV( dy, dbx, 0x40 );
6458
6459       R.x = TT_MULDIV( val, dax, discriminant );
6460       R.y = TT_MULDIV( val, day, discriminant );
6461
6462       CUR.zp2.cur[point].x = CUR.zp1.cur[a0].x + R.x;
6463       CUR.zp2.cur[point].y = CUR.zp1.cur[a0].y + R.y;
6464     }
6465     else
6466     {
6467       /* else, take the middle of the middles of A and B */
6468
6469       CUR.zp2.cur[point].x = ( CUR.zp1.cur[a0].x +
6470                                CUR.zp1.cur[a1].x +
6471                                CUR.zp0.cur[b0].x +
6472                                CUR.zp0.cur[b1].x ) / 4;
6473       CUR.zp2.cur[point].y = ( CUR.zp1.cur[a0].y +
6474                                CUR.zp1.cur[a1].y +
6475                                CUR.zp0.cur[b0].y +
6476                                CUR.zp0.cur[b1].y ) / 4;
6477     }
6478   }
6479
6480
6481   /*************************************************************************/
6482   /*                                                                       */
6483   /* ALIGNPTS[]:   ALIGN PoinTS                                            */
6484   /* Opcode range: 0x27                                                    */
6485   /* Stack:        uint32 uint32 -->                                       */
6486   /*                                                                       */
6487   static void
6488   Ins_ALIGNPTS( INS_ARG )
6489   {
6490     FT_UShort   p1, p2;
6491     FT_F26Dot6  distance;
6492
6493
6494     p1 = (FT_UShort)args[0];
6495     p2 = (FT_UShort)args[1];
6496
6497     if ( BOUNDS( p1, CUR.zp1.n_points ) ||
6498          BOUNDS( p2, CUR.zp0.n_points ) )
6499     {
6500       if ( CUR.pedantic_hinting )
6501         CUR.error = TT_Err_Invalid_Reference;
6502       return;
6503     }
6504
6505     distance = CUR_Func_project( CUR.zp0.cur + p2,
6506                                  CUR.zp1.cur + p1 ) / 2;
6507
6508     CUR_Func_move( &CUR.zp1, p1, distance );
6509     CUR_Func_move( &CUR.zp0, p2, -distance );
6510   }
6511
6512
6513   /*************************************************************************/
6514   /*                                                                       */
6515   /* IP[]:         Interpolate Point                                       */
6516   /* Opcode range: 0x39                                                    */
6517   /* Stack:        uint32... -->                                           */
6518   /*                                                                       */
6519
6520   /* SOMETIMES, DUMBER CODE IS BETTER CODE */
6521
6522   static void
6523   Ins_IP( INS_ARG )
6524   {
6525     FT_F26Dot6  old_range, cur_range;
6526     FT_Vector*  orus_base;
6527     FT_Vector*  cur_base;
6528     FT_Int      twilight;
6529
6530     FT_UNUSED_ARG;
6531
6532
6533     if ( CUR.top < CUR.GS.loop )
6534     {
6535       if ( CUR.pedantic_hinting )
6536         CUR.error = TT_Err_Invalid_Reference;
6537       goto Fail;
6538     }
6539
6540     /*
6541      * We need to deal in a special way with the twilight zone.
6542      * Otherwise, by definition, the value of CUR.twilight.orus[n] is (0,0),
6543      * for every n.
6544      */
6545     twilight = CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 || CUR.GS.gep2 == 0;
6546
6547     if ( BOUNDS( CUR.GS.rp1, CUR.zp0.n_points ) )
6548     {
6549       if ( CUR.pedantic_hinting )
6550         CUR.error = TT_Err_Invalid_Reference;
6551       goto Fail;
6552     }
6553
6554     if ( twilight )
6555       orus_base = &CUR.zp0.org[CUR.GS.rp1];
6556     else
6557       orus_base = &CUR.zp0.orus[CUR.GS.rp1];
6558
6559     cur_base = &CUR.zp0.cur[CUR.GS.rp1];
6560
6561     /* XXX: There are some glyphs in some braindead but popular */
6562     /*      fonts out there (e.g. [aeu]grave in monotype.ttf)   */
6563     /*      calling IP[] with bad values of rp[12].             */
6564     /*      Do something sane when this odd thing happens.      */
6565     if ( BOUNDS( CUR.GS.rp1, CUR.zp0.n_points ) ||
6566          BOUNDS( CUR.GS.rp2, CUR.zp1.n_points ) )
6567     {
6568       old_range = 0;
6569       cur_range = 0;
6570     }
6571     else
6572     {
6573       if ( twilight )
6574         old_range = CUR_Func_dualproj( &CUR.zp1.org[CUR.GS.rp2],
6575                                        orus_base );
6576       else if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
6577         old_range = CUR_Func_dualproj( &CUR.zp1.orus[CUR.GS.rp2],
6578                                        orus_base );
6579       else
6580       {
6581         FT_Vector  vec;
6582
6583
6584         vec.x = TT_MULFIX( CUR.zp1.orus[CUR.GS.rp2].x - orus_base->x,
6585                            CUR.metrics.x_scale );
6586         vec.y = TT_MULFIX( CUR.zp1.orus[CUR.GS.rp2].y - orus_base->y,
6587                            CUR.metrics.y_scale );
6588
6589         old_range = CUR_fast_dualproj( &vec );
6590       }
6591
6592       cur_range = CUR_Func_project ( &CUR.zp1.cur[CUR.GS.rp2], cur_base );
6593     }
6594
6595     for ( ; CUR.GS.loop > 0; --CUR.GS.loop )
6596     {
6597       FT_UInt     point = (FT_UInt)CUR.stack[--CUR.args];
6598       FT_F26Dot6  org_dist, cur_dist, new_dist;
6599
6600
6601       /* check point bounds */
6602       if ( BOUNDS( point, CUR.zp2.n_points ) )
6603       {
6604         if ( CUR.pedantic_hinting )
6605         {
6606           CUR.error = TT_Err_Invalid_Reference;
6607           return;
6608         }
6609         continue;
6610       }
6611
6612       if ( twilight )
6613         org_dist = CUR_Func_dualproj( &CUR.zp2.org[point], orus_base );
6614       else if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
6615         org_dist = CUR_Func_dualproj( &CUR.zp2.orus[point], orus_base );
6616       else
6617       {
6618         FT_Vector  vec;
6619
6620
6621         vec.x = TT_MULFIX( CUR.zp2.orus[point].x - orus_base->x,
6622                            CUR.metrics.x_scale );
6623         vec.y = TT_MULFIX( CUR.zp2.orus[point].y - orus_base->y,
6624                            CUR.metrics.y_scale );
6625
6626         org_dist = CUR_fast_dualproj( &vec );
6627       }
6628
6629       cur_dist = CUR_Func_project ( &CUR.zp2.cur[point], cur_base );
6630
6631       if ( org_dist )
6632         new_dist = ( old_range != 0 )
6633                      ? TT_MULDIV( org_dist, cur_range, old_range )
6634                      : cur_dist;
6635       else
6636         new_dist = 0;
6637
6638       CUR_Func_move( &CUR.zp2, (FT_UShort)point, new_dist - cur_dist );
6639     }
6640
6641   Fail:
6642     CUR.GS.loop = 1;
6643     CUR.new_top = CUR.args;
6644   }
6645
6646
6647   /*************************************************************************/
6648   /*                                                                       */
6649   /* UTP[a]:       UnTouch Point                                           */
6650   /* Opcode range: 0x29                                                    */
6651   /* Stack:        uint32 -->                                              */
6652   /*                                                                       */
6653   static void
6654   Ins_UTP( INS_ARG )
6655   {
6656     FT_UShort  point;
6657     FT_Byte    mask;
6658
6659
6660     point = (FT_UShort)args[0];
6661
6662     if ( BOUNDS( point, CUR.zp0.n_points ) )
6663     {
6664       if ( CUR.pedantic_hinting )
6665         CUR.error = TT_Err_Invalid_Reference;
6666       return;
6667     }
6668
6669     mask = 0xFF;
6670
6671     if ( CUR.GS.freeVector.x != 0 )
6672       mask &= ~FT_CURVE_TAG_TOUCH_X;
6673
6674     if ( CUR.GS.freeVector.y != 0 )
6675       mask &= ~FT_CURVE_TAG_TOUCH_Y;
6676
6677     CUR.zp0.tags[point] &= mask;
6678   }
6679
6680
6681   /* Local variables for Ins_IUP: */
6682   typedef struct  IUP_WorkerRec_
6683   {
6684     FT_Vector*  orgs;   /* original and current coordinate */
6685     FT_Vector*  curs;   /* arrays                          */
6686     FT_Vector*  orus;
6687     FT_UInt     max_points;
6688
6689   } IUP_WorkerRec, *IUP_Worker;
6690
6691
6692   static void
6693   _iup_worker_shift( IUP_Worker  worker,
6694                      FT_UInt     p1,
6695                      FT_UInt     p2,
6696                      FT_UInt     p )
6697   {
6698     FT_UInt     i;
6699     FT_F26Dot6  dx;
6700
6701
6702     dx = worker->curs[p].x - worker->orgs[p].x;
6703     if ( dx != 0 )
6704     {
6705       for ( i = p1; i < p; i++ )
6706         worker->curs[i].x += dx;
6707
6708       for ( i = p + 1; i <= p2; i++ )
6709         worker->curs[i].x += dx;
6710     }
6711   }
6712
6713
6714   static void
6715   _iup_worker_interpolate( IUP_Worker  worker,
6716                            FT_UInt     p1,
6717                            FT_UInt     p2,
6718                            FT_UInt     ref1,
6719                            FT_UInt     ref2 )
6720   {
6721     FT_UInt     i;
6722     FT_F26Dot6  orus1, orus2, org1, org2, delta1, delta2;
6723
6724
6725     if ( p1 > p2 )
6726       return;
6727
6728     if ( BOUNDS( ref1, worker->max_points ) ||
6729          BOUNDS( ref2, worker->max_points ) )
6730       return;
6731
6732     orus1 = worker->orus[ref1].x;
6733     orus2 = worker->orus[ref2].x;
6734
6735     if ( orus1 > orus2 )
6736     {
6737       FT_F26Dot6  tmp_o;
6738       FT_UInt     tmp_r;
6739
6740
6741       tmp_o = orus1;
6742       orus1 = orus2;
6743       orus2 = tmp_o;
6744
6745       tmp_r = ref1;
6746       ref1  = ref2;
6747       ref2  = tmp_r;
6748     }
6749
6750     org1   = worker->orgs[ref1].x;
6751     org2   = worker->orgs[ref2].x;
6752     delta1 = worker->curs[ref1].x - org1;
6753     delta2 = worker->curs[ref2].x - org2;
6754
6755     if ( orus1 == orus2 )
6756     {
6757       /* simple shift of untouched points */
6758       for ( i = p1; i <= p2; i++ )
6759       {
6760         FT_F26Dot6  x = worker->orgs[i].x;
6761
6762
6763         if ( x <= org1 )
6764           x += delta1;
6765         else
6766           x += delta2;
6767
6768         worker->curs[i].x = x;
6769       }
6770     }
6771     else
6772     {
6773       FT_Fixed  scale       = 0;
6774       FT_Bool   scale_valid = 0;
6775
6776
6777       /* interpolation */
6778       for ( i = p1; i <= p2; i++ )
6779       {
6780         FT_F26Dot6  x = worker->orgs[i].x;
6781
6782
6783         if ( x <= org1 )
6784           x += delta1;
6785
6786         else if ( x >= org2 )
6787           x += delta2;
6788
6789         else
6790         {
6791           if ( !scale_valid )
6792           {
6793             scale_valid = 1;
6794             scale       = TT_MULDIV( org2 + delta2 - ( org1 + delta1 ),
6795                                      0x10000L, orus2 - orus1 );
6796           }
6797
6798           x = ( org1 + delta1 ) +
6799               TT_MULFIX( worker->orus[i].x - orus1, scale );
6800         }
6801         worker->curs[i].x = x;
6802       }
6803     }
6804   }
6805
6806
6807   /*************************************************************************/
6808   /*                                                                       */
6809   /* IUP[a]:       Interpolate Untouched Points                            */
6810   /* Opcode range: 0x30-0x31                                               */
6811   /* Stack:        -->                                                     */
6812   /*                                                                       */
6813   static void
6814   Ins_IUP( INS_ARG )
6815   {
6816     IUP_WorkerRec  V;
6817     FT_Byte        mask;
6818
6819     FT_UInt   first_point;   /* first point of contour        */
6820     FT_UInt   end_point;     /* end point (last+1) of contour */
6821
6822     FT_UInt   first_touched; /* first touched point in contour   */
6823     FT_UInt   cur_touched;   /* current touched point in contour */
6824
6825     FT_UInt   point;         /* current point   */
6826     FT_Short  contour;       /* current contour */
6827
6828     FT_UNUSED_ARG;
6829
6830
6831     /* ignore empty outlines */
6832     if ( CUR.pts.n_contours == 0 )
6833       return;
6834
6835     if ( CUR.opcode & 1 )
6836     {
6837       mask   = FT_CURVE_TAG_TOUCH_X;
6838       V.orgs = CUR.pts.org;
6839       V.curs = CUR.pts.cur;
6840       V.orus = CUR.pts.orus;
6841     }
6842     else
6843     {
6844       mask   = FT_CURVE_TAG_TOUCH_Y;
6845       V.orgs = (FT_Vector*)( (FT_Pos*)CUR.pts.org + 1 );
6846       V.curs = (FT_Vector*)( (FT_Pos*)CUR.pts.cur + 1 );
6847       V.orus = (FT_Vector*)( (FT_Pos*)CUR.pts.orus + 1 );
6848     }
6849     V.max_points = CUR.pts.n_points;
6850
6851     contour = 0;
6852     point   = 0;
6853
6854     do
6855     {
6856       end_point   = CUR.pts.contours[contour] - CUR.pts.first_point;
6857       first_point = point;
6858
6859       if ( BOUNDS ( end_point, CUR.pts.n_points ) )
6860         end_point = CUR.pts.n_points - 1;
6861
6862       while ( point <= end_point && ( CUR.pts.tags[point] & mask ) == 0 )
6863         point++;
6864
6865       if ( point <= end_point )
6866       {
6867         first_touched = point;
6868         cur_touched   = point;
6869
6870         point++;
6871
6872         while ( point <= end_point )
6873         {
6874           if ( ( CUR.pts.tags[point] & mask ) != 0 )
6875           {
6876             _iup_worker_interpolate( &V,
6877                                      cur_touched + 1,
6878                                      point - 1,
6879                                      cur_touched,
6880                                      point );
6881             cur_touched = point;
6882           }
6883
6884           point++;
6885         }
6886
6887         if ( cur_touched == first_touched )
6888           _iup_worker_shift( &V, first_point, end_point, cur_touched );
6889         else
6890         {
6891           _iup_worker_interpolate( &V,
6892                                    (FT_UShort)( cur_touched + 1 ),
6893                                    end_point,
6894                                    cur_touched,
6895                                    first_touched );
6896
6897           if ( first_touched > 0 )
6898             _iup_worker_interpolate( &V,
6899                                      first_point,
6900                                      first_touched - 1,
6901                                      cur_touched,
6902                                      first_touched );
6903         }
6904       }
6905       contour++;
6906     } while ( contour < CUR.pts.n_contours );
6907   }
6908
6909
6910   /*************************************************************************/
6911   /*                                                                       */
6912   /* DELTAPn[]:    DELTA exceptions P1, P2, P3                             */
6913   /* Opcode range: 0x5D,0x71,0x72                                          */
6914   /* Stack:        uint32 (2 * uint32)... -->                              */
6915   /*                                                                       */
6916   static void
6917   Ins_DELTAP( INS_ARG )
6918   {
6919     FT_ULong   k, nump;
6920     FT_UShort  A;
6921     FT_ULong   C;
6922     FT_Long    B;
6923
6924
6925 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
6926     /* Delta hinting is covered by US Patent 5159668. */
6927     if ( CUR.face->unpatented_hinting )
6928     {
6929       FT_Long  n = args[0] * 2;
6930
6931
6932       if ( CUR.args < n )
6933       {
6934         if ( CUR.pedantic_hinting )
6935           CUR.error = TT_Err_Too_Few_Arguments;
6936         n = CUR.args;
6937       }
6938
6939       CUR.args -= n;
6940       CUR.new_top = CUR.args;
6941       return;
6942     }
6943 #endif
6944
6945     nump = (FT_ULong)args[0];   /* some points theoretically may occur more
6946                                    than once, thus UShort isn't enough */
6947
6948     for ( k = 1; k <= nump; k++ )
6949     {
6950       if ( CUR.args < 2 )
6951       {
6952         if ( CUR.pedantic_hinting )
6953           CUR.error = TT_Err_Too_Few_Arguments;
6954         CUR.args = 0;
6955         goto Fail;
6956       }
6957
6958       CUR.args -= 2;
6959
6960       A = (FT_UShort)CUR.stack[CUR.args + 1];
6961       B = CUR.stack[CUR.args];
6962
6963       /* XXX: Because some popular fonts contain some invalid DeltaP */
6964       /*      instructions, we simply ignore them when the stacked   */
6965       /*      point reference is off limit, rather than returning an */
6966       /*      error.  As a delta instruction doesn't change a glyph  */
6967       /*      in great ways, this shouldn't be a problem.            */
6968
6969       if ( !BOUNDS( A, CUR.zp0.n_points ) )
6970       {
6971         C = ( (FT_ULong)B & 0xF0 ) >> 4;
6972
6973         switch ( CUR.opcode )
6974         {
6975         case 0x5D:
6976           break;
6977
6978         case 0x71:
6979           C += 16;
6980           break;
6981
6982         case 0x72:
6983           C += 32;
6984           break;
6985         }
6986
6987         C += CUR.GS.delta_base;
6988
6989         if ( CURRENT_Ppem() == (FT_Long)C )
6990         {
6991           B = ( (FT_ULong)B & 0xF ) - 8;
6992           if ( B >= 0 )
6993             B++;
6994           B = B * 64 / ( 1L << CUR.GS.delta_shift );
6995
6996           CUR_Func_move( &CUR.zp0, A, B );
6997         }
6998       }
6999       else
7000         if ( CUR.pedantic_hinting )
7001           CUR.error = TT_Err_Invalid_Reference;
7002     }
7003
7004   Fail:
7005     CUR.new_top = CUR.args;
7006   }
7007
7008
7009   /*************************************************************************/
7010   /*                                                                       */
7011   /* DELTACn[]:    DELTA exceptions C1, C2, C3                             */
7012   /* Opcode range: 0x73,0x74,0x75                                          */
7013   /* Stack:        uint32 (2 * uint32)... -->                              */
7014   /*                                                                       */
7015   static void
7016   Ins_DELTAC( INS_ARG )
7017   {
7018     FT_ULong  nump, k;
7019     FT_ULong  A, C;
7020     FT_Long   B;
7021
7022
7023 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
7024     /* Delta hinting is covered by US Patent 5159668. */
7025     if ( CUR.face->unpatented_hinting )
7026     {
7027       FT_Long  n = args[0] * 2;
7028
7029
7030       if ( CUR.args < n )
7031       {
7032         if ( CUR.pedantic_hinting )
7033           CUR.error = TT_Err_Too_Few_Arguments;
7034         n = CUR.args;
7035       }
7036
7037       CUR.args -= n;
7038       CUR.new_top = CUR.args;
7039       return;
7040     }
7041 #endif
7042
7043     nump = (FT_ULong)args[0];
7044
7045     for ( k = 1; k <= nump; k++ )
7046     {
7047       if ( CUR.args < 2 )
7048       {
7049         if ( CUR.pedantic_hinting )
7050           CUR.error = TT_Err_Too_Few_Arguments;
7051         CUR.args = 0;
7052         goto Fail;
7053       }
7054
7055       CUR.args -= 2;
7056
7057       A = (FT_ULong)CUR.stack[CUR.args + 1];
7058       B = CUR.stack[CUR.args];
7059
7060       if ( BOUNDSL( A, CUR.cvtSize ) )
7061       {
7062         if ( CUR.pedantic_hinting )
7063         {
7064           CUR.error = TT_Err_Invalid_Reference;
7065           return;
7066         }
7067       }
7068       else
7069       {
7070         C = ( (FT_ULong)B & 0xF0 ) >> 4;
7071
7072         switch ( CUR.opcode )
7073         {
7074         case 0x73:
7075           break;
7076
7077         case 0x74:
7078           C += 16;
7079           break;
7080
7081         case 0x75:
7082           C += 32;
7083           break;
7084         }
7085
7086         C += CUR.GS.delta_base;
7087
7088         if ( CURRENT_Ppem() == (FT_Long)C )
7089         {
7090           B = ( (FT_ULong)B & 0xF ) - 8;
7091           if ( B >= 0 )
7092             B++;
7093           B = B * 64 / ( 1L << CUR.GS.delta_shift );
7094
7095           CUR_Func_move_cvt( A, B );
7096         }
7097       }
7098     }
7099
7100   Fail:
7101     CUR.new_top = CUR.args;
7102   }
7103
7104
7105   /*************************************************************************/
7106   /*                                                                       */
7107   /* MISC. INSTRUCTIONS                                                    */
7108   /*                                                                       */
7109   /*************************************************************************/
7110
7111
7112   /*************************************************************************/
7113   /*                                                                       */
7114   /* GETINFO[]:    GET INFOrmation                                         */
7115   /* Opcode range: 0x88                                                    */
7116   /* Stack:        uint32 --> uint32                                       */
7117   /*                                                                       */
7118   static void
7119   Ins_GETINFO( INS_ARG )
7120   {
7121     FT_Long  K;
7122
7123
7124     K = 0;
7125
7126     /* We return MS rasterizer version 1.7 for the font scaler. */
7127     if ( ( args[0] & 1 ) != 0 )
7128       K = 35;
7129
7130     /* Has the glyph been rotated? */
7131     if ( ( args[0] & 2 ) != 0 && CUR.tt_metrics.rotated )
7132       K |= 0x80;
7133
7134     /* Has the glyph been stretched? */
7135     if ( ( args[0] & 4 ) != 0 && CUR.tt_metrics.stretched )
7136       K |= 1 << 8;
7137
7138     /* Are we hinting for grayscale? */
7139     if ( ( args[0] & 32 ) != 0 && CUR.grayscale )
7140       K |= 1 << 12;
7141
7142     args[0] = K;
7143   }
7144
7145
7146   static void
7147   Ins_UNKNOWN( INS_ARG )
7148   {
7149     TT_DefRecord*  def   = CUR.IDefs;
7150     TT_DefRecord*  limit = def + CUR.numIDefs;
7151
7152     FT_UNUSED_ARG;
7153
7154
7155     for ( ; def < limit; def++ )
7156     {
7157       if ( (FT_Byte)def->opc == CUR.opcode && def->active )
7158       {
7159         TT_CallRec*  call;
7160
7161
7162         if ( CUR.callTop >= CUR.callSize )
7163         {
7164           CUR.error = TT_Err_Stack_Overflow;
7165           return;
7166         }
7167
7168         call = CUR.callStack + CUR.callTop++;
7169
7170         call->Caller_Range = CUR.curRange;
7171         call->Caller_IP    = CUR.IP + 1;
7172         call->Cur_Count    = 1;
7173         call->Cur_Restart  = def->start;
7174         call->Cur_End      = def->end;
7175
7176         INS_Goto_CodeRange( def->range, def->start );
7177
7178         CUR.step_ins = FALSE;
7179         return;
7180       }
7181     }
7182
7183     CUR.error = TT_Err_Invalid_Opcode;
7184   }
7185
7186
7187 #ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
7188
7189
7190   static
7191   TInstruction_Function  Instruct_Dispatch[256] =
7192   {
7193     /* Opcodes are gathered in groups of 16. */
7194     /* Please keep the spaces as they are.   */
7195
7196     /*  SVTCA  y  */  Ins_SVTCA,
7197     /*  SVTCA  x  */  Ins_SVTCA,
7198     /*  SPvTCA y  */  Ins_SPVTCA,
7199     /*  SPvTCA x  */  Ins_SPVTCA,
7200     /*  SFvTCA y  */  Ins_SFVTCA,
7201     /*  SFvTCA x  */  Ins_SFVTCA,
7202     /*  SPvTL //  */  Ins_SPVTL,
7203     /*  SPvTL +   */  Ins_SPVTL,
7204     /*  SFvTL //  */  Ins_SFVTL,
7205     /*  SFvTL +   */  Ins_SFVTL,
7206     /*  SPvFS     */  Ins_SPVFS,
7207     /*  SFvFS     */  Ins_SFVFS,
7208     /*  GPV       */  Ins_GPV,
7209     /*  GFV       */  Ins_GFV,
7210     /*  SFvTPv    */  Ins_SFVTPV,
7211     /*  ISECT     */  Ins_ISECT,
7212
7213     /*  SRP0      */  Ins_SRP0,
7214     /*  SRP1      */  Ins_SRP1,
7215     /*  SRP2      */  Ins_SRP2,
7216     /*  SZP0      */  Ins_SZP0,
7217     /*  SZP1      */  Ins_SZP1,
7218     /*  SZP2      */  Ins_SZP2,
7219     /*  SZPS      */  Ins_SZPS,
7220     /*  SLOOP     */  Ins_SLOOP,
7221     /*  RTG       */  Ins_RTG,
7222     /*  RTHG      */  Ins_RTHG,
7223     /*  SMD       */  Ins_SMD,
7224     /*  ELSE      */  Ins_ELSE,
7225     /*  JMPR      */  Ins_JMPR,
7226     /*  SCvTCi    */  Ins_SCVTCI,
7227     /*  SSwCi     */  Ins_SSWCI,
7228     /*  SSW       */  Ins_SSW,
7229
7230     /*  DUP       */  Ins_DUP,
7231     /*  POP       */  Ins_POP,
7232     /*  CLEAR     */  Ins_CLEAR,
7233     /*  SWAP      */  Ins_SWAP,
7234     /*  DEPTH     */  Ins_DEPTH,
7235     /*  CINDEX    */  Ins_CINDEX,
7236     /*  MINDEX    */  Ins_MINDEX,
7237     /*  AlignPTS  */  Ins_ALIGNPTS,
7238     /*  INS_0x28  */  Ins_UNKNOWN,
7239     /*  UTP       */  Ins_UTP,
7240     /*  LOOPCALL  */  Ins_LOOPCALL,
7241     /*  CALL      */  Ins_CALL,
7242     /*  FDEF      */  Ins_FDEF,
7243     /*  ENDF      */  Ins_ENDF,
7244     /*  MDAP[0]   */  Ins_MDAP,
7245     /*  MDAP[1]   */  Ins_MDAP,
7246
7247     /*  IUP[0]    */  Ins_IUP,
7248     /*  IUP[1]    */  Ins_IUP,
7249     /*  SHP[0]    */  Ins_SHP,
7250     /*  SHP[1]    */  Ins_SHP,
7251     /*  SHC[0]    */  Ins_SHC,
7252     /*  SHC[1]    */  Ins_SHC,
7253     /*  SHZ[0]    */  Ins_SHZ,
7254     /*  SHZ[1]    */  Ins_SHZ,
7255     /*  SHPIX     */  Ins_SHPIX,
7256     /*  IP        */  Ins_IP,
7257     /*  MSIRP[0]  */  Ins_MSIRP,
7258     /*  MSIRP[1]  */  Ins_MSIRP,
7259     /*  AlignRP   */  Ins_ALIGNRP,
7260     /*  RTDG      */  Ins_RTDG,
7261     /*  MIAP[0]   */  Ins_MIAP,
7262     /*  MIAP[1]   */  Ins_MIAP,
7263
7264     /*  NPushB    */  Ins_NPUSHB,
7265     /*  NPushW    */  Ins_NPUSHW,
7266     /*  WS        */  Ins_WS,
7267     /*  RS        */  Ins_RS,
7268     /*  WCvtP     */  Ins_WCVTP,
7269     /*  RCvt      */  Ins_RCVT,
7270     /*  GC[0]     */  Ins_GC,
7271     /*  GC[1]     */  Ins_GC,
7272     /*  SCFS      */  Ins_SCFS,
7273     /*  MD[0]     */  Ins_MD,
7274     /*  MD[1]     */  Ins_MD,
7275     /*  MPPEM     */  Ins_MPPEM,
7276     /*  MPS       */  Ins_MPS,
7277     /*  FlipON    */  Ins_FLIPON,
7278     /*  FlipOFF   */  Ins_FLIPOFF,
7279     /*  DEBUG     */  Ins_DEBUG,
7280
7281     /*  LT        */  Ins_LT,
7282     /*  LTEQ      */  Ins_LTEQ,
7283     /*  GT        */  Ins_GT,
7284     /*  GTEQ      */  Ins_GTEQ,
7285     /*  EQ        */  Ins_EQ,
7286     /*  NEQ       */  Ins_NEQ,
7287     /*  ODD       */  Ins_ODD,
7288     /*  EVEN      */  Ins_EVEN,
7289     /*  IF        */  Ins_IF,
7290     /*  EIF       */  Ins_EIF,
7291     /*  AND       */  Ins_AND,
7292     /*  OR        */  Ins_OR,
7293     /*  NOT       */  Ins_NOT,
7294     /*  DeltaP1   */  Ins_DELTAP,
7295     /*  SDB       */  Ins_SDB,
7296     /*  SDS       */  Ins_SDS,
7297
7298     /*  ADD       */  Ins_ADD,
7299     /*  SUB       */  Ins_SUB,
7300     /*  DIV       */  Ins_DIV,
7301     /*  MUL       */  Ins_MUL,
7302     /*  ABS       */  Ins_ABS,
7303     /*  NEG       */  Ins_NEG,
7304     /*  FLOOR     */  Ins_FLOOR,
7305     /*  CEILING   */  Ins_CEILING,
7306     /*  ROUND[0]  */  Ins_ROUND,
7307     /*  ROUND[1]  */  Ins_ROUND,
7308     /*  ROUND[2]  */  Ins_ROUND,
7309     /*  ROUND[3]  */  Ins_ROUND,
7310     /*  NROUND[0] */  Ins_NROUND,
7311     /*  NROUND[1] */  Ins_NROUND,
7312     /*  NROUND[2] */  Ins_NROUND,
7313     /*  NROUND[3] */  Ins_NROUND,
7314
7315     /*  WCvtF     */  Ins_WCVTF,
7316     /*  DeltaP2   */  Ins_DELTAP,
7317     /*  DeltaP3   */  Ins_DELTAP,
7318     /*  DeltaCn[0] */ Ins_DELTAC,
7319     /*  DeltaCn[1] */ Ins_DELTAC,
7320     /*  DeltaCn[2] */ Ins_DELTAC,
7321     /*  SROUND    */  Ins_SROUND,
7322     /*  S45Round  */  Ins_S45ROUND,
7323     /*  JROT      */  Ins_JROT,
7324     /*  JROF      */  Ins_JROF,
7325     /*  ROFF      */  Ins_ROFF,
7326     /*  INS_0x7B  */  Ins_UNKNOWN,
7327     /*  RUTG      */  Ins_RUTG,
7328     /*  RDTG      */  Ins_RDTG,
7329     /*  SANGW     */  Ins_SANGW,
7330     /*  AA        */  Ins_AA,
7331
7332     /*  FlipPT    */  Ins_FLIPPT,
7333     /*  FlipRgON  */  Ins_FLIPRGON,
7334     /*  FlipRgOFF */  Ins_FLIPRGOFF,
7335     /*  INS_0x83  */  Ins_UNKNOWN,
7336     /*  INS_0x84  */  Ins_UNKNOWN,
7337     /*  ScanCTRL  */  Ins_SCANCTRL,
7338     /*  SDPVTL[0] */  Ins_SDPVTL,
7339     /*  SDPVTL[1] */  Ins_SDPVTL,
7340     /*  GetINFO   */  Ins_GETINFO,
7341     /*  IDEF      */  Ins_IDEF,
7342     /*  ROLL      */  Ins_ROLL,
7343     /*  MAX       */  Ins_MAX,
7344     /*  MIN       */  Ins_MIN,
7345     /*  ScanTYPE  */  Ins_SCANTYPE,
7346     /*  InstCTRL  */  Ins_INSTCTRL,
7347     /*  INS_0x8F  */  Ins_UNKNOWN,
7348
7349     /*  INS_0x90  */   Ins_UNKNOWN,
7350     /*  INS_0x91  */   Ins_UNKNOWN,
7351     /*  INS_0x92  */   Ins_UNKNOWN,
7352     /*  INS_0x93  */   Ins_UNKNOWN,
7353     /*  INS_0x94  */   Ins_UNKNOWN,
7354     /*  INS_0x95  */   Ins_UNKNOWN,
7355     /*  INS_0x96  */   Ins_UNKNOWN,
7356     /*  INS_0x97  */   Ins_UNKNOWN,
7357     /*  INS_0x98  */   Ins_UNKNOWN,
7358     /*  INS_0x99  */   Ins_UNKNOWN,
7359     /*  INS_0x9A  */   Ins_UNKNOWN,
7360     /*  INS_0x9B  */   Ins_UNKNOWN,
7361     /*  INS_0x9C  */   Ins_UNKNOWN,
7362     /*  INS_0x9D  */   Ins_UNKNOWN,
7363     /*  INS_0x9E  */   Ins_UNKNOWN,
7364     /*  INS_0x9F  */   Ins_UNKNOWN,
7365
7366     /*  INS_0xA0  */   Ins_UNKNOWN,
7367     /*  INS_0xA1  */   Ins_UNKNOWN,
7368     /*  INS_0xA2  */   Ins_UNKNOWN,
7369     /*  INS_0xA3  */   Ins_UNKNOWN,
7370     /*  INS_0xA4  */   Ins_UNKNOWN,
7371     /*  INS_0xA5  */   Ins_UNKNOWN,
7372     /*  INS_0xA6  */   Ins_UNKNOWN,
7373     /*  INS_0xA7  */   Ins_UNKNOWN,
7374     /*  INS_0xA8  */   Ins_UNKNOWN,
7375     /*  INS_0xA9  */   Ins_UNKNOWN,
7376     /*  INS_0xAA  */   Ins_UNKNOWN,
7377     /*  INS_0xAB  */   Ins_UNKNOWN,
7378     /*  INS_0xAC  */   Ins_UNKNOWN,
7379     /*  INS_0xAD  */   Ins_UNKNOWN,
7380     /*  INS_0xAE  */   Ins_UNKNOWN,
7381     /*  INS_0xAF  */   Ins_UNKNOWN,
7382
7383     /*  PushB[0]  */  Ins_PUSHB,
7384     /*  PushB[1]  */  Ins_PUSHB,
7385     /*  PushB[2]  */  Ins_PUSHB,
7386     /*  PushB[3]  */  Ins_PUSHB,
7387     /*  PushB[4]  */  Ins_PUSHB,
7388     /*  PushB[5]  */  Ins_PUSHB,
7389     /*  PushB[6]  */  Ins_PUSHB,
7390     /*  PushB[7]  */  Ins_PUSHB,
7391     /*  PushW[0]  */  Ins_PUSHW,
7392     /*  PushW[1]  */  Ins_PUSHW,
7393     /*  PushW[2]  */  Ins_PUSHW,
7394     /*  PushW[3]  */  Ins_PUSHW,
7395     /*  PushW[4]  */  Ins_PUSHW,
7396     /*  PushW[5]  */  Ins_PUSHW,
7397     /*  PushW[6]  */  Ins_PUSHW,
7398     /*  PushW[7]  */  Ins_PUSHW,
7399
7400     /*  MDRP[00]  */  Ins_MDRP,
7401     /*  MDRP[01]  */  Ins_MDRP,
7402     /*  MDRP[02]  */  Ins_MDRP,
7403     /*  MDRP[03]  */  Ins_MDRP,
7404     /*  MDRP[04]  */  Ins_MDRP,
7405     /*  MDRP[05]  */  Ins_MDRP,
7406     /*  MDRP[06]  */  Ins_MDRP,
7407     /*  MDRP[07]  */  Ins_MDRP,
7408     /*  MDRP[08]  */  Ins_MDRP,
7409     /*  MDRP[09]  */  Ins_MDRP,
7410     /*  MDRP[10]  */  Ins_MDRP,
7411     /*  MDRP[11]  */  Ins_MDRP,
7412     /*  MDRP[12]  */  Ins_MDRP,
7413     /*  MDRP[13]  */  Ins_MDRP,
7414     /*  MDRP[14]  */  Ins_MDRP,
7415     /*  MDRP[15]  */  Ins_MDRP,
7416
7417     /*  MDRP[16]  */  Ins_MDRP,
7418     /*  MDRP[17]  */  Ins_MDRP,
7419     /*  MDRP[18]  */  Ins_MDRP,
7420     /*  MDRP[19]  */  Ins_MDRP,
7421     /*  MDRP[20]  */  Ins_MDRP,
7422     /*  MDRP[21]  */  Ins_MDRP,
7423     /*  MDRP[22]  */  Ins_MDRP,
7424     /*  MDRP[23]  */  Ins_MDRP,
7425     /*  MDRP[24]  */  Ins_MDRP,
7426     /*  MDRP[25]  */  Ins_MDRP,
7427     /*  MDRP[26]  */  Ins_MDRP,
7428     /*  MDRP[27]  */  Ins_MDRP,
7429     /*  MDRP[28]  */  Ins_MDRP,
7430     /*  MDRP[29]  */  Ins_MDRP,
7431     /*  MDRP[30]  */  Ins_MDRP,
7432     /*  MDRP[31]  */  Ins_MDRP,
7433
7434     /*  MIRP[00]  */  Ins_MIRP,
7435     /*  MIRP[01]  */  Ins_MIRP,
7436     /*  MIRP[02]  */  Ins_MIRP,
7437     /*  MIRP[03]  */  Ins_MIRP,
7438     /*  MIRP[04]  */  Ins_MIRP,
7439     /*  MIRP[05]  */  Ins_MIRP,
7440     /*  MIRP[06]  */  Ins_MIRP,
7441     /*  MIRP[07]  */  Ins_MIRP,
7442     /*  MIRP[08]  */  Ins_MIRP,
7443     /*  MIRP[09]  */  Ins_MIRP,
7444     /*  MIRP[10]  */  Ins_MIRP,
7445     /*  MIRP[11]  */  Ins_MIRP,
7446     /*  MIRP[12]  */  Ins_MIRP,
7447     /*  MIRP[13]  */  Ins_MIRP,
7448     /*  MIRP[14]  */  Ins_MIRP,
7449     /*  MIRP[15]  */  Ins_MIRP,
7450
7451     /*  MIRP[16]  */  Ins_MIRP,
7452     /*  MIRP[17]  */  Ins_MIRP,
7453     /*  MIRP[18]  */  Ins_MIRP,
7454     /*  MIRP[19]  */  Ins_MIRP,
7455     /*  MIRP[20]  */  Ins_MIRP,
7456     /*  MIRP[21]  */  Ins_MIRP,
7457     /*  MIRP[22]  */  Ins_MIRP,
7458     /*  MIRP[23]  */  Ins_MIRP,
7459     /*  MIRP[24]  */  Ins_MIRP,
7460     /*  MIRP[25]  */  Ins_MIRP,
7461     /*  MIRP[26]  */  Ins_MIRP,
7462     /*  MIRP[27]  */  Ins_MIRP,
7463     /*  MIRP[28]  */  Ins_MIRP,
7464     /*  MIRP[29]  */  Ins_MIRP,
7465     /*  MIRP[30]  */  Ins_MIRP,
7466     /*  MIRP[31]  */  Ins_MIRP
7467   };
7468
7469
7470 #endif /* !TT_CONFIG_OPTION_INTERPRETER_SWITCH */
7471
7472
7473   /*************************************************************************/
7474   /*                                                                       */
7475   /* RUN                                                                   */
7476   /*                                                                       */
7477   /*  This function executes a run of opcodes.  It will exit in the        */
7478   /*  following cases:                                                     */
7479   /*                                                                       */
7480   /*  - Errors (in which case it returns FALSE).                           */
7481   /*                                                                       */
7482   /*  - Reaching the end of the main code range (returns TRUE).            */
7483   /*    Reaching the end of a code range within a function call is an      */
7484   /*    error.                                                             */
7485   /*                                                                       */
7486   /*  - After executing one single opcode, if the flag `Instruction_Trap'  */
7487   /*    is set to TRUE (returns TRUE).                                     */
7488   /*                                                                       */
7489   /*  On exit with TRUE, test IP < CodeSize to know whether it comes from  */
7490   /*  an instruction trap or a normal termination.                         */
7491   /*                                                                       */
7492   /*                                                                       */
7493   /*  Note: The documented DEBUG opcode pops a value from the stack.  This */
7494   /*        behaviour is unsupported; here a DEBUG opcode is always an     */
7495   /*        error.                                                         */
7496   /*                                                                       */
7497   /*                                                                       */
7498   /* THIS IS THE INTERPRETER'S MAIN LOOP.                                  */
7499   /*                                                                       */
7500   /*  Instructions appear in the specification's order.                    */
7501   /*                                                                       */
7502   /*************************************************************************/
7503
7504
7505   /* documentation is in ttinterp.h */
7506
7507   FT_EXPORT_DEF( FT_Error )
7508   TT_RunIns( TT_ExecContext  exc )
7509   {
7510     FT_Long  ins_counter = 0;  /* executed instructions counter */
7511
7512
7513 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
7514     cur = *exc;
7515 #endif
7516
7517     /* set CVT functions */
7518     CUR.tt_metrics.ratio = 0;
7519     if ( CUR.metrics.x_ppem != CUR.metrics.y_ppem )
7520     {
7521       /* non-square pixels, use the stretched routines */
7522       CUR.func_read_cvt  = Read_CVT_Stretched;
7523       CUR.func_write_cvt = Write_CVT_Stretched;
7524       CUR.func_move_cvt  = Move_CVT_Stretched;
7525     }
7526     else
7527     {
7528       /* square pixels, use normal routines */
7529       CUR.func_read_cvt  = Read_CVT;
7530       CUR.func_write_cvt = Write_CVT;
7531       CUR.func_move_cvt  = Move_CVT;
7532     }
7533
7534     COMPUTE_Funcs();
7535     COMPUTE_Round( (FT_Byte)exc->GS.round_state );
7536
7537     do
7538     {
7539       CUR.opcode = CUR.code[CUR.IP];
7540
7541       FT_TRACE7(( "  " ));
7542       FT_TRACE7(( opcode_name[CUR.opcode] ));
7543       FT_TRACE7(( "\n" ));
7544
7545       if ( ( CUR.length = opcode_length[CUR.opcode] ) < 0 )
7546       {
7547         if ( CUR.IP + 1 >= CUR.codeSize )
7548           goto LErrorCodeOverflow_;
7549
7550         CUR.length = 2 - CUR.length * CUR.code[CUR.IP + 1];
7551       }
7552
7553       if ( CUR.IP + CUR.length > CUR.codeSize )
7554         goto LErrorCodeOverflow_;
7555
7556       /* First, let's check for empty stack and overflow */
7557       CUR.args = CUR.top - ( Pop_Push_Count[CUR.opcode] >> 4 );
7558
7559       /* `args' is the top of the stack once arguments have been popped. */
7560       /* One can also interpret it as the index of the last argument.    */
7561       if ( CUR.args < 0 )
7562       {
7563         FT_UShort  i;
7564
7565
7566         if ( CUR.pedantic_hinting )
7567         {
7568           CUR.error = TT_Err_Too_Few_Arguments;
7569           goto LErrorLabel_;
7570         }
7571
7572         /* push zeroes onto the stack */
7573         for ( i = 0; i < Pop_Push_Count[CUR.opcode] >> 4; i++ )
7574           CUR.stack[i] = 0;
7575         CUR.args = 0;
7576       }
7577
7578       CUR.new_top = CUR.args + ( Pop_Push_Count[CUR.opcode] & 15 );
7579
7580       /* `new_top' is the new top of the stack, after the instruction's */
7581       /* execution.  `top' will be set to `new_top' after the `switch'  */
7582       /* statement.                                                     */
7583       if ( CUR.new_top > CUR.stackSize )
7584       {
7585         CUR.error = TT_Err_Stack_Overflow;
7586         goto LErrorLabel_;
7587       }
7588
7589       CUR.step_ins = TRUE;
7590       CUR.error    = TT_Err_Ok;
7591
7592 #ifdef TT_CONFIG_OPTION_INTERPRETER_SWITCH
7593
7594       {
7595         FT_Long*  args   = CUR.stack + CUR.args;
7596         FT_Byte   opcode = CUR.opcode;
7597
7598
7599 #undef  ARRAY_BOUND_ERROR
7600 #define ARRAY_BOUND_ERROR  goto Set_Invalid_Ref
7601
7602
7603         switch ( opcode )
7604         {
7605         case 0x00:  /* SVTCA y  */
7606         case 0x01:  /* SVTCA x  */
7607         case 0x02:  /* SPvTCA y */
7608         case 0x03:  /* SPvTCA x */
7609         case 0x04:  /* SFvTCA y */
7610         case 0x05:  /* SFvTCA x */
7611           {
7612             FT_Short  AA, BB;
7613
7614
7615             AA = (FT_Short)( ( opcode & 1 ) << 14 );
7616             BB = (FT_Short)( AA ^ 0x4000 );
7617
7618             if ( opcode < 4 )
7619             {
7620               CUR.GS.projVector.x = AA;
7621               CUR.GS.projVector.y = BB;
7622
7623               CUR.GS.dualVector.x = AA;
7624               CUR.GS.dualVector.y = BB;
7625             }
7626             else
7627             {
7628               GUESS_VECTOR( projVector );
7629             }
7630
7631             if ( ( opcode & 2 ) == 0 )
7632             {
7633               CUR.GS.freeVector.x = AA;
7634               CUR.GS.freeVector.y = BB;
7635             }
7636             else
7637             {
7638               GUESS_VECTOR( freeVector );
7639             }
7640
7641             COMPUTE_Funcs();
7642           }
7643           break;
7644
7645         case 0x06:  /* SPvTL // */
7646         case 0x07:  /* SPvTL +  */
7647           DO_SPVTL
7648           break;
7649
7650         case 0x08:  /* SFvTL // */
7651         case 0x09:  /* SFvTL +  */
7652           DO_SFVTL
7653           break;
7654
7655         case 0x0A:  /* SPvFS */
7656           DO_SPVFS
7657           break;
7658
7659         case 0x0B:  /* SFvFS */
7660           DO_SFVFS
7661           break;
7662
7663         case 0x0C:  /* GPV */
7664           DO_GPV
7665           break;
7666
7667         case 0x0D:  /* GFV */
7668           DO_GFV
7669           break;
7670
7671         case 0x0E:  /* SFvTPv */
7672           DO_SFVTPV
7673           break;
7674
7675         case 0x0F:  /* ISECT  */
7676           Ins_ISECT( EXEC_ARG_ args );
7677           break;
7678
7679         case 0x10:  /* SRP0 */
7680           DO_SRP0
7681           break;
7682
7683         case 0x11:  /* SRP1 */
7684           DO_SRP1
7685           break;
7686
7687         case 0x12:  /* SRP2 */
7688           DO_SRP2
7689           break;
7690
7691         case 0x13:  /* SZP0 */
7692           Ins_SZP0( EXEC_ARG_ args );
7693           break;
7694
7695         case 0x14:  /* SZP1 */
7696           Ins_SZP1( EXEC_ARG_ args );
7697           break;
7698
7699         case 0x15:  /* SZP2 */
7700           Ins_SZP2( EXEC_ARG_ args );
7701           break;
7702
7703         case 0x16:  /* SZPS */
7704           Ins_SZPS( EXEC_ARG_ args );
7705           break;
7706
7707         case 0x17:  /* SLOOP */
7708           DO_SLOOP
7709           break;
7710
7711         case 0x18:  /* RTG */
7712           DO_RTG
7713           break;
7714
7715         case 0x19:  /* RTHG */
7716           DO_RTHG
7717           break;
7718
7719         case 0x1A:  /* SMD */
7720           DO_SMD
7721           break;
7722
7723         case 0x1B:  /* ELSE */
7724           Ins_ELSE( EXEC_ARG_ args );
7725           break;
7726
7727         case 0x1C:  /* JMPR */
7728           DO_JMPR
7729           break;
7730
7731         case 0x1D:  /* SCVTCI */
7732           DO_SCVTCI
7733           break;
7734
7735         case 0x1E:  /* SSWCI */
7736           DO_SSWCI
7737           break;
7738
7739         case 0x1F:  /* SSW */
7740           DO_SSW
7741           break;
7742
7743         case 0x20:  /* DUP */
7744           DO_DUP
7745           break;
7746
7747         case 0x21:  /* POP */
7748           /* nothing :-) */
7749           break;
7750
7751         case 0x22:  /* CLEAR */
7752           DO_CLEAR
7753           break;
7754
7755         case 0x23:  /* SWAP */
7756           DO_SWAP
7757           break;
7758
7759         case 0x24:  /* DEPTH */
7760           DO_DEPTH
7761           break;
7762
7763         case 0x25:  /* CINDEX */
7764           DO_CINDEX
7765           break;
7766
7767         case 0x26:  /* MINDEX */
7768           Ins_MINDEX( EXEC_ARG_ args );
7769           break;
7770
7771         case 0x27:  /* ALIGNPTS */
7772           Ins_ALIGNPTS( EXEC_ARG_ args );
7773           break;
7774
7775         case 0x28:  /* ???? */
7776           Ins_UNKNOWN( EXEC_ARG_ args );
7777           break;
7778
7779         case 0x29:  /* UTP */
7780           Ins_UTP( EXEC_ARG_ args );
7781           break;
7782
7783         case 0x2A:  /* LOOPCALL */
7784           Ins_LOOPCALL( EXEC_ARG_ args );
7785           break;
7786
7787         case 0x2B:  /* CALL */
7788           Ins_CALL( EXEC_ARG_ args );
7789           break;
7790
7791         case 0x2C:  /* FDEF */
7792           Ins_FDEF( EXEC_ARG_ args );
7793           break;
7794
7795         case 0x2D:  /* ENDF */
7796           Ins_ENDF( EXEC_ARG_ args );
7797           break;
7798
7799         case 0x2E:  /* MDAP */
7800         case 0x2F:  /* MDAP */
7801           Ins_MDAP( EXEC_ARG_ args );
7802           break;
7803
7804
7805         case 0x30:  /* IUP */
7806         case 0x31:  /* IUP */
7807           Ins_IUP( EXEC_ARG_ args );
7808           break;
7809
7810         case 0x32:  /* SHP */
7811         case 0x33:  /* SHP */
7812           Ins_SHP( EXEC_ARG_ args );
7813           break;
7814
7815         case 0x34:  /* SHC */
7816         case 0x35:  /* SHC */
7817           Ins_SHC( EXEC_ARG_ args );
7818           break;
7819
7820         case 0x36:  /* SHZ */
7821         case 0x37:  /* SHZ */
7822           Ins_SHZ( EXEC_ARG_ args );
7823           break;
7824
7825         case 0x38:  /* SHPIX */
7826           Ins_SHPIX( EXEC_ARG_ args );
7827           break;
7828
7829         case 0x39:  /* IP    */
7830           Ins_IP( EXEC_ARG_ args );
7831           break;
7832
7833         case 0x3A:  /* MSIRP */
7834         case 0x3B:  /* MSIRP */
7835           Ins_MSIRP( EXEC_ARG_ args );
7836           break;
7837
7838         case 0x3C:  /* AlignRP */
7839           Ins_ALIGNRP( EXEC_ARG_ args );
7840           break;
7841
7842         case 0x3D:  /* RTDG */
7843           DO_RTDG
7844           break;
7845
7846         case 0x3E:  /* MIAP */
7847         case 0x3F:  /* MIAP */
7848           Ins_MIAP( EXEC_ARG_ args );
7849           break;
7850
7851         case 0x40:  /* NPUSHB */
7852           Ins_NPUSHB( EXEC_ARG_ args );
7853           break;
7854
7855         case 0x41:  /* NPUSHW */
7856           Ins_NPUSHW( EXEC_ARG_ args );
7857           break;
7858
7859         case 0x42:  /* WS */
7860           DO_WS
7861           break;
7862
7863       Set_Invalid_Ref:
7864             CUR.error = TT_Err_Invalid_Reference;
7865           break;
7866
7867         case 0x43:  /* RS */
7868           DO_RS
7869           break;
7870
7871         case 0x44:  /* WCVTP */
7872           DO_WCVTP
7873           break;
7874
7875         case 0x45:  /* RCVT */
7876           DO_RCVT
7877           break;
7878
7879         case 0x46:  /* GC */
7880         case 0x47:  /* GC */
7881           Ins_GC( EXEC_ARG_ args );
7882           break;
7883
7884         case 0x48:  /* SCFS */
7885           Ins_SCFS( EXEC_ARG_ args );
7886           break;
7887
7888         case 0x49:  /* MD */
7889         case 0x4A:  /* MD */
7890           Ins_MD( EXEC_ARG_ args );
7891           break;
7892
7893         case 0x4B:  /* MPPEM */
7894           DO_MPPEM
7895           break;
7896
7897         case 0x4C:  /* MPS */
7898           DO_MPS
7899           break;
7900
7901         case 0x4D:  /* FLIPON */
7902           DO_FLIPON
7903           break;
7904
7905         case 0x4E:  /* FLIPOFF */
7906           DO_FLIPOFF
7907           break;
7908
7909         case 0x4F:  /* DEBUG */
7910           DO_DEBUG
7911           break;
7912
7913         case 0x50:  /* LT */
7914           DO_LT
7915           break;
7916
7917         case 0x51:  /* LTEQ */
7918           DO_LTEQ
7919           break;
7920
7921         case 0x52:  /* GT */
7922           DO_GT
7923           break;
7924
7925         case 0x53:  /* GTEQ */
7926           DO_GTEQ
7927           break;
7928
7929         case 0x54:  /* EQ */
7930           DO_EQ
7931           break;
7932
7933         case 0x55:  /* NEQ */
7934           DO_NEQ
7935           break;
7936
7937         case 0x56:  /* ODD */
7938           DO_ODD
7939           break;
7940
7941         case 0x57:  /* EVEN */
7942           DO_EVEN
7943           break;
7944
7945         case 0x58:  /* IF */
7946           Ins_IF( EXEC_ARG_ args );
7947           break;
7948
7949         case 0x59:  /* EIF */
7950           /* do nothing */
7951           break;
7952
7953         case 0x5A:  /* AND */
7954           DO_AND
7955           break;
7956
7957         case 0x5B:  /* OR */
7958           DO_OR
7959           break;
7960
7961         case 0x5C:  /* NOT */
7962           DO_NOT
7963           break;
7964
7965         case 0x5D:  /* DELTAP1 */
7966           Ins_DELTAP( EXEC_ARG_ args );
7967           break;
7968
7969         case 0x5E:  /* SDB */
7970           DO_SDB
7971           break;
7972
7973         case 0x5F:  /* SDS */
7974           DO_SDS
7975           break;
7976
7977         case 0x60:  /* ADD */
7978           DO_ADD
7979           break;
7980
7981         case 0x61:  /* SUB */
7982           DO_SUB
7983           break;
7984
7985         case 0x62:  /* DIV */
7986           DO_DIV
7987           break;
7988
7989         case 0x63:  /* MUL */
7990           DO_MUL
7991           break;
7992
7993         case 0x64:  /* ABS */
7994           DO_ABS
7995           break;
7996
7997         case 0x65:  /* NEG */
7998           DO_NEG
7999           break;
8000
8001         case 0x66:  /* FLOOR */
8002           DO_FLOOR
8003           break;
8004
8005         case 0x67:  /* CEILING */
8006           DO_CEILING
8007           break;
8008
8009         case 0x68:  /* ROUND */
8010         case 0x69:  /* ROUND */
8011         case 0x6A:  /* ROUND */
8012         case 0x6B:  /* ROUND */
8013           DO_ROUND
8014           break;
8015
8016         case 0x6C:  /* NROUND */
8017         case 0x6D:  /* NROUND */
8018         case 0x6E:  /* NRRUND */
8019         case 0x6F:  /* NROUND */
8020           DO_NROUND
8021           break;
8022
8023         case 0x70:  /* WCVTF */
8024           DO_WCVTF
8025           break;
8026
8027         case 0x71:  /* DELTAP2 */
8028         case 0x72:  /* DELTAP3 */
8029           Ins_DELTAP( EXEC_ARG_ args );
8030           break;
8031
8032         case 0x73:  /* DELTAC0 */
8033         case 0x74:  /* DELTAC1 */
8034         case 0x75:  /* DELTAC2 */
8035           Ins_DELTAC( EXEC_ARG_ args );
8036           break;
8037
8038         case 0x76:  /* SROUND */
8039           DO_SROUND
8040           break;
8041
8042         case 0x77:  /* S45Round */
8043           DO_S45ROUND
8044           break;
8045
8046         case 0x78:  /* JROT */
8047           DO_JROT
8048           break;
8049
8050         case 0x79:  /* JROF */
8051           DO_JROF
8052           break;
8053
8054         case 0x7A:  /* ROFF */
8055           DO_ROFF
8056           break;
8057
8058         case 0x7B:  /* ???? */
8059           Ins_UNKNOWN( EXEC_ARG_ args );
8060           break;
8061
8062         case 0x7C:  /* RUTG */
8063           DO_RUTG
8064           break;
8065
8066         case 0x7D:  /* RDTG */
8067           DO_RDTG
8068           break;
8069
8070         case 0x7E:  /* SANGW */
8071         case 0x7F:  /* AA    */
8072           /* nothing - obsolete */
8073           break;
8074
8075         case 0x80:  /* FLIPPT */
8076           Ins_FLIPPT( EXEC_ARG_ args );
8077           break;
8078
8079         case 0x81:  /* FLIPRGON */
8080           Ins_FLIPRGON( EXEC_ARG_ args );
8081           break;
8082
8083         case 0x82:  /* FLIPRGOFF */
8084           Ins_FLIPRGOFF( EXEC_ARG_ args );
8085           break;
8086
8087         case 0x83:  /* UNKNOWN */
8088         case 0x84:  /* UNKNOWN */
8089           Ins_UNKNOWN( EXEC_ARG_ args );
8090           break;
8091
8092         case 0x85:  /* SCANCTRL */
8093           Ins_SCANCTRL( EXEC_ARG_ args );
8094           break;
8095
8096         case 0x86:  /* SDPVTL */
8097         case 0x87:  /* SDPVTL */
8098           Ins_SDPVTL( EXEC_ARG_ args );
8099           break;
8100
8101         case 0x88:  /* GETINFO */
8102           Ins_GETINFO( EXEC_ARG_ args );
8103           break;
8104
8105         case 0x89:  /* IDEF */
8106           Ins_IDEF( EXEC_ARG_ args );
8107           break;
8108
8109         case 0x8A:  /* ROLL */
8110           Ins_ROLL( EXEC_ARG_ args );
8111           break;
8112
8113         case 0x8B:  /* MAX */
8114           DO_MAX
8115           break;
8116
8117         case 0x8C:  /* MIN */
8118           DO_MIN
8119           break;
8120
8121         case 0x8D:  /* SCANTYPE */
8122           Ins_SCANTYPE( EXEC_ARG_ args );
8123           break;
8124
8125         case 0x8E:  /* INSTCTRL */
8126           Ins_INSTCTRL( EXEC_ARG_ args );
8127           break;
8128
8129         case 0x8F:
8130           Ins_UNKNOWN( EXEC_ARG_ args );
8131           break;
8132
8133         default:
8134           if ( opcode >= 0xE0 )
8135             Ins_MIRP( EXEC_ARG_ args );
8136           else if ( opcode >= 0xC0 )
8137             Ins_MDRP( EXEC_ARG_ args );
8138           else if ( opcode >= 0xB8 )
8139             Ins_PUSHW( EXEC_ARG_ args );
8140           else if ( opcode >= 0xB0 )
8141             Ins_PUSHB( EXEC_ARG_ args );
8142           else
8143             Ins_UNKNOWN( EXEC_ARG_ args );
8144         }
8145
8146       }
8147
8148 #else
8149
8150       Instruct_Dispatch[CUR.opcode]( EXEC_ARG_ &CUR.stack[CUR.args] );
8151
8152 #endif /* TT_CONFIG_OPTION_INTERPRETER_SWITCH */
8153
8154       if ( CUR.error != TT_Err_Ok )
8155       {
8156         switch ( CUR.error )
8157         {
8158         case TT_Err_Invalid_Opcode: /* looking for redefined instructions */
8159           {
8160             TT_DefRecord*  def   = CUR.IDefs;
8161             TT_DefRecord*  limit = def + CUR.numIDefs;
8162
8163
8164             for ( ; def < limit; def++ )
8165             {
8166               if ( def->active && CUR.opcode == (FT_Byte)def->opc )
8167               {
8168                 TT_CallRec*  callrec;
8169
8170
8171                 if ( CUR.callTop >= CUR.callSize )
8172                 {
8173                   CUR.error = TT_Err_Invalid_Reference;
8174                   goto LErrorLabel_;
8175                 }
8176
8177                 callrec = &CUR.callStack[CUR.callTop];
8178
8179                 callrec->Caller_Range = CUR.curRange;
8180                 callrec->Caller_IP    = CUR.IP + 1;
8181                 callrec->Cur_Count    = 1;
8182                 callrec->Cur_Restart  = def->start;
8183                 callrec->Cur_End      = def->end;
8184
8185                 if ( INS_Goto_CodeRange( def->range, def->start ) == FAILURE )
8186                   goto LErrorLabel_;
8187
8188                 goto LSuiteLabel_;
8189               }
8190             }
8191           }
8192
8193           CUR.error = TT_Err_Invalid_Opcode;
8194           goto LErrorLabel_;
8195
8196 #if 0
8197           break;   /* Unreachable code warning suppression.             */
8198                    /* Leave to remind in case a later change the editor */
8199                    /* to consider break;                                */
8200 #endif
8201
8202         default:
8203           goto LErrorLabel_;
8204
8205 #if 0
8206         break;
8207 #endif
8208         }
8209       }
8210
8211       CUR.top = CUR.new_top;
8212
8213       if ( CUR.step_ins )
8214         CUR.IP += CUR.length;
8215
8216       /* increment instruction counter and check if we didn't */
8217       /* run this program for too long (e.g. infinite loops). */
8218       if ( ++ins_counter > MAX_RUNNABLE_OPCODES )
8219         return TT_Err_Execution_Too_Long;
8220
8221     LSuiteLabel_:
8222       if ( CUR.IP >= CUR.codeSize )
8223       {
8224         if ( CUR.callTop > 0 )
8225         {
8226           CUR.error = TT_Err_Code_Overflow;
8227           goto LErrorLabel_;
8228         }
8229         else
8230           goto LNo_Error_;
8231       }
8232     } while ( !CUR.instruction_trap );
8233
8234   LNo_Error_:
8235
8236 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
8237     *exc = cur;
8238 #endif
8239
8240     return TT_Err_Ok;
8241
8242   LErrorCodeOverflow_:
8243     CUR.error = TT_Err_Code_Overflow;
8244
8245   LErrorLabel_:
8246
8247 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
8248     *exc = cur;
8249 #endif
8250
8251     /* If any errors have occurred, function tables may be broken. */
8252     /* Force a re-execution of `prep' and `fpgm' tables if no      */
8253     /* bytecode debugger is run.                                   */
8254     if ( CUR.error && !CUR.instruction_trap )
8255     {
8256       FT_TRACE1(( "  The interpreter returned error 0x%x\n", CUR.error ));
8257       exc->size->cvt_ready      = FALSE;
8258     }
8259
8260     return CUR.error;
8261   }
8262
8263
8264 #endif /* TT_USE_BYTECODE_INTERPRETER */
8265
8266
8267 /* END */