zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
ttinterp.c
Go to the documentation of this file.
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++;