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