| blob | 28587e6143e204268d3dfa62aadf5cb51010d8d1 |
1 /***************************************************************************/
2 /* */
3 /* ttinterp.c */
4 /* */
5 /* TrueType bytecode interpreter (body). */
6 /* */
7 /* Copyright 1996-2001, 2002 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_CONFIG_OPTION_BYTECODE_INTERPRETER
33 #define TT_MULFIX FT_MulFix
34 #define TT_MULDIV FT_MulDiv
35 #define TT_INT64 FT_Int64
37 /*************************************************************************/
38 /* */
39 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
40 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
41 /* messages during execution. */
42 /* */
43 #undef FT_COMPONENT
44 #define FT_COMPONENT trace_ttinterp
46 #undef NO_APPLE_PATENT
47 #define APPLE_THRESHOLD 0x4000000L
49 /*************************************************************************/
50 /* */
51 /* In order to detect infinite loops in the code, we set up a counter */
52 /* within the run loop. A single stroke of interpretation is now */
53 /* limitet to a maximal number of opcodes defined below. */
54 /* */
55 #define MAX_RUNNABLE_OPCODES 1000000L
58 /*************************************************************************/
59 /* */
60 /* There are two kinds of implementations: */
61 /* */
62 /* a. static implementation */
63 /* */
64 /* The current execution context is a static variable, which fields */
65 /* are accessed directly by the interpreter during execution. The */
66 /* context is named `cur'. */
67 /* */
68 /* This version is non-reentrant, of course. */
69 /* */
70 /* b. indirect implementation */
71 /* */
72 /* The current execution context is passed to _each_ function as its */
73 /* first argument, and each field is thus accessed indirectly. */
74 /* */
75 /* This version is fully re-entrant. */
76 /* */
77 /* The idea is that an indirect implementation may be slower to execute */
78 /* on low-end processors that are used in some systems (like 386s or */
79 /* even 486s). */
80 /* */
81 /* As a consequence, the indirect implementation is now the default, as */
82 /* its performance costs can be considered negligible in our context. */
83 /* Note, however, that we kept the same source with macros because: */
84 /* */
85 /* - The code is kept very close in design to the Pascal code used for */
86 /* development. */
87 /* */
88 /* - It's much more readable that way! */
89 /* */
90 /* - It's still open to experimentation and tuning. */
91 /* */
92 /*************************************************************************/
101 #define CUR cur
103 static
106 /* apparently, we have a _lot_ of direct indexing when accessing */
107 /* the static `cur', which makes the code bigger (due to all the */
108 /* four bytes addresses). */
113 /*************************************************************************/
114 /* */
115 /* The instruction argument stack. */
116 /* */
120 /*************************************************************************/
121 /* */
122 /* This macro is used whenever `exec' is unused in a function, to avoid */
123 /* stupid warnings from pedantic compilers. */
124 /* */
125 #define FT_UNUSED_EXEC FT_UNUSED( CUR )
128 /*************************************************************************/
129 /* */
130 /* This macro is used whenever `args' is unused in a function, to avoid */
131 /* stupid warnings from pedantic compilers. */
132 /* */
133 #define FT_UNUSED_ARG FT_UNUSED_EXEC; FT_UNUSED( args )
136 /*************************************************************************/
137 /* */
138 /* The following macros hide the use of EXEC_ARG and EXEC_ARG_ to */
139 /* increase readabilty of the code. */
140 /* */
141 /*************************************************************************/
144 #define SKIP_Code() \
145 SkipCode( EXEC_ARG )
147 #define GET_ShortIns() \
148 GetShortIns( EXEC_ARG )
150 #define NORMalize( x, y, v ) \
151 Normalize( EXEC_ARG_ x, y, v )
153 #define SET_SuperRound( scale, flags ) \
154 SetSuperRound( EXEC_ARG_ scale, flags )
156 #define ROUND_None( d, c ) \
157 Round_None( EXEC_ARG_ d, c )
159 #define INS_Goto_CodeRange( range, ip ) \
160 Ins_Goto_CodeRange( EXEC_ARG_ range, ip )
162 #define CUR_Func_project( x, y ) \
163 CUR.func_project( EXEC_ARG_ x, y )
165 #define CUR_Func_move( z, p, d ) \
166 CUR.func_move( EXEC_ARG_ z, p, d )
168 #define CUR_Func_dualproj( x, y ) \
169 CUR.func_dualproj( EXEC_ARG_ x, y )
171 #define CUR_Func_freeProj( x, y ) \
172 CUR.func_freeProj( EXEC_ARG_ x, y )
174 #define CUR_Func_round( d, c ) \
175 CUR.func_round( EXEC_ARG_ d, c )
177 #define CUR_Func_read_cvt( index ) \
178 CUR.func_read_cvt( EXEC_ARG_ index )
180 #define CUR_Func_write_cvt( index, val ) \
181 CUR.func_write_cvt( EXEC_ARG_ index, val )
183 #define CUR_Func_move_cvt( index, val ) \
184 CUR.func_move_cvt( EXEC_ARG_ index, val )
186 #define CURRENT_Ratio() \
187 Current_Ratio( EXEC_ARG )
189 #define CURRENT_Ppem() \
190 Current_Ppem( EXEC_ARG )
192 #define CUR_Ppem() \
193 Cur_PPEM( EXEC_ARG )
195 #define INS_SxVTL( a, b, c, d ) \
196 Ins_SxVTL( EXEC_ARG_ a, b, c, d )
198 #define COMPUTE_Funcs() \
199 Compute_Funcs( EXEC_ARG )
201 #define COMPUTE_Round( a ) \
202 Compute_Round( EXEC_ARG_ a )
204 #define COMPUTE_Point_Displacement( a, b, c, d ) \
205 Compute_Point_Displacement( EXEC_ARG_ a, b, c, d )
207 #define MOVE_Zp2_Point( a, b, c, t ) \
208 Move_Zp2_Point( EXEC_ARG_ a, b, c, t )
211 /*************************************************************************/
212 /* */
213 /* Instruction dispatch function, as used by the interpreter. */
214 /* */
218 /*************************************************************************/
219 /* */
220 /* A simple bounds-checking macro. */
221 /* */
222 #define BOUNDS( x, n ) ( (FT_UInt)(x) >= (FT_UInt)(n) )
225 #undef SUCCESS
226 #define SUCCESS 0
228 #undef FAILURE
229 #define FAILURE 1
232 /*************************************************************************/
233 /* */
234 /* CODERANGE FUNCTIONS */
235 /* */
236 /*************************************************************************/
239 /*************************************************************************/
240 /* */
241 /* <Function> */
242 /* TT_Goto_CodeRange */
243 /* */
244 /* <Description> */
245 /* Switches to a new code range (updates the code related elements in */
246 /* `exec', and `IP'). */
247 /* */
248 /* <Input> */
249 /* range :: The new execution code range. */
250 /* */
251 /* IP :: The new IP in the new code range. */
252 /* */
253 /* <InOut> */
254 /* exec :: The target execution context. */
255 /* */
256 /* <Return> */
257 /* FreeType error code. 0 means success. */
258 /* */
261 FT_Int range,
262 FT_Long IP )
263 {
273 /* NOTE: Because the last instruction of a program may be a CALL */
274 /* which will return to the first byte *after* the code */
275 /* range, we test for IP <= Size instead of IP < Size. */
276 /* */
285 }
288 /*************************************************************************/
289 /* */
290 /* <Function> */
291 /* TT_Set_CodeRange */
292 /* */
293 /* <Description> */
294 /* Sets a code range. */
295 /* */
296 /* <Input> */
297 /* range :: The code range index. */
298 /* */
299 /* base :: The new code base. */
300 /* */
301 /* length :: The range size in bytes. */
302 /* */
303 /* <InOut> */
304 /* exec :: The target execution context. */
305 /* */
306 /* <Return> */
307 /* FreeType error code. 0 means success. */
308 /* */
311 FT_Int range,
313 FT_Long length )
314 {
321 }
324 /*************************************************************************/
325 /* */
326 /* <Function> */
327 /* TT_Clear_CodeRange */
328 /* */
329 /* <Description> */
330 /* Clears a code range. */
331 /* */
332 /* <Input> */
333 /* range :: The code range index. */
334 /* */
335 /* <InOut> */
336 /* exec :: The target execution context. */
337 /* */
338 /* <Return> */
339 /* FreeType error code. 0 means success. */
340 /* */
341 /* <Note> */
342 /* Does not set the Error variable. */
343 /* */
346 FT_Int range )
347 {
354 }
357 /*************************************************************************/
358 /* */
359 /* EXECUTION CONTEXT ROUTINES */
360 /* */
361 /*************************************************************************/
364 /*************************************************************************/
365 /* */
366 /* <Function> */
367 /* TT_Destroy_Context */
368 /* */
369 /* <Description> */
370 /* Destroys a given context. */
371 /* */
372 /* <Input> */
373 /* exec :: A handle to the target execution context. */
374 /* */
375 /* memory :: A handle to the parent memory object. */
376 /* */
377 /* <Return> */
378 /* FreeType error code. 0 means success. */
379 /* */
380 /* <Note> */
381 /* Only the glyph loader and debugger should call this function. */
382 /* */
385 FT_Memory memory )
386 {
387 /* free composite load stack */
391 /* points zone */
395 /* free stack */
399 /* free call stack */
404 /* free glyph code range */
413 }
416 /*************************************************************************/
417 /* */
418 /* <Function> */
419 /* Init_Context */
420 /* */
421 /* <Description> */
422 /* Initializes a context object. */
423 /* */
424 /* <Input> */
425 /* memory :: A handle to the parent memory object. */
426 /* */
427 /* face :: A handle to the source TrueType face object. */
428 /* */
429 /* <InOut> */
430 /* exec :: A handle to the target execution context. */
431 /* */
432 /* <Return> */
433 /* FreeType error code. 0 means success. */
434 /* */
435 static FT_Error
437 TT_Face face,
438 FT_Memory memory )
439 {
440 FT_Error error;
452 /* all values in the context are set to 0 already, but this is */
453 /* here as a remainder */
470 Fail_Memory:
476 }
479 /*************************************************************************/
480 /* */
481 /* <Function> */
482 /* Update_Max */
483 /* */
484 /* <Description> */
485 /* Checks the size of a buffer and reallocates it if necessary. */
486 /* */
487 /* <Input> */
488 /* memory :: A handle to the parent memory object. */
489 /* */
490 /* multiplier :: The size in bytes of each element in the buffer. */
491 /* */
492 /* new_max :: The new capacity (size) of the buffer. */
493 /* */
494 /* <InOut> */
495 /* size :: The address of the buffer's current size expressed */
496 /* in elements. */
497 /* */
498 /* buff :: The address of the buffer base pointer. */
499 /* */
500 /* <Return> */
501 /* FreeType error code. 0 means success. */
502 /* */
503 static FT_Error
506 FT_Long multiplier,
508 FT_ULong new_max )
509 {
510 FT_Error error;
514 {
519 }
522 }
525 /*************************************************************************/
526 /* */
527 /* <Function> */
528 /* TT_Load_Context */
529 /* */
530 /* <Description> */
531 /* Prepare an execution context for glyph hinting. */
532 /* */
533 /* <Input> */
534 /* face :: A handle to the source face object. */
535 /* */
536 /* size :: A handle to the source size object. */
537 /* */
538 /* <InOut> */
539 /* exec :: A handle to the target execution context. */
540 /* */
541 /* <Return> */
542 /* FreeType error code. 0 means success. */
543 /* */
544 /* <Note> */
545 /* Only the glyph loader and debugger should call this function. */
546 /* */
549 TT_Face face,
550 TT_Size size )
551 {
552 FT_Int i;
553 FT_ULong tmp;
555 FT_Error error;
563 {
579 /* set graphics state */
589 }
599 /* XXX: We reserve a little more elements on the stack to deal safely */
600 /* with broken fonts like arialbs, courbs, timesbs, etc. */
627 }
630 /*************************************************************************/
631 /* */
632 /* <Function> */
633 /* TT_Save_Context */
634 /* */
635 /* <Description> */
636 /* Saves the code ranges in a `size' object. */
637 /* */
638 /* <Input> */
639 /* exec :: A handle to the source execution context. */
640 /* */
641 /* <InOut> */
642 /* size :: A handle to the target size object. */
643 /* */
644 /* <Return> */
645 /* FreeType error code. 0 means success. */
646 /* */
647 /* <Note> */
648 /* Only the glyph loader and debugger should call this function. */
649 /* */
652 TT_Size size )
653 {
654 FT_Int i;
657 /* XXXX: Will probably disappear soon with all the code range */
658 /* management, which is now rather obsolete. */
659 /* */
670 }
673 /*************************************************************************/
674 /* */
675 /* <Function> */
676 /* TT_Run_Context */
677 /* */
678 /* <Description> */
679 /* Executes one or more instructions in the execution context. */
680 /* */
681 /* <Input> */
682 /* debug :: A Boolean flag. If set, the function sets some internal */
683 /* variables and returns immediately, otherwise TT_RunIns() */
684 /* is called. */
685 /* */
686 /* This is commented out currently. */
687 /* */
688 /* <Input> */
689 /* exec :: A handle to the target execution context. */
690 /* */
691 /* <Return> */
692 /* TrueTyoe error code. 0 means success. */
693 /* */
694 /* <Note> */
695 /* Only the glyph loader and debugger should call this function. */
696 /* */
699 FT_Bool debug )
700 {
701 FT_Error error;
725 /* some glyphs leave something on the stack. so we clean it */
726 /* before a new execution. */
730 #if 1
734 #else
737 else
739 #endif
740 }
744 {
752 };
755 /* documentation is in ttinterp.h */
759 {
760 TT_Driver driver;
761 TT_ExecContext exec;
762 FT_Memory memory;
774 {
775 FT_Error error;
778 /* allocate object */
782 /* initialize it */
787 /* store it into the driver */
789 }
791 Exit:
794 Fail:
798 }
801 /*************************************************************************/
802 /* */
803 /* <Function> */
804 /* TT_Done_Context */
805 /* */
806 /* <Description> */
807 /* Discards an execution context. */
808 /* */
809 /* <Input> */
810 /* exec :: A handle to the target execution context. */
811 /* */
812 /* <Return> */
813 /* FreeType error code. 0 means success. */
814 /* */
815 /* <Note> */
816 /* Only the glyph loader and debugger should call this function. */
817 /* */
820 {
821 /* Nothing at all for now */
825 }
829 /*************************************************************************/
830 /* */
831 /* Before an opcode is executed, the interpreter verifies that there are */
832 /* enough arguments on the stack, with the help of the Pop_Push_Count */
833 /* table. */
834 /* */
835 /* For each opcode, the first column gives the number of arguments that */
836 /* are popped from the stack; the second one gives the number of those */
837 /* that are pushed in result. */
838 /* */
839 /* Note that for opcodes with a varying number of parameters, either 0 */
840 /* or 1 arg is verified before execution, depending on the nature of the */
841 /* instruction: */
842 /* */
843 /* - if the number of arguments is given by the bytecode stream or the */
844 /* loop variable, 0 is chosen. */
845 /* */
846 /* - if the first argument is a count n that is followed by arguments */
847 /* a1 .. an, then 1 is chosen. */
848 /* */
849 /*************************************************************************/
852 #undef PACK
853 #define PACK( x, y ) ( ( x << 4 ) | y )
856 static
858 {
859 /* opcodes are gathered in groups of 16 */
860 /* please keep the spaces as they are */
1133 };
1136 static
1138 {
1158 };
1160 static
1164 #undef PACK
1167 #undef NULL_Vector
1168 #define NULL_Vector (FT_Vector*)&Null_Vector
1171 /* compute (a*b)/2^14 with maximal accuracy and rounding */
1172 static FT_Int32
1174 FT_Int b )
1175 {
1180 /* compute ax*bx as 64-bit value */
1187 /* divide the result by 2^14 with rounding */
1197 }
1200 /* compute (ax*bx+ay*by)/2^14 with maximal accuracy and rounding */
1201 static FT_Int32
1203 FT_Int32 ay,
1204 FT_Int bx,
1205 FT_Int by )
1206 {
1211 /* compute ax*bx as 64-bit value */
1218 /* compute ay*by as 64-bit value */
1225 /* add them */
1229 /* divide the result by 2^14 with rounding */
1239 }
1242 /* return length of given vector */
1244 #if 0
1246 static FT_Int32
1248 FT_Int32 y )
1249 {
1254 /* compute x*x as 64-bit value */
1265 /* compute y*y as 64-bit value */
1276 /* add them to get 'x*x+y*y' as 64-bit value */
1280 /* compute the square root of this value */
1281 {
1283 FT_Int count;
1288 {
1291 do
1292 {
1300 {
1303 }
1305 }
1308 }
1309 }
1311 #else
1313 /* this version uses FT_Vector_Length which computes the same value */
1314 /* much, much faster.. */
1315 /* */
1316 static FT_F26Dot6
1318 FT_F26Dot6 Y )
1319 {
1320 FT_Vector v;
1327 }
1329 #endif
1332 /*************************************************************************/
1333 /* */
1334 /* <Function> */
1335 /* Current_Ratio */
1336 /* */
1337 /* <Description> */
1338 /* Returns the current aspect ratio scaling factor depending on the */
1339 /* projection vector's state and device resolutions. */
1340 /* */
1341 /* <Return> */
1342 /* The aspect ratio in 16.16 format, always <= 1.0 . */
1343 /* */
1344 static FT_Long
1346 {
1356 else
1357 {
1363 }
1366 }
1369 static FT_Long
1371 {
1373 }
1376 /*************************************************************************/
1377 /* */
1378 /* Functions related to the control value table (CVT). */
1379 /* */
1380 /*************************************************************************/
1385 {
1387 }
1392 {
1394 }
1399 FT_F26Dot6 value )
1400 {
1402 }
1407 FT_F26Dot6 value )
1408 {
1410 }
1415 FT_F26Dot6 value )
1416 {
1418 }
1423 FT_F26Dot6 value )
1424 {
1426 }
1429 /*************************************************************************/
1430 /* */
1431 /* <Function> */
1432 /* GetShortIns */
1433 /* */
1434 /* <Description> */
1435 /* Returns a short integer taken from the instruction stream at */
1436 /* address IP. */
1437 /* */
1438 /* <Return> */
1439 /* Short read at code[IP]. */
1440 /* */
1441 /* <Note> */
1442 /* This one could become a macro. */
1443 /* */
1444 static FT_Short
1446 {
1447 /* Reading a byte stream so there is no endianess (DaveP) */
1451 }
1454 /*************************************************************************/
1455 /* */
1456 /* <Function> */
1457 /* Ins_Goto_CodeRange */
1458 /* */
1459 /* <Description> */
1460 /* Goes to a certain code range in the instruction stream. */
1461 /* */
1462 /* <Input> */
1463 /* aRange :: The index of the code range. */
1464 /* */
1465 /* aIP :: The new IP address in the code range. */
1466 /* */
1467 /* <Return> */
1468 /* SUCCESS or FAILURE. */
1469 /* */
1470 static FT_Bool
1472 FT_ULong aIP )
1473 {
1478 {
1481 }
1486 {
1489 }
1491 /* NOTE: Because the last instruction of a program may be a CALL */
1492 /* which will return to the first byte *after* the code */
1493 /* range, we test for AIP <= Size, instead of AIP < Size. */
1496 {
1499 }
1507 }
1510 /*************************************************************************/
1511 /* */
1512 /* <Function> */
1513 /* Direct_Move */
1514 /* */
1515 /* <Description> */
1516 /* Moves a point by a given distance along the freedom vector. The */
1517 /* point will be `touched'. */
1518 /* */
1519 /* <Input> */
1520 /* point :: The index of the point to move. */
1521 /* */
1522 /* distance :: The distance to apply. */
1523 /* */
1524 /* <InOut> */
1525 /* zone :: The affected glyph zone. */
1526 /* */
1527 static void
1529 FT_UShort point,
1530 FT_F26Dot6 distance )
1531 {
1532 FT_F26Dot6 v;
1538 {
1540 #ifdef NO_APPLE_PATENT
1545 #else
1551 #endif
1554 }
1559 {
1561 #ifdef NO_APPLE_PATENT
1566 #else
1572 #endif
1575 }
1576 }
1579 /*************************************************************************/
1580 /* */
1581 /* Special versions of Direct_Move() */
1582 /* */
1583 /* The following versions are used whenever both vectors are both */
1584 /* along one of the coordinate unit vectors, i.e. in 90% of the cases. */
1585 /* */
1586 /*************************************************************************/
1589 static void
1591 FT_UShort point,
1592 FT_F26Dot6 distance )
1593 {
1594 FT_UNUSED_EXEC;
1598 }
1601 static void
1603 FT_UShort point,
1604 FT_F26Dot6 distance )
1605 {
1606 FT_UNUSED_EXEC;
1610 }
1613 /*************************************************************************/
1614 /* */
1615 /* <Function> */
1616 /* Round_None */
1617 /* */
1618 /* <Description> */
1619 /* Does not round, but adds engine compensation. */
1620 /* */
1621 /* <Input> */
1622 /* distance :: The distance (not) to round. */
1623 /* */
1624 /* compensation :: The engine compensation. */
1625 /* */
1626 /* <Return> */
1627 /* The compensated distance. */
1628 /* */
1629 /* <Note> */
1630 /* The TrueType specification says very few about the relationship */
1631 /* between rounding and engine compensation. However, it seems from */
1632 /* the description of super round that we should add the compensation */
1633 /* before rounding. */
1634 /* */
1635 static FT_F26Dot6
1637 FT_F26Dot6 compensation )
1638 {
1639 FT_F26Dot6 val;
1641 FT_UNUSED_EXEC;
1645 {
1649 }
1654 }
1656 }
1659 /*************************************************************************/
1660 /* */
1661 /* <Function> */
1662 /* Round_To_Grid */
1663 /* */
1664 /* <Description> */
1665 /* Rounds value to grid after adding engine compensation. */
1666 /* */
1667 /* <Input> */
1668 /* distance :: The distance to round. */
1669 /* */
1670 /* compensation :: The engine compensation. */
1671 /* */
1672 /* <Return> */
1673 /* Rounded distance. */
1674 /* */
1675 static FT_F26Dot6
1677 FT_F26Dot6 compensation )
1678 {
1679 FT_F26Dot6 val;
1681 FT_UNUSED_EXEC;
1685 {
1689 else
1691 }
1692 else
1693 {
1697 }
1700 }
1703 /*************************************************************************/
1704 /* */
1705 /* <Function> */
1706 /* Round_To_Half_Grid */
1707 /* */
1708 /* <Description> */
1709 /* Rounds value to half grid after adding engine compensation. */
1710 /* */
1711 /* <Input> */
1712 /* distance :: The distance to round. */
1713 /* */
1714 /* compensation :: The engine compensation. */
1715 /* */
1716 /* <Return> */
1717 /* Rounded distance. */
1718 /* */
1719 static FT_F26Dot6
1721 FT_F26Dot6 compensation )
1722 {
1723 FT_F26Dot6 val;
1725 FT_UNUSED_EXEC;
1729 {
1733 }
1734 else
1735 {
1739 }
1742 }
1745 /*************************************************************************/
1746 /* */
1747 /* <Function> */
1748 /* Round_Down_To_Grid */
1749 /* */
1750 /* <Description> */
1751 /* Rounds value down to grid after adding engine compensation. */
1752 /* */
1753 /* <Input> */
1754 /* distance :: The distance to round. */
1755 /* */
1756 /* compensation :: The engine compensation. */
1757 /* */
1758 /* <Return> */
1759 /* Rounded distance. */
1760 /* */
1761 static FT_F26Dot6
1763 FT_F26Dot6 compensation )
1764 {
1765 FT_F26Dot6 val;
1767 FT_UNUSED_EXEC;
1771 {
1775 else
1777 }
1778 else
1779 {
1783 }
1786 }
1789 /*************************************************************************/
1790 /* */
1791 /* <Function> */
1792 /* Round_Up_To_Grid */
1793 /* */
1794 /* <Description> */
1795 /* Rounds value up to grid after adding engine compensation. */
1796 /* */
1797 /* <Input> */
1798 /* distance :: The distance to round. */
1799 /* */
1800 /* compensation :: The engine compensation. */
1801 /* */
1802 /* <Return> */
1803 /* Rounded distance. */
1804 /* */
1805 static FT_F26Dot6
1807 FT_F26Dot6 compensation )
1808 {
1809 FT_F26Dot6 val;
1812 FT_UNUSED_EXEC;
1815 {
1819 else
1821 }
1822 else
1823 {
1827 }
1830 }
1833 /*************************************************************************/
1834 /* */
1835 /* <Function> */
1836 /* Round_To_Double_Grid */
1837 /* */
1838 /* <Description> */
1839 /* Rounds value to double grid after adding engine compensation. */
1840 /* */
1841 /* <Input> */
1842 /* distance :: The distance to round. */
1843 /* */
1844 /* compensation :: The engine compensation. */
1845 /* */
1846 /* <Return> */
1847 /* Rounded distance. */
1848 /* */
1849 static FT_F26Dot6
1851 FT_F26Dot6 compensation )
1852 {
1853 FT_F26Dot6 val;
1855 FT_UNUSED_EXEC;
1859 {
1863 else
1865 }
1866 else
1867 {
1871 }
1874 }
1877 /*************************************************************************/
1878 /* */
1879 /* <Function> */
1880 /* Round_Super */
1881 /* */
1882 /* <Description> */
1883 /* Super-rounds value to grid after adding engine compensation. */
1884 /* */
1885 /* <Input> */
1886 /* distance :: The distance to round. */
1887 /* */
1888 /* compensation :: The engine compensation. */
1889 /* */
1890 /* <Return> */
1891 /* Rounded distance. */
1892 /* */
1893 /* <Note> */
1894 /* The TrueType specification says very few about the relationship */
1895 /* between rounding and engine compensation. However, it seems from */
1896 /* the description of super round that we should add the compensation */
1897 /* before rounding. */
1898 /* */
1899 static FT_F26Dot6
1901 FT_F26Dot6 compensation )
1902 {
1903 FT_F26Dot6 val;
1907 {
1913 }
1914 else
1915 {
1921 }
1924 }
1927 /*************************************************************************/
1928 /* */
1929 /* <Function> */
1930 /* Round_Super_45 */
1931 /* */
1932 /* <Description> */
1933 /* Super-rounds value to grid after adding engine compensation. */
1934 /* */
1935 /* <Input> */
1936 /* distance :: The distance to round. */
1937 /* */
1938 /* compensation :: The engine compensation. */
1939 /* */
1940 /* <Return> */
1941 /* Rounded distance. */
1942 /* */
1943 /* <Note> */
1944 /* There is a separate function for Round_Super_45() as we may need */
1945 /* greater precision. */
1946 /* */
1947 static FT_F26Dot6
1949 FT_F26Dot6 compensation )
1950 {
1951 FT_F26Dot6 val;
1955 {
1961 }
1962 else
1963 {
1969 }
1972 }
1975 /*************************************************************************/
1976 /* */
1977 /* <Function> */
1978 /* Compute_Round */
1979 /* */
1980 /* <Description> */
1981 /* Sets the rounding mode. */
1982 /* */
1983 /* <Input> */
1984 /* round_mode :: The rounding mode to be used. */
1985 /* */
1986 static void
1988 {
1990 {
2022 }
2023 }
2026 /*************************************************************************/
2027 /* */
2028 /* <Function> */
2029 /* SetSuperRound */
2030 /* */
2031 /* <Description> */
2032 /* Sets Super Round parameters. */
2033 /* */
2034 /* <Input> */
2035 /* GridPeriod :: Grid period */
2036 /* selector :: SROUND opcode */
2037 /* */
2038 static void
2040 FT_Long selector )
2041 {
2043 {
2056 /* This opcode is reserved, but... */
2061 }
2064 {
2080 }
2084 else
2090 }
2093 /*************************************************************************/
2094 /* */
2095 /* <Function> */
2096 /* Project */
2097 /* */
2098 /* <Description> */
2099 /* Computes the projection of vector given by (v2-v1) along the */
2100 /* current projection vector. */
2101 /* */
2102 /* <Input> */
2103 /* v1 :: First input vector. */
2104 /* v2 :: Second input vector. */
2105 /* */
2106 /* <Return> */
2107 /* The distance in F26dot6 format. */
2108 /* */
2109 static FT_F26Dot6
2112 {
2117 }
2120 /*************************************************************************/
2121 /* */
2122 /* <Function> */
2123 /* Dual_Project */
2124 /* */
2125 /* <Description> */
2126 /* Computes the projection of the vector given by (v2-v1) along the */
2127 /* current dual vector. */
2128 /* */
2129 /* <Input> */
2130 /* v1 :: First input vector. */
2131 /* v2 :: Second input vector. */
2132 /* */
2133 /* <Return> */
2134 /* The distance in F26dot6 format. */
2135 /* */
2136 static FT_F26Dot6
2139 {
2144 }
2147 /*************************************************************************/
2148 /* */
2149 /* <Function> */
2150 /* Free_Project */
2151 /* */
2152 /* <Description> */
2153 /* Computes the projection of the vector given by (v2-v1) along the */
2154 /* current freedom vector. */
2155 /* */
2156 /* <Input> */
2157 /* v1 :: First input vector. */
2158 /* v2 :: Second input vector. */
2159 /* */
2160 /* <Return> */
2161 /* The distance in F26dot6 format. */
2162 /* */
2163 static FT_F26Dot6
2166 {
2171 }
2174 /*************************************************************************/
2175 /* */
2176 /* <Function> */
2177 /* Project_x */
2178 /* */
2179 /* <Description> */
2180 /* Computes the projection of the vector given by (v2-v1) along the */
2181 /* horizontal axis. */
2182 /* */
2183 /* <Input> */
2184 /* v1 :: First input vector. */
2185 /* v2 :: Second input vector. */
2186 /* */
2187 /* <Return> */
2188 /* The distance in F26dot6 format. */
2189 /* */
2190 static FT_F26Dot6
2193 {
2194 FT_UNUSED_EXEC;
2197 }
2200 /*************************************************************************/
2201 /* */
2202 /* <Function> */
2203 /* Project_y */
2204 /* */
2205 /* <Description> */
2206 /* Computes the projection of the vector given by (v2-v1) along the */
2207 /* vertical axis. */
2208 /* */
2209 /* <Input> */
2210 /* v1 :: First input vector. */
2211 /* v2 :: Second input vector. */
2212 /* */
2213 /* <Return> */
2214 /* The distance in F26dot6 format. */
2215 /* */
2216 static FT_F26Dot6
2219 {
2220 FT_UNUSED_EXEC;
2223 }
2226 /*************************************************************************/
2227 /* */
2228 /* <Function> */
2229 /* Compute_Funcs */
2230 /* */
2231 /* <Description> */
2232 /* Computes the projection and movement function pointers according */
2233 /* to the current graphics state. */
2234 /* */
2235 static void
2237 {
2239 {
2242 }
2243 else
2244 {
2246 {
2249 }
2250 else
2251 {
2255 }
2256 }
2260 else
2261 {
2264 else
2266 }
2270 else
2271 {
2274 else
2276 }
2281 {
2284 else
2285 {
2288 }
2289 }
2291 /* at small sizes, F_dot_P can become too small, resulting */
2292 /* in overflows and `spikes' in a number of glyphs like `w'. */
2297 /* Disable cached aspect ratio */
2299 }
2302 /*************************************************************************/
2303 /* */
2304 /* <Function> */
2305 /* Normalize */
2306 /* */
2307 /* <Description> */
2308 /* Norms a vector. */
2309 /* */
2310 /* <Input> */
2311 /* Vx :: The horizontal input vector coordinate. */
2312 /* Vy :: The vertical input vector coordinate. */
2313 /* */
2314 /* <Output> */
2315 /* R :: The normed unit vector. */
2316 /* */
2317 /* <Return> */
2318 /* Returns FAILURE if a vector parameter is zero. */
2319 /* */
2320 /* <Note> */
2321 /* In case Vx and Vy are both zero, Normalize() returns SUCCESS, and */
2322 /* R is undefined. */
2323 /* */
2326 static FT_Bool
2328 FT_F26Dot6 Vy,
2330 {
2331 FT_F26Dot6 W;
2334 FT_UNUSED_EXEC;
2338 {
2345 {
2346 /* XXX: UNDOCUMENTED! It seems that it is possible to try */
2347 /* to normalize the vector (0,0). Return immediately. */
2349 }
2355 }
2364 /* Now, we want that Sqrt( W ) = 0x4000 */
2365 /* Or 0x1000000 <= W < 0x1004000 */
2368 {
2371 }
2372 else
2376 {
2379 }
2380 else
2384 {
2385 /* We need to increase W by a minimal amount */
2387 Vx++;
2388 else
2389 Vy++;
2392 }
2395 {
2396 /* We need to decrease W by a minimal amount */
2398 Vx--;
2399 else
2400 Vy--;
2403 }
2405 /* Note that in various cases, we can only */
2406 /* compute a Sqrt(W) of 0x3FFF, eg. Vx = Vy */
2418 }
2421 /*************************************************************************/
2422 /* */
2423 /* Here we start with the implementation of the various opcodes. */
2424 /* */
2425 /*************************************************************************/
2428 static FT_Bool
2430 FT_UShort aIdx2,
2431 FT_Int aOpc,
2433 {
2441 {
2445 }
2454 {
2458 }
2463 }
2466 /* When not using the big switch statements, the interpreter uses a */
2467 /* call table defined later below in this source. Each opcode must */
2468 /* thus have a corresponding function, even trivial ones. */
2469 /* */
2470 /* They are all defined there. */
2472 #define DO_SVTCA \
2473 { \
2474 FT_Short A, B; \
2475 \
2476 \
2477 A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2478 B = A ^ (FT_Short)0x4000; \
2479 \
2480 CUR.GS.freeVector.x = A; \
2481 CUR.GS.projVector.x = A; \
2482 CUR.GS.dualVector.x = A; \
2483 \
2484 CUR.GS.freeVector.y = B; \
2485 CUR.GS.projVector.y = B; \
2486 CUR.GS.dualVector.y = B; \
2487 \
2488 COMPUTE_Funcs(); \
2489 }
2492 #define DO_SPVTCA \
2493 { \
2494 FT_Short A, B; \
2495 \
2496 \
2497 A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2498 B = A ^ (FT_Short)0x4000; \
2499 \
2500 CUR.GS.projVector.x = A; \
2501 CUR.GS.dualVector.x = A; \
2502 \
2503 CUR.GS.projVector.y = B; \
2504 CUR.GS.dualVector.y = B; \
2505 \
2506 COMPUTE_Funcs(); \
2507 }
2510 #define DO_SFVTCA \
2511 { \
2512 FT_Short A, B; \
2513 \
2514 \
2515 A = (FT_Short)( CUR.opcode & 1 ) << 14; \
2516 B = A ^ (FT_Short)0x4000; \
2517 \
2518 CUR.GS.freeVector.x = A; \
2519 CUR.GS.freeVector.y = B; \
2520 \
2521 COMPUTE_Funcs(); \
2522 }
2525 #define DO_SPVTL \
2526 if ( INS_SxVTL( (FT_UShort)args[1], \
2527 (FT_UShort)args[0], \
2528 CUR.opcode, \
2529 &CUR.GS.projVector ) == SUCCESS ) \
2530 { \
2531 CUR.GS.dualVector = CUR.GS.projVector; \
2532 COMPUTE_Funcs(); \
2533 }
2536 #define DO_SFVTL \
2537 if ( INS_SxVTL( (FT_UShort)args[1], \
2538 (FT_UShort)args[0], \
2539 CUR.opcode, \
2540 &CUR.GS.freeVector ) == SUCCESS ) \
2541 COMPUTE_Funcs();
2544 #define DO_SFVTPV \
2545 CUR.GS.freeVector = CUR.GS.projVector; \
2546 COMPUTE_Funcs();
2549 #define DO_SPVFS \
2550 { \
2551 FT_Short S; \
2552 FT_Long X, Y; \
2553 \
2554 \
2556 S = (FT_Short)args[1]; \
2557 Y = (FT_Long)S; \
2558 S = (FT_Short)args[0]; \
2559 X = (FT_Long)S; \
2560 \
2561 NORMalize( X, Y, &CUR.GS.projVector ); \
2562 \
2563 CUR.GS.dualVector = CUR.GS.projVector; \
2564 COMPUTE_Funcs(); \
2565 }
2568 #define DO_SFVFS \
2569 { \
2570 FT_Short S; \
2571 FT_Long X, Y; \
2572 \
2573 \
2575 S = (FT_Short)args[1]; \
2576 Y = (FT_Long)S; \
2577 S = (FT_Short)args[0]; \
2578 X = S; \
2579 \
2580 NORMalize( X, Y, &CUR.GS.freeVector ); \
2581 COMPUTE_Funcs(); \
2582 }
2585 #define DO_GPV \
2586 args[0] = CUR.GS.projVector.x; \
2587 args[1] = CUR.GS.projVector.y;
2590 #define DO_GFV \
2591 args[0] = CUR.GS.freeVector.x; \
2592 args[1] = CUR.GS.freeVector.y;
2595 #define DO_SRP0 \
2596 CUR.GS.rp0 = (FT_UShort)args[0];
2599 #define DO_SRP1 \
2600 CUR.GS.rp1 = (FT_UShort)args[0];
2603 #define DO_SRP2 \
2604 CUR.GS.rp2 = (FT_UShort)args[0];
2607 #define DO_RTHG \
2608 CUR.GS.round_state = TT_Round_To_Half_Grid; \
2609 CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
2612 #define DO_RTG \
2613 CUR.GS.round_state = TT_Round_To_Grid; \
2614 CUR.func_round = (TT_Round_Func)Round_To_Grid;
2617 #define DO_RTDG \
2618 CUR.GS.round_state = TT_Round_To_Double_Grid; \
2619 CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
2622 #define DO_RUTG \
2623 CUR.GS.round_state = TT_Round_Up_To_Grid; \
2624 CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
2627 #define DO_RDTG \
2628 CUR.GS.round_state = TT_Round_Down_To_Grid; \
2629 CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
2632 #define DO_ROFF \
2633 CUR.GS.round_state = TT_Round_Off; \
2634 CUR.func_round = (TT_Round_Func)Round_None;
2637 #define DO_SROUND \
2638 SET_SuperRound( 0x4000, args[0] ); \
2639 CUR.GS.round_state = TT_Round_Super; \
2640 CUR.func_round = (TT_Round_Func)Round_Super;
2643 #define DO_S45ROUND \
2644 SET_SuperRound( 0x2D41, args[0] ); \
2645 CUR.GS.round_state = TT_Round_Super_45; \
2646 CUR.func_round = (TT_Round_Func)Round_Super_45;
2649 #define DO_SLOOP \
2650 if ( args[0] < 0 ) \
2651 CUR.error = TT_Err_Bad_Argument; \
2652 else \
2653 CUR.GS.loop = args[0];
2656 #define DO_SMD \
2657 CUR.GS.minimum_distance = args[0];
2660 #define DO_SCVTCI \
2661 CUR.GS.control_value_cutin = (FT_F26Dot6)args[0];
2664 #define DO_SSWCI \
2665 CUR.GS.single_width_cutin = (FT_F26Dot6)args[0];
2668 /* XXX: UNDOCUMENTED! or bug in the Windows engine? */
2669 /* */
2670 /* It seems that the value that is read here is */
2671 /* expressed in 16.16 format rather than in font */
2672 /* units. */
2673 /* */
2674 #define DO_SSW \
2675 CUR.GS.single_width_value = (FT_F26Dot6)( args[0] >> 10 );
2678 #define DO_FLIPON \
2679 CUR.GS.auto_flip = TRUE;
2682 #define DO_FLIPOFF \
2683 CUR.GS.auto_flip = FALSE;
2686 #define DO_SDB \
2687 CUR.GS.delta_base = (FT_Short)args[0];
2690 #define DO_SDS \
2691 CUR.GS.delta_shift = (FT_Short)args[0];
2697 #define DO_MPPEM \
2698 args[0] = CURRENT_Ppem();
2701 /* Note: The pointSize should be irrelevant in a given font program; */
2702 /* we thus decide to return only the ppem. */
2703 #if 0
2705 #define DO_MPS \
2706 args[0] = CUR.metrics.pointSize;
2708 #else
2710 #define DO_MPS \
2711 args[0] = CURRENT_Ppem();
2716 #define DO_DUP \
2717 args[1] = args[0];
2720 #define DO_CLEAR \
2721 CUR.new_top = 0;
2724 #define DO_SWAP \
2725 { \
2726 FT_Long L; \
2727 \
2728 \
2729 L = args[0]; \
2730 args[0] = args[1]; \
2731 args[1] = L; \
2732 }
2735 #define DO_DEPTH \
2736 args[0] = CUR.top;
2739 #define DO_CINDEX \
2740 { \
2741 FT_Long L; \
2742 \
2743 \
2744 L = args[0]; \
2745 \
2746 if ( L <= 0 || L > CUR.args ) \
2747 CUR.error = TT_Err_Invalid_Reference; \
2748 else \
2749 args[0] = CUR.stack[CUR.args - L]; \
2750 }
2753 #define DO_JROT \
2754 if ( args[1] != 0 ) \
2755 { \
2756 CUR.IP += args[0]; \
2757 CUR.step_ins = FALSE; \
2758 }
2761 #define DO_JMPR \
2762 CUR.IP += args[0]; \
2763 CUR.step_ins = FALSE;
2766 #define DO_JROF \
2767 if ( args[1] == 0 ) \
2768 { \
2769 CUR.IP += args[0]; \
2770 CUR.step_ins = FALSE; \
2771 }
2774 #define DO_LT \
2775 args[0] = ( args[0] < args[1] );
2778 #define DO_LTEQ \
2779 args[0] = ( args[0] <= args[1] );
2782 #define DO_GT \
2783 args[0] = ( args[0] > args[1] );
2786 #define DO_GTEQ \
2787 args[0] = ( args[0] >= args[1] );
2790 #define DO_EQ \
2791 args[0] = ( args[0] == args[1] );
2794 #define DO_NEQ \
2795 args[0] = ( args[0] != args[1] );
2798 #define DO_ODD \
2799 args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 64 );
2802 #define DO_EVEN \
2803 args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 0 );
2806 #define DO_AND \
2807 args[0] = ( args[0] && args[1] );
2810 #define DO_OR \
2811 args[0] = ( args[0] || args[1] );
2814 #define DO_NOT \
2815 args[0] = !args[0];
2818 #define DO_ADD \
2819 args[0] += args[1];
2822 #define DO_SUB \
2823 args[0] -= args[1];
2826 #define DO_DIV \
2827 if ( args[1] == 0 ) \
2828 CUR.error = TT_Err_Divide_By_Zero; \
2829 else \
2830 args[0] = TT_MULDIV( args[0], 64L, args[1] );
2833 #define DO_MUL \
2834 args[0] = TT_MULDIV( args[0], args[1], 64L );
2837 #define DO_ABS \
2838 args[0] = ABS( args[0] );
2841 #define DO_NEG \
2842 args[0] = -args[0];
2845 #define DO_FLOOR \
2846 args[0] &= -64;
2849 #define DO_CEILING \
2850 args[0] = ( args[0] + 63 ) & -64;
2853 #define DO_RS \
2854 { \
2855 FT_ULong I = (FT_ULong)args[0]; \
2856 \
2857 \
2858 if ( BOUNDS( I, CUR.storeSize ) ) \
2859 { \
2860 if ( CUR.pedantic_hinting ) \
2861 { \
2862 ARRAY_BOUND_ERROR; \
2863 } \
2864 else \
2865 args[0] = 0; \
2866 } \
2867 else \
2868 args[0] = CUR.storage[I]; \
2869 }
2872 #define DO_WS \
2873 { \
2874 FT_ULong I = (FT_ULong)args[0]; \
2875 \
2876 \
2877 if ( BOUNDS( I, CUR.storeSize ) ) \
2878 { \
2879 if ( CUR.pedantic_hinting ) \
2880 { \
2881 ARRAY_BOUND_ERROR; \
2882 } \
2883 } \
2884 else \
2885 CUR.storage[I] = args[1]; \
2886 }
2889 #define DO_RCVT \
2890 { \
2891 FT_ULong I = (FT_ULong)args[0]; \
2892 \
2893 \
2894 if ( BOUNDS( I, CUR.cvtSize ) ) \
2895 { \
2896 if ( CUR.pedantic_hinting ) \
2897 { \
2898 ARRAY_BOUND_ERROR; \
2899 } \
2900 else \
2901 args[0] = 0; \
2902 } \
2903 else \
2904 args[0] = CUR_Func_read_cvt( I ); \
2905 }
2908 #define DO_WCVTP \
2909 { \
2910 FT_ULong I = (FT_ULong)args[0]; \
2911 \
2912 \
2913 if ( BOUNDS( I, CUR.cvtSize ) ) \
2914 { \
2915 if ( CUR.pedantic_hinting ) \
2916 { \
2917 ARRAY_BOUND_ERROR; \
2918 } \
2919 } \
2920 else \
2921 CUR_Func_write_cvt( I, args[1] ); \
2922 }
2925 #define DO_WCVTF \
2926 { \
2927 FT_ULong I = (FT_ULong)args[0]; \
2928 \
2929 \
2930 if ( BOUNDS( I, CUR.cvtSize ) ) \
2931 { \
2932 if ( CUR.pedantic_hinting ) \
2933 { \
2934 ARRAY_BOUND_ERROR; \
2935 } \
2936 } \
2937 else \
2938 CUR.cvt[I] = TT_MULFIX( args[1], CUR.tt_metrics.scale ); \
2939 }
2942 #define DO_DEBUG \
2943 CUR.error = TT_Err_Debug_OpCode;
2946 #define DO_ROUND \
2947 args[0] = CUR_Func_round( \
2948 args[0], \
2949 CUR.tt_metrics.compensations[CUR.opcode - 0x68] );
2952 #define DO_NROUND \
2953 args[0] = ROUND_None( args[0], \
2954 CUR.tt_metrics.compensations[CUR.opcode - 0x6C] );
2957 #define DO_MAX \
2958 if ( args[1] > args[0] ) \
2959 args[0] = args[1];
2962 #define DO_MIN \
2963 if ( args[1] < args[0] ) \
2964 args[0] = args[1];
2967 #ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
2970 #undef ARRAY_BOUND_ERROR
2971 #define ARRAY_BOUND_ERROR \
2972 { \
2973 CUR.error = TT_Err_Invalid_Reference; \
2974 return; \
2975 }
2978 /*************************************************************************/
2979 /* */
2980 /* SVTCA[a]: Set (F and P) Vectors to Coordinate Axis */
2981 /* Opcode range: 0x00-0x01 */
2982 /* Stack: --> */
2983 /* */
2984 static void
2986 {
2987 DO_SVTCA
2988 }
2991 /*************************************************************************/
2992 /* */
2993 /* SPVTCA[a]: Set PVector to Coordinate Axis */
2994 /* Opcode range: 0x02-0x03 */
2995 /* Stack: --> */
2996 /* */
2997 static void
2999 {
3000 DO_SPVTCA
3001 }
3004 /*************************************************************************/
3005 /* */
3006 /* SFVTCA[a]: Set FVector to Coordinate Axis */
3007 /* Opcode range: 0x04-0x05 */
3008 /* Stack: --> */
3009 /* */
3010 static void
3012 {
3013 DO_SFVTCA
3014 }
3017 /*************************************************************************/
3018 /* */
3019 /* SPVTL[a]: Set PVector To Line */
3020 /* Opcode range: 0x06-0x07 */
3021 /* Stack: uint32 uint32 --> */
3022 /* */
3023 static void
3025 {
3026 DO_SPVTL
3027 }
3030 /*************************************************************************/
3031 /* */
3032 /* SFVTL[a]: Set FVector To Line */
3033 /* Opcode range: 0x08-0x09 */
3034 /* Stack: uint32 uint32 --> */
3035 /* */
3036 static void
3038 {
3039 DO_SFVTL
3040 }
3043 /*************************************************************************/
3044 /* */
3045 /* SFVTPV[]: Set FVector To PVector */
3046 /* Opcode range: 0x0E */
3047 /* Stack: --> */
3048 /* */
3049 static void
3051 {
3052 DO_SFVTPV
3053 }
3056 /*************************************************************************/
3057 /* */
3058 /* SPVFS[]: Set PVector From Stack */
3059 /* Opcode range: 0x0A */
3060 /* Stack: f2.14 f2.14 --> */
3061 /* */
3062 static void
3064 {
3065 DO_SPVFS
3066 }
3069 /*************************************************************************/
3070 /* */
3071 /* SFVFS[]: Set FVector From Stack */
3072 /* Opcode range: 0x0B */
3073 /* Stack: f2.14 f2.14 --> */
3074 /* */
3075 static void
3077 {
3078 DO_SFVFS
3079 }
3082 /*************************************************************************/
3083 /* */
3084 /* GPV[]: Get Projection Vector */
3085 /* Opcode range: 0x0C */
3086 /* Stack: ef2.14 --> ef2.14 */
3087 /* */
3088 static void
3090 {
3091 DO_GPV
3092 }
3095 /*************************************************************************/
3096 /* GFV[]: Get Freedom Vector */
3097 /* Opcode range: 0x0D */
3098 /* Stack: ef2.14 --> ef2.14 */
3099 /* */
3100 static void
3102 {
3103 DO_GFV
3104 }
3107 /*************************************************************************/
3108 /* */
3109 /* SRP0[]: Set Reference Point 0 */
3110 /* Opcode range: 0x10 */
3111 /* Stack: uint32 --> */
3112 /* */
3113 static void
3115 {
3116 DO_SRP0
3117 }
3120 /*************************************************************************/
3121 /* */
3122 /* SRP1[]: Set Reference Point 1 */
3123 /* Opcode range: 0x11 */
3124 /* Stack: uint32 --> */
3125 /* */
3126 static void
3128 {
3129 DO_SRP1
3130 }
3133 /*************************************************************************/
3134 /* */
3135 /* SRP2[]: Set Reference Point 2 */
3136 /* Opcode range: 0x12 */
3137 /* Stack: uint32 --> */
3138 /* */
3139 static void
3141 {
3142 DO_SRP2
3143 }
3146 /*************************************************************************/
3147 /* */
3148 /* RTHG[]: Round To Half Grid */
3149 /* Opcode range: 0x19 */
3150 /* Stack: --> */
3151 /* */
3152 static void
3154 {
3155 DO_RTHG
3156 }
3159 /*************************************************************************/
3160 /* */
3161 /* RTG[]: Round To Grid */
3162 /* Opcode range: 0x18 */
3163 /* Stack: --> */
3164 /* */
3165 static void
3167 {
3168 DO_RTG
3169 }
3172 /*************************************************************************/
3173 /* RTDG[]: Round To Double Grid */
3174 /* Opcode range: 0x3D */
3175 /* Stack: --> */
3176 /* */
3177 static void
3179 {
3180 DO_RTDG
3181 }
3184 /*************************************************************************/
3185 /* RUTG[]: Round Up To Grid */
3186 /* Opcode range: 0x7C */
3187 /* Stack: --> */
3188 /* */
3189 static void
3191 {
3192 DO_RUTG
3193 }
3196 /*************************************************************************/
3197 /* */
3198 /* RDTG[]: Round Down To Grid */
3199 /* Opcode range: 0x7D */
3200 /* Stack: --> */
3201 /* */
3202 static void
3204 {
3205 DO_RDTG
3206 }
3209 /*************************************************************************/
3210 /* */
3211 /* ROFF[]: Round OFF */
3212 /* Opcode range: 0x7A */
3213 /* Stack: --> */
3214 /* */
3215 static void
3217 {
3218 DO_ROFF
3219 }
3222 /*************************************************************************/
3223 /* */
3224 /* SROUND[]: Super ROUND */
3225 /* Opcode range: 0x76 */
3226 /* Stack: Eint8 --> */
3227 /* */
3228 static void
3230 {
3231 DO_SROUND
3232 }
3235 /*************************************************************************/
3236 /* */
3237 /* S45ROUND[]: Super ROUND 45 degrees */
3238 /* Opcode range: 0x77 */
3239 /* Stack: uint32 --> */
3240 /* */
3241 static void
3243 {
3244 DO_S45ROUND
3245 }
3248 /*************************************************************************/
3249 /* */
3250 /* SLOOP[]: Set LOOP variable */
3251 /* Opcode range: 0x17 */
3252 /* Stack: int32? --> */
3253 /* */
3254 static void
3256 {
3257 DO_SLOOP
3258 }
3261 /*************************************************************************/
3262 /* */
3263 /* SMD[]: Set Minimum Distance */
3264 /* Opcode range: 0x1A */
3265 /* Stack: f26.6 --> */
3266 /* */
3267 static void
3269 {
3270 DO_SMD
3271 }
3274 /*************************************************************************/
3275 /* */
3276 /* SCVTCI[]: Set Control Value Table Cut In */
3277 /* Opcode range: 0x1D */
3278 /* Stack: f26.6 --> */
3279 /* */
3280 static void
3282 {
3283 DO_SCVTCI
3284 }
3287 /*************************************************************************/
3288 /* */
3289 /* SSWCI[]: Set Single Width Cut In */
3290 /* Opcode range: 0x1E */
3291 /* Stack: f26.6 --> */
3292 /* */
3293 static void
3295 {
3296 DO_SSWCI
3297 }
3300 /*************************************************************************/
3301 /* */
3302 /* SSW[]: Set Single Width */
3303 /* Opcode range: 0x1F */
3304 /* Stack: int32? --> */
3305 /* */
3306 static void
3308 {
3309 DO_SSW
3310 }
3313 /*************************************************************************/
3314 /* */
3315 /* FLIPON[]: Set auto-FLIP to ON */
3316 /* Opcode range: 0x4D */
3317 /* Stack: --> */
3318 /* */
3319 static void
3321 {
3322 DO_FLIPON
3323 }
3326 /*************************************************************************/
3327 /* */
3328 /* FLIPOFF[]: Set auto-FLIP to OFF */
3329 /* Opcode range: 0x4E */
3330 /* Stack: --> */
3331 /* */
3332 static void
3334 {
3335 DO_FLIPOFF
3336 }
3339 /*************************************************************************/
3340 /* */
3341 /* SANGW[]: Set ANGle Weight */
3342 /* Opcode range: 0x7E */
3343 /* Stack: uint32 --> */
3344 /* */
3345 static void
3347 {
3348 /* instruction not supported anymore */
3349 }
3352 /*************************************************************************/
3353 /* */
3354 /* SDB[]: Set Delta Base */
3355 /* Opcode range: 0x5E */
3356 /* Stack: uint32 --> */
3357 /* */
3358 static void
3360 {
3361 DO_SDB
3362 }
3365 /*************************************************************************/
3366 /* */
3367 /* SDS[]: Set Delta Shift */
3368 /* Opcode range: 0x5F */
3369 /* Stack: uint32 --> */
3370 /* */
3371 static void
3373 {
3374 DO_SDS
3375 }
3378 /*************************************************************************/
3379 /* */
3380 /* MPPEM[]: Measure Pixel Per EM */
3381 /* Opcode range: 0x4B */
3382 /* Stack: --> Euint16 */
3383 /* */
3384 static void
3386 {
3387 DO_MPPEM
3388 }
3391 /*************************************************************************/
3392 /* */
3393 /* MPS[]: Measure Point Size */
3394 /* Opcode range: 0x4C */
3395 /* Stack: --> Euint16 */
3396 /* */
3397 static void
3399 {
3400 DO_MPS
3401 }
3404 /*************************************************************************/
3405 /* */
3406 /* DUP[]: DUPlicate the top stack's element */
3407 /* Opcode range: 0x20 */
3408 /* Stack: StkElt --> StkElt StkElt */
3409 /* */
3410 static void
3412 {
3413 DO_DUP
3414 }
3417 /*************************************************************************/
3418 /* */
3419 /* POP[]: POP the stack's top element */
3420 /* Opcode range: 0x21 */
3421 /* Stack: StkElt --> */
3422 /* */
3423 static void
3425 {
3426 /* nothing to do */
3427 }
3430 /*************************************************************************/
3431 /* */
3432 /* CLEAR[]: CLEAR the entire stack */
3433 /* Opcode range: 0x22 */
3434 /* Stack: StkElt... --> */
3435 /* */
3436 static void
3438 {
3439 DO_CLEAR
3440 }
3443 /*************************************************************************/
3444 /* */
3445 /* SWAP[]: SWAP the stack's top two elements */
3446 /* Opcode range: 0x23 */
3447 /* Stack: 2 * StkElt --> 2 * StkElt */
3448 /* */
3449 static void
3451 {
3452 DO_SWAP
3453 }
3456 /*************************************************************************/
3457 /* */
3458 /* DEPTH[]: return the stack DEPTH */
3459 /* Opcode range: 0x24 */
3460 /* Stack: --> uint32 */
3461 /* */
3462 static void
3464 {
3465 DO_DEPTH
3466 }
3469 /*************************************************************************/
3470 /* */
3471 /* CINDEX[]: Copy INDEXed element */
3472 /* Opcode range: 0x25 */
3473 /* Stack: int32 --> StkElt */
3474 /* */
3475 static void
3477 {
3478 DO_CINDEX
3479 }
3482 /*************************************************************************/
3483 /* */
3484 /* EIF[]: End IF */
3485 /* Opcode range: 0x59 */
3486 /* Stack: --> */
3487 /* */
3488 static void
3490 {
3491 /* nothing to do */
3492 }
3495 /*************************************************************************/
3496 /* */
3497 /* JROT[]: Jump Relative On True */
3498 /* Opcode range: 0x78 */
3499 /* Stack: StkElt int32 --> */
3500 /* */
3501 static void
3503 {
3504 DO_JROT
3505 }
3508 /*************************************************************************/
3509 /* */
3510 /* JMPR[]: JuMP Relative */
3511 /* Opcode range: 0x1C */
3512 /* Stack: int32 --> */
3513 /* */
3514 static void
3516 {
3517 DO_JMPR
3518 }
3521 /*************************************************************************/
3522 /* */
3523 /* JROF[]: Jump Relative On False */
3524 /* Opcode range: 0x79 */
3525 /* Stack: StkElt int32 --> */
3526 /* */
3527 static void
3529 {
3530 DO_JROF
3531 }
3534 /*************************************************************************/
3535 /* */
3536 /* LT[]: Less Than */
3537 /* Opcode range: 0x50 */
3538 /* Stack: int32? int32? --> bool */
3539 /* */
3540 static void
3542 {
3543 DO_LT
3544 }
3547 /*************************************************************************/
3548 /* */
3549 /* LTEQ[]: Less Than or EQual */
3550 /* Opcode range: 0x51 */
3551 /* Stack: int32? int32? --> bool */
3552 /* */
3553 static void
3555 {
3556 DO_LTEQ
3557 }
3560 /*************************************************************************/
3561 /* */
3562 /* GT[]: Greater Than */
3563 /* Opcode range: 0x52 */
3564 /* Stack: int32? int32? --> bool */
3565 /* */
3566 static void
3568 {
3569 DO_GT
3570 }
3573 /*************************************************************************/
3574 /* */
3575 /* GTEQ[]: Greater Than or EQual */
3576 /* Opcode range: 0x53 */
3577 /* Stack: int32? int32? --> bool */
3578 /* */
3579 static void
3581 {
3582 DO_GTEQ
3583 }
3586 /*************************************************************************/
3587 /* */
3588 /* EQ[]: EQual */
3589 /* Opcode range: 0x54 */
3590 /* Stack: StkElt StkElt --> bool */
3591 /* */
3592 static void
3594 {
3595 DO_EQ
3596 }
3599 /*************************************************************************/
3600 /* */
3601 /* NEQ[]: Not EQual */
3602 /* Opcode range: 0x55 */
3603 /* Stack: StkElt StkElt --> bool */
3604 /* */
3605 static void
3607 {
3608 DO_NEQ
3609 }
3612 /*************************************************************************/
3613 /* */
3614 /* ODD[]: Is ODD */
3615 /* Opcode range: 0x56 */
3616 /* Stack: f26.6 --> bool */
3617 /* */
3618 static void
3620 {
3621 DO_ODD
3622 }
3625 /*************************************************************************/
3626 /* */
3627 /* EVEN[]: Is EVEN */
3628 /* Opcode range: 0x57 */
3629 /* Stack: f26.6 --> bool */
3630 /* */
3631 static void
3633 {
3634 DO_EVEN
3635 }
3638 /*************************************************************************/
3639 /* */
3640 /* AND[]: logical AND */
3641 /* Opcode range: 0x5A */
3642 /* Stack: uint32 uint32 --> uint32 */
3643 /* */
3644 static void
3646 {
3647 DO_AND
3648 }
3651 /*************************************************************************/
3652 /* */
3653 /* OR[]: logical OR */
3654 /* Opcode range: 0x5B */
3655 /* Stack: uint32 uint32 --> uint32 */
3656 /* */
3657 static void
3659 {
3660 DO_OR
3661 }
3664 /*************************************************************************/
3665 /* */
3666 /* NOT[]: logical NOT */
3667 /* Opcode range: 0x5C */
3668 /* Stack: StkElt --> uint32 */
3669 /* */
3670 static void
3672 {
3673 DO_NOT
3674 }
3677 /*************************************************************************/
3678 /* */
3679 /* ADD[]: ADD */
3680 /* Opcode range: 0x60 */
3681 /* Stack: f26.6 f26.6 --> f26.6 */
3682 /* */
3683 static void
3685 {
3686 DO_ADD
3687 }
3690 /*************************************************************************/
3691 /* */
3692 /* SUB[]: SUBtract */
3693 /* Opcode range: 0x61 */
3694 /* Stack: f26.6 f26.6 --> f26.6 */
3695 /* */
3696 static void
3698 {
3699 DO_SUB
3700 }
3703 /*************************************************************************/
3704 /* */
3705 /* DIV[]: DIVide */
3706 /* Opcode range: 0x62 */
3707 /* Stack: f26.6 f26.6 --> f26.6 */
3708 /* */
3709 static void
3711 {
3712 DO_DIV
3713 }
3716 /*************************************************************************/
3717 /* */
3718 /* MUL[]: MULtiply */
3719 /* Opcode range: 0x63 */
3720 /* Stack: f26.6 f26.6 --> f26.6 */
3721 /* */
3722 static void
3724 {
3725 DO_MUL
3726 }
3729 /*************************************************************************/
3730 /* */
3731 /* ABS[]: ABSolute value */
3732 /* Opcode range: 0x64 */
3733 /* Stack: f26.6 --> f26.6 */
3734 /* */
3735 static void
3737 {
3738 DO_ABS
3739 }
3742 /*************************************************************************/
3743 /* */
3744 /* NEG[]: NEGate */
3745 /* Opcode range: 0x65 */
3746 /* Stack: f26.6 --> f26.6 */
3747 /* */
3748 static void
3750 {
3751 DO_NEG
3752 }
3755 /*************************************************************************/
3756 /* */
3757 /* FLOOR[]: FLOOR */
3758 /* Opcode range: 0x66 */
3759 /* Stack: f26.6 --> f26.6 */
3760 /* */
3761 static void
3763 {
3764 DO_FLOOR
3765 }
3768 /*************************************************************************/
3769 /* */
3770 /* CEILING[]: CEILING */
3771 /* Opcode range: 0x67 */
3772 /* Stack: f26.6 --> f26.6 */
3773 /* */
3774 static void
3776 {
3777 DO_CEILING
3778 }
3781 /*************************************************************************/
3782 /* */
3783 /* RS[]: Read Store */
3784 /* Opcode range: 0x43 */
3785 /* Stack: uint32 --> uint32 */
3786 /* */
3787 static void
3789 {
3790 DO_RS
3791 }
3794 /*************************************************************************/
3795 /* */
3796 /* WS[]: Write Store */
3797 /* Opcode range: 0x42 */
3798 /* Stack: uint32 uint32 --> */
3799 /* */
3800 static void
3802 {
3803 DO_WS
3804 }
3807 /*************************************************************************/
3808 /* */
3809 /* WCVTP[]: Write CVT in Pixel units */
3810 /* Opcode range: 0x44 */
3811 /* Stack: f26.6 uint32 --> */
3812 /* */
3813 static void
3815 {
3816 DO_WCVTP
3817 }
3820 /*************************************************************************/
3821 /* */
3822 /* WCVTF[]: Write CVT in Funits */
3823 /* Opcode range: 0x70 */
3824 /* Stack: uint32 uint32 --> */
3825 /* */
3826 static void
3828 {
3829 DO_WCVTF
3830 }
3833 /*************************************************************************/
3834 /* */
3835 /* RCVT[]: Read CVT */
3836 /* Opcode range: 0x45 */
3837 /* Stack: uint32 --> f26.6 */
3838 /* */
3839 static void
3841 {
3842 DO_RCVT
3843 }
3846 /*************************************************************************/
3847 /* */
3848 /* AA[]: Adjust Angle */
3849 /* Opcode range: 0x7F */
3850 /* Stack: uint32 --> */
3851 /* */
3852 static void
3854 {
3855 /* intentionally no longer supported */
3856 }
3859 /*************************************************************************/
3860 /* */
3861 /* DEBUG[]: DEBUG. Unsupported. */
3862 /* Opcode range: 0x4F */
3863 /* Stack: uint32 --> */
3864 /* */
3865 /* Note: The original instruction pops a value from the stack. */
3866 /* */
3867 static void
3869 {
3870 DO_DEBUG
3871 }
3874 /*************************************************************************/
3875 /* */
3876 /* ROUND[ab]: ROUND value */
3877 /* Opcode range: 0x68-0x6B */
3878 /* Stack: f26.6 --> f26.6 */
3879 /* */
3880 static void
3882 {
3883 DO_ROUND
3884 }
3887 /*************************************************************************/
3888 /* */
3889 /* NROUND[ab]: No ROUNDing of value */
3890 /* Opcode range: 0x6C-0x6F */
3891 /* Stack: f26.6 --> f26.6 */
3892 /* */
3893 static void
3895 {
3896 DO_NROUND
3897 }
3900 /*************************************************************************/
3901 /* */
3902 /* MAX[]: MAXimum */
3903 /* Opcode range: 0x68 */
3904 /* Stack: int32? int32? --> int32 */
3905 /* */
3906 static void
3908 {
3909 DO_MAX
3910 }
3913 /*************************************************************************/
3914 /* */
3915 /* MIN[]: MINimum */
3916 /* Opcode range: 0x69 */
3917 /* Stack: int32? int32? --> int32 */
3918 /* */
3919 static void
3921 {
3922 DO_MIN
3923 }
3929 /*************************************************************************/
3930 /* */
3931 /* The following functions are called as is within the switch statement. */
3932 /* */
3933 /*************************************************************************/
3936 /*************************************************************************/
3937 /* */
3938 /* MINDEX[]: Move INDEXed element */
3939 /* Opcode range: 0x26 */
3940 /* Stack: int32? --> StkElt */
3941 /* */
3942 static void
3944 {
3951 {
3954 }
3963 }
3966 /*************************************************************************/
3967 /* */
3968 /* ROLL[]: ROLL top three elements */
3969 /* Opcode range: 0x8A */
3970 /* Stack: 3 * StkElt --> 3 * StkElt */
3971 /* */
3972 static void
3974 {
3977 FT_UNUSED_EXEC;
3987 }
3990 /*************************************************************************/
3991 /* */
3992 /* MANAGING THE FLOW OF CONTROL */
3993 /* */
3994 /* Instructions appear in the specification's order. */
3995 /* */
3996 /*************************************************************************/
3999 static FT_Bool
4001 {
4005 {
4010 {
4014 }
4018 }
4020 Fail_Overflow:
4023 }
4026 /*************************************************************************/
4027 /* */
4028 /* IF[]: IF test */
4029 /* Opcode range: 0x58 */
4030 /* Stack: StkElt --> */
4031 /* */
4032 static void
4034 {
4035 FT_Int nIfs;
4036 FT_Bool Out;
4045 do
4046 {
4051 {
4053 nIfs++;
4061 nIfs--;
4064 }
4066 }
4069 /*************************************************************************/
4070 /* */
4071 /* ELSE[]: ELSE */
4072 /* Opcode range: 0x1B */
4073 /* Stack: --> */
4074 /* */
4075 static void
4077 {
4078 FT_Int nIfs;
4080 FT_UNUSED_ARG;
4085 do
4086 {
4091 {
4093 nIfs++;
4097 nIfs--;
4099 }
4101 }
4104 /*************************************************************************/
4105 /* */
4106 /* DEFINING AND USING FUNCTIONS AND INSTRUCTIONS */
4107 /* */
4108 /* Instructions appear in the specification's order. */
4109 /* */
4110 /*************************************************************************/
4113 /*************************************************************************/
4114 /* */
4115 /* FDEF[]: Function DEFinition */
4116 /* Opcode range: 0x2C */
4117 /* Stack: uint32 --> */
4118 /* */
4119 static void
4121 {
4122 FT_ULong n;
4127 /* some font programs are broken enough to redefine functions! */
4128 /* We will then parse the current table. */
4135 {
4138 }
4141 {
4142 /* check that there is enough room for new functions */
4144 {
4147 }
4149 }
4159 /* Now skip the whole function definition. */
4160 /* We don't allow nested IDEFS & FDEFs. */
4163 {
4165 {
4173 }
4174 }
4175 }
4178 /*************************************************************************/
4179 /* */
4180 /* ENDF[]: END Function definition */
4181 /* Opcode range: 0x2D */
4182 /* Stack: --> */
4183 /* */
4184 static void
4186 {
4189 FT_UNUSED_ARG;
4193 {
4196 }
4207 {
4210 }
4211 else
4212 /* Loop through the current function */
4216 /* Exit the current call frame. */
4218 /* NOTE: If the last intruction of a program is a */
4219 /* CALL or LOOPCALL, the return address is */
4220 /* always out of the code range. This is a */
4221 /* valid address, and it is why we do not test */
4222 /* the result of Ins_Goto_CodeRange() here! */
4223 }
4226 /*************************************************************************/
4227 /* */
4228 /* CALL[]: CALL function */
4229 /* Opcode range: 0x2B */
4230 /* Stack: uint32? --> */
4231 /* */
4232 static void
4234 {
4235 FT_ULong F;
4240 /* first of all, check the index */
4246 /* Except for some old Apple fonts, all functions in a TrueType */
4247 /* font are defined in increasing order, starting from 0. This */
4248 /* means that we normally have */
4249 /* */
4250 /* CUR.maxFunc+1 == CUR.numFDefs */
4251 /* CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc */
4252 /* */
4253 /* If this isn't true, we need to look up the function table. */
4257 {
4258 /* look up the FDefs table */
4266 def++;
4270 }
4272 /* check that the function is active */
4276 /* check the call stack */
4278 {
4281 }
4298 Fail:
4300 }
4303 /*************************************************************************/
4304 /* */
4305 /* LOOPCALL[]: LOOP and CALL function */
4306 /* Opcode range: 0x2A */
4307 /* Stack: uint32? Eint16? --> */
4308 /* */
4309 static void
4311 {
4312 FT_ULong F;
4317 /* first of all, check the index */
4322 /* Except for some old Apple fonts, all functions in a TrueType */
4323 /* font are defined in increasing order, starting from 0. This */
4324 /* means that we normally have */
4325 /* */
4326 /* CUR.maxFunc+1 == CUR.numFDefs */
4327 /* CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc */
4328 /* */
4329 /* If this isn't true, we need to look up the function table. */
4333 {
4334 /* look up the FDefs table */
4342 def++;
4346 }
4348 /* check that the function is active */
4352 /* check stack */
4354 {
4357 }
4360 {
4373 }
4376 Fail:
4378 }
4381 /*************************************************************************/
4382 /* */
4383 /* IDEF[]: Instruction DEFinition */
4384 /* Opcode range: 0x89 */
4385 /* Stack: Eint8 --> */
4386 /* */
4387 static void
4389 {
4394 /* First of all, look for the same function in our table */
4404 {
4405 /* check that there is enough room for a new instruction */
4407 {
4410 }
4412 }
4422 /* Now skip the whole function definition. */
4423 /* We don't allow nested IDEFs & FDEFs. */
4426 {
4428 {
4435 }
4436 }
4437 }
4440 /*************************************************************************/
4441 /* */
4442 /* PUSHING DATA ONTO THE INTERPRETER STACK */
4443 /* */
4444 /* Instructions appear in the specification's order. */
4445 /* */
4446 /*************************************************************************/
4449 /*************************************************************************/
4450 /* */
4451 /* NPUSHB[]: PUSH N Bytes */
4452 /* Opcode range: 0x40 */
4453 /* Stack: --> uint32... */
4454 /* */
4455 static void
4457 {
4464 {
4467 }
4473 }
4476 /*************************************************************************/
4477 /* */
4478 /* NPUSHW[]: PUSH N Words */
4479 /* Opcode range: 0x41 */
4480 /* Stack: --> int32... */
4481 /* */
4482 static void
4484 {
4491 {
4494 }
4503 }
4506 /*************************************************************************/
4507 /* */
4508 /* PUSHB[abc]: PUSH Bytes */
4509 /* Opcode range: 0xB0-0xB7 */
4510 /* Stack: --> uint32... */
4511 /* */
4512 static void
4514 {
4521 {
4524 }
4528 }
4531 /*************************************************************************/
4532 /* */
4533 /* PUSHW[abc]: PUSH Words */
4534 /* Opcode range: 0xB8-0xBF */
4535 /* Stack: --> int32... */
4536 /* */
4537 static void
4539 {
4546 {
4549 }
4557 }
4560 /*************************************************************************/
4561 /* */
4562 /* MANAGING THE GRAPHICS STATE */
4563 /* */
4564 /* Instructions appear in the specs' order. */
4565 /* */
4566 /*************************************************************************/
4569 /*************************************************************************/
4570 /* */
4571 /* GC[a]: Get Coordinate projected onto */
4572 /* Opcode range: 0x46-0x47 */
4573 /* Stack: uint32 --> f26.6 */
4574 /* */
4575 /* BULLSHIT: Measures from the original glyph must be taken along the */
4576 /* dual projection vector! */
4577 /* */
4578 static void
4580 {
4581 FT_ULong L;
4582 FT_F26Dot6 R;
4588 {
4590 {
4593 }
4594 else
4596 }
4597 else
4598 {
4601 else
4603 }
4606 }
4609 /*************************************************************************/
4610 /* */
4611 /* SCFS[]: Set Coordinate From Stack */
4612 /* Opcode range: 0x48 */
4613 /* Stack: f26.6 uint32 --> */
4614 /* */
4615 /* Formula: */
4616 /* */
4617 /* OA := OA + ( value - OA.p )/( f.p ) * f */
4618 /* */
4619 static void
4621 {
4622 FT_Long K;
4623 FT_UShort L;
4629 {
4633 }
4639 /* not part of the specs, but here for safety */
4643 }
4646 /*************************************************************************/
4647 /* */
4648 /* MD[a]: Measure Distance */
4649 /* Opcode range: 0x49-0x4A */
4650 /* Stack: uint32 uint32 --> f26.6 */
4651 /* */
4652 /* BULLSHIT: Measure taken in the original glyph must be along the dual */
4653 /* projection vector. */
4654 /* */
4655 /* Second BULLSHIT: Flag attributes are inverted! */
4656 /* 0 => measure distance in original outline */
4657 /* 1 => measure distance in grid-fitted outline */
4658 /* */
4659 /* Third one: `zp0 - zp1', and not `zp2 - zp1! */
4660 /* */
4661 static void
4663 {
4665 FT_F26Dot6 D;
4673 {
4675 {
4678 }
4680 }
4681 else
4682 {
4685 else
4687 }
4690 }
4693 /*************************************************************************/
4694 /* */
4695 /* SDPVTL[a]: Set Dual PVector to Line */
4696 /* Opcode range: 0x86-0x87 */
4697 /* Stack: uint32 uint32 --> */
4698 /* */
4699 static void
4701 {
4711 {
4715 }
4717 {
4724 }
4727 {
4731 }
4735 {
4742 }
4745 {
4749 }
4754 }
4757 /*************************************************************************/
4758 /* */
4759 /* SZP0[]: Set Zone Pointer 0 */
4760 /* Opcode range: 0x13 */
4761 /* Stack: uint32 --> */
4762 /* */
4763 static void
4765 {
4767 {
4780 }
4783 }
4786 /*************************************************************************/
4787 /* */
4788 /* SZP1[]: Set Zone Pointer 1 */
4789 /* Opcode range: 0x14 */
4790 /* Stack: uint32 --> */
4791 /* */
4792 static void
4794 {
4796 {
4809 }
4812 }
4815 /*************************************************************************/
4816 /* */
4817 /* SZP2[]: Set Zone Pointer 2 */
4818 /* Opcode range: 0x15 */
4819 /* Stack: uint32 --> */
4820 /* */
4821 static void
4823 {
4825 {
4838 }
4841 }
4844 /*************************************************************************/
4845 /* */
4846 /* SZPS[]: Set Zone PointerS */
4847 /* Opcode range: 0x16 */
4848 /* Stack: uint32 --> */
4849 /* */
4850 static void
4852 {
4854 {
4867 }
4875 }
4878 /*************************************************************************/
4879 /* */
4880 /* INSTCTRL[]: INSTruction ConTRoL */
4881 /* Opcode range: 0x8e */
4882 /* Stack: int32 int32 --> */
4883 /* */
4884 static void
4886 {
4894 {
4898 }
4905 }
4908 /*************************************************************************/
4909 /* */
4910 /* SCANCTRL[]: SCAN ConTRoL */
4911 /* Opcode range: 0x85 */
4912 /* Stack: uint32? --> */
4913 /* */
4914 static void
4916 {
4917 FT_Int A;
4920 /* Get Threshold */
4924 {
4927 }
4929 {
4932 }
4936 #if 0
4939 #endif
4947 #if 0
4950 #endif
4957 }
4960 /*************************************************************************/
4961 /* */
4962 /* SCANTYPE[]: SCAN TYPE */
4963 /* Opcode range: 0x8D */
4964 /* Stack: uint32? --> */
4965 /* */
4966 static void
4968 {
4969 /* for compatibility with future enhancements, */
4970 /* we must ignore new modes */
4973 {
4978 }
4979 }
4982 /*************************************************************************/
4983 /* */
4984 /* MANAGING OUTLINES */
4985 /* */
4986 /* Instructions appear in the specification's order. */
4987 /* */
4988 /*************************************************************************/
4991 /*************************************************************************/
4992 /* */
4993 /* FLIPPT[]: FLIP PoinT */
4994 /* Opcode range: 0x80 */
4995 /* Stack: uint32... --> */
4996 /* */
4997 static void
4999 {
5000 FT_UShort point;
5002 FT_UNUSED_ARG;
5006 {
5009 }
5012 {
5018 {
5020 {
5023 }
5024 }
5025 else
5029 }
5033 }
5036 /*************************************************************************/
5037 /* */
5038 /* FLIPRGON[]: FLIP RanGe ON */
5039 /* Opcode range: 0x81 */
5040 /* Stack: uint32 uint32 --> */
5041 /* */
5042 static void
5044 {
5053 {
5057 }
5061 }
5064 /*************************************************************************/
5065 /* */
5066 /* FLIPRGOFF: FLIP RanGe OFF */
5067 /* Opcode range: 0x82 */
5068 /* Stack: uint32 uint32 --> */
5069 /* */
5070 static void
5072 {
5081 {
5085 }
5089 }
5092 static FT_Bool
5095 TT_GlyphZone zone,
5097 {
5098 TT_GlyphZoneRec zp;
5099 FT_UShort p;
5100 FT_F26Dot6 d;
5104 {
5107 }
5108 else
5109 {
5112 }
5115 {
5119 }
5126 #ifdef NO_APPLE_PATENT
5131 #else
5143 }
5146 static void
5148 FT_F26Dot6 dx,
5149 FT_F26Dot6 dy,
5150 FT_Bool touch )
5151 {
5153 {
5157 }
5160 {
5164 }
5165 }
5168 /*************************************************************************/
5169 /* */
5170 /* SHP[a]: SHift Point by the last point */
5171 /* Opcode range: 0x32-0x33 */
5172 /* Stack: uint32... --> */
5173 /* */
5174 static void
5176 {
5177 TT_GlyphZoneRec zp;
5178 FT_UShort refp;
5180 FT_F26Dot6 dx,
5181 dy;
5182 FT_UShort point;
5184 FT_UNUSED_ARG;
5188 {
5191 }
5197 {
5202 {
5204 {
5207 }
5208 }
5209 else
5210 /* XXX: UNDOCUMENTED! SHP touches the points */
5214 }
5218 }
5221 /*************************************************************************/
5222 /* */
5223 /* SHC[a]: SHift Contour */
5224 /* Opcode range: 0x34-35 */
5225 /* Stack: uint32 --> */
5226 /* */
5227 static void
5229 {
5230 TT_GlyphZoneRec zp;
5231 FT_UShort refp;
5232 FT_F26Dot6 dx,
5233 dy;
5235 FT_Short contour;
5242 {
5246 }
5253 else
5258 /* XXX: this is probably wrong... at least it prevents memory */
5259 /* corruption when zp2 is the twilight zone */
5261 {
5264 else
5266 }
5268 /* XXX: UNDOCUMENTED! SHC doesn't touch the points */
5270 {
5273 }
5274 }
5277 /*************************************************************************/
5278 /* */
5279 /* SHZ[a]: SHift Zone */
5280 /* Opcode range: 0x36-37 */
5281 /* Stack: uint32 --> */
5282 /* */
5283 static void
5285 {
5286 TT_GlyphZoneRec zp;
5287 FT_UShort refp;
5288 FT_F26Dot6 dx,
5289 dy;
5295 {
5299 }
5306 else
5309 /* XXX: UNDOCUMENTED! SHZ doesn't touch the points */
5311 {
5314 }
5315 }
5318 /*************************************************************************/
5319 /* */
5320 /* SHPIX[]: SHift points by a PIXel amount */
5321 /* Opcode range: 0x38 */
5322 /* Stack: f26.6 uint32... --> */
5323 /* */
5324 static void
5326 {
5328 FT_UShort point;
5332 {
5335 }
5341 {
5347 {
5349 {
5352 }
5353 }
5354 else
5358 }
5362 }
5365 /*************************************************************************/
5366 /* */
5367 /* MSIRP[a]: Move Stack Indirect Relative Position */
5368 /* Opcode range: 0x3A-0x3B */
5369 /* Stack: f26.6 uint32 --> */
5370 /* */
5371 static void
5373 {
5374 FT_UShort point;
5375 FT_F26Dot6 distance;
5382 {
5386 }
5388 /* XXX: UNDOCUMENTED! behaviour */
5390 {
5393 }
5405 }
5408 /*************************************************************************/
5409 /* */
5410 /* MDAP[a]: Move Direct Absolute Point */
5411 /* Opcode range: 0x2E-0x2F */
5412 /* Stack: uint32 --> */
5413 /* */
5414 static void
5416 {
5417 FT_UShort point;
5418 FT_F26Dot6 cur_dist,
5419 distance;
5425 {
5429 }
5431 /* XXX: Is there some undocumented feature while in the */
5432 /* twilight zone? ? */
5434 {
5438 }
5439 else
5446 }
5449 /*************************************************************************/
5450 /* */
5451 /* MIAP[a]: Move Indirect Absolute Point */
5452 /* Opcode range: 0x3E-0x3F */
5453 /* Stack: uint32 uint32 --> */
5454 /* */
5455 static void
5457 {
5458 FT_ULong cvtEntry;
5459 FT_UShort point;
5460 FT_F26Dot6 distance,
5461 org_dist;
5469 {
5473 }
5475 /* UNDOCUMENTED! */
5476 /* */
5477 /* The behaviour of an MIAP instruction is quite */
5478 /* different when used in the twilight zone. */
5479 /* */
5480 /* First, no control value cutin test is performed */
5481 /* as it would fail anyway. Second, the original */
5482 /* point, i.e. (org_x,org_y) of zp0.point, is set */
5483 /* to the absolute, unrounded distance found in */
5484 /* the CVT. */
5485 /* */
5486 /* This is used in the CVT programs of the Microsoft */
5487 /* fonts Arial, Times, etc., in order to re-adjust */
5488 /* some key font heights. It allows the use of the */
5489 /* IP instruction in the twilight zone, which */
5490 /* otherwise would be `illegal' according to the */
5491 /* specification. */
5492 /* */
5493 /* We implement it with a special sequence for the */
5494 /* twilight zone. This is a bad hack, but it seems */
5495 /* to work. */
5500 {
5504 }
5509 {
5514 }
5520 }
5523 /*************************************************************************/
5524 /* */
5525 /* MDRP[abcde]: Move Direct Relative Point */
5526 /* Opcode range: 0xC0-0xDF */
5527 /* Stack: uint32 --> */
5528 /* */
5529 static void
5531 {
5532 FT_UShort point;
5540 {
5544 }
5546 /* XXX: Is there some undocumented feature while in the */
5547 /* twilight zone? */
5552 /* single width cutin test */
5555 {
5558 else
5560 }
5562 /* round flag */
5566 org_dist,
5568 else
5570 org_dist,
5573 /* minimum distance flag */
5576 {
5578 {
5581 }
5582 else
5583 {
5586 }
5587 }
5589 /* now move the point */
5601 }
5604 /*************************************************************************/
5605 /* */
5606 /* MIRP[abcde]: Move Indirect Relative Point */
5607 /* Opcode range: 0xE0-0xFF */
5608 /* Stack: int32? uint32 --> */
5609 /* */
5610 static void
5612 {
5613 FT_UShort point;
5614 FT_ULong cvtEntry;
5616 FT_F26Dot6 cvt_dist,
5617 distance,
5618 cur_dist,
5619 org_dist;
5625 /* XXX: UNDOCUMENTED! cvt[-1] = 0 always */
5630 {
5634 }
5638 else
5641 /* single width test */
5644 {
5647 else
5649 }
5651 /* XXX: UNDOCUMENTED! -- twilight zone */
5654 {
5662 }
5670 /* auto-flip test */
5673 {
5676 }
5678 /* control value cutin and round */
5681 {
5682 /* XXX: UNDOCUMENTED! Only perform cut-in test when both points */
5683 /* refer to the same zone. */
5690 cvt_dist,
5692 }
5693 else
5695 cvt_dist,
5698 /* minimum distance test */
5701 {
5703 {
5706 }
5707 else
5708 {
5711 }
5712 }
5721 /* XXX: UNDOCUMENTED! */
5724 }
5727 /*************************************************************************/
5728 /* */
5729 /* ALIGNRP[]: ALIGN Relative Point */
5730 /* Opcode range: 0x3C */
5731 /* Stack: uint32 uint32... --> */
5732 /* */
5733 static void
5735 {
5736 FT_UShort point;
5737 FT_F26Dot6 distance;
5739 FT_UNUSED_ARG;
5744 {
5748 }
5751 {
5757 {
5759 {
5762 }
5763 }
5764 else
5765 {
5770 }
5773 }
5777 }
5780 /*************************************************************************/
5781 /* */
5782 /* ISECT[]: moves point to InterSECTion */
5783 /* Opcode range: 0x0F */
5784 /* Stack: 5 * uint32 --> */
5785 /* */
5786 static void
5788 {
5789 FT_UShort point,
5793 FT_F26Dot6 discriminant;
5799 FT_F26Dot6 val;
5801 FT_Vector R;
5816 {
5820 }
5837 {
5845 }
5846 else
5847 {
5848 /* else, take the middle of the middles of A and B */
5858 }
5859 }
5862 /*************************************************************************/
5863 /* */
5864 /* ALIGNPTS[]: ALIGN PoinTS */
5865 /* Opcode range: 0x27 */
5866 /* Stack: uint32 uint32 --> */
5867 /* */
5868 static void
5870 {
5872 FT_F26Dot6 distance;
5880 {
5884 }
5891 }
5894 /*************************************************************************/
5895 /* */
5896 /* IP[]: Interpolate Point */
5897 /* Opcode range: 0x39 */
5898 /* Stack: uint32... --> */
5899 /* */
5900 static void
5902 {
5905 distance;
5906 FT_UShort point;
5908 FT_UNUSED_ARG;
5912 {
5915 }
5917 /* XXX: There are some glyphs in some braindead but popular */
5918 /* fonts out there (e.g. [aeu]grave in monotype.ttf) */
5919 /* calling IP[] with bad values of rp[12]. */
5920 /* Do something sane when this odd thing happens. */
5924 {
5927 }
5928 else
5929 {
5935 }
5938 {
5943 {
5945 {
5948 }
5949 }
5950 else
5951 {
5965 else
5966 /* note: it seems that rounding this value isn't a good */
5967 /* idea (cf. width of capital `S' in Times) */
5974 }
5977 }
5981 }
5984 /*************************************************************************/
5985 /* */
5986 /* UTP[a]: UnTouch Point */
5987 /* Opcode range: 0x29 */
5988 /* Stack: uint32 --> */
5989 /* */
5990 static void
5992 {
5993 FT_UShort point;
5994 FT_Byte mask;
6000 {
6004 }
6015 }
6018 /* Local variables for Ins_IUP: */
6019 struct LOC_Ins_IUP
6020 {
6023 };
6026 static void
6028 FT_UInt p2,
6029 FT_UInt p,
6031 {
6032 FT_UInt i;
6033 FT_F26Dot6 x;
6043 }
6046 static void
6048 FT_UInt p2,
6049 FT_UInt ref1,
6050 FT_UInt ref2,
6052 {
6053 FT_UInt i;
6066 {
6068 {
6073 else
6077 }
6079 }
6082 {
6084 {
6089 else
6090 {
6093 else
6098 }
6100 }
6102 }
6104 /* x2 < x1 */
6107 {
6111 else
6112 {
6115 else
6120 }
6122 }
6123 }
6126 /*************************************************************************/
6127 /* */
6128 /* IUP[a]: Interpolate Untouched Points */
6129 /* Opcode range: 0x30-0x31 */
6130 /* Stack: --> */
6131 /* */
6132 static void
6134 {
6136 FT_Byte mask;
6147 FT_UNUSED_ARG;
6151 {
6155 }
6156 else
6157 {
6161 }
6166 do
6167 {
6172 point++;
6175 {
6179 point++;
6182 {
6184 {
6188 cur_touched,
6189 point,
6192 }
6194 point++;
6195 }
6199 else
6200 {
6202 end_point,
6203 cur_touched,
6204 first_touched,
6210 cur_touched,
6211 first_touched,
6213 }
6214 }
6215 contour++;
6217 }
6220 /*************************************************************************/
6221 /* */
6222 /* DELTAPn[]: DELTA exceptions P1, P2, P3 */
6223 /* Opcode range: 0x5D,0x71,0x72 */
6224 /* Stack: uint32 (2 * uint32)... --> */
6225 /* */
6226 static void
6228 {
6230 FT_UShort A;
6231 FT_ULong C;
6232 FT_Long B;
6236 than once, thus UShort isn't enough */
6239 {
6241 {
6244 }
6251 /* XXX: Because some popular fonts contain some invalid DeltaP */
6252 /* instructions, we simply ignore them when the stacked */
6253 /* point reference is off limit, rather than returning an */
6254 /* error. As a delta instruction doesn't change a glyph */
6255 /* in great ways, this shouldn't be a problem. */
6258 {
6262 {
6273 }
6278 {
6281 B++;
6285 }
6286 }
6287 else
6290 }
6293 }
6296 /*************************************************************************/
6297 /* */
6298 /* DELTACn[]: DELTA exceptions C1, C2, C3 */
6299 /* Opcode range: 0x73,0x74,0x75 */
6300 /* Stack: uint32 (2 * uint32)... --> */
6301 /* */
6302 static void
6304 {
6307 FT_Long B;
6313 {
6315 {
6318 }
6326 {
6328 {
6331 }
6332 }
6333 else
6334 {
6338 {
6349 }
6354 {
6357 B++;
6361 }
6362 }
6363 }
6366 }
6369 /*************************************************************************/
6370 /* */
6371 /* MISC. INSTRUCTIONS */
6372 /* */
6373 /*************************************************************************/
6376 /*************************************************************************/
6377 /* */
6378 /* GETINFO[]: GET INFOrmation */
6379 /* Opcode range: 0x88 */
6380 /* Stack: uint32 --> uint32 */
6381 /* */
6382 /* XXX: According to Apple specs, bits 1 & 2 of the argument ought to be */
6383 /* consulted before rotated/stretched info is returned. */
6384 static void
6386 {
6387 FT_Long K;
6392 /* We return then Windows 3.1 version number */
6393 /* for the font scaler */
6397 /* Has the glyph been rotated ? */
6401 /* Has the glyph been stretched ? */
6406 }
6409 static void
6411 {
6415 FT_UNUSED_ARG;
6419 {
6421 {
6426 {
6429 }
6442 }
6443 }
6446 }
6449 #ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
6452 static
6454 {
6455 /* Opcodes are gathered in groups of 16. */
6456 /* Please keep the spaces as they are. */
6728 /* MIRP[31] */ Ins_MIRP
6729 };
6735 /*************************************************************************/
6736 /* */
6737 /* RUN */
6738 /* */
6739 /* This function executes a run of opcodes. It will exit in the */
6740 /* following cases: */
6741 /* */
6742 /* - Errors (in which case it returns FALSE). */
6743 /* */
6744 /* - Reaching the end of the main code range (returns TRUE). */
6745 /* Reaching the end of a code range within a function call is an */
6746 /* error. */
6747 /* */
6748 /* - After executing one single opcode, if the flag `Instruction_Trap' */
6749 /* is set to TRUE (returns TRUE). */
6750 /* */
6751 /* On exit whith TRUE, test IP < CodeSize to know wether it comes from */
6752 /* an instruction trap or a normal termination. */
6753 /* */
6754 /* */
6755 /* Note: The documented DEBUG opcode pops a value from the stack. This */
6756 /* behaviour is unsupported; here a DEBUG opcode is always an */
6757 /* error. */
6758 /* */
6759 /* */
6760 /* THIS IS THE INTERPRETER'S MAIN LOOP. */
6761 /* */
6762 /* Instructions appear in the specification's order. */
6763 /* */
6764 /*************************************************************************/
6767 /* documentation is in ttinterp.h */
6771 {
6775 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
6777 #endif
6779 /* set CVT functions */
6782 {
6783 /* non-square pixels, use the stretched routines */
6787 }
6788 else
6789 {
6790 /* square pixels, use normal routines */
6794 }
6799 do
6800 {
6804 {
6809 }
6814 /* First, let's check for empty stack and overflow */
6817 /* `args' is the top of the stack once arguments have been popped. */
6818 /* One can also interpret it as the index of the last argument. */
6820 {
6823 }
6827 /* `new_top' is the new top of the stack, after the instruction's */
6828 /* execution. `top' will be set to `new_top' after the `switch' */
6829 /* statement. */
6831 {
6834 }
6839 #ifdef TT_CONFIG_OPTION_INTERPRETER_SWITCH
6841 {
6846 #undef ARRAY_BOUND_ERROR
6847 #define ARRAY_BOUND_ERROR goto Set_Invalid_Ref
6851 {
6858 {
6866 {
6872 }
6875 {
6878 }
6881 }
6886 DO_SPVTL
6891 DO_SFVTL
6895 DO_SPVFS
6899 DO_SFVFS
6903 DO_GPV
6907 DO_GFV
6911 DO_SFVTPV
6919 DO_SRP0
6923 DO_SRP1
6927 DO_SRP2
6947 DO_SLOOP
6951 DO_RTG
6955 DO_RTHG
6959 DO_SMD
6967 DO_JMPR
6971 DO_SCVTCI
6975 DO_SSWCI
6979 DO_SSW
6983 DO_DUP
6987 /* nothing :-) */
6991 DO_CLEAR
6995 DO_SWAP
6999 DO_DEPTH
7003 DO_CINDEX
7082 DO_RTDG
7099 DO_WS
7102 Set_Invalid_Ref:
7107 DO_RS
7111 DO_WCVTP
7115 DO_RCVT
7133 DO_MPPEM
7137 DO_MPS
7141 DO_FLIPON
7145 DO_FLIPOFF
7149 DO_DEBUG
7153 DO_LT
7157 DO_LTEQ
7161 DO_GT
7165 DO_GTEQ
7169 DO_EQ
7173 DO_NEQ
7177 DO_ODD
7181 DO_EVEN
7189 /* do nothing */
7193 DO_AND
7197 DO_OR
7201 DO_NOT
7209 DO_SDB
7213 DO_SDS
7217 DO_ADD
7221 DO_SUB
7225 DO_DIV
7229 DO_MUL
7233 DO_ABS
7237 DO_NEG
7241 DO_FLOOR
7245 DO_CEILING
7252 DO_ROUND
7259 DO_NROUND
7263 DO_WCVTF
7278 DO_SROUND
7282 DO_S45ROUND
7286 DO_JROT
7290 DO_JROF
7294 DO_ROFF
7302 DO_RUTG
7306 DO_RDTG
7311 /* nothing - obsolete */
7353 DO_MAX
7357 DO_MIN
7381 else
7383 }
7385 }
7387 #else
7394 {
7396 {
7398 {
7404 {
7406 {
7411 {
7414 }
7427 }
7428 }
7429 }
7434 #if 0
7436 /* Leave to remind in case a later change the editor */
7437 /* to consider break; */
7438 #endif
7443 #if 0
7445 #endif
7446 }
7447 }
7454 /* increment instruction counter and check if we didn't */
7455 /* run this program for too long (e.g. infinite loops). */
7459 LSuiteLabel_:
7461 {
7463 {
7466 }
7467 else
7469 }
7472 LNo_Error_:
7474 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
7476 #endif
7480 LErrorCodeOverflow_:
7483 LErrorLabel_:
7485 #ifdef TT_CONFIG_OPTION_STATIC_RASTER
7487 #endif
7490 }
7496 /* END */