| blob | 13aa9a27c4c44e8c4934cc764235be04dd9f4fa0 |
1 /***************************************************************************/
2 /* */
3 /* ttinterp.c */
4 /* */
5 /* TrueType bytecode interpreter (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 /***************************************************************************/
19 #include <ft2build.h>
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_CALC_H
22 #include FT_TRIGONOMETRY_H
23 #include FT_SYSTEM_H
30 #ifdef TT_USE_BYTECODE_INTERPRETER
33 #define TT_MULFIX FT_MulFix
34 #define TT_MULDIV FT_MulDiv
35 #define TT_MULDIV_NO_ROUND FT_MulDiv_No_Round
38 /*************************************************************************/
39 /* */
40 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
41 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
42 /* messages during execution. */
43 /* */
44 #undef FT_COMPONENT
45 #define FT_COMPONENT trace_ttinterp
47 /*************************************************************************/
48 /* */
49 /* In order to detect infinite loops in the code, we set up a counter */
50 /* within the run loop. A single stroke of interpretation is now */
51 /* limited to a maximal number of opcodes defined below. */
52 /* */
53 #define MAX_RUNNABLE_OPCODES 1000000L
56 /*************************************************************************/
57 /* */
58 /* There are two kinds of implementations: */
59 /* */
60 /* a. static implementation */
61 /* */
62 /* The current execution context is a static variable, which fields */
63 /* are accessed directly by the interpreter during execution. The */
64 /* context is named `cur'. */
65 /* */
66 /* This version is non-reentrant, of course. */
67 /* */
68 /* b. indirect implementation */
69 /* */
70 /* The current execution context is passed to _each_ function as its */
71 /* first argument, and each field is thus accessed indirectly. */
72 /* */
73 /* This version is fully re-entrant. */
74 /* */
75 /* The idea is that an indirect implementation may be slower to execute */
76 /* on low-end processors that are used in some systems (like 386s or */
77 /* even 486s). */
78 /* */
79 /* As a consequence, the indirect implementation is now the default, as */
80 /* its performance costs can be considered negligible in our context. */
81 /* Note, however, that we kept the same source with macros because: */
82 /* */
83 /* - The code is kept very close in design to the Pascal code used for */
84 /* development. */
85 /* */
86 /* - It's much more readable that way! */
87 /* */
88 /* - It's still open to experimentation and tuning. */
89 /* */
90 /*************************************************************************/
97 /*************************************************************************/
98 /* */
99 /* This macro is used whenever `exec' is unused in a function, to avoid */
100 /* stupid warnings from pedantic compilers. */
101 /* */
102 #define FT_UNUSED_EXEC FT_UNUSED( exc )
106 #define CUR cur
108 #define FT_UNUSED_EXEC int __dummy = __dummy
110 static
113 /* apparently, we have a _lot_ of direct indexing when accessing */
114 /* the static `cur', which makes the code bigger (due to all the */
115 /* four bytes addresses). */
120 /*************************************************************************/
121 /* */
122 /* The instruction argument stack. */
123 /* */
127 /*************************************************************************/
128 /* */
129 /* This macro is used whenever `args' is unused in a function, to avoid */
130 /* stupid warnings from pedantic compilers. */
131 /* */
132 #define FT_UNUSED_ARG FT_UNUSED_EXEC; FT_UNUSED( args )
135 /*************************************************************************/
136 /* */
137 /* The following macros hide the use of EXEC_ARG and EXEC_ARG_ to */
138 /* increase readability of the code. */
139 /* */
140 /*************************************************************************/
143 #define SKIP_Code() \
144 SkipCode( EXEC_ARG )
146 #define GET_ShortIns() \
147 GetShortIns( EXEC_ARG )
149 #define NORMalize( x, y, v ) \
150 Normalize( EXEC_ARG_ x, y, v )
152 #define SET_SuperRound( scale, flags ) \
153 SetSuperRound( EXEC_ARG_ scale, flags )
155 #define ROUND_None( d, c ) \
156 Round_None( EXEC_ARG_ d, c )
158 #define INS_Goto_CodeRange( range, ip ) \
159 Ins_Goto_CodeRange( EXEC_ARG_ range, ip )
161 #define CUR_Func_move( z, p, d ) \
162 CUR.func_move( EXEC_ARG_ z, p, d )
164 #define CUR_Func_move_orig( z, p, d ) \
165 CUR.func_move_orig( EXEC_ARG_ z, p, d )
167 #define CUR_Func_round( d, c ) \
168 CUR.func_round( EXEC_ARG_ d, c )
170 #define CUR_Func_read_cvt( index ) \
171 CUR.func_read_cvt( EXEC_ARG_ index )
173 #define CUR_Func_write_cvt( index, val ) \
174 CUR.func_write_cvt( EXEC_ARG_ index, val )
176 #define CUR_Func_move_cvt( index, val ) \
177 CUR.func_move_cvt( EXEC_ARG_ index, val )
179 #define CURRENT_Ratio() \
180 Current_Ratio( EXEC_ARG )
182 #define CURRENT_Ppem() \
183 Current_Ppem( EXEC_ARG )
185 #define CUR_Ppem() \
186 Cur_PPEM( EXEC_ARG )
188 #define INS_SxVTL( a, b, c, d ) \
189 Ins_SxVTL( EXEC_ARG_ a, b, c, d )
191 #define COMPUTE_Funcs() \
192 Compute_Funcs( EXEC_ARG )
194 #define COMPUTE_Round( a ) \
195 Compute_Round( EXEC_ARG_ a )
197 #define COMPUTE_Point_Displacement( a, b, c, d ) \
198 Compute_Point_Displacement( EXEC_ARG_ a, b, c, d )
200 #define MOVE_Zp2_Point( a, b, c, t ) \
201 Move_Zp2_Point( EXEC_ARG_ a, b, c, t )
204 #define CUR_Func_project( v1, v2 ) \
205 CUR.func_project( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
207 #define CUR_Func_dualproj( v1, v2 ) \
208 CUR.func_dualproj( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
210 #define CUR_fast_project( v ) \
211 CUR.func_project( EXEC_ARG_ (v)->x, (v)->y )
213 #define CUR_fast_dualproj( v ) \
214 CUR.func_dualproj( EXEC_ARG_ (v)->x, (v)->y )
217 /*************************************************************************/
218 /* */
219 /* Instruction dispatch function, as used by the interpreter. */
220 /* */
224 /*************************************************************************/
225 /* */
226 /* A simple bounds-checking macro. */
227 /* */
228 #define BOUNDS( x, n ) ( (FT_UInt)(x) >= (FT_UInt)(n) )
230 #undef SUCCESS
231 #define SUCCESS 0
233 #undef FAILURE
234 #define FAILURE 1
236 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
237 #define GUESS_VECTOR( V ) \
238 if ( CUR.face->unpatented_hinting ) \
239 { \
240 CUR.GS.V.x = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0x4000 : 0 ); \
241 CUR.GS.V.y = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0 : 0x4000 ); \
242 }
243 #else
244 #define GUESS_VECTOR( V )
245 #endif
247 /*************************************************************************/
248 /* */
249 /* CODERANGE FUNCTIONS */
250 /* */
251 /*************************************************************************/
254 /*************************************************************************/
255 /* */
256 /* <Function> */
257 /* TT_Goto_CodeRange */
258 /* */
259 /* <Description> */
260 /* Switches to a new code range (updates the code related elements in */
261 /* `exec', and `IP'). */
262 /* */
263 /* <Input> */
264 /* range :: The new execution code range. */
265 /* */
266 /* IP :: The new IP in the new code range. */
267 /* */
268 /* <InOut> */
269 /* exec :: The target execution context. */
270 /* */
271 /* <Return> */
272 /* FreeType error code. 0 means success. */
273 /* */
276 FT_Int range,
277 FT_Long IP )
278 {
288 /* NOTE: Because the last instruction of a program may be a CALL */
289 /* which will return to the first byte *after* the code */
290 /* range, we test for IP <= Size instead of IP < Size. */
291 /* */
300 }
303 /*************************************************************************/
304 /* */
305 /* <Function> */
306 /* TT_Set_CodeRange */
307 /* */
308 /* <Description> */
309 /* Sets a code range. */
310 /* */
311 /* <Input> */
312 /* range :: The code range index. */
313 /* */
314 /* base :: The new code base. */
315 /* */
316 /* length :: The range size in bytes. */
317 /* */
318 /* <InOut> */
319 /* exec :: The target execution context. */
320 /* */
321 /* <Return> */
322 /* FreeType error code. 0 means success. */
323 /* */
326 FT_Int range,
328 FT_Long length )
329 {
336 }
339 /*************************************************************************/
340 /* */
341 /* <Function> */
342 /* TT_Clear_CodeRange */
343 /* */
344 /* <Description> */
345 /* Clears a code range. */
346 /* */
347 /* <Input> */
348 /* range :: The code range index. */
349 /* */
350 /* <InOut> */
351 /* exec :: The target execution context. */
352 /* */
353 /* <Return> */
354 /* FreeType error code. 0 means success. */
355 /* */
356 /* <Note> */
357 /* Does not set the Error variable. */
358 /* */
361 FT_Int range )
362 {
369 }
372 /*************************************************************************/
373 /* */
374 /* EXECUTION CONTEXT ROUTINES */
375 /* */
376 /*************************************************************************/
379 /*************************************************************************/
380 /* */
381 /* <Function> */
382 /* TT_Done_Context */
383 /* */
384 /* <Description> */
385 /* Destroys a given context. */
386 /* */
387 /* <Input> */
388 /* exec :: A handle to the target execution context. */
389 /* */
390 /* memory :: A handle to the parent memory object. */
391 /* */
392 /* <Return> */
393 /* FreeType error code. 0 means success. */
394 /* */
395 /* <Note> */
396 /* Only the glyph loader and debugger should call this function. */
397 /* */
400 {
404 /* points zone */
408 /* free stack */
412 /* free call stack */
417 /* free glyph code range */
427 }
430 /*************************************************************************/
431 /* */
432 /* <Function> */
433 /* Init_Context */
434 /* */
435 /* <Description> */
436 /* Initializes a context object. */
437 /* */
438 /* <Input> */
439 /* memory :: A handle to the parent memory object. */
440 /* */
441 /* <InOut> */
442 /* exec :: A handle to the target execution context. */
443 /* */
444 /* <Return> */
445 /* FreeType error code. 0 means success. */
446 /* */
447 static FT_Error
449 FT_Memory memory )
450 {
451 FT_Error error;
462 /* all values in the context are set to 0 already, but this is */
463 /* here as a remainder */
478 Fail_Memory:
484 }
487 /*************************************************************************/
488 /* */
489 /* <Function> */
490 /* Update_Max */
491 /* */
492 /* <Description> */
493 /* Checks the size of a buffer and reallocates it if necessary. */
494 /* */
495 /* <Input> */
496 /* memory :: A handle to the parent memory object. */
497 /* */
498 /* multiplier :: The size in bytes of each element in the buffer. */
499 /* */
500 /* new_max :: The new capacity (size) of the buffer. */
501 /* */
502 /* <InOut> */
503 /* size :: The address of the buffer's current size expressed */
504 /* in elements. */
505 /* */
506 /* buff :: The address of the buffer base pointer. */
507 /* */
508 /* <Return> */
509 /* FreeType error code. 0 means success. */
510 /* */
511 static FT_Error
514 FT_Long multiplier,
516 FT_ULong new_max )
517 {
518 FT_Error error;
523 {
527 }
530 }
533 /*************************************************************************/
534 /* */
535 /* <Function> */
536 /* TT_Load_Context */
537 /* */
538 /* <Description> */
539 /* Prepare an execution context for glyph hinting. */
540 /* */
541 /* <Input> */
542 /* face :: A handle to the source face object. */
543 /* */
544 /* size :: A handle to the source size object. */
545 /* */
546 /* <InOut> */
547 /* exec :: A handle to the target execution context. */
548 /* */
549 /* <Return> */
550 /* FreeType error code. 0 means success. */
551 /* */
552 /* <Note> */
553 /* Only the glyph loader and debugger should call this function. */
554 /* */
557 TT_Face face,
558 TT_Size size )
559 {
560 FT_Int i;
561 FT_ULong tmp;
563 FT_Error error;
571 {
587 /* set graphics state */
597 }
599 /* XXX: We reserve a little more elements on the stack to deal safely */
600 /* with broken fonts like arialbs, courbs, timesbs, etc. */
631 }
634 /*************************************************************************/
635 /* */
636 /* <Function> */
637 /* TT_Save_Context */
638 /* */
639 /* <Description> */
640 /* Saves the code ranges in a `size' object. */
641 /* */
642 /* <Input> */
643 /* exec :: A handle to the source execution context. */
644 /* */
645 /* <InOut> */
646 /* size :: A handle to the target size object. */
647 /* */
648 /* <Return> */
649 /* FreeType error code. 0 means success. */
650 /* */
651 /* <Note> */
652 /* Only the glyph loader and debugger should call this function. */
653 /* */
656 TT_Size size )
657 {
658 FT_Int i;
661 /* XXXX: Will probably disappear soon with all the code range */
662 /* management, which is now rather obsolete. */
663 /* */
674 }
677 /*************************************************************************/
678 /* */
679 /* <Function> */
680 /* TT_Run_Context */
681 /* */
682 /* <Description> */
683 /* Executes one or more instructions in the execution context. */
684 /* */
685 /* <Input> */
686 /* debug :: A Boolean flag. If set, the function sets some internal */
687 /* variables and returns immediately, otherwise TT_RunIns() */
688 /* is called. */
689 /* */
690 /* This is commented out currently. */
691 /* */
692 /* <Input> */
693 /* exec :: A handle to the target execution context. */
694 /* */
695 /* <Return> */
696 /* TrueType error code. 0 means success. */
697 /* */
698 /* <Note> */
699 /* Only the glyph loader and debugger should call this function. */
700 /* */
703 FT_Bool debug )
704 {
705 FT_Error error;
726 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
728 #endif
733 /* some glyphs leave something on the stack. so we clean it */
734 /* before a new execution. */
738 #if 1
742 #else
745 else
747 #endif
748 }
751 /* The default value for `scan_control' is documented as FALSE in the */
752 /* TrueType specification. This is confusing since it implies a */
753 /* Boolean value. However, this is not the case, thus both the */
754 /* default values of our `scan_type' and `scan_control' fields (which */
755 /* the documentation's `scan_control' variable is split into) are */
756 /* zero. */
759 {
765 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
766 TRUE,
767 #endif
772 };
775 /* documentation is in ttinterp.h */
779 {
780 TT_ExecContext exec;
781 FT_Memory memory;
788 {
789 FT_Error error;
792 /* allocate object */
796 /* initialize it; in case of error this deallocates `exec' too */
801 /* store it into the driver */
803 }
807 Fail:
809 }
812 /*************************************************************************/
813 /* */
814 /* Before an opcode is executed, the interpreter verifies that there are */
815 /* enough arguments on the stack, with the help of the `Pop_Push_Count' */
816 /* table. */
817 /* */
818 /* For each opcode, the first column gives the number of arguments that */
819 /* are popped from the stack; the second one gives the number of those */
820 /* that are pushed in result. */
821 /* */
822 /* Opcodes which have a varying number of parameters in the data stream */
823 /* (NPUSHB, NPUSHW) are handled specially; they have a negative value in */
824 /* the `opcode_length' table, and the value in `Pop_Push_Count' is set */
825 /* to zero. */
826 /* */
827 /*************************************************************************/
830 #undef PACK
831 #define PACK( x, y ) ( ( x << 4 ) | y )
834 static
836 {
837 /* opcodes are gathered in groups of 16 */
838 /* please keep the spaces as they are */
1111 };
1114 static
1116 {
1136 };
1138 #undef PACK
1140 #if 1
1142 static FT_Int32
1144 FT_Int b )
1145 {
1146 FT_Int32 sign;
1171 }
1173 #else
1175 /* compute (a*b)/2^14 with maximal accuracy and rounding */
1176 static FT_Int32
1178 FT_Int b )
1179 {
1184 /* compute ax*bx as 64-bit value */
1191 /* divide the result by 2^14 with rounding */
1201 }
1202 #endif
1205 /* compute (ax*bx+ay*by)/2^14 with maximal accuracy and rounding */
1206 static FT_Int32
1208 FT_Int32 ay,
1209 FT_Int bx,
1210 FT_Int by )
1211 {
1216 /* compute ax*bx as 64-bit value */
1223 /* compute ay*by as 64-bit value */
1230 /* add them */
1234 /* divide the result by 2^14 with rounding */
1244 }
1247 /* return length of given vector */
1249 #if 0
1251 static FT_Int32
1253 FT_Int32 y )
1254 {
1259 /* compute x*x as 64-bit value */
1270 /* compute y*y as 64-bit value */
1281 /* add them to get 'x*x+y*y' as 64-bit value */
1285 /* compute the square root of this value */
1286 {
1288 FT_Int count;
1293 {
1296 do
1297 {
1305 {
1308 }
1310 }
1313 }
1314 }
1316 #else
1318 /* this version uses FT_Vector_Length which computes the same value */
1319 /* much, much faster.. */
1320 /* */
1321 static FT_F26Dot6
1323 FT_F26Dot6 Y )
1324 {
1325 FT_Vector v;
1332 }
1334 #endif
1337 /*************************************************************************/
1338 /* */
1339 /* <Function> */
1340 /* Current_Ratio */
1341 /* */
1342 /* <Description> */
1343 /* Returns the current aspect ratio scaling factor depending on the */
1344 /* projection vector's state and device resolutions. */
1345 /* */
1346 /* <Return> */
1347 /* The aspect ratio in 16.16 format, always <= 1.0 . */
1348 /* */
1349 static FT_Long
1351 {
1353 {
1354 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
1356 {
1359 else
1361 }
1362 else
1363 #endif
1364 {
1371 else
1372 {
1381 }
1382 }
1383 }
1385 }
1388 static FT_Long
1390 {
1392 }
1395 /*************************************************************************/
1396 /* */
1397 /* Functions related to the control value table (CVT). */
1398 /* */
1399 /*************************************************************************/
1404 {
1406 }
1411 {
1413 }
1418 FT_F26Dot6 value )
1419 {
1421 }
1426 FT_F26Dot6 value )
1427 {
1429 }
1434 FT_F26Dot6 value )
1435 {
1437 }
1442 FT_F26Dot6 value )
1443 {
1445 }
1448 /*************************************************************************/
1449 /* */
1450 /* <Function> */
1451 /* GetShortIns */
1452 /* */
1453 /* <Description> */
1454 /* Returns a short integer taken from the instruction stream at */
1455 /* address IP. */
1456 /* */
1457 /* <Return> */
1458 /* Short read at code[IP]. */
1459 /* */
1460 /* <Note> */
1461 /* This one could become a macro. */
1462 /* */
1463 static FT_Short
1465 {
1466 /* Reading a byte stream so there is no endianess (DaveP) */
1470 }
1473 /*************************************************************************/
1474 /* */
1475 /* <Function> */
1476 /* Ins_Goto_CodeRange */
1477 /* */
1478 /* <Description> */
1479 /* Goes to a certain code range in the instruction stream. */
1480 /* */
1481 /* <Input> */
1482 /* aRange :: The index of the code range. */
1483 /* */
1484 /* aIP :: The new IP address in the code range. */
1485 /* */
1486 /* <Return> */
1487 /* SUCCESS or FAILURE. */
1488 /* */
1489 static FT_Bool
1491 FT_ULong aIP )
1492 {
1497 {
1500 }
1505 {
1508 }
1510 /* NOTE: Because the last instruction of a program may be a CALL */
1511 /* which will return to the first byte *after* the code */
1512 /* range, we test for AIP <= Size, instead of AIP < Size. */
1515 {
1518 }
1526 }
1529 /*************************************************************************/
1530 /* */
1531 /* <Function> */
1532 /* Direct_Move */
1533 /* */
1534 /* <Description> */
1535 /* Moves a point by a given distance along the freedom vector. The */
1536 /* point will be `touched'. */
1537 /* */
1538 /* <Input> */
1539 /* point :: The index of the point to move. */
1540 /* */
1541 /* distance :: The distance to apply. */
1542 /* */
1543 /* <InOut> */
1544 /* zone :: The affected glyph zone. */
1545 /* */
1546 static void
1548 FT_UShort point,
1549 FT_F26Dot6 distance )
1550 {
1551 FT_F26Dot6 v;
1554 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
1556 #endif
1561 {
1567 }
1572 {
1578 }
1579 }
1582 /*************************************************************************/
1583 /* */
1584 /* <Function> */
1585 /* Direct_Move_Orig */
1586 /* */
1587 /* <Description> */
1588 /* Moves the *original* position of a point by a given distance along */
1589 /* the freedom vector. Obviously, the point will not be `touched'. */
1590 /* */
1591 /* <Input> */
1592 /* point :: The index of the point to move. */
1593 /* */
1594 /* distance :: The distance to apply. */
1595 /* */
1596 /* <InOut> */
1597 /* zone :: The affected glyph zone. */
1598 /* */
1599 static void
1601 FT_UShort point,
1602 FT_F26Dot6 distance )
1603 {
1604 FT_F26Dot6 v;
1607 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
1609 #endif
1624 }
1627 /*************************************************************************/
1628 /* */
1629 /* Special versions of Direct_Move() */
1630 /* */
1631 /* The following versions are used whenever both vectors are both */
1632 /* along one of the coordinate unit vectors, i.e. in 90% of the cases. */
1633 /* */
1634 /*************************************************************************/
1637 static void
1639 FT_UShort point,
1640 FT_F26Dot6 distance )
1641 {
1642 FT_UNUSED_EXEC;
1646 }
1649 static void
1651 FT_UShort point,
1652 FT_F26Dot6 distance )
1653 {
1654 FT_UNUSED_EXEC;
1658 }
1661 /*************************************************************************/
1662 /* */
1663 /* Special versions of Direct_Move_Orig() */
1664 /* */
1665 /* The following versions are used whenever both vectors are both */
1666 /* along one of the coordinate unit vectors, i.e. in 90% of the cases. */
1667 /* */
1668 /*************************************************************************/
1671 static void
1673 FT_UShort point,
1674 FT_F26Dot6 distance )
1675 {
1676 FT_UNUSED_EXEC;
1679 }
1682 static void
1684 FT_UShort point,
1685 FT_F26Dot6 distance )
1686 {
1687 FT_UNUSED_EXEC;
1690 }
1693 /*************************************************************************/
1694 /* */
1695 /* <Function> */
1696 /* Round_None */
1697 /* */
1698 /* <Description> */
1699 /* Does not round, but adds engine compensation. */
1700 /* */
1701 /* <Input> */
1702 /* distance :: The distance (not) to round. */
1703 /* */
1704 /* compensation :: The engine compensation. */
1705 /* */
1706 /* <Return> */
1707 /* The compensated distance. */
1708 /* */
1709 /* <Note> */
1710 /* The TrueType specification says very few about the relationship */
1711 /* between rounding and engine compensation. However, it seems from */
1712 /* the description of super round that we should add the compensation */
1713 /* before rounding. */
1714 /* */
1715 static FT_F26Dot6
1717 FT_F26Dot6 compensation )
1718 {
1719 FT_F26Dot6 val;
1721 FT_UNUSED_EXEC;
1725 {
1729 }
1734 }
1736 }
1739 /*************************************************************************/
1740 /* */
1741 /* <Function> */
1742 /* Round_To_Grid */
1743 /* */
1744 /* <Description> */
1745 /* Rounds value to grid after adding engine compensation. */
1746 /* */
1747 /* <Input> */
1748 /* distance :: The distance to round. */
1749 /* */
1750 /* compensation :: The engine compensation. */
1751 /* */
1752 /* <Return> */
1753 /* Rounded distance. */
1754 /* */
1755 static FT_F26Dot6
1757 FT_F26Dot6 compensation )
1758 {
1759 FT_F26Dot6 val;
1761 FT_UNUSED_EXEC;
1765 {
1769 else
1771 }
1772 else
1773 {
1777 }
1780 }
1783 /*************************************************************************/
1784 /* */
1785 /* <Function> */
1786 /* Round_To_Half_Grid */
1787 /* */
1788 /* <Description> */
1789 /* Rounds value to half grid after adding engine compensation. */
1790 /* */
1791 /* <Input> */
1792 /* distance :: The distance to round. */
1793 /* */
1794 /* compensation :: The engine compensation. */
1795 /* */
1796 /* <Return> */
1797 /* Rounded distance. */
1798 /* */
1799 static FT_F26Dot6
1801 FT_F26Dot6 compensation )
1802 {
1803 FT_F26Dot6 val;
1805 FT_UNUSED_EXEC;
1809 {
1813 }
1814 else
1815 {
1819 }
1822 }
1825 /*************************************************************************/
1826 /* */
1827 /* <Function> */
1828 /* Round_Down_To_Grid */
1829 /* */
1830 /* <Description> */
1831 /* Rounds value down to grid after adding engine compensation. */
1832 /* */
1833 /* <Input> */
1834 /* distance :: The distance to round. */
1835 /* */
1836 /* compensation :: The engine compensation. */
1837 /* */
1838 /* <Return> */
1839 /* Rounded distance. */
1840 /* */
1841 static FT_F26Dot6
1843 FT_F26Dot6 compensation )
1844 {
1845 FT_F26Dot6 val;
1847 FT_UNUSED_EXEC;
1851 {
1855 else
1857 }
1858 else
1859 {
1863 }
1866 }
1869 /*************************************************************************/
1870 /* */
1871 /* <Function> */
1872 /* Round_Up_To_Grid */
1873 /* */
1874 /* <Description> */
1875 /* Rounds value up to grid after adding engine compensation. */
1876 /* */
1877 /* <Input> */
1878 /* distance :: The distance to round. */
1879 /* */
1880 /* compensation :: The engine compensation. */
1881 /* */
1882 /* <Return> */
1883 /* Rounded distance. */
1884 /* */
1885 static FT_F26Dot6
1887 FT_F26Dot6 compensation )
1888 {
1889 FT_F26Dot6 val;
1891 FT_UNUSED_EXEC;
1895 {
1899 else
1901 }
1902 else
1903 {
1907 }
1910 }
1913 /*************************************************************************/
1914 /* */
1915 /* <Function> */
1916 /* Round_To_Double_Grid */
1917 /* */
1918 /* <Description> */
1919 /* Rounds value to double grid after adding engine compensation. */
1920 /* */
1921 /* <Input> */
1922 /* distance :: The distance to round. */
1923 /* */
1924 /* compensation :: The engine compensation. */
1925 /* */
1926 /* <Return> */
1927 /* Rounded distance. */
1928 /* */
1929 static FT_F26Dot6
1931 FT_F26Dot6 compensation )
1932 {
1933 FT_F26Dot6 val;
1935 FT_UNUSED_EXEC;
1939 {
1943 else
1945 }
1946 else
1947 {
1951 }
1954 }
1957 /*************************************************************************/
1958 /* */
1959 /* <Function> */
1960 /* Round_Super */
1961 /* */
1962 /* <Description> */
1963 /* Super-rounds value to grid after adding engine compensation. */
1964 /* */
1965 /* <Input> */
1966 /* distance :: The distance to round. */
1967 /* */
1968 /* compensation :: The engine compensation. */
1969 /* */
1970 /* <Return> */
1971 /* Rounded distance. */
1972 /* */
1973 /* <Note> */
1974 /* The TrueType specification says very few about the relationship */
1975 /* between rounding and engine compensation. However, it seems from */
1976 /* the description of super round that we should add the compensation */
1977 /* before rounding. */
1978 /* */
1979 static FT_F26Dot6
1981 FT_F26Dot6 compensation )
1982 {
1983 FT_F26Dot6 val;
1987 {
1993 }
1994 else
1995 {
2001 }
2004 }
2007 /*************************************************************************/
2008 /* */
2009 /* <Function> */
2010 /* Round_Super_45 */
2011 /* */
2012 /* <Description> */
2013 /* Super-rounds value to grid after adding engine compensation. */
2014 /* */
2015 /* <Input> */
2016 /* distance :: The distance to round. */
2017 /* */
2018 /* compensation :: The engine compensation. */
2019 /* */
2020 /* <Return> */
2021 /* Rounded distance. */
2022 /* */
2023 /* <Note> */
2024 /* There is a separate function for Round_Super_45() as we may need */
2025 /* greater precision. */
2026 /* */
2027 static FT_F26Dot6
2029 FT_F26Dot6 compensation )
2030 {
2031 FT_F26Dot6 val;
2035 {
2041 }
2042 else
2043 {
2049 }
2052 }
2055 /*************************************************************************/
2056 /* */
2057 /* <Function> */
2058 /* Compute_Round */
2059 /* */
2060 /* <Description> */
2061 /* Sets the rounding mode. */
2062 /* */
2063 /* <Input> */
2064 /* round_mode :: The rounding mode to be used. */
2065 /* */
2066 static void
2068 {
2070 {
2102 }
2103 }
2106 /*************************************************************************/
2107 /* */
2108 /* <Function> */
2109 /* SetSuperRound */
2110 /* */
2111 /* <Description> */
2112 /* Sets Super Round parameters. */
2113 /* */
2114 /* <Input> */
2115 /* GridPeriod :: Grid period */
2116 /* selector :: SROUND opcode */
2117 /* */
2118 static void
2120 FT_Long selector )
2121 {
2123 {
2136 /* This opcode is reserved, but... */
2141 }
2144 {
2160 }
2164 else
2170 }
2173 /*************************************************************************/
2174 /* */
2175 /* <Function> */
2176 /* Project */
2177 /* */
2178 /* <Description> */
2179 /* Computes the projection of vector given by (v2-v1) along the */
2180 /* current projection vector. */
2181 /* */
2182 /* <Input> */
2183 /* v1 :: First input vector. */
2184 /* v2 :: Second input vector. */
2185 /* */
2186 /* <Return> */
2187 /* The distance in F26dot6 format. */
2188 /* */
2189 static FT_F26Dot6
2191 FT_Pos dy )
2192 {
2193 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
2195 #endif
2200 }
2203 /*************************************************************************/
2204 /* */
2205 /* <Function> */
2206 /* Dual_Project */
2207 /* */
2208 /* <Description> */
2209 /* Computes the projection of the vector given by (v2-v1) along the */
2210 /* current dual vector. */
2211 /* */
2212 /* <Input> */
2213 /* v1 :: First input vector. */
2214 /* v2 :: Second input vector. */
2215 /* */
2216 /* <Return> */
2217 /* The distance in F26dot6 format. */
2218 /* */
2219 static FT_F26Dot6
2221 FT_Pos dy )
2222 {
2226 }
2229 /*************************************************************************/
2230 /* */
2231 /* <Function> */
2232 /* Project_x */
2233 /* */
2234 /* <Description> */
2235 /* Computes the projection of the vector given by (v2-v1) along the */
2236 /* horizontal axis. */
2237 /* */
2238 /* <Input> */
2239 /* v1 :: First input vector. */
2240 /* v2 :: Second input vector. */
2241 /* */
2242 /* <Return> */
2243 /* The distance in F26dot6 format. */
2244 /* */
2245 static FT_F26Dot6
2247 FT_Pos dy )
2248 {
2249 FT_UNUSED_EXEC;
2253 }
2256 /*************************************************************************/
2257 /* */
2258 /* <Function> */
2259 /* Project_y */
2260 /* */
2261 /* <Description> */
2262 /* Computes the projection of the vector given by (v2-v1) along the */
2263 /* vertical axis. */
2264 /* */
2265 /* <Input> */
2266 /* v1 :: First input vector. */
2267 /* v2 :: Second input vector. */
2268 /* */
2269 /* <Return> */
2270 /* The distance in F26dot6 format. */
2271 /* */
2272 static FT_F26Dot6
2274 FT_Pos dy )
2275 {
2276 FT_UNUSED_EXEC;
2280 }
2283 /*************************************************************************/
2284 /* */
2285 /* <Function> */
2286 /* Compute_Funcs */
2287 /* */
2288 /* <Description> */
2289 /* Computes the projection and movement function pointers according */
2290 /* to the current graphics state. */
2291 /* */
2292 static void
2294 {
2295 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
2297 {
2298 /* If both vectors point rightwards along the x axis, set */
2299 /* `both-x-axis' true, otherwise set it false. The x values only */
2300 /* need be tested because the vector has been normalised to a unit */
2301 /* vector of length 0x4000 = unity. */
2305 /* Throw away projection and freedom vector information */
2306 /* because the patents don't allow them to be stored. */
2307 /* The relevant US Patents are 5155805 and 5325479. */
2314 {
2318 }
2319 else
2320 {
2324 }
2328 else
2329 {
2332 else
2334 }
2336 /* Force recalculation of cached aspect ratio */
2340 }
2345 else
2346 {
2349 else
2352 }
2356 else
2357 {
2360 else
2362 }
2366 else
2367 {
2370 else
2372 }
2378 {
2380 {
2383 }
2384 else
2385 {
2387 {
2390 }
2391 }
2392 }
2394 /* at small sizes, F_dot_P can become too small, resulting */
2395 /* in overflows and `spikes' in a number of glyphs like `w'. */
2400 /* Disable cached aspect ratio */
2402 }
2405 /*************************************************************************/
2406 /* */
2407 /* <Function> */
2408 /* Normalize */
2409 /* */
2410 /* <Description> */
2411 /* Norms a vector. */
2412 /* */
2413 /* <Input> */
2414 /* Vx :: The horizontal input vector coordinate. */
2415 /* Vy :: The vertical input vector coordinate. */
2416 /* */
2417 /* <Output> */
2418 /* R :: The normed unit vector. */
2419 /* */
2420 /* <Return> */
2421 /* Returns FAILURE if a vector parameter is zero. */
2422 /* */
2423 /* <Note> */
2424 /* In case Vx and Vy are both zero, Normalize() returns SUCCESS, and */
2425 /* R is undefined. */
2426 /* */
2429 static FT_Bool
2431 FT_F26Dot6 Vy,
2433 {
2434 FT_F26Dot6 W;
2437 FT_UNUSED_EXEC;
2441 {
2448 {
2449 /* XXX: UNDOCUMENTED! It seems that it is possible to try */
2450 /* to normalize the vector (0,0). Return immediately. */
2452 }
2458 }
2467 /* Now, we want that Sqrt( W ) = 0x4000 */
2468 /* Or 0x10000000 <= W < 0x10004000 */
2471 {
2474 }
2475 else
2479 {
2482 }
2483 else
2487 {
2488 /* We need to increase W by a minimal amount */
2490 Vx++;
2491 else
2492 Vy++;
2495 }
2498 {
2499 /* We need to decrease W by a minimal amount */
2501 Vx--;
2502 else
2503 Vy--;
2506 }
2508 /* Note that in various cases, we can only */
2509 /* compute a Sqrt(W) of 0x3FFF, eg. Vx = Vy */
2521 }
2524 /*************************************************************************/
2525 /* */
2526 /* Here we start with the implementation of the various opcodes. */
2527 /* */
2528 /*************************************************************************/
2531 static FT_Bool
2533 FT_UShort aIdx2,
2534 FT_Int aOpc,
2536 {
2544 {
2548 }
2557 {
2561 }
2566 }
2569 /* When not using the big switch statements, the interpreter uses a */
2570 /* call table defined later below in this source. Each opcode must */
2571 /* thus have a corresponding function, even trivial ones. */
2572 /* */
2573 /* They are all defined there. */
2575 #define DO_SVTCA \
2576 { \
2577 FT_Short A, B; \
2578 \
2579 \
2580 A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2581 B = A ^ (FT_Short)0x4000; \
2582 \
2583 CUR.GS.freeVector.x = A; \
2584 CUR.GS.projVector.x = A; \
2585 CUR.GS.dualVector.x = A; \
2586 \
2587 CUR.GS.freeVector.y = B; \
2588 CUR.GS.projVector.y = B; \
2589 CUR.GS.dualVector.y = B; \
2590 \
2591 COMPUTE_Funcs(); \
2592 }
2595 #define DO_SPVTCA \
2596 { \
2597 FT_Short A, B; \
2598 \
2599 \
2600 A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2601 B = A ^ (FT_Short)0x4000; \
2602 \
2603 CUR.GS.projVector.x = A; \
2604 CUR.GS.dualVector.x = A; \
2605 \
2606 CUR.GS.projVector.y = B; \
2607 CUR.GS.dualVector.y = B; \
2608 \
2609 GUESS_VECTOR( freeVector ); \
2610 \
2611 COMPUTE_Funcs(); \
2612 }
2615 #define DO_SFVTCA \
2616 { \
2617 FT_Short A, B; \
2618 \
2619 \
2620 A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2621 B = A ^ (FT_Short)0x4000; \
2622 \
2623 CUR.GS.freeVector.x = A; \
2624 CUR.GS.freeVector.y = B; \
2625 \
2626 GUESS_VECTOR( projVector ); \
2627 \
2628 COMPUTE_Funcs(); \
2629 }
2632 #define DO_SPVTL \
2633 if ( INS_SxVTL( (FT_UShort)args[1], \
2634 (FT_UShort)args[0], \
2635 CUR.opcode, \
2636 &CUR.GS.projVector ) == SUCCESS ) \
2637 { \
2638 CUR.GS.dualVector = CUR.GS.projVector; \
2639 GUESS_VECTOR( freeVector ); \
2640 COMPUTE_Funcs(); \
2641 }
2644 #define DO_SFVTL \
2645 if ( INS_SxVTL( (FT_UShort)args[1], \
2646 (FT_UShort)args[0], \
2647 CUR.opcode, \
2648 &CUR.GS.freeVector ) == SUCCESS ) \
2649 { \
2650 GUESS_VECTOR( projVector ); \
2651 COMPUTE_Funcs(); \
2652 }
2655 #define DO_SFVTPV \
2656 GUESS_VECTOR( projVector ); \
2657 CUR.GS.freeVector = CUR.GS.projVector; \
2658 COMPUTE_Funcs();
2661 #define DO_SPVFS \
2662 { \
2663 FT_Short S; \
2664 FT_Long X, Y; \
2665 \
2666 \
2668 S = (FT_Short)args[1]; \
2669 Y = (FT_Long)S; \
2670 S = (FT_Short)args[0]; \
2671 X = (FT_Long)S; \
2672 \
2673 NORMalize( X, Y, &CUR.GS.projVector ); \
2674 \
2675 CUR.GS.dualVector = CUR.GS.projVector; \
2676 GUESS_VECTOR( freeVector ); \
2677 COMPUTE_Funcs(); \
2678 }
2681 #define DO_SFVFS \
2682 { \
2683 FT_Short S; \
2684 FT_Long X, Y; \
2685 \
2686 \
2688 S = (FT_Short)args[1]; \
2689 Y = (FT_Long)S; \
2690 S = (FT_Short)args[0]; \
2691 X = S; \
2692 \
2693 NORMalize( X, Y, &CUR.GS.freeVector ); \
2694 GUESS_VECTOR( projVector ); \
2695 COMPUTE_Funcs(); \
2696 }
2699 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
2700 #define DO_GPV \
2701 if ( CUR.face->unpatented_hinting ) \
2702 { \
2703 args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
2704 args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
2705 } \
2706 else \
2707 { \
2708 args[0] = CUR.GS.projVector.x; \
2709 args[1] = CUR.GS.projVector.y; \
2710 }
2711 #else
2712 #define DO_GPV \
2713 args[0] = CUR.GS.projVector.x; \
2714 args[1] = CUR.GS.projVector.y;
2715 #endif
2718 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
2719 #define DO_GFV \
2720 if ( CUR.face->unpatented_hinting ) \
2721 { \
2722 args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
2723 args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
2724 } \
2725 else \
2726 { \
2727 args[0] = CUR.GS.freeVector.x; \
2728 args[1] = CUR.GS.freeVector.y; \
2729 }
2730 #else
2731 #define DO_GFV \
2732 args[0] = CUR.GS.freeVector.x; \
2733 args[1] = CUR.GS.freeVector.y;
2734 #endif
2737 #define DO_SRP0 \
2738 CUR.GS.rp0 = (FT_UShort)args[0];
2741 #define DO_SRP1 \
2742 CUR.GS.rp1 = (FT_UShort)args[0];
2745 #define DO_SRP2 \
2746 CUR.GS.rp2 = (FT_UShort)args[0];
2749 #define DO_RTHG \
2750 CUR.GS.round_state = TT_Round_To_Half_Grid; \
2751 CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
2754 #define DO_RTG \
2755 CUR.GS.round_state = TT_Round_To_Grid; \
2756 CUR.func_round = (TT_Round_Func)Round_To_Grid;
2759 #define DO_RTDG \
2760 CUR.GS.round_state = TT_Round_To_Double_Grid; \
2761 CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
2764 #define DO_RUTG \
2765 CUR.GS.round_state = TT_Round_Up_To_Grid; \
2766 CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
2769 #define DO_RDTG \
2770 CUR.GS.round_state = TT_Round_Down_To_Grid; \
2771 CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
2774 #define DO_ROFF \
2775 CUR.GS.round_state = TT_Round_Off; \
2776 CUR.func_round = (TT_Round_Func)Round_None;
2779 #define DO_SROUND \
2780 SET_SuperRound( 0x4000, args[0] ); \
2781 CUR.GS.round_state = TT_Round_Super; \
2782 CUR.func_round = (TT_Round_Func)Round_Super;
2785 #define DO_S45ROUND \
2786 SET_SuperRound( 0x2D41, args[0] ); \
2787 CUR.GS.round_state = TT_Round_Super_45; \
2788 CUR.func_round = (TT_Round_Func)Round_Super_45;
2791 #define DO_SLOOP \
2792 if ( args[0] < 0 ) \
2793 CUR.error = TT_Err_Bad_Argument; \
2794 else \
2795 CUR.GS.loop = args[0];
2798 #define DO_SMD \
2799 CUR.GS.minimum_distance = args[0];
2802 #define DO_SCVTCI \
2803 CUR.GS.control_value_cutin = (FT_F26Dot6)args[0];
2806 #define DO_SSWCI \
2807 CUR.GS.single_width_cutin = (FT_F26Dot6)args[0];
2810 /* XXX: UNDOCUMENTED! or bug in the Windows engine? */
2811 /* */
2812 /* It seems that the value that is read here is */
2813 /* expressed in 16.16 format rather than in font */
2814 /* units. */
2815 /* */
2816 #define DO_SSW \
2817 CUR.GS.single_width_value = (FT_F26Dot6)( args[0] >> 10 );
2820 #define DO_FLIPON \
2821 CUR.GS.auto_flip = TRUE;
2824 #define DO_FLIPOFF \
2825 CUR.GS.auto_flip = FALSE;
2828 #define DO_SDB \
2829 CUR.GS.delta_base = (FT_Short)args[0];
2832 #define DO_SDS \
2833 CUR.GS.delta_shift = (FT_Short)args[0];
2839 #define DO_MPPEM \
2840 args[0] = CURRENT_Ppem();
2843 /* Note: The pointSize should be irrelevant in a given font program; */
2844 /* we thus decide to return only the ppem. */
2845 #if 0
2847 #define DO_MPS \
2848 args[0] = CUR.metrics.pointSize;
2850 #else
2852 #define DO_MPS \
2853 args[0] = CURRENT_Ppem();
2858 #define DO_DUP \
2859 args[1] = args[0];
2862 #define DO_CLEAR \
2863 CUR.new_top = 0;
2866 #define DO_SWAP \
2867 { \
2868 FT_Long L; \
2869 \
2870 \
2871 L = args[0]; \
2872 args[0] = args[1]; \
2873 args[1] = L; \
2874 }
2877 #define DO_DEPTH \
2878 args[0] = CUR.top;
2881 #define DO_CINDEX \
2882 { \
2883 FT_Long L; \
2884 \
2885 \
2886 L = args[0]; \
2887 \
2888 if ( L <= 0 || L > CUR.args ) \
2889 CUR.error = TT_Err_Invalid_Reference; \
2890 else \
2891 args[0] = CUR.stack[CUR.args - L]; \
2892 }
2895 #define DO_JROT \
2896 if ( args[1] != 0 ) \
2897 { \
2898 CUR.IP += args[0]; \
2899 CUR.step_ins = FALSE; \
2900 }
2903 #define DO_JMPR \
2904 CUR.IP += args[0]; \
2905 CUR.step_ins = FALSE;
2908 #define DO_JROF \
2909 if ( args[1] == 0 ) \
2910 { \
2911 CUR.IP += args[0]; \
2912 CUR.step_ins = FALSE; \
2913 }
2916 #define DO_LT \
2917 args[0] = ( args[0] < args[1] );
2920 #define DO_LTEQ \
2921 args[0] = ( args[0] <= args[1] );
2924 #define DO_GT \
2925 args[0] = ( args[0] > args[1] );
2928 #define DO_GTEQ \
2929 args[0] = ( args[0] >= args[1] );
2932 #define DO_EQ \
2933 args[0] = ( args[0] == args[1] );
2936 #define DO_NEQ \
2937 args[0] = ( args[0] != args[1] );
2940 #define DO_ODD \
2941 args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 64 );
2944 #define DO_EVEN \
2945 args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 0 );
2948 #define DO_AND \
2949 args[0] = ( args[0] && args[1] );
2952 #define DO_OR \
2953 args[0] = ( args[0] || args[1] );
2956 #define DO_NOT \
2957 args[0] = !args[0];
2960 #define DO_ADD \
2961 args[0] += args[1];
2964 #define DO_SUB \
2965 args[0] -= args[1];
2968 #define DO_DIV \
2969 if ( args[1] == 0 ) \
2970 CUR.error = TT_Err_Divide_By_Zero; \
2971 else \
2972 args[0] = TT_MULDIV_NO_ROUND( args[0], 64L, args[1] );
2975 #define DO_MUL \
2976 args[0] = TT_MULDIV( args[0], args[1], 64L );
2979 #define DO_ABS \
2980 args[0] = FT_ABS( args[0] );
2983 #define DO_NEG \
2984 args[0] = -args[0];
2987 #define DO_FLOOR \
2988 args[0] = FT_PIX_FLOOR( args[0] );
2991 #define DO_CEILING \
2992 args[0] = FT_PIX_CEIL( args[0] );
2995 #define DO_RS \
2996 { \
2997 FT_ULong I = (FT_ULong)args[0]; \
2998 \
2999 \
3000 if ( BOUNDS( I, CUR.storeSize ) ) \
3001 { \
3002 if ( CUR.pedantic_hinting ) \
3003 { \
3004 ARRAY_BOUND_ERROR; \
3005 } \
3006 else \
3007 args[0] = 0; \
3008 } \
3009 else \
3010 args[0] = CUR.storage[I]; \
3011 }
3014 #define DO_WS \
3015 { \
3016 FT_ULong I = (FT_ULong)args[0]; \
3017 \
3018 \
3019 if ( BOUNDS( I, CUR.storeSize ) ) \
3020 { \
3021 if ( CUR.pedantic_hinting ) \
3022 { \
3023 ARRAY_BOUND_ERROR; \
3024 } \
3025 } \
3026 else \
3027 CUR.storage[I] = args[1]; \
3028 }
3031 #define DO_RCVT \
3032 { \
3033 FT_ULong I = (FT_ULong)args[0]; \
3034 \
3035 \
3036 if ( BOUNDS( I, CUR.cvtSize ) ) \
3037 { \
3038 if ( CUR.pedantic_hinting ) \
3039 { \
3040 ARRAY_BOUND_ERROR; \
3041 } \
3042 else \
3043 args[0] = 0; \
3044 } \
3045 else \
3046 args[0] = CUR_Func_read_cvt( I ); \
3047 }
3050 #define DO_WCVTP \
3051 { \
3052 FT_ULong I = (FT_ULong)args[0]; \
3053 \
3054 \
3055 if ( BOUNDS( I, CUR.cvtSize ) ) \
3056 { \
3057 if ( CUR.pedantic_hinting ) \
3058 { \
3059 ARRAY_BOUND_ERROR; \
3060 } \
3061 } \
3062 else \
3063 CUR_Func_write_cvt( I, args[1] ); \
3064 }
3067 #define DO_WCVTF \
3068 { \
3069 FT_ULong I = (FT_ULong)args[0]; \
3070 \
3071 \
3072 if ( BOUNDS( I, CUR.cvtSize ) ) \
3073 { \
3074 if ( CUR.pedantic_hinting ) \
3075 { \
3076 ARRAY_BOUND_ERROR; \
3077 } \
3078 } \
3079 else \
3080 CUR.cvt[I] = TT_MULFIX( args[1], CUR.tt_metrics.scale ); \
3081 }
3084 #define DO_DEBUG \
3085 CUR.error = TT_Err_Debug_OpCode;
3088 #define DO_ROUND \
3089 args[0] = CUR_Func_round( \
3090 args[0], \
3091 CUR.tt_metrics.compensations[CUR.opcode - 0x68] );
3094 #define DO_NROUND \
3095 args[0] = ROUND_None( args[0], \
3096 CUR.tt_metrics.compensations[CUR.opcode - 0x6C] );
3099 #define DO_MAX \
3100 if ( args[1] > args[0] ) \
3101 args[0] = args[1];
3104 #define DO_MIN \
3105 if ( args[1] < args[0] ) \
3106 args[0] = args[1];
3109 #ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
3112 #undef ARRAY_BOUND_ERROR
3113 #define ARRAY_BOUND_ERROR \
3114 { \
3115 CUR.error = TT_Err_Invalid_Reference; \
3116 return; \
3117 }
3120 /*************************************************************************/
3121 /* */
3122 /* SVTCA[a]: Set (F and P) Vectors to Coordinate Axis */
3123 /* Opcode range: 0x00-0x01 */
3124 /* Stack: --> */
3125 /* */
3126 static void
3128 {
3129 DO_SVTCA
3130 }
3133 /*************************************************************************/
3134 /* */
3135 /* SPVTCA[a]: Set PVector to Coordinate Axis */
3136 /* Opcode range: 0x02-0x03 */
3137 /* Stack: --> */
3138 /* */
3139 static void
3141 {
3142 DO_SPVTCA
3143 }
3146 /*************************************************************************/
3147 /* */
3148 /* SFVTCA[a]: Set FVector to Coordinate Axis */
3149 /* Opcode range: 0x04-0x05 */
3150 /* Stack: --> */
3151 /* */
3152 static void
3154 {
3155 DO_SFVTCA
3156 }
3159 /*************************************************************************/
3160 /* */
3161 /* SPVTL[a]: Set PVector To Line */
3162 /* Opcode range: 0x06-0x07 */
3163 /* Stack: uint32 uint32 --> */
3164 /* */
3165 static void
3167 {
3168 DO_SPVTL
3169 }
3172 /*************************************************************************/
3173 /* */
3174 /* SFVTL[a]: Set FVector To Line */
3175 /* Opcode range: 0x08-0x09 */
3176 /* Stack: uint32 uint32 --> */
3177 /* */
3178 static void
3180 {
3181 DO_SFVTL
3182 }
3185 /*************************************************************************/
3186 /* */
3187 /* SFVTPV[]: Set FVector To PVector */
3188 /* Opcode range: 0x0E */
3189 /* Stack: --> */
3190 /* */
3191 static void
3193 {
3194 DO_SFVTPV
3195 }
3198 /*************************************************************************/
3199 /* */
3200 /* SPVFS[]: Set PVector From Stack */
3201 /* Opcode range: 0x0A */
3202 /* Stack: f2.14 f2.14 --> */
3203 /* */
3204 static void
3206 {
3207 DO_SPVFS
3208 }
3211 /*************************************************************************/
3212 /* */
3213 /* SFVFS[]: Set FVector From Stack */
3214 /* Opcode range: 0x0B */
3215 /* Stack: f2.14 f2.14 --> */
3216 /* */
3217 static void
3219 {
3220 DO_SFVFS
3221 }
3224 /*************************************************************************/
3225 /* */
3226 /* GPV[]: Get Projection Vector */
3227 /* Opcode range: 0x0C */
3228 /* Stack: ef2.14 --> ef2.14 */
3229 /* */
3230 static void
3232 {
3233 DO_GPV
3234 }
3237 /*************************************************************************/
3238 /* GFV[]: Get Freedom Vector */
3239 /* Opcode range: 0x0D */
3240 /* Stack: ef2.14 --> ef2.14 */
3241 /* */
3242 static void
3244 {
3245 DO_GFV
3246 }
3249 /*************************************************************************/
3250 /* */
3251 /* SRP0[]: Set Reference Point 0 */
3252 /* Opcode range: 0x10 */
3253 /* Stack: uint32 --> */
3254 /* */
3255 static void
3257 {
3258 DO_SRP0
3259 }
3262 /*************************************************************************/
3263 /* */
3264 /* SRP1[]: Set Reference Point 1 */
3265 /* Opcode range: 0x11 */
3266 /* Stack: uint32 --> */
3267 /* */
3268 static void
3270 {
3271 DO_SRP1
3272 }
3275 /*************************************************************************/
3276 /* */
3277 /* SRP2[]: Set Reference Point 2 */
3278 /* Opcode range: 0x12 */
3279 /* Stack: uint32 --> */
3280 /* */
3281 static void
3283 {
3284 DO_SRP2
3285 }
3288 /*************************************************************************/
3289 /* */
3290 /* RTHG[]: Round To Half Grid */
3291 /* Opcode range: 0x19 */
3292 /* Stack: --> */
3293 /* */
3294 static void
3296 {
3297 DO_RTHG
3298 }
3301 /*************************************************************************/
3302 /* */
3303 /* RTG[]: Round To Grid */
3304 /* Opcode range: 0x18 */
3305 /* Stack: --> */
3306 /* */
3307 static void
3309 {
3310 DO_RTG
3311 }
3314 /*************************************************************************/
3315 /* RTDG[]: Round To Double Grid */
3316 /* Opcode range: 0x3D */
3317 /* Stack: --> */
3318 /* */
3319 static void
3321 {
3322 DO_RTDG
3323 }
3326 /*************************************************************************/
3327 /* RUTG[]: Round Up To Grid */
3328 /* Opcode range: 0x7C */
3329 /* Stack: --> */
3330 /* */
3331 static void
3333 {
3334 DO_RUTG
3335 }
3338 /*************************************************************************/
3339 /* */
3340 /* RDTG[]: Round Down To Grid */
3341 /* Opcode range: 0x7D */
3342 /* Stack: --> */
3343 /* */
3344 static void
3346 {
3347 DO_RDTG
3348 }
3351 /*************************************************************************/
3352 /* */
3353 /* ROFF[]: Round OFF */
3354 /* Opcode range: 0x7A */
3355 /* Stack: --> */
3356 /* */
3357 static void
3359 {
3360 DO_ROFF
3361 }
3364 /*************************************************************************/
3365 /* */
3366 /* SROUND[]: Super ROUND */
3367 /* Opcode range: 0x76 */
3368 /* Stack: Eint8 --> */
3369 /* */
3370 static void
3372 {
3373 DO_SROUND
3374 }
3377 /*************************************************************************/
3378 /* */
3379 /* S45ROUND[]: Super ROUND 45 degrees */
3380 /* Opcode range: 0x77 */
3381 /* Stack: uint32 --> */
3382 /* */
3383 static void
3385 {
3386 DO_S45ROUND
3387 }
3390 /*************************************************************************/
3391 /* */
3392 /* SLOOP[]: Set LOOP variable */
3393 /* Opcode range: 0x17 */
3394 /* Stack: int32? --> */
3395 /* */
3396 static void
3398 {
3399 DO_SLOOP
3400 }
3403 /*************************************************************************/
3404 /* */
3405 /* SMD[]: Set Minimum Distance */
3406 /* Opcode range: 0x1A */
3407 /* Stack: f26.6 --> */
3408 /* */
3409 static void
3411 {
3412 DO_SMD
3413 }
3416 /*************************************************************************/
3417 /* */
3418 /* SCVTCI[]: Set Control Value Table Cut In */
3419 /* Opcode range: 0x1D */
3420 /* Stack: f26.6 --> */
3421 /* */
3422 static void
3424 {
3425 DO_SCVTCI
3426 }
3429 /*************************************************************************/
3430 /* */
3431 /* SSWCI[]: Set Single Width Cut In */
3432 /* Opcode range: 0x1E */
3433 /* Stack: f26.6 --> */
3434 /* */
3435 static void
3437 {
3438 DO_SSWCI
3439 }
3442 /*************************************************************************/
3443 /* */
3444 /* SSW[]: Set Single Width */
3445 /* Opcode range: 0x1F */
3446 /* Stack: int32? --> */
3447 /* */
3448 static void
3450 {
3451 DO_SSW
3452 }
3455 /*************************************************************************/
3456 /* */
3457 /* FLIPON[]: Set auto-FLIP to ON */
3458 /* Opcode range: 0x4D */
3459 /* Stack: --> */
3460 /* */
3461 static void
3463 {
3464 DO_FLIPON
3465 }
3468 /*************************************************************************/
3469 /* */
3470 /* FLIPOFF[]: Set auto-FLIP to OFF */
3471 /* Opcode range: 0x4E */
3472 /* Stack: --> */
3473 /* */
3474 static void
3476 {
3477 DO_FLIPOFF
3478 }
3481 /*************************************************************************/
3482 /* */
3483 /* SANGW[]: Set ANGle Weight */
3484 /* Opcode range: 0x7E */
3485 /* Stack: uint32 --> */
3486 /* */
3487 static void
3489 {
3490 /* instruction not supported anymore */
3491 }
3494 /*************************************************************************/
3495 /* */
3496 /* SDB[]: Set Delta Base */
3497 /* Opcode range: 0x5E */
3498 /* Stack: uint32 --> */
3499 /* */
3500 static void
3502 {
3503 DO_SDB
3504 }
3507 /*************************************************************************/
3508 /* */
3509 /* SDS[]: Set Delta Shift */
3510 /* Opcode range: 0x5F */
3511 /* Stack: uint32 --> */
3512 /* */
3513 static void
3515 {
3516 DO_SDS
3517 }
3520 /*************************************************************************/
3521 /* */
3522 /* MPPEM[]: Measure Pixel Per EM */
3523 /* Opcode range: 0x4B */
3524 /* Stack: --> Euint16 */
3525 /* */
3526 static void
3528 {
3529 DO_MPPEM
3530 }
3533 /*************************************************************************/
3534 /* */
3535 /* MPS[]: Measure Point Size */
3536 /* Opcode range: 0x4C */
3537 /* Stack: --> Euint16 */
3538 /* */
3539 static void
3541 {
3542 DO_MPS
3543 }
3546 /*************************************************************************/
3547 /* */
3548 /* DUP[]: DUPlicate the top stack's element */
3549 /* Opcode range: 0x20 */
3550 /* Stack: StkElt --> StkElt StkElt */
3551 /* */
3552 static void
3554 {
3555 DO_DUP
3556 }
3559 /*************************************************************************/
3560 /* */
3561 /* POP[]: POP the stack's top element */
3562 /* Opcode range: 0x21 */
3563 /* Stack: StkElt --> */
3564 /* */
3565 static void
3567 {
3568 /* nothing to do */
3569 }
3572 /*************************************************************************/
3573 /* */
3574 /* CLEAR[]: CLEAR the entire stack */
3575 /* Opcode range: 0x22 */
3576 /* Stack: StkElt... --> */
3577 /* */
3578 static void
3580 {
3581 DO_CLEAR
3582 }
3585 /*************************************************************************/
3586 /* */
3587 /* SWAP[]: SWAP the stack's top two elements */
3588 /* Opcode range: 0x23 */
3589 /* Stack: 2 * StkElt --> 2 * StkElt */
3590 /* */
3591 static void
3593 {
3594 DO_SWAP
3595 }
3598 /*************************************************************************/
3599 /* */
3600 /* DEPTH[]: return the stack DEPTH */
3601 /* Opcode range: 0x24 */
3602 /* Stack: --> uint32 */
3603 /* */
3604 static void
3606 {
3607 DO_DEPTH
3608 }
3611 /*************************************************************************/
3612 /* */
3613 /* CINDEX[]: Copy INDEXed element */
3614 /* Opcode range: 0x25 */
3615 /* Stack: int32 --> StkElt */
3616 /* */
3617 static void
3619 {
3620 DO_CINDEX
3621 }
3624 /*************************************************************************/
3625 /* */
3626 /* EIF[]: End IF */
3627 /* Opcode range: 0x59 */
3628 /* Stack: --> */
3629 /* */
3630 static void
3632 {
3633 /* nothing to do */
3634 }
3637 /*************************************************************************/
3638 /* */
3639 /* JROT[]: Jump Relative On True */
3640 /* Opcode range: 0x78 */
3641 /* Stack: StkElt int32 --> */
3642 /* */
3643 static void
3645 {
3646 DO_JROT
3647 }
3650 /*************************************************************************/
3651 /* */
3652 /* JMPR[]: JuMP Relative */
3653 /* Opcode range: 0x1C */
3654 /* Stack: int32 --> */
3655 /* */
3656 static void
3658 {
3659 DO_JMPR
3660 }
3663 /*************************************************************************/
3664 /* */
3665 /* JROF[]: Jump Relative On False */
3666 /* Opcode range: 0x79 */
3667 /* Stack: StkElt int32 --> */
3668 /* */
3669 static void
3671 {
3672 DO_JROF
3673 }
3676 /*************************************************************************/
3677 /* */
3678 /* LT[]: Less Than */
3679 /* Opcode range: 0x50 */
3680 /* Stack: int32? int32? --> bool */
3681 /* */
3682 static void
3684 {
3685 DO_LT
3686 }
3689 /*************************************************************************/
3690 /* */
3691 /* LTEQ[]: Less Than or EQual */
3692 /* Opcode range: 0x51 */
3693 /* Stack: int32? int32? --> bool */
3694 /* */
3695 static void
3697 {
3698 DO_LTEQ
3699 }
3702 /*************************************************************************/
3703 /* */
3704 /* GT[]: Greater Than */
3705 /* Opcode range: 0x52 */
3706 /* Stack: int32? int32? --> bool */
3707 /* */
3708 static void
3710 {
3711 DO_GT
3712 }
3715 /*************************************************************************/
3716 /* */
3717 /* GTEQ[]: Greater Than or EQual */
3718 /* Opcode range: 0x53 */
3719 /* Stack: int32? int32? --> bool */
3720 /* */
3721 static void
3723 {
3724 DO_GTEQ
3725 }
3728 /*************************************************************************/
3729 /* */
3730 /* EQ[]: EQual */
3731 /* Opcode range: 0x54 */
3732 /* Stack: StkElt StkElt --> bool */
3733 /* */
3734 static void
3736 {
3737 DO_EQ
3738 }
3741 /*************************************************************************/
3742 /* */
3743 /* NEQ[]: Not EQual */
3744 /* Opcode range: 0x55 */
3745 /* Stack: StkElt StkElt --> bool */
3746 /* */
3747 static void
3749 {
3750 DO_NEQ
3751 }
3754 /*************************************************************************/
3755 /* */
3756 /* ODD[]: Is ODD */
3757 /* Opcode range: 0x56 */
3758 /* Stack: f26.6 --> bool */
3759 /* */
3760 static void
3762 {
3763 DO_ODD
3764 }
3767 /*************************************************************************/
3768 /* */
3769 /* EVEN[]: Is EVEN */
3770 /* Opcode range: 0x57 */
3771 /* Stack: f26.6 --> bool */
3772 /* */
3773 static void
3775 {
3776 DO_EVEN
3777 }
3780 /*************************************************************************/
3781 /* */
3782 /* AND[]: logical AND */
3783 /* Opcode range: 0x5A */
3784 /* Stack: uint32 uint32 --> uint32 */
3785 /* */
3786 static void
3788 {
3789 DO_AND
3790 }
3793 /*************************************************************************/
3794 /* */
3795 /* OR[]: logical OR */
3796 /* Opcode range: 0x5B */
3797 /* Stack: uint32 uint32 --> uint32 */
3798 /* */
3799 static void
3801 {
3802 DO_OR
3803 }
3806 /*************************************************************************/
3807 /* */
3808 /* NOT[]: logical NOT */
3809 /* Opcode range: 0x5C */
3810 /* Stack: StkElt --> uint32 */
3811 /* */
3812 static void
3814 {
3815 DO_NOT
3816 }
3819 /*************************************************************************/
3820 /* */
3821 /* ADD[]: ADD */
3822 /* Opcode range: 0x60 */
3823 /* Stack: f26.6 f26.6 --> f26.6 */
3824 /* */
3825 static void
3827 {
3828 DO_ADD
3829 }
3832 /*************************************************************************/
3833 /* */
3834 /* SUB[]: SUBtract */
3835 /* Opcode range: 0x61 */
3836 /* Stack: f26.6 f26.6 --> f26.6 */
3837 /* */
3838 static void
3840 {
3841 DO_SUB
3842 }
3845 /*************************************************************************/
3846 /* */
3847 /* DIV[]: DIVide */
3848 /* Opcode range: 0x62 */
3849 /* Stack: f26.6 f26.6 --> f26.6 */
3850 /* */
3851 static void
3853 {
3854 DO_DIV
3855 }
3858 /*************************************************************************/
3859 /* */
3860 /* MUL[]: MULtiply */
3861 /* Opcode range: 0x63 */
3862 /* Stack: f26.6 f26.6 --> f26.6 */
3863 /* */
3864 static void
3866 {
3867 DO_MUL
3868 }
3871 /*************************************************************************/
3872 /* */
3873 /* ABS[]: ABSolute value */
3874 /* Opcode range: 0x64 */
3875 /* Stack: f26.6 --> f26.6 */
3876 /* */
3877 static void
3879 {
3880 DO_ABS
3881 }
3884 /*************************************************************************/
3885 /* */
3886 /* NEG[]: NEGate */
3887 /* Opcode range: 0x65 */
3888 /* Stack: f26.6 --> f26.6 */
3889 /* */
3890 static void
3892 {
3893 DO_NEG
3894 }
3897 /*************************************************************************/
3898 /* */
3899 /* FLOOR[]: FLOOR */
3900 /* Opcode range: 0x66 */
3901 /* Stack: f26.6 --> f26.6 */
3902 /* */
3903 static void
3905 {
3906 DO_FLOOR
3907 }
3910 /*************************************************************************/
3911 /* */
3912 /* CEILING[]: CEILING */
3913 /* Opcode range: 0x67 */
3914 /* Stack: f26.6 --> f26.6 */
3915 /* */
3916 static void
3918 {
3919 DO_CEILING
3920 }
3923 /*************************************************************************/
3924 /* */
3925 /* RS[]: Read Store */
3926 /* Opcode range: 0x43 */
3927 /* Stack: uint32 --> uint32 */
3928 /* */
3929 static void
3931 {
3932 DO_RS
3933 }
3936 /*************************************************************************/
3937 /* */
3938 /* WS[]: Write Store */
3939 /* Opcode range: 0x42 */
3940 /* Stack: uint32 uint32 --> */
3941 /* */
3942 static void
3944 {
3945 DO_WS
3946 }
3949 /*************************************************************************/
3950 /* */
3951 /* WCVTP[]: Write CVT in Pixel units */
3952 /* Opcode range: 0x44 */
3953 /* Stack: f26.6 uint32 --> */
3954 /* */
3955 static void
3957 {
3958 DO_WCVTP
3959 }
3962 /*************************************************************************/
3963 /* */
3964 /* WCVTF[]: Write CVT in Funits */
3965 /* Opcode range: 0x70 */
3966 /* Stack: uint32 uint32 --> */
3967 /* */
3968 static void
3970 {
3971 DO_WCVTF
3972 }
3975 /*************************************************************************/
3976 /* */
3977 /* RCVT[]: Read CVT */
3978 /* Opcode range: 0x45 */
3979 /* Stack: uint32 --> f26.6 */
3980 /* */
3981 static void
3983 {
3984 DO_RCVT
3985 }
3988 /*************************************************************************/
3989 /* */
3990 /* AA[]: Adjust Angle */
3991 /* Opcode range: 0x7F */
3992 /* Stack: uint32 --> */
3993 /* */
3994 static void
3996 {
3997 /* intentionally no longer supported */
3998 }
4001 /*************************************************************************/
4002 /* */
4003 /* DEBUG[]: DEBUG. Unsupported. */
4004 /* Opcode range: 0x4F */
4005 /* Stack: uint32 --> */
4006 /* */
4007 /* Note: The original instruction pops a value from the stack. */
4008 /* */
4009 static void
4011 {
4012 DO_DEBUG
4013 }
4016 /*************************************************************************/
4017 /* */
4018 /* ROUND[ab]: ROUND value */
4019 /* Opcode range: 0x68-0x6B */
4020 /* Stack: f26.6 --> f26.6 */
4021 /* */
4022 static void
4024 {
4025 DO_ROUND
4026 }
4029 /*************************************************************************/
4030 /* */
4031 /* NROUND[ab]: No ROUNDing of value */
4032 /* Opcode range: 0x6C-0x6F */
4033 /* Stack: f26.6 --> f26.6 */
4034 /* */
4035 static void
4037 {
4038 DO_NROUND
4039 }
4042 /*************************************************************************/
4043 /* */
4044 /* MAX[]: MAXimum */
4045 /* Opcode range: 0x68 */
4046 /* Stack: int32? int32? --> int32 */
4047 /* */
4048 static void
4050 {
4051 DO_MAX
4052 }
4055 /*************************************************************************/
4056 /* */
4057 /* MIN[]: MINimum */
4058 /* Opcode range: 0x69 */
4059 /* Stack: int32? int32? --> int32 */
4060 /* */
4061 static void
4063 {
4064 DO_MIN
4065 }
4071 /*************************************************************************/
4072 /* */
4073 /* The following functions are called as is within the switch statement. */
4074 /* */
4075 /*************************************************************************/
4078 /*************************************************************************/
4079 /* */
4080 /* MINDEX[]: Move INDEXed element */
4081 /* Opcode range: 0x26 */
4082 /* Stack: int32? --> StkElt */
4083 /* */
4084 static void
4086 {
4093 {
4096 }
4105 }
4108 /*************************************************************************/
4109 /* */
4110 /* ROLL[]: ROLL top three elements */
4111 /* Opcode range: 0x8A */
4112 /* Stack: 3 * StkElt --> 3 * StkElt */
4113 /* */
4114 static void
4116 {
4119 FT_UNUSED_EXEC;
4129 }
4132 /*************************************************************************/
4133 /* */
4134 /* MANAGING THE FLOW OF CONTROL */
4135 /* */
4136 /* Instructions appear in the specification's order. */
4137 /* */
4138 /*************************************************************************/
4141 static FT_Bool
4143 {
4147 {
4152 {
4156 }
4160 }
4162 Fail_Overflow:
4165 }
4168 /*************************************************************************/
4169 /* */
4170 /* IF[]: IF test */
4171 /* Opcode range: 0x58 */
4172 /* Stack: StkElt --> */
4173 /* */
4174 static void
4176 {
4177 FT_Int nIfs;
4178 FT_Bool Out;
4187 do
4188 {
4193 {
4195 nIfs++;
4203 nIfs--;
4206 }
4208 }
4211 /*************************************************************************/
4212 /* */
4213 /* ELSE[]: ELSE */
4214 /* Opcode range: 0x1B */
4215 /* Stack: --> */
4216 /* */
4217 static void
4219 {
4220 FT_Int nIfs;
4222 FT_UNUSED_ARG;
4227 do
4228 {
4233 {
4235 nIfs++;
4239 nIfs--;
4241 }
4243 }
4246 /*************************************************************************/
4247 /* */
4248 /* DEFINING AND USING FUNCTIONS AND INSTRUCTIONS */
4249 /* */
4250 /* Instructions appear in the specification's order. */
4251 /* */
4252 /*************************************************************************/
4255 /*************************************************************************/
4256 /* */
4257 /* FDEF[]: Function DEFinition */
4258 /* Opcode range: 0x2C */
4259 /* Stack: uint32 --> */
4260 /* */
4261 static void
4263 {
4264 FT_ULong n;
4269 /* some font programs are broken enough to redefine functions! */
4270 /* We will then parse the current table. */
4277 {
4280 }
4283 {
4284 /* check that there is enough room for new functions */
4286 {
4289 }
4291 }
4293 /* Although FDEF takes unsigned 32-bit integer, */
4294 /* func # must be within unsigned 16-bit integer */
4296 {
4299 }
4309 /* Now skip the whole function definition. */
4310 /* We don't allow nested IDEFS & FDEFs. */
4313 {
4315 {
4323 }
4324 }
4325 }
4328 /*************************************************************************/
4329 /* */
4330 /* ENDF[]: END Function definition */
4331 /* Opcode range: 0x2D */
4332 /* Stack: --> */
4333 /* */
4334 static void
4336 {
4339 FT_UNUSED_ARG;
4343 {
4346 }
4357 {
4360 }
4361 else
4362 /* Loop through the current function */
4366 /* Exit the current call frame. */
4368 /* NOTE: If the last instruction of a program is a */
4369 /* CALL or LOOPCALL, the return address is */
4370 /* always out of the code range. This is a */
4371 /* valid address, and it is why we do not test */
4372 /* the result of Ins_Goto_CodeRange() here! */
4373 }
4376 /*************************************************************************/
4377 /* */
4378 /* CALL[]: CALL function */
4379 /* Opcode range: 0x2B */
4380 /* Stack: uint32? --> */
4381 /* */
4382 static void
4384 {
4385 FT_ULong F;
4390 /* first of all, check the index */
4396 /* Except for some old Apple fonts, all functions in a TrueType */
4397 /* font are defined in increasing order, starting from 0. This */
4398 /* means that we normally have */
4399 /* */
4400 /* CUR.maxFunc+1 == CUR.numFDefs */
4401 /* CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc */
4402 /* */
4403 /* If this isn't true, we need to look up the function table. */
4407 {
4408 /* look up the FDefs table */
4416 def++;
4420 }
4422 /* check that the function is active */
4426 /* check the call stack */
4428 {
4431 }
4448 Fail:
4450 }
4453 /*************************************************************************/
4454 /* */
4455 /* LOOPCALL[]: LOOP and CALL function */
4456 /* Opcode range: 0x2A */
4457 /* Stack: uint32? Eint16? --> */
4458 /* */
4459 static void
4461 {
4462 FT_ULong F;
4467 /* first of all, check the index */
4472 /* Except for some old Apple fonts, all functions in a TrueType */
4473 /* font are defined in increasing order, starting from 0. This */
4474 /* means that we normally have */
4475 /* */
4476 /* CUR.maxFunc+1 == CUR.numFDefs */
4477 /* CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc */
4478 /* */
4479 /* If this isn't true, we need to look up the function table. */
4483 {
4484 /* look up the FDefs table */
4492 def++;
4496 }
4498 /* check that the function is active */
4502 /* check stack */
4504 {
4507 }
4510 {
4523 }
4526 Fail:
4528 }
4531 /*************************************************************************/
4532 /* */
4533 /* IDEF[]: Instruction DEFinition */
4534 /* Opcode range: 0x89 */
4535 /* Stack: Eint8 --> */
4536 /* */
4537 static void
4539 {
4544 /* First of all, look for the same function in our table */
4554 {
4555 /* check that there is enough room for a new instruction */
4557 {
4560 }
4562 }
4564 /* opcode must be unsigned 8-bit integer */
4566 {
4569 }
4579 /* Now skip the whole function definition. */
4580 /* We don't allow nested IDEFs & FDEFs. */
4583 {
4585 {
4592 }
4593 }
4594 }
4597 /*************************************************************************/
4598 /* */
4599 /* PUSHING DATA ONTO THE INTERPRETER STACK */
4600 /* */
4601 /* Instructions appear in the specification's order. */
4602 /* */
4603 /*************************************************************************/
4606 /*************************************************************************/
4607 /* */
4608 /* NPUSHB[]: PUSH N Bytes */
4609 /* Opcode range: 0x40 */
4610 /* Stack: --> uint32... */
4611 /* */
4612 static void
4614 {
4621 {
4624 }
4630 }
4633 /*************************************************************************/
4634 /* */
4635 /* NPUSHW[]: PUSH N Words */
4636 /* Opcode range: 0x41 */
4637 /* Stack: --> int32... */
4638 /* */
4639 static void
4641 {
4648 {
4651 }
4660 }
4663 /*************************************************************************/
4664 /* */
4665 /* PUSHB[abc]: PUSH Bytes */
4666 /* Opcode range: 0xB0-0xB7 */
4667 /* Stack: --> uint32... */
4668 /* */
4669 static void
4671 {
4678 {
4681 }
4685 }
4688 /*************************************************************************/
4689 /* */
4690 /* PUSHW[abc]: PUSH Words */
4691 /* Opcode range: 0xB8-0xBF */
4692 /* Stack: --> int32... */
4693 /* */
4694 static void
4696 {
4703 {
4706 }
4714 }
4717 /*************************************************************************/
4718 /* */
4719 /* MANAGING THE GRAPHICS STATE */
4720 /* */
4721 /* Instructions appear in the specs' order. */
4722 /* */
4723 /*************************************************************************/
4726 /*************************************************************************/
4727 /* */
4728 /* GC[a]: Get Coordinate projected onto */
4729 /* Opcode range: 0x46-0x47 */
4730 /* Stack: uint32 --> f26.6 */
4731 /* */
4732 /* BULLSHIT: Measures from the original glyph must be taken along the */
4733 /* dual projection vector! */
4734 /* */
4735 static void
4737 {
4738 FT_ULong L;
4739 FT_F26Dot6 R;
4745 {
4747 {
4750 }
4751 else
4753 }
4754 else
4755 {
4758 else
4760 }
4763 }
4766 /*************************************************************************/
4767 /* */
4768 /* SCFS[]: Set Coordinate From Stack */
4769 /* Opcode range: 0x48 */
4770 /* Stack: f26.6 uint32 --> */
4771 /* */
4772 /* Formula: */
4773 /* */
4774 /* OA := OA + ( value - OA.p )/( f.p ) * f */
4775 /* */
4776 static void
4778 {
4779 FT_Long K;
4780 FT_UShort L;
4786 {
4790 }
4796 /* not part of the specs, but here for safety */
4800 }
4803 /*************************************************************************/
4804 /* */
4805 /* MD[a]: Measure Distance */
4806 /* Opcode range: 0x49-0x4A */
4807 /* Stack: uint32 uint32 --> f26.6 */
4808 /* */
4809 /* BULLSHIT: Measure taken in the original glyph must be along the dual */
4810 /* projection vector. */
4811 /* */
4812 /* Second BULLSHIT: Flag attributes are inverted! */
4813 /* 0 => measure distance in original outline */
4814 /* 1 => measure distance in grid-fitted outline */
4815 /* */
4816 /* Third one: `zp0 - zp1', and not `zp2 - zp1! */
4817 /* */
4818 static void
4820 {
4822 FT_F26Dot6 D;
4830 {
4832 {
4835 }
4837 }
4838 else
4839 {
4842 else
4843 {
4849 {
4850 /* this should be faster */
4853 }
4854 else
4855 {
4856 FT_Vector vec;
4863 }
4864 }
4865 }
4868 }
4871 /*************************************************************************/
4872 /* */
4873 /* SDPVTL[a]: Set Dual PVector to Line */
4874 /* Opcode range: 0x86-0x87 */
4875 /* Stack: uint32 uint32 --> */
4876 /* */
4877 static void
4879 {
4889 {
4893 }
4895 {
4902 }
4905 {
4909 }
4913 {
4920 }
4923 {
4927 }
4934 }
4937 /*************************************************************************/
4938 /* */
4939 /* SZP0[]: Set Zone Pointer 0 */
4940 /* Opcode range: 0x13 */
4941 /* Stack: uint32 --> */
4942 /* */
4943 static void
4945 {
4947 {
4960 }
4963 }
4966 /*************************************************************************/
4967 /* */
4968 /* SZP1[]: Set Zone Pointer 1 */
4969 /* Opcode range: 0x14 */
4970 /* Stack: uint32 --> */
4971 /* */
4972 static void
4974 {
4976 {
4989 }
4992 }
4995 /*************************************************************************/
4996 /* */
4997 /* SZP2[]: Set Zone Pointer 2 */
4998 /* Opcode range: 0x15 */
4999 /* Stack: uint32 --> */
5000 /* */
5001 static void
5003 {
5005 {
5018 }
5021 }
5024 /*************************************************************************/
5025 /* */
5026 /* SZPS[]: Set Zone PointerS */
5027 /* Opcode range: 0x16 */
5028 /* Stack: uint32 --> */
5029 /* */
5030 static void
5032 {
5034 {
5047 }
5055 }
5058 /*************************************************************************/
5059 /* */
5060 /* INSTCTRL[]: INSTruction ConTRoL */
5061 /* Opcode range: 0x8e */
5062 /* Stack: int32 int32 --> */
5063 /* */
5064 static void
5066 {
5074 {
5078 }
5085 }
5088 /*************************************************************************/
5089 /* */
5090 /* SCANCTRL[]: SCAN ConTRoL */
5091 /* Opcode range: 0x85 */
5092 /* Stack: uint32? --> */
5093 /* */
5094 static void
5096 {
5097 FT_Int A;
5100 /* Get Threshold */
5104 {
5107 }
5109 {
5112 }
5131 }
5134 /*************************************************************************/
5135 /* */
5136 /* SCANTYPE[]: SCAN TYPE */
5137 /* Opcode range: 0x8D */
5138 /* Stack: uint32? --> */
5139 /* */
5140 static void
5142 {
5145 }
5148 /*************************************************************************/
5149 /* */
5150 /* MANAGING OUTLINES */
5151 /* */
5152 /* Instructions appear in the specification's order. */
5153 /* */
5154 /*************************************************************************/
5157 /*************************************************************************/
5158 /* */
5159 /* FLIPPT[]: FLIP PoinT */
5160 /* Opcode range: 0x80 */
5161 /* Stack: uint32... --> */
5162 /* */
5163 static void
5165 {
5166 FT_UShort point;
5168 FT_UNUSED_ARG;
5172 {
5175 }
5178 {
5184 {
5186 {
5189 }
5190 }
5191 else
5195 }
5199 }
5202 /*************************************************************************/
5203 /* */
5204 /* FLIPRGON[]: FLIP RanGe ON */
5205 /* Opcode range: 0x81 */
5206 /* Stack: uint32 uint32 --> */
5207 /* */
5208 static void
5210 {
5219 {
5223 }
5227 }
5230 /*************************************************************************/
5231 /* */
5232 /* FLIPRGOFF: FLIP RanGe OFF */
5233 /* Opcode range: 0x82 */
5234 /* Stack: uint32 uint32 --> */
5235 /* */
5236 static void
5238 {
5247 {
5251 }
5255 }
5258 static FT_Bool
5261 TT_GlyphZone zone,
5263 {
5264 TT_GlyphZoneRec zp;
5265 FT_UShort p;
5266 FT_F26Dot6 d;
5270 {
5273 }
5274 else
5275 {
5278 }
5281 {
5286 }
5293 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
5295 {
5297 {
5300 }
5301 else
5302 {
5305 }
5306 }
5307 else
5308 #endif
5309 {
5316 }
5319 }
5322 static void
5324 FT_F26Dot6 dx,
5325 FT_F26Dot6 dy,
5326 FT_Bool touch )
5327 {
5328 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
5330 {
5332 {
5336 }
5337 else
5338 {
5342 }
5344 }
5345 #endif
5348 {
5352 }
5355 {
5359 }
5360 }
5363 /*************************************************************************/
5364 /* */
5365 /* SHP[a]: SHift Point by the last point */
5366 /* Opcode range: 0x32-0x33 */
5367 /* Stack: uint32... --> */
5368 /* */
5369 static void
5371 {
5372 TT_GlyphZoneRec zp;
5373 FT_UShort refp;
5375 FT_F26Dot6 dx,
5376 dy;
5377 FT_UShort point;
5379 FT_UNUSED_ARG;
5383 {
5386 }
5392 {
5397 {
5399 {
5402 }
5403 }
5404 else
5405 /* XXX: UNDOCUMENTED! SHP touches the points */
5409 }
5413 }
5416 /*************************************************************************/
5417 /* */
5418 /* SHC[a]: SHift Contour */
5419 /* Opcode range: 0x34-35 */
5420 /* Stack: uint32 --> */
5421 /* */
5422 static void
5424 {
5425 TT_GlyphZoneRec zp;
5426 FT_UShort refp;
5427 FT_F26Dot6 dx,
5428 dy;
5430 FT_Short contour;
5437 {
5441 }
5448 else
5455 /* XXX: this is probably wrong... at least it prevents memory */
5456 /* corruption when zp2 is the twilight zone */
5458 {
5461 else
5463 }
5465 /* XXX: UNDOCUMENTED! SHC touches the points */
5467 {
5470 }
5471 }
5474 /*************************************************************************/
5475 /* */
5476 /* SHZ[a]: SHift Zone */
5477 /* Opcode range: 0x36-37 */
5478 /* Stack: uint32 --> */
5479 /* */
5480 static void
5482 {
5483 TT_GlyphZoneRec zp;
5484 FT_UShort refp;
5485 FT_F26Dot6 dx,
5486 dy;
5492 {
5496 }
5501 /* XXX: UNDOCUMENTED! SHZ doesn't move the phantom points. */
5502 /* Twilight zone has no contours, so use `n_points'. */
5503 /* Normal zone's `n_points' includes phantoms, so must */
5504 /* use end of last contour. */
5509 else
5512 /* XXX: UNDOCUMENTED! SHZ doesn't touch the points */
5514 {
5517 }
5518 }
5521 /*************************************************************************/
5522 /* */
5523 /* SHPIX[]: SHift points by a PIXel amount */
5524 /* Opcode range: 0x38 */
5525 /* Stack: f26.6 uint32... --> */
5526 /* */
5527 static void
5529 {
5531 FT_UShort point;
5535 {
5538 }
5540 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
5542 {
5544 {
5547 }
5548 else
5549 {
5552 }
5553 }
5554 else
5555 #endif
5556 {
5559 }
5562 {
5568 {
5570 {
5573 }
5574 }
5575 else
5579 }
5583 }
5586 /*************************************************************************/
5587 /* */
5588 /* MSIRP[a]: Move Stack Indirect Relative Position */
5589 /* Opcode range: 0x3A-0x3B */
5590 /* Stack: f26.6 uint32 --> */
5591 /* */
5592 static void
5594 {
5595 FT_UShort point;
5596 FT_F26Dot6 distance;
5603 {
5607 }
5609 /* XXX: UNDOCUMENTED! behaviour */
5611 /* is in twilight zone */
5612 {
5616 }
5628 }
5631 /*************************************************************************/
5632 /* */
5633 /* MDAP[a]: Move Direct Absolute Point */
5634 /* Opcode range: 0x2E-0x2F */
5635 /* Stack: uint32 --> */
5636 /* */
5637 static void
5639 {
5640 FT_UShort point;
5641 FT_F26Dot6 cur_dist,
5642 distance;
5648 {
5652 }
5654 /* XXX: Is there some undocumented feature while in the */
5655 /* twilight zone? ? */
5657 {
5661 }
5662 else
5669 }
5672 /*************************************************************************/
5673 /* */
5674 /* MIAP[a]: Move Indirect Absolute Point */
5675 /* Opcode range: 0x3E-0x3F */
5676 /* Stack: uint32 uint32 --> */
5677 /* */
5678 static void
5680 {
5681 FT_ULong cvtEntry;
5682 FT_UShort point;
5683 FT_F26Dot6 distance,
5684 org_dist;
5692 {
5696 }
5698 /* XXX: UNDOCUMENTED! */
5699 /* */
5700 /* The behaviour of an MIAP instruction is quite */
5701 /* different when used in the twilight zone. */
5702 /* */
5703 /* First, no control value cut-in test is performed */
5704 /* as it would fail anyway. Second, the original */
5705 /* point, i.e. (org_x,org_y) of zp0.point, is set */
5706 /* to the absolute, unrounded distance found in */
5707 /* the CVT. */
5708 /* */
5709 /* This is used in the CVT programs of the Microsoft */
5710 /* fonts Arial, Times, etc., in order to re-adjust */
5711 /* some key font heights. It allows the use of the */
5712 /* IP instruction in the twilight zone, which */
5713 /* otherwise would be `illegal' according to the */
5714 /* specification. */
5715 /* */
5716 /* We implement it with a special sequence for the */
5717 /* twilight zone. This is a bad hack, but it seems */
5718 /* to work. */
5723 {
5727 }
5732 {
5737 }
5743 }
5746 /*************************************************************************/
5747 /* */
5748 /* MDRP[abcde]: Move Direct Relative Point */
5749 /* Opcode range: 0xC0-0xDF */
5750 /* Stack: uint32 --> */
5751 /* */
5752 static void
5754 {
5755 FT_UShort point;
5763 {
5767 }
5769 /* XXX: Is there some undocumented feature while in the */
5770 /* twilight zone? */
5772 /* XXX: UNDOCUMENTED: twilight zone special case */
5775 {
5781 }
5782 else
5783 {
5789 {
5790 /* this should be faster */
5793 }
5794 else
5795 {
5796 FT_Vector vec;
5803 }
5804 }
5806 /* single width cut-in test */
5810 {
5813 else
5815 }
5817 /* round flag */
5821 org_dist,
5823 else
5825 org_dist,
5828 /* minimum distance flag */
5831 {
5833 {
5836 }
5837 else
5838 {
5841 }
5842 }
5844 /* now move the point */
5856 }
5859 /*************************************************************************/
5860 /* */
5861 /* MIRP[abcde]: Move Indirect Relative Point */
5862 /* Opcode range: 0xE0-0xFF */
5863 /* Stack: int32? uint32 --> */
5864 /* */
5865 static void
5867 {
5868 FT_UShort point;
5869 FT_ULong cvtEntry;
5871 FT_F26Dot6 cvt_dist,
5872 distance,
5873 cur_dist,
5874 org_dist;
5880 /* XXX: UNDOCUMENTED! cvt[-1] = 0 always */
5885 {
5889 }
5893 else
5896 /* single width test */
5900 {
5903 else
5905 }
5907 /* XXX: UNDOCUMENTED! -- twilight zone */
5910 {
5920 }
5927 /* auto-flip test */
5930 {
5933 }
5935 /* control value cutin and round */
5938 {
5939 /* XXX: UNDOCUMENTED! Only perform cut-in test when both points */
5940 /* refer to the same zone. */
5947 cvt_dist,
5949 }
5950 else
5952 cvt_dist,
5955 /* minimum distance test */
5958 {
5960 {
5963 }
5964 else
5965 {
5968 }
5969 }
5978 /* XXX: UNDOCUMENTED! */
5980 }
5983 /*************************************************************************/
5984 /* */
5985 /* ALIGNRP[]: ALIGN Relative Point */
5986 /* Opcode range: 0x3C */
5987 /* Stack: uint32 uint32... --> */
5988 /* */
5989 static void
5991 {
5992 FT_UShort point;
5993 FT_F26Dot6 distance;
5995 FT_UNUSED_ARG;
6000 {
6004 }
6007 {
6013 {
6015 {
6018 }
6019 }
6020 else
6021 {
6026 }
6029 }
6033 }
6036 /*************************************************************************/
6037 /* */
6038 /* ISECT[]: moves point to InterSECTion */
6039 /* Opcode range: 0x0F */
6040 /* Stack: 5 * uint32 --> */
6041 /* */
6042 static void
6044 {
6045 FT_UShort point,
6049 FT_F26Dot6 discriminant;
6055 FT_F26Dot6 val;
6057 FT_Vector R;
6072 {
6076 }
6093 {
6101 }
6102 else
6103 {
6104 /* else, take the middle of the middles of A and B */
6114 }
6115 }
6118 /*************************************************************************/
6119 /* */
6120 /* ALIGNPTS[]: ALIGN PoinTS */
6121 /* Opcode range: 0x27 */
6122 /* Stack: uint32 uint32 --> */
6123 /* */
6124 static void
6126 {
6128 FT_F26Dot6 distance;
6136 {
6140 }
6147 }
6150 /*************************************************************************/
6151 /* */
6152 /* IP[]: Interpolate Point */
6153 /* Opcode range: 0x39 */
6154 /* Stack: uint32... --> */
6155 /* */
6157 /* SOMETIMES, DUMBER CODE IS BETTER CODE */
6159 static void
6161 {
6165 FT_Int twilight;
6167 FT_UNUSED_ARG;
6171 {
6174 }
6176 /*
6177 * We need to deal in a special way with the twilight zone.
6178 * Otherwise, by definition, the value of CUR.twilight.orus[n] is (0,0),
6179 * for every n.
6180 */
6184 {
6188 }
6192 else
6197 /* XXX: There are some glyphs in some braindead but popular */
6198 /* fonts out there (e.g. [aeu]grave in monotype.ttf) */
6199 /* calling IP[] with bad values of rp[12]. */
6200 /* Do something sane when this odd thing happens. */
6203 {
6206 }
6207 else
6208 {
6211 orus_base );
6212 else
6214 orus_base );
6217 }
6220 {
6225 /* check point bounds */
6227 {
6229 {
6232 }
6234 }
6238 else
6247 else
6251 }
6254 }
6257 /*************************************************************************/
6258 /* */
6259 /* UTP[a]: UnTouch Point */
6260 /* Opcode range: 0x29 */
6261 /* Stack: uint32 --> */
6262 /* */
6263 static void
6265 {
6266 FT_UShort point;
6267 FT_Byte mask;
6273 {
6277 }
6288 }
6291 /* Local variables for Ins_IUP: */
6293 {
6297 FT_UInt max_points;
6302 static void
6304 FT_UInt p1,
6305 FT_UInt p2,
6306 FT_UInt p )
6307 {
6308 FT_UInt i;
6309 FT_F26Dot6 dx;
6314 {
6320 }
6321 }
6324 static void
6326 FT_UInt p1,
6327 FT_UInt p2,
6328 FT_UInt ref1,
6329 FT_UInt ref2 )
6330 {
6331 FT_UInt i;
6346 {
6347 FT_F26Dot6 tmp_o;
6348 FT_UInt tmp_r;
6358 }
6366 {
6367 /* simple shift of untouched points */
6369 {
6375 else
6379 }
6380 }
6381 else
6382 {
6387 /* interpolation */
6389 {
6399 else
6400 {
6402 {
6406 }
6410 }
6412 }
6413 }
6414 }
6417 /*************************************************************************/
6418 /* */
6419 /* IUP[a]: Interpolate Untouched Points */
6420 /* Opcode range: 0x30-0x31 */
6421 /* Stack: --> */
6422 /* */
6423 static void
6425 {
6426 IUP_WorkerRec V;
6427 FT_Byte mask;
6438 FT_UNUSED_ARG;
6441 /* ignore empty outlines */
6446 {
6451 }
6452 else
6453 {
6458 }
6464 do
6465 {
6473 point++;
6476 {
6480 point++;
6483 {
6485 {
6490 cur_touched,
6491 point );
6493 }
6495 point++;
6496 }
6500 else
6501 {
6504 end_point,
6505 cur_touched,
6506 first_touched );
6510 first_point,
6512 cur_touched,
6513 first_touched );
6514 }
6515 }
6516 contour++;
6518 }
6521 /*************************************************************************/
6522 /* */
6523 /* DELTAPn[]: DELTA exceptions P1, P2, P3 */
6524 /* Opcode range: 0x5D,0x71,0x72 */
6525 /* Stack: uint32 (2 * uint32)... --> */
6526 /* */
6527 static void
6529 {
6531 FT_UShort A;
6532 FT_ULong C;
6533 FT_Long B;
6536 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
6537 /* Delta hinting is covered by US Patent 5159668. */
6539 {
6544 {
6547 }
6552 }
6553 #endif
6556 than once, thus UShort isn't enough */
6559 {
6561 {
6564 }
6571 /* XXX: Because some popular fonts contain some invalid DeltaP */
6572 /* instructions, we simply ignore them when the stacked */
6573 /* point reference is off limit, rather than returning an */
6574 /* error. As a delta instruction doesn't change a glyph */
6575 /* in great ways, this shouldn't be a problem. */
6578 {
6582 {
6593 }
6598 {
6601 B++;
6605 }
6606 }
6607 else
6610 }
6613 }
6616 /*************************************************************************/
6617 /* */
6618 /* DELTACn[]: DELTA exceptions C1, C2, C3 */
6619 /* Opcode range: 0x73,0x74,0x75 */
6620 /* Stack: uint32 (2 * uint32)... --> */
6621 /* */
6622 static void
6624 {
6627 FT_Long B;
6630 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
6631 /* Delta hinting is covered by US Patent 5159668. */
6633 {
6638 {
6641 }
6646 }
6647 #endif
6652 {
6654 {
6657 }
6665 {
6667 {
6670 }
6671 }
6672 else
6673 {
6677 {
6688 }
6693 {
6696 B++;
6700 }
6701 }
6702 }
6705 }
6708 /*************************************************************************/
6709 /* */
6710 /* MISC. INSTRUCTIONS */
6711 /* */
6712 /*************************************************************************/
6715 /*************************************************************************/
6716 /* */
6717 /* GETINFO[]: GET INFOrmation */
6718 /* Opcode range: 0x88 */
6719 /* Stack: uint32 --> uint32 */
6720 /* */
6721 static void
6723 {
6724 FT_Long K;
6729 /* We return MS rasterizer version 1.7 for the font scaler. */
6733 /* Has the glyph been rotated? */
6737 /* Has the glyph been stretched? */
6741 /* Are we hinting for grayscale? */
6746 }
6749 static void
6751 {
6755 FT_UNUSED_ARG;
6759 {
6761 {
6766 {
6769 }
6782 }
6783 }
6786 }
6789 #ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
6792 static
6794 {
6795 /* Opcodes are gathered in groups of 16. */
6796 /* Please keep the spaces as they are. */
7068 /* MIRP[31] */ Ins_MIRP
7069 };
7075 /*************************************************************************/
7076 /* */
7077 /* RUN */
7078 /* */
7079 /* This function executes a run of opcodes. It will exit in the */
7080 /* following cases: */
7081 /* */
7082 /* - Errors (in which case it returns FALSE). */
7083 /* */
7084 /* - Reaching the end of the main code range (returns TRUE). */
7085 /* Reaching the end of a code range within a function call is an */
7086 /* error. */
7087 /* */
7088 /* - After executing one single opcode, if the flag `Instruction_Trap' */
7089 /* is set to TRUE (returns TRUE). */
7090 /* */
7091 /* On exit with TRUE, test IP < CodeSize to know whether it comes from */
7092 /* an instruction trap or a normal termination. */
7093 /* */
7094 /* */
7095 /* Note: The documented DEBUG opcode pops a value from the stack. This */
7096 /* behaviour is unsupported; here a DEBUG opcode is always an */
7097 /* error. */
7098 /* */
7099 /* */
7100 /* THIS IS THE INTERPRETER'S MAIN LOOP. */
7101 /* */
7102 /* Instructions appear in the specification's order. */
7103 /* */
7104 /*************************************************************************/
7107 /* documentation is in ttinterp.h */
7111 {
7115 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
7117 #endif
7119 /* set CVT functions */
7122 {
7123 /* non-square pixels, use the stretched routines */
7127 }
7128 else
7129 {
7130 /* square pixels, use normal routines */
7134 }
7139 do
7140 {
7144 {
7149 }
7154 /* First, let's check for empty stack and overflow */
7157 /* `args' is the top of the stack once arguments have been popped. */
7158 /* One can also interpret it as the index of the last argument. */
7160 {
7163 }
7167 /* `new_top' is the new top of the stack, after the instruction's */
7168 /* execution. `top' will be set to `new_top' after the `switch' */
7169 /* statement. */
7171 {
7174 }
7179 #ifdef TT_CONFIG_OPTION_INTERPRETER_SWITCH
7181 {
7186 #undef ARRAY_BOUND_ERROR
7187 #define ARRAY_BOUND_ERROR goto Set_Invalid_Ref
7191 {
7198 {
7206 {
7212 }
7213 else
7214 {
7216 }
7219 {
7222 }
7223 else
7224 {
7226 }
7229 }
7234 DO_SPVTL
7239 DO_SFVTL
7243 DO_SPVFS
7247 DO_SFVFS
7251 DO_GPV
7255 DO_GFV
7259 DO_SFVTPV
7267 DO_SRP0
7271 DO_SRP1
7275 DO_SRP2
7295 DO_SLOOP
7299 DO_RTG
7303 DO_RTHG
7307 DO_SMD
7315 DO_JMPR
7319 DO_SCVTCI
7323 DO_SSWCI
7327 DO_SSW
7331 DO_DUP
7335 /* nothing :-) */
7339 DO_CLEAR
7343 DO_SWAP
7347 DO_DEPTH
7351 DO_CINDEX
7430 DO_RTDG
7447 DO_WS
7450 Set_Invalid_Ref:
7455 DO_RS
7459 DO_WCVTP
7463 DO_RCVT
7481 DO_MPPEM
7485 DO_MPS
7489 DO_FLIPON
7493 DO_FLIPOFF
7497 DO_DEBUG
7501 DO_LT
7505 DO_LTEQ
7509 DO_GT
7513 DO_GTEQ
7517 DO_EQ
7521 DO_NEQ
7525 DO_ODD
7529 DO_EVEN
7537 /* do nothing */
7541 DO_AND
7545 DO_OR
7549 DO_NOT
7557 DO_SDB
7561 DO_SDS
7565 DO_ADD
7569 DO_SUB
7573 DO_DIV
7577 DO_MUL
7581 DO_ABS
7585 DO_NEG
7589 DO_FLOOR
7593 DO_CEILING
7600 DO_ROUND
7607 DO_NROUND
7611 DO_WCVTF
7626 DO_SROUND
7630 DO_S45ROUND
7634 DO_JROT
7638 DO_JROF
7642 DO_ROFF
7650 DO_RUTG
7654 DO_RDTG
7659 /* nothing - obsolete */
7701 DO_MAX
7705 DO_MIN
7729 else
7731 }
7733 }
7735 #else
7742 {
7744 {
7746 {
7752 {
7754 {
7759 {
7762 }
7775 }
7776 }
7777 }
7782 #if 0
7784 /* Leave to remind in case a later change the editor */
7785 /* to consider break; */
7786 #endif
7791 #if 0
7793 #endif
7794 }
7795 }
7802 /* increment instruction counter and check if we didn't */
7803 /* run this program for too long (e.g. infinite loops). */
7807 LSuiteLabel_:
7809 {
7811 {
7814 }
7815 else
7817 }
7820 LNo_Error_:
7822 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
7824 #endif
7828 LErrorCodeOverflow_:
7831 LErrorLabel_:
7833 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
7835 #endif
7838 }
7844 /* END */