| blob | 8a3203550ef544aabb6e46d66586e562d20b0aa7 |
1 /* tafpgm.c */
3 /*
4 * Copyright (C) 2011-2014 by Werner Lemberg.
5 *
6 * This file is part of the ttfautohint library, and may only be used,
7 * modified, and distributed under the terms given in `COPYING'. By
8 * continuing to use, modify, or distribute this file you indicate that you
9 * have read `COPYING' and understand and accept it fully.
10 *
11 * The file `COPYING' mentioned in the previous paragraph is distributed
12 * with the ttfautohint library.
13 */
19 /* we need the following macro */
20 /* so that `func_name' doesn't get replaced with its #defined value */
21 /* (as defined in `tabytecode.h') */
23 #define FPGM(func_name) fpgm_ ## func_name
26 /*
27 * Due to a bug in FreeType up to and including version 2.4.7,
28 * it is not possible to use MD_orig with twilight points.
29 * We circumvent this by using GC_orig.
30 */
31 #define MD_orig_fixed \
32 GC_orig, \
33 SWAP, \
34 GC_orig, \
35 SWAP, \
36 SUB
38 #define MD_orig_ZP2_0 \
39 MD_orig_fixed
41 #define MD_orig_ZP2_1 \
42 PUSHB_1, \
43 0, \
44 SZP2, \
45 MD_orig_fixed, \
46 PUSHB_1, \
47 1, \
48 SZP2
51 /*
52 * Older versions of Monotype's `iType' bytecode interpreter have a serious
53 * bug: The DIV instruction rounds the result, while the correct operation
54 * is truncation. (Note, however, that MUL always rounds the result.)
55 * Since many printers contain this rasterizer without any possibility to
56 * update to a non-buggy version, we have to work around the problem.
57 *
58 * DIV and MUL work on 26.6 numbers which means that the numerator gets
59 * multiplied by 64 before the division, and the product gets divided by 64
60 * after the multiplication, respectively. For example, to divide 2 by 3,
61 * you have to write
62 *
63 * PUSHB_1,
64 * 2,
65 * 3*64,
66 * DIV
67 *
68 * The correct formula to divide two values in 26.6 format with truncation
69 * is
70 *
71 * a*64 / b ,
72 *
73 * while older `iType' versions incorrectly apply rounding by using
74 *
75 * (a*64 + b/2) / b .
76 *
77 * Doing our 2/3 division, we have a=2 and b=3*64, so we get
78 *
79 * (2*64 + (3*64)/2) / (3*64) = 1
80 *
81 * instead of the correct result 0.
82 *
83 * The solution to the rounding issue is to use a 26.6 value as an
84 * intermediate result so that we can truncate to the nearest integer (in
85 * 26.6 format) with the FLOOR operator before converting back to a plain
86 * integer (in 32.0 format).
87 *
88 * For the common divisions by 2 and 2^10 we define macros.
89 */
90 #define DIV_POS_BY_2 \
91 PUSHB_1, \
92 2, \
94 FLOOR, \
95 PUSHB_1, \
96 1, \
99 #define DIV_BY_2 \
100 PUSHB_1, \
101 2, \
102 DIV, \
103 DUP, \
104 PUSHB_1, \
105 0, \
106 LT, \
107 IF, \
108 PUSHB_1, \
109 64, \
111 EIF, \
112 FLOOR, \
113 PUSHB_1, \
114 1, \
115 MUL
117 #define DIV_BY_1024 \
118 PUSHW_1, \
120 0x00, \
121 DIV, \
122 DUP, \
123 PUSHB_1, \
124 0, \
125 LT, \
126 IF, \
127 PUSHB_1, \
128 64, \
129 ADD, \
130 EIF, \
131 FLOOR, \
132 PUSHB_1, \
133 1, \
134 MUL
137 /* a convenience shorthand for scaling; see `bci_cvt_rescale' for details */
138 #define DO_SCALE \
140 PUSHB_1, \
141 sal_scale, \
142 RS, \
148 /* in the comments below, the top of the stack (`s:') */
149 /* is the rightmost element; the stack is shown */
150 /* after the instruction on the same line has been executed */
153 /*
154 * bci_align_top
155 *
156 * Optimize the alignment of the top of small letters to the pixel grid.
157 *
158 * This function gets used in the `prep' table.
159 *
160 * in: blue_idx (CVT index for the style's top of small letters blue zone)
161 *
162 * sal: sal_i (CVT index of the style's scaling value;
163 * gets incremented by 1 after execution)
164 */
167 {
169 PUSHB_1,
170 bci_align_top,
171 FDEF,
173 /* only get CVT value for non-zero index */
174 DUP,
175 PUSHB_1,
177 NEQ,
178 IF,
179 RCVT,
180 EIF,
181 DUP,
184 };
186 /* if (font->increase_x_height) */
187 /* { */
190 {
192 /* apply much `stronger' rounding up of x height for */
193 /* 6 <= PPEM <= increase_x_height */
194 MPPEM,
195 PUSHW_1,
197 };
199 /* %d, x height increase limit */
202 {
204 LTEQ,
205 MPPEM,
206 PUSHB_1,
208 GTEQ,
209 AND,
210 IF,
211 PUSHB_1,
214 ELSE,
215 PUSHB_1,
218 EIF,
219 ADD,
222 };
224 /* } */
226 /* if (!font->increase_x_height) */
227 /* { */
230 {
232 PUSHB_1,
234 ADD,
237 };
239 /* } */
242 {
245 ROLL,
246 NEQ,
248 PUSHB_1,
250 CINDEX,
252 PUSHW_2,
259 SWAP,
262 ELSE,
263 POP,
264 POP,
265 PUSHB_1,
268 EIF,
270 PUSHB_1,
271 sal_i,
273 SWAP,
274 WCVTP,
276 PUSHB_3,
277 sal_i,
279 sal_i,
280 RS,
282 WS,
284 ENDF,
286 };
289 /*
290 * bci_round
291 *
292 * Round a 26.6 number. Contrary to the ROUND bytecode instruction, no
293 * engine specific corrections are applied.
294 *
295 * in: val
296 *
297 * out: ROUND(val)
298 */
301 {
303 PUSHB_1,
304 bci_round,
305 FDEF,
307 PUSHB_1,
309 ADD,
310 FLOOR,
312 ENDF,
314 };
317 /*
318 * bci_smooth_stem_width
319 *
320 * This is the equivalent to the following code from function
321 * `ta_latin_compute_stem_width':
322 *
323 * dist = ABS(width)
324 *
325 * if (stem_is_serif
326 * && dist < 3*64)
327 * || std_width < 40:
328 * return width
329 * else if base_is_round:
330 * if dist < 80:
331 * dist = 64
332 * else if dist < 56:
333 * dist = 56
334 *
335 * delta = ABS(dist - std_width)
336 *
337 * if delta < 40:
338 * dist = std_width
339 * if dist < 48:
340 * dist = 48
341 * goto End
342 *
343 * if dist < 3*64:
344 * delta = dist
345 * dist = FLOOR(dist)
346 * delta = delta - dist
347 *
348 * if delta < 10:
349 * dist = dist + delta
350 * else if delta < 32:
351 * dist = dist + 10
352 * else if delta < 54:
353 * dist = dist + 54
354 * else:
355 * dist = dist + delta
356 * else:
357 * dist = ROUND(dist)
358 *
359 * End:
360 * if width < 0:
361 * dist = -dist
362 * return dist
363 *
364 * in: width
365 * stem_is_serif
366 * base_is_round
367 *
368 * out: new_width
369 *
370 * sal: sal_vwidth_data_offset
371 *
372 * CVT: std_width
373 *
374 * uses: bci_round
375 */
378 {
380 PUSHB_1,
381 bci_smooth_stem_width,
382 FDEF,
384 DUP,
387 DUP,
388 PUSHB_1,
392 PUSHB_1,
397 PUSHB_3,
400 sal_vwidth_data_offset,
401 RS,
409 POP,
410 SWAP,
413 ELSE,
416 DUP,
417 PUSHB_1,
421 POP,
422 PUSHB_1,
424 EIF,
426 ELSE,
427 DUP,
428 PUSHB_1,
432 POP,
433 PUSHB_1,
435 EIF,
436 EIF,
439 PUSHB_2,
441 sal_vwidth_data_offset,
442 RS,
446 SUB,
449 PUSHB_1,
453 POP,
454 PUSHB_2,
456 sal_vwidth_data_offset,
457 RS,
461 DUP,
462 PUSHB_1,
465 IF,
466 POP,
467 PUSHB_1,
469 EIF,
471 ELSE,
473 PUSHB_1,
476 IF,
480 ROLL,
485 PUSHB_1,
491 ELSE,
492 DUP,
493 PUSHB_1,
496 IF,
497 POP,
498 PUSHB_1,
502 ELSE,
503 DUP,
504 PUSHB_1,
507 IF,
508 POP,
509 PUSHB_1,
513 ELSE,
516 EIF,
517 EIF,
518 EIF,
520 ELSE,
521 PUSHB_1,
522 bci_round,
525 EIF,
526 EIF,
529 PUSHB_1,
532 IF,
534 EIF,
535 EIF,
537 ENDF,
539 };
542 /*
543 * bci_get_best_width
544 *
545 * An auxiliary function for `bci_strong_stem_width'.
546 *
547 * in: n (initialized with CVT index for first vertical width)
548 * dist
549 *
550 * out: n+1
551 * dist
552 *
553 * sal: sal_best
554 * sal_ref
555 *
556 * CVT: widths[]
557 */
560 {
562 PUSHB_1,
563 bci_get_best_width,
564 FDEF,
566 DUP,
568 DUP,
569 PUSHB_1,
572 SUB,
574 DUP,
575 PUSHB_1,
576 sal_best,
579 IF,
580 PUSHB_1,
581 sal_best,
582 SWAP,
584 PUSHB_1,
585 sal_ref,
586 SWAP,
589 ELSE,
590 POP,
591 POP,
592 EIF,
594 PUSHB_1,
598 ENDF,
600 };
603 /*
604 * bci_strong_stem_width
605 *
606 * This is the equivalent to the following code (function
607 * `ta_latin_snap_width' and some lines from
608 * `ta_latin_compute_stem_width'):
609 *
610 * best = 64 + 32 + 2
611 * reference = width
612 * dist = ABS(width)
613 *
614 * for n in 0 .. num_widths:
615 * w = widths[n]
616 * d = ABS(dist - w)
617 *
618 * if d < best:
619 * best = d
620 * reference = w
621 *
622 * if dist >= reference:
623 * if dist < ROUND(reference) + 48:
624 * dist = reference
625 * else:
626 * if dist > ROUND(reference) - 48:
627 * dist = reference
628 *
629 * if dist >= 64:
630 * dist = ROUND(dist)
631 * else:
632 * dist = 64
633 *
634 * if width < 0:
635 * dist = -dist
636 * return dist
637 *
638 * in: width
639 * stem_is_serif (unused)
640 * base_is_round (unused)
641 *
642 * out: new_width
643 *
644 * sal: sal_best
645 * sal_ref
646 * sal_vwidth_data_offset
647 *
648 * CVT: widths[]
649 *
650 * uses: bci_get_best_width
651 * bci_round
652 */
655 {
657 PUSHB_1,
658 bci_strong_stem_width,
659 FDEF,
661 SWAP,
662 POP,
663 SWAP,
664 POP,
665 DUP,
668 PUSHB_2,
669 sal_best,
673 DUP,
674 PUSHB_1,
675 sal_ref,
676 SWAP,
679 PUSHB_2,
681 sal_vwidth_data_offset,
682 RS,
683 RCVT,
686 PUSHB_2,
688 sal_vwidth_data_offset,
689 RS,
690 PUSHB_1,
692 };
694 /* %c, number of used styles */
697 {
699 ADD,
703 PUSHB_1,
704 bci_get_best_width,
705 LOOPCALL,
708 DUP,
709 PUSHB_1,
710 sal_ref,
712 DUP,
713 ROLL,
714 DUP,
715 ROLL,
716 PUSHB_1,
717 bci_round,
719 PUSHB_2,
723 PUSHB_1,
729 ADD,
732 ELSE,
733 SUB,
735 EIF,
737 IF,
739 EIF,
740 POP,
742 DUP,
743 PUSHB_1,
746 IF,
747 PUSHB_1,
748 bci_round,
751 ELSE,
752 POP,
753 PUSHB_1,
755 EIF,
758 PUSHB_1,
761 IF,
763 EIF,
765 ENDF,
767 };
770 /*
771 * bci_do_loop
772 *
773 * An auxiliary function for `bci_loop'.
774 *
775 * sal: sal_i (gets incremented by 2 after execution)
776 * sal_func
777 *
778 * uses: func[sal_func]
779 */
782 {
784 PUSHB_1,
785 bci_loop_do,
786 FDEF,
788 PUSHB_1,
789 sal_func,
790 RS,
791 CALL,
793 PUSHB_3,
794 sal_i,
796 sal_i,
797 RS,
799 WS,
801 ENDF,
803 };
806 /*
807 * bci_loop
808 *
809 * Take a range `start'..`end' and a function number and apply the
810 * associated function to the range elements `start', `start+2',
811 * `start+4', ...
812 *
813 * in: func_num
814 * end
815 * start
816 *
817 * sal: sal_i (counter initialized with `start')
818 * sal_func (`func_num')
819 *
820 * uses: bci_loop_do
821 */
824 {
826 PUSHB_1,
827 bci_loop,
828 FDEF,
830 PUSHB_1,
831 sal_func,
832 SWAP,
835 SWAP,
836 DUP,
837 PUSHB_1,
838 sal_i,
839 SWAP,
842 SUB,
843 DIV_POS_BY_2,
844 PUSHB_1,
848 PUSHB_1,
849 bci_loop_do,
850 LOOPCALL,
852 ENDF,
854 };
857 /*
858 * bci_cvt_rescale
859 *
860 * Rescale CVT value by `sal_scale' (in 16.16 format).
861 *
862 * The scaling factor `sal_scale' isn't stored as `b/c' but as `(b-c)/c';
863 * consequently, the calculation `a * b/c' is done as `a + delta' with
864 * `delta = a * (b-c)/c'. This avoids overflow.
865 *
866 * in: cvt_idx
867 *
868 * out: cvt_idx+1
869 *
870 * sal: sal_scale
871 */
874 {
876 PUSHB_1,
877 bci_cvt_rescale,
878 FDEF,
880 DUP,
881 DUP,
882 RCVT,
883 DO_SCALE,
884 WCVTP,
886 PUSHB_1,
888 ADD,
890 ENDF,
892 };
895 /*
896 * bci_cvt_rescale_range
897 *
898 * Rescale a range of CVT values with `bci_cvt_rescale', using a custom
899 * scaling value.
900 *
901 * This function gets used in the `prep' table.
902 *
903 * in: num_cvt
904 * cvt_start_idx
905 *
906 * sal: sal_i (CVT index of the style's scaling value;
907 * gets incremented by 1 after execution)
908 * sal_scale
909 *
910 * uses: bci_cvt_rescale
911 */
914 {
916 PUSHB_1,
917 bci_cvt_rescale_range,
918 FDEF,
920 /* store scaling value in `sal_scale' */
921 PUSHB_3,
922 bci_cvt_rescale,
923 sal_scale,
924 sal_i,
925 RS,
926 RCVT,
929 LOOPCALL,
930 POP,
932 PUSHB_3,
933 sal_i,
935 sal_i,
936 RS,
938 WS,
940 ENDF,
942 };
945 /*
946 * bci_vwidth_data_store
947 *
948 * Store a vertical width array value.
949 *
950 * This function gets used in the `prep' table.
951 *
952 * in: value
953 *
954 * sal: sal_i (CVT index of the style's vwidth data;
955 * gets incremented by 1 after execution)
956 */
959 {
961 PUSHB_1,
962 bci_vwidth_data_store,
963 FDEF,
965 PUSHB_1,
966 sal_i,
967 RS,
968 SWAP,
969 WCVTP,
971 PUSHB_3,
972 sal_i,
974 sal_i,
975 RS,
977 WS,
979 ENDF,
981 };
984 /*
985 * bci_smooth_blue_round
986 *
987 * Round a blue ref value and adjust its corresponding shoot value.
988 *
989 * This is the equivalent to the following code (function
990 * `ta_latin_metrics_scale_dim':
991 *
992 * delta = dist
993 * if dist < 0:
994 * delta = -delta
995 *
996 * if delta < 32:
997 * delta = 0
998 * else if delta < 48:
999 * delta = 32
1000 * else:
1001 * delta = 64
1002 *
1003 * if dist < 0:
1004 * delta = -delta
1005 *
1006 * in: ref_idx
1007 *
1008 * sal: sal_i (number of blue zones)
1009 *
1010 * out: ref_idx+1
1011 *
1012 * uses: bci_round
1013 */
1016 {
1018 PUSHB_1,
1019 bci_smooth_blue_round,
1020 FDEF,
1022 DUP,
1023 DUP,
1026 DUP,
1027 PUSHB_1,
1028 bci_round,
1029 CALL,
1032 PUSHB_1,
1033 sal_i,
1034 RS,
1035 PUSHB_1,
1037 CINDEX,
1039 DUP,
1043 SWAP,
1045 DUP,
1048 DUP,
1049 PUSHB_1,
1052 IF,
1053 POP,
1054 PUSHB_1,
1057 ELSE,
1058 PUSHB_1,
1061 IF,
1062 PUSHB_1,
1065 ELSE,
1066 PUSHB_1,
1068 EIF,
1069 EIF,
1072 PUSHB_1,
1075 IF,
1077 EIF,
1079 PUSHB_1,
1081 CINDEX,
1082 SWAP,
1085 WCVTP,
1086 WCVTP,
1088 PUSHB_1,
1092 ENDF,
1094 };
1097 /*
1098 * bci_strong_blue_round
1099 *
1100 * Round a blue ref value and adjust its corresponding shoot value.
1101 *
1102 * This is the equivalent to the following code:
1103 *
1104 * delta = dist
1105 * if dist < 0:
1106 * delta = -delta
1107 *
1108 * if delta < 36:
1109 * delta = 0
1110 * else:
1111 * delta = 64
1112 *
1113 * if dist < 0:
1114 * delta = -delta
1115 *
1116 * It doesn't have corresponding code in talatin.c; however, some tests
1117 * have shown that the `smooth' code works just fine for this case also.
1118 *
1119 * in: ref_idx
1120 *
1121 * sal: sal_i (number of blue zones)
1122 *
1123 * out: ref_idx+1
1124 *
1125 * uses: bci_round
1126 */
1129 {
1131 PUSHB_1,
1132 bci_strong_blue_round,
1133 FDEF,
1135 DUP,
1136 DUP,
1139 DUP,
1140 PUSHB_1,
1141 bci_round,
1142 CALL,
1145 PUSHB_1,
1146 sal_i,
1147 RS,
1148 PUSHB_1,
1150 CINDEX,
1152 DUP,
1156 SWAP,
1158 DUP,
1161 PUSHB_1,
1164 IF,
1165 PUSHB_1,
1168 ELSE,
1169 PUSHB_1,
1171 EIF,
1174 PUSHB_1,
1177 IF,
1179 EIF,
1181 PUSHB_1,
1183 CINDEX,
1184 SWAP,
1187 WCVTP,
1188 WCVTP,
1190 PUSHB_1,
1194 ENDF,
1196 };
1199 /*
1200 * bci_blue_round_range
1201 *
1202 * Round a range of blue zones (both reference and shoot values).
1203 *
1204 * This function gets used in the `prep' table.
1205 *
1206 * in: num_blue_zones
1207 * blue_ref_idx
1208 *
1209 * sal: sal_i (holds a copy of `num_blue_zones' for blue rounding function)
1210 *
1211 * uses: bci_smooth_blue_round
1212 * bci_strong_blue_round
1213 */
1216 {
1218 PUSHB_1,
1219 bci_blue_round_range,
1220 FDEF,
1222 DUP,
1223 PUSHB_1,
1224 sal_i,
1225 SWAP,
1226 WS,
1228 /* select blue rounding function based on flag in CVT */
1229 PUSHB_3,
1230 bci_strong_blue_round,
1231 bci_smooth_blue_round,
1232 cvtl_use_strong_functions,
1233 RCVT,
1234 IF,
1235 POP,
1237 ELSE,
1238 SWAP,
1239 POP,
1241 EIF,
1242 LOOPCALL,
1243 POP,
1245 ENDF,
1247 };
1250 /*
1251 * bci_decrement_component_counter
1252 *
1253 * An auxiliary function for composite glyphs.
1254 *
1255 * CVT: cvtl_is_subglyph
1256 */
1259 {
1261 PUSHB_1,
1262 bci_decrement_component_counter,
1263 FDEF,
1265 /* decrement `cvtl_is_subglyph' counter */
1266 PUSHB_2,
1267 cvtl_is_subglyph,
1268 cvtl_is_subglyph,
1269 RCVT,
1270 PUSHB_1,
1272 SUB,
1273 WCVTP,
1275 ENDF,
1277 };
1280 /*
1281 * bci_get_point_extrema
1282 *
1283 * An auxiliary function for `bci_create_segment'.
1284 *
1285 * in: point-1
1286 *
1287 * out: point
1288 *
1289 * sal: sal_point_min
1290 * sal_point_max
1291 */
1294 {
1296 PUSHB_1,
1297 bci_get_point_extrema,
1298 FDEF,
1300 PUSHB_1,
1303 DUP,
1304 DUP,
1306 /* check whether `point' is a new minimum */
1307 PUSHB_1,
1308 sal_point_min,
1310 MD_orig,
1311 /* if distance is negative, we have a new minimum */
1312 PUSHB_1,
1314 LT,
1316 DUP,
1317 PUSHB_1,
1318 sal_point_min,
1319 SWAP,
1320 WS,
1321 EIF,
1323 /* check whether `point' is a new maximum */
1324 PUSHB_1,
1325 sal_point_max,
1327 MD_orig,
1328 /* if distance is positive, we have a new maximum */
1329 PUSHB_1,
1331 GT,
1333 DUP,
1334 PUSHB_1,
1335 sal_point_max,
1336 SWAP,
1337 WS,
1340 ENDF,
1342 };
1345 /*
1346 * bci_nibbles
1347 *
1348 * Pop a byte with two delta arguments in its nibbles and push the
1349 * expanded arguments separately as two bytes.
1350 *
1351 * in: 16 * (end - start) + (start - base)
1352 *
1353 * out: start
1354 * end
1355 *
1356 * sal: sal_base (set to `end' at return)
1357 */
1361 {
1362 PUSHB_1,
1363 bci_nibbles,
1364 FDEF,
1366 DUP,
1369 DIV,
1370 FLOOR,
1371 PUSHB_1,
1374 DUP,
1375 PUSHW_1,
1379 ROLL,
1380 SWAP,
1383 PUSHB_1,
1384 sal_base,
1385 RS,
1387 DUP,
1388 ROLL,
1391 DUP,
1392 PUSHB_1,
1393 sal_base,
1394 SWAP,
1397 SWAP,
1399 ENDF,
1401 };
1404 /*
1405 * bci_number_set_is_element
1406 *
1407 * Pop values from stack until it is empty. If one of them is equal to
1408 * the current PPEM value, set `cvtl_is_element' to 100 (and to 0
1409 * otherwise).
1410 *
1411 * in: ppem_value_1
1412 * ppem_value_2
1413 * ...
1414 *
1415 * CVT: cvtl_is_element
1416 */
1419 {
1421 PUSHB_1,
1422 bci_number_set_is_element,
1423 FDEF,
1425 /* start_loop: */
1426 MPPEM,
1427 EQ,
1428 IF,
1429 PUSHB_2,
1430 cvtl_is_element,
1432 WCVTP,
1433 EIF,
1435 DEPTH,
1436 PUSHB_1,
1438 NEG,
1439 SWAP,
1442 ENDF,
1444 };
1447 /*
1448 * bci_number_set_is_element2
1449 *
1450 * Pop value ranges from stack until it is empty. If one of them contains
1451 * the current PPEM value, set `cvtl_is_element' to 100 (and to 0
1452 * otherwise).
1453 *
1454 * in: ppem_range_1_start
1455 * ppem_range_1_end
1456 * ppem_range_2_start
1457 * ppem_range_2_end
1458 * ...
1459 *
1460 * CVT: cvtl_is_element
1461 */
1464 {
1466 PUSHB_1,
1467 bci_number_set_is_element2,
1468 FDEF,
1470 /* start_loop: */
1471 MPPEM,
1472 LTEQ,
1473 IF,
1474 MPPEM,
1475 GTEQ,
1476 IF,
1477 PUSHB_2,
1478 cvtl_is_element,
1480 WCVTP,
1481 EIF,
1482 ELSE,
1483 POP,
1484 EIF,
1486 DEPTH,
1487 PUSHB_1,
1489 NEG,
1490 SWAP,
1493 ENDF,
1495 };
1498 /*
1499 * bci_create_segment
1500 *
1501 * Store start and end point of a segment in the storage area,
1502 * then construct a point in the twilight zone to represent it.
1503 *
1504 * This function is used by `bci_create_segments'.
1505 *
1506 * in: start
1507 * end
1508 * [last (if wrap-around segment)]
1509 * [first (if wrap-around segment)]
1510 *
1511 * sal: sal_i (start of current segment)
1512 * sal_j (current twilight point)
1513 * sal_point_min
1514 * sal_point_max
1515 * sal_base
1516 * sal_num_packed_segments
1517 * sal_scale
1518 *
1519 * CVT: cvtl_temp
1520 *
1521 * uses: bci_get_point_extrema
1522 * bci_nibbles
1523 *
1524 * If `sal_num_packed_segments' is > 0, the start/end pair is stored as
1525 * delta values in nibbles (without a wrap-around segment).
1526 */
1529 {
1531 PUSHB_1,
1532 bci_create_segment,
1533 FDEF,
1535 PUSHB_2,
1537 sal_num_packed_segments,
1538 RS,
1539 NEQ,
1540 IF,
1541 PUSHB_2,
1542 sal_num_packed_segments,
1543 sal_num_packed_segments,
1544 RS,
1545 PUSHB_1,
1547 SUB,
1550 PUSHB_1,
1551 bci_nibbles,
1552 CALL,
1553 EIF,
1555 PUSHB_1,
1556 sal_i,
1557 RS,
1558 PUSHB_1,
1560 CINDEX,
1563 /* initialize inner loop(s) */
1564 PUSHB_2,
1565 sal_point_min,
1567 CINDEX,
1569 PUSHB_2,
1570 sal_point_max,
1572 CINDEX,
1575 PUSHB_1,
1579 SWAP,
1580 DUP,
1581 PUSHB_1,
1585 IF,
1586 /* we have a wrap-around segment with two more arguments */
1587 /* to give the last and first point of the contour, respectively; */
1588 /* our job is to store a segment `start'-`last', */
1589 /* and to get extrema for the two segments */
1590 /* `start'-`last' and `first'-`end' */
1592 /* s: first last start end */
1593 PUSHB_2,
1595 sal_i,
1596 RS,
1597 ADD,
1598 PUSHB_1,
1600 CINDEX,
1603 ROLL,
1605 DUP,
1606 ROLL,
1610 PUSHB_1,
1611 bci_get_point_extrema,
1612 LOOPCALL,
1613 /* clean up stack */
1614 POP,
1617 PUSHB_1,
1619 SUB,
1620 DUP,
1622 SWAP,
1625 PUSHB_1,
1626 bci_get_point_extrema,
1627 LOOPCALL,
1628 /* clean up stack */
1629 POP,
1632 PUSHB_2,
1634 sal_i,
1635 RS,
1636 ADD,
1637 PUSHB_1,
1639 CINDEX,
1642 PUSHB_1,
1644 CINDEX,
1647 PUSHB_1,
1648 bci_get_point_extrema,
1649 LOOPCALL,
1650 /* clean up stack */
1651 POP,
1652 EIF,
1654 /* the twilight point representing a segment */
1655 /* is in the middle between the minimum and maximum */
1656 PUSHB_1,
1657 sal_point_min,
1658 RS,
1659 GC_orig,
1660 PUSHB_1,
1661 sal_point_max,
1662 RS,
1663 GC_orig,
1664 ADD,
1669 /* write it to temporary CVT location */
1670 PUSHB_2,
1671 cvtl_temp,
1674 SWAP,
1675 WCVTP,
1677 /* create twilight point with index `sal_j' */
1678 PUSHB_1,
1679 sal_j,
1680 RS,
1681 PUSHB_1,
1682 cvtl_temp,
1683 MIAP_noround,
1685 PUSHB_3,
1686 sal_j,
1688 sal_j,
1689 RS,
1691 WS,
1693 ENDF,
1695 };
1698 /*
1699 * bci_create_segments
1700 *
1701 * This is the top-level entry function.
1702 *
1703 * It pops point ranges from the stack to define segments, computes
1704 * twilight points to represent segments, and finally calls
1705 * `bci_hint_glyph' to handle the rest.
1706 *
1707 * The second argument (`data_offset') addresses three CVT arrays in
1708 * parallel:
1709 *
1710 * CVT(data_offset):
1711 * the current style's scaling value (stored in `sal_scale')
1712 *
1713 * data_offset + num_used_styles:
1714 * offset to the current style's vwidth index array (this value gets
1715 * stored in `sal_vwidth_data_offset')
1716 *
1717 * data_offset + 2*num_used_styles:
1718 * offset to the current style's vwidth size
1719 *
1720 * This addressing scheme ensures that (a) we only need a single argument,
1721 * and (b) this argument supports up to (256-cvtl_max_runtime) styles,
1722 * which should be sufficient for a long time.
1723 *
1724 * in: num_packed_segments
1725 * data_offset
1726 * num_segments (N)
1727 * segment_start_0
1728 * segment_end_0
1729 * [contour_last 0 (if wrap-around segment)]
1730 * [contour_first 0 (if wrap-around segment)]
1731 * segment_start_1
1732 * segment_end_1
1733 * [contour_last 0 (if wrap-around segment)]
1734 * [contour_first 0 (if wrap-around segment)]
1735 * ...
1736 * segment_start_(N-1)
1737 * segment_end_(N-1)
1738 * [contour_last (N-1) (if wrap-around segment)]
1739 * [contour_first (N-1) (if wrap-around segment)]
1740 * ... stuff for bci_hint_glyph ...
1741 *
1742 * sal: sal_i (start of current segment)
1743 * sal_j (current twilight point)
1744 * sal_num_packed_segments
1745 * sal_base (the base for delta values in nibbles)
1746 * sal_vwidth_data_offset
1747 * sal_scale
1748 *
1749 * CVT: cvtl_is_subglyph
1750 *
1751 * uses: bci_create_segment
1752 * bci_loop
1753 * bci_hint_glyph
1754 *
1755 * If `num_packed_segments' is set to p, the first p start/end pairs are
1756 * stored as delta values in nibbles, with the `start' delta in the lower
1757 * nibble (and there are no wrap-around segments). For example, if the
1758 * first three pairs are 1/3, 5/8, and 12/13, the topmost three bytes on the
1759 * stack are 0x21, 0x32, and 0x14.
1760 *
1761 */
1764 {
1766 PUSHB_1,
1767 bci_create_segments,
1768 FDEF,
1770 /* all our measurements are taken along the y axis */
1771 SVTCA_y,
1773 /* only do something if we are not a subglyph */
1774 PUSHB_2,
1776 cvtl_is_subglyph,
1777 RCVT,
1778 EQ,
1779 IF,
1780 PUSHB_1,
1781 sal_num_packed_segments,
1782 SWAP,
1783 WS,
1785 DUP,
1786 RCVT,
1787 PUSHB_1,
1789 SWAP,
1790 WS,
1792 PUSHB_1,
1793 sal_vwidth_data_offset,
1794 SWAP,
1795 PUSHB_1,
1797 };
1799 /* %c, number of used styles */
1802 {
1804 ADD,
1807 DUP,
1808 ADD,
1809 PUSHB_1,
1813 PUSHB_6,
1814 sal_segment_offset,
1815 sal_segment_offset,
1817 sal_j,
1819 sal_base,
1824 ROLL,
1827 PUSHB_2,
1828 bci_create_segment,
1829 bci_loop,
1830 CALL,
1832 PUSHB_1,
1833 bci_hint_glyph,
1834 CALL,
1836 };
1838 /* used if we have delta exceptions */
1841 {
1843 PUSHB_1,
1845 SZPS,
1847 };
1850 {
1852 ELSE,
1853 CLEAR,
1854 EIF,
1856 ENDF,
1858 };
1861 /*
1862 * bci_create_segments_X
1863 *
1864 * Top-level routines for calling `bci_create_segments'.
1865 */
1868 {
1870 PUSHB_1,
1871 bci_create_segments_0,
1872 FDEF,
1874 PUSHB_2,
1876 bci_create_segments,
1877 CALL,
1879 ENDF,
1881 };
1884 {
1886 PUSHB_1,
1887 bci_create_segments_1,
1888 FDEF,
1890 PUSHB_2,
1892 bci_create_segments,
1893 CALL,
1895 ENDF,
1897 };
1900 {
1902 PUSHB_1,
1903 bci_create_segments_2,
1904 FDEF,
1906 PUSHB_2,
1908 bci_create_segments,
1909 CALL,
1911 ENDF,
1913 };
1916 {
1918 PUSHB_1,
1919 bci_create_segments_3,
1920 FDEF,
1922 PUSHB_2,
1924 bci_create_segments,
1925 CALL,
1927 ENDF,
1929 };
1932 {
1934 PUSHB_1,
1935 bci_create_segments_4,
1936 FDEF,
1938 PUSHB_2,
1940 bci_create_segments,
1941 CALL,
1943 ENDF,
1945 };
1948 {
1950 PUSHB_1,
1951 bci_create_segments_5,
1952 FDEF,
1954 PUSHB_2,
1956 bci_create_segments,
1957 CALL,
1959 ENDF,
1961 };
1964 {
1966 PUSHB_1,
1967 bci_create_segments_6,
1968 FDEF,
1970 PUSHB_2,
1972 bci_create_segments,
1973 CALL,
1975 ENDF,
1977 };
1980 {
1982 PUSHB_1,
1983 bci_create_segments_7,
1984 FDEF,
1986 PUSHB_2,
1988 bci_create_segments,
1989 CALL,
1991 ENDF,
1993 };
1996 {
1998 PUSHB_1,
1999 bci_create_segments_8,
2000 FDEF,
2002 PUSHB_2,
2004 bci_create_segments,
2005 CALL,
2007 ENDF,
2009 };
2012 {
2014 PUSHB_1,
2015 bci_create_segments_9,
2016 FDEF,
2018 PUSHB_2,
2020 bci_create_segments,
2021 CALL,
2023 ENDF,
2025 };
2028 /*
2029 * bci_create_segments_composite
2030 *
2031 * The same as `bci_create_segments'.
2032 * It also decrements the composite component counter.
2033 *
2034 * sal: sal_num_packed_segments
2035 * sal_segment_offset
2036 * sal_vwidth_data_offset
2037 *
2038 * CVT: cvtl_is_subglyph
2039 *
2040 * uses: bci_decrement_component_counter
2041 * bci_create_segment
2042 * bci_loop
2043 * bci_hint_glyph
2044 */
2047 {
2049 PUSHB_1,
2050 bci_create_segments_composite,
2051 FDEF,
2053 /* all our measurements are taken along the y axis */
2054 SVTCA_y,
2056 PUSHB_1,
2057 bci_decrement_component_counter,
2058 CALL,
2060 /* only do something if we are not a subglyph */
2061 PUSHB_2,
2063 cvtl_is_subglyph,
2064 RCVT,
2065 EQ,
2066 IF,
2067 PUSHB_1,
2068 sal_num_packed_segments,
2069 SWAP,
2070 WS,
2072 DUP,
2073 RCVT,
2074 PUSHB_1,
2076 SWAP,
2077 WS,
2079 PUSHB_1,
2080 sal_vwidth_data_offset,
2081 SWAP,
2082 PUSHB_1,
2084 };
2086 /* %c, number of used styles */
2089 {
2091 ADD,
2094 DUP,
2095 ADD,
2096 PUSHB_1,
2100 PUSHB_6,
2101 sal_segment_offset,
2102 sal_segment_offset,
2104 sal_j,
2106 sal_base,
2111 ROLL,
2114 PUSHB_2,
2115 bci_create_segment,
2116 bci_loop,
2117 CALL,
2119 PUSHB_1,
2120 bci_hint_glyph,
2121 CALL,
2123 };
2125 /* used if we have delta exceptions */
2128 {
2130 PUSHB_1,
2132 SZPS,
2134 };
2137 {
2139 ELSE,
2140 CLEAR,
2141 EIF,
2143 ENDF,
2145 };
2148 /*
2149 * bci_create_segments_composite_X
2150 *
2151 * Top-level routines for calling `bci_create_segments_composite'.
2152 */
2155 {
2157 PUSHB_1,
2158 bci_create_segments_composite_0,
2159 FDEF,
2161 PUSHB_2,
2163 bci_create_segments_composite,
2164 CALL,
2166 ENDF,
2168 };
2171 {
2173 PUSHB_1,
2174 bci_create_segments_composite_1,
2175 FDEF,
2177 PUSHB_2,
2179 bci_create_segments_composite,
2180 CALL,
2182 ENDF,
2184 };
2187 {
2189 PUSHB_1,
2190 bci_create_segments_composite_2,
2191 FDEF,
2193 PUSHB_2,
2195 bci_create_segments_composite,
2196 CALL,
2198 ENDF,
2200 };
2203 {
2205 PUSHB_1,
2206 bci_create_segments_composite_3,
2207 FDEF,
2209 PUSHB_2,
2211 bci_create_segments_composite,
2212 CALL,
2214 ENDF,
2216 };
2219 {
2221 PUSHB_1,
2222 bci_create_segments_composite_4,
2223 FDEF,
2225 PUSHB_2,
2227 bci_create_segments_composite,
2228 CALL,
2230 ENDF,
2232 };
2235 {
2237 PUSHB_1,
2238 bci_create_segments_composite_5,
2239 FDEF,
2241 PUSHB_2,
2243 bci_create_segments_composite,
2244 CALL,
2246 ENDF,
2248 };
2251 {
2253 PUSHB_1,
2254 bci_create_segments_composite_6,
2255 FDEF,
2257 PUSHB_2,
2259 bci_create_segments_composite,
2260 CALL,
2262 ENDF,
2264 };
2267 {
2269 PUSHB_1,
2270 bci_create_segments_composite_7,
2271 FDEF,
2273 PUSHB_2,
2275 bci_create_segments_composite,
2276 CALL,
2278 ENDF,
2280 };
2283 {
2285 PUSHB_1,
2286 bci_create_segments_composite_8,
2287 FDEF,
2289 PUSHB_2,
2291 bci_create_segments_composite,
2292 CALL,
2294 ENDF,
2296 };
2299 {
2301 PUSHB_1,
2302 bci_create_segments_composite_9,
2303 FDEF,
2305 PUSHB_2,
2307 bci_create_segments_composite,
2308 CALL,
2310 ENDF,
2312 };
2315 /*
2316 * bci_align_point
2317 *
2318 * An auxiliary function for `bci_align_segment'.
2319 *
2320 * in: point
2321 *
2322 * out: point+1
2323 */
2326 {
2328 PUSHB_1,
2329 bci_align_point,
2330 FDEF,
2332 DUP,
2335 PUSHB_1,
2337 ADD,
2339 ENDF,
2341 };
2344 /*
2345 * bci_align_segment
2346 *
2347 * Align all points in a segment to the twilight point in rp0.
2348 * zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
2349 *
2350 * in: segment_index
2351 *
2352 * sal: sal_segment_offset
2353 *
2354 * uses: bci_align_point
2355 */
2358 {
2360 PUSHB_1,
2361 bci_align_segment,
2362 FDEF,
2364 /* we need the values of `sal_segment_offset + 2*segment_index' */
2365 /* and `sal_segment_offset + 2*segment_index + 1' */
2366 DUP,
2367 ADD,
2368 PUSHB_1,
2369 sal_segment_offset,
2370 ADD,
2371 DUP,
2372 RS,
2373 SWAP,
2374 PUSHB_1,
2376 ADD,
2379 PUSHB_1,
2382 SUB,
2383 PUSHB_1,
2387 PUSHB_1,
2388 bci_align_point,
2389 LOOPCALL,
2390 /* clean up stack */
2391 POP,
2393 ENDF,
2395 };
2398 /*
2399 * bci_align_segments
2400 *
2401 * Align segments to the twilight point in rp0.
2402 * zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
2403 *
2404 * in: first_segment
2405 * loop_counter (N)
2406 * segment_1
2407 * segment_2
2408 * ...
2409 * segment_N
2410 *
2411 * uses: bci_align_segment
2412 */
2415 {
2417 PUSHB_1,
2418 bci_align_segments,
2419 FDEF,
2421 PUSHB_1,
2422 bci_align_segment,
2423 CALL,
2425 PUSHB_1,
2426 bci_align_segment,
2427 LOOPCALL,
2429 ENDF,
2431 };
2434 /*
2435 * bci_scale_contour
2436 *
2437 * Scale a contour using two points giving the maximum and minimum
2438 * coordinates.
2439 *
2440 * It expects that no point on the contour is touched.
2441 *
2442 * in: min_point
2443 * max_point
2444 *
2445 * sal: sal_scale
2446 */
2449 {
2451 PUSHB_1,
2452 bci_scale_contour,
2453 FDEF,
2455 DUP,
2456 DUP,
2457 GC_orig,
2458 DUP,
2460 SWAP,
2461 SUB,
2462 SHPIX,
2464 /* don't scale a single-point contour twice */
2465 SWAP,
2466 DUP,
2467 ROLL,
2468 NEQ,
2469 IF,
2470 DUP,
2471 GC_orig,
2472 DUP,
2474 SWAP,
2475 SUB,
2476 SHPIX,
2478 ELSE,
2479 POP,
2480 EIF,
2482 ENDF,
2484 };
2487 /*
2488 * bci_scale_glyph
2489 *
2490 * Scale a glyph using a list of points (two points per contour, giving
2491 * the maximum and mininum coordinates).
2492 *
2493 * It expects that no point in the glyph is touched.
2494 *
2495 * Note that the point numbers are sorted in ascending order;
2496 * `min_point_X' and `max_point_X' thus refer to the two extrema of a
2497 * contour without specifying which one is the minimum and maximum.
2498 *
2499 * in: num_contours (N)
2500 * min_point_1
2501 * max_point_1
2502 * min_point_2
2503 * max_point_2
2504 * ...
2505 * min_point_N
2506 * max_point_N
2507 *
2508 * CVT: cvtl_is_subglyph
2509 *
2510 * uses: bci_scale_contour
2511 */
2514 {
2516 PUSHB_1,
2517 bci_scale_glyph,
2518 FDEF,
2520 /* all our measurements are taken along the y axis */
2521 SVTCA_y,
2523 /* only do something if we are not a subglyph */
2524 PUSHB_2,
2526 cvtl_is_subglyph,
2527 RCVT,
2528 EQ,
2529 IF,
2530 PUSHB_1,
2534 PUSHB_1,
2535 bci_scale_contour,
2536 LOOPCALL,
2538 PUSHB_1,
2541 IUP_y,
2543 ELSE,
2544 CLEAR,
2545 EIF,
2547 ENDF,
2549 };
2552 /*
2553 * bci_scale_composite_glyph
2554 *
2555 * The same as `bci_scale_glyph'.
2556 * It also decrements the composite component counter.
2557 *
2558 * CVT: cvtl_is_subglyph
2559 *
2560 * uses: bci_decrement_component_counter
2561 * bci_scale_contour
2562 */
2565 {
2567 PUSHB_1,
2568 bci_scale_composite_glyph,
2569 FDEF,
2571 /* all our measurements are taken along the y axis */
2572 SVTCA_y,
2574 PUSHB_1,
2575 bci_decrement_component_counter,
2576 CALL,
2578 /* only do something if we are not a subglyph */
2579 PUSHB_2,
2581 cvtl_is_subglyph,
2582 RCVT,
2583 EQ,
2584 IF,
2585 PUSHB_1,
2589 PUSHB_1,
2590 bci_scale_contour,
2591 LOOPCALL,
2593 PUSHB_1,
2596 IUP_y,
2598 ELSE,
2599 CLEAR,
2600 EIF,
2602 ENDF,
2604 };
2607 /*
2608 * bci_shift_contour
2609 *
2610 * Shift a contour by a given amount.
2611 *
2612 * It expects that rp1 (pointed to by zp0) is set up properly; zp2 must
2613 * point to the normal zone 1.
2614 *
2615 * in: contour
2616 *
2617 * out: contour+1
2618 */
2621 {
2623 PUSHB_1,
2624 bci_shift_contour,
2625 FDEF,
2627 DUP,
2630 PUSHB_1,
2632 ADD,
2634 ENDF,
2636 };
2639 /*
2640 * bci_shift_subglyph
2641 *
2642 * Shift a subglyph. To be more specific, it corrects the already applied
2643 * subglyph offset (if any) from the `glyf' table which needs to be scaled
2644 * also.
2645 *
2646 * If this function is called, a point `x' in the subglyph has been scaled
2647 * already (during the hinting of the subglyph itself), and `offset' has
2648 * been applied also:
2649 *
2650 * x -> x * scale + offset (1)
2651 *
2652 * However, the offset should be applied first, then the scaling:
2653 *
2654 * x -> (x + offset) * scale (2)
2655 *
2656 * Our job is now to transform (1) to (2); a simple calculation shows that
2657 * we have to shift all points of the subglyph by
2658 *
2659 * offset * scale - offset = offset * (scale - 1)
2660 *
2661 * Note that `sal_scale' is equal to the above `scale - 1'.
2662 *
2663 * in: offset (in FUnits)
2664 * num_contours
2665 * first_contour
2666 *
2667 * CVT: cvtl_funits_to_pixels
2668 *
2669 * sal: sal_scale
2670 *
2671 * uses: bci_round
2672 * bci_shift_contour
2673 */
2676 {
2678 PUSHB_1,
2679 bci_shift_subglyph,
2680 FDEF,
2682 /* all our measurements are taken along the y axis */
2683 SVTCA_y,
2685 PUSHB_1,
2686 cvtl_funits_to_pixels,
2688 MUL,
2689 DIV_BY_1024,
2691 /* the autohinter always rounds offsets */
2692 PUSHB_1,
2693 bci_round,
2696 PUSHB_1,
2697 sal_scale,
2698 RS,
2699 MUL,
2702 /* and round again */
2703 PUSHB_1,
2704 bci_round,
2707 PUSHB_1,
2711 /* we create twilight point 0 as a reference point, */
2712 /* setting the original position to zero (using `cvtl_temp') */
2713 PUSHB_5,
2716 cvtl_temp,
2717 cvtl_temp,
2719 WCVTP,
2725 PUSHB_2,
2726 bci_shift_contour,
2729 LOOPCALL,
2731 };
2733 /* used if we have delta exceptions */
2736 {
2738 PUSHB_1,
2740 SZPS,
2742 };
2745 {
2747 ENDF,
2749 };
2752 /*
2753 * bci_ip_outer_align_point
2754 *
2755 * Auxiliary function for `bci_action_ip_before' and
2756 * `bci_action_ip_after'.
2757 *
2758 * It expects rp0 to contain the edge for alignment, zp0 set to twilight
2759 * zone, and both zp1 and zp2 set to normal zone.
2760 *
2761 * in: point
2762 *
2763 * sal: sal_i (edge_orig_pos)
2764 * sal_scale
2765 */
2768 {
2770 PUSHB_1,
2771 bci_ip_outer_align_point,
2772 FDEF,
2774 DUP,
2776 DUP,
2777 GC_orig,
2780 PUSHB_1,
2781 sal_i,
2782 RS,
2784 SHPIX,
2786 ENDF,
2788 };
2791 /*
2792 * bci_ip_on_align_points
2793 *
2794 * Auxiliary function for `bci_action_ip_on'.
2795 *
2796 * in: edge (in twilight zone)
2797 * loop_counter (N)
2798 * point_1
2799 * point_2
2800 * ...
2801 * point_N
2802 */
2805 {
2807 PUSHB_1,
2808 bci_ip_on_align_points,
2809 FDEF,
2813 SLOOP,
2814 ALIGNRP,
2816 ENDF,
2818 };
2821 /*
2822 * bci_ip_between_align_point
2823 *
2824 * Auxiliary function for `bci_ip_between_align_points'.
2825 *
2826 * It expects rp0 to contain the edge for alignment, zp0 set to twilight
2827 * zone, and both zp1 and zp2 set to normal zone.
2828 *
2829 * in: point
2830 *
2831 * sal: sal_i (edge_orig_pos)
2832 * sal_j (stretch_factor)
2833 * sal_scale
2834 */
2837 {
2839 PUSHB_1,
2840 bci_ip_between_align_point,
2841 FDEF,
2843 DUP,
2845 DUP,
2846 GC_orig,
2849 PUSHB_1,
2850 sal_i,
2851 RS,
2853 PUSHB_1,
2854 sal_j,
2855 RS,
2857 SHPIX,
2859 ENDF,
2861 };
2864 /*
2865 * bci_ip_between_align_points
2866 *
2867 * Auxiliary function for `bci_action_ip_between'.
2868 *
2869 * in: after_edge (in twilight zone)
2870 * before_edge (in twilight zone)
2871 * loop_counter (N)
2872 * point_1
2873 * point_2
2874 * ...
2875 * point_N
2876 *
2877 * sal: sal_i (before_orig_pos)
2878 * sal_j (stretch_factor)
2879 *
2880 * uses: bci_ip_between_align_point
2881 */
2884 {
2886 PUSHB_1,
2887 bci_ip_between_align_points,
2888 FDEF,
2890 PUSHB_2,
2894 CINDEX,
2897 DUP,
2899 PUSHB_1,
2900 sal_i,
2901 SWAP,
2903 PUSHB_1,
2907 ROLL,
2908 ROLL,
2911 DUP,
2914 ELSE,
2916 EIF,
2918 PUSHB_1,
2919 sal_j,
2920 SWAP,
2923 PUSHB_3,
2924 bci_ip_between_align_point,
2929 LOOPCALL,
2931 ENDF,
2933 };
2936 /*
2937 * bci_action_ip_before
2938 *
2939 * Handle `ip_before' data to align points located before the first edge.
2940 *
2941 * in: first_edge (in twilight zone)
2942 * loop_counter (N)
2943 * point_1
2944 * point_2
2945 * ...
2946 * point_N
2947 *
2948 * sal: sal_i (first_edge_orig_pos)
2949 *
2950 * uses: bci_ip_outer_align_point
2951 */
2954 {
2956 PUSHB_1,
2957 bci_action_ip_before,
2958 FDEF,
2960 PUSHB_1,
2964 DUP,
2965 GC_orig,
2966 PUSHB_1,
2967 sal_i,
2968 SWAP,
2971 PUSHB_3,
2981 PUSHB_1,
2982 bci_ip_outer_align_point,
2983 LOOPCALL,
2985 ENDF,
2987 };
2990 /*
2991 * bci_action_ip_after
2992 *
2993 * Handle `ip_after' data to align points located after the last edge.
2994 *
2995 * in: last_edge (in twilight zone)
2996 * loop_counter (N)
2997 * point_1
2998 * point_2
2999 * ...
3000 * point_N
3001 *
3002 * sal: sal_i (last_edge_orig_pos)
3003 *
3004 * uses: bci_ip_outer_align_point
3005 */
3008 {
3010 PUSHB_1,
3011 bci_action_ip_after,
3012 FDEF,
3014 PUSHB_1,
3018 DUP,
3019 GC_orig,
3020 PUSHB_1,
3021 sal_i,
3022 SWAP,
3025 PUSHB_3,
3035 PUSHB_1,
3036 bci_ip_outer_align_point,
3037 LOOPCALL,
3039 ENDF,
3041 };
3044 /*
3045 * bci_action_ip_on
3046 *
3047 * Handle `ip_on' data to align points located on an edge coordinate (but
3048 * not part of an edge).
3049 *
3050 * in: loop_counter (M)
3051 * edge_1 (in twilight zone)
3052 * loop_counter (N_1)
3053 * point_1
3054 * point_2
3055 * ...
3056 * point_N_1
3057 * edge_2 (in twilight zone)
3058 * loop_counter (N_2)
3059 * point_1
3060 * point_2
3061 * ...
3062 * point_N_2
3063 * ...
3064 * edge_M (in twilight zone)
3065 * loop_counter (N_M)
3066 * point_1
3067 * point_2
3068 * ...
3069 * point_N_M
3070 *
3071 * uses: bci_ip_on_align_points
3072 */
3075 {
3077 PUSHB_1,
3078 bci_action_ip_on,
3079 FDEF,
3081 PUSHB_2,
3087 PUSHB_1,
3088 bci_ip_on_align_points,
3089 LOOPCALL,
3091 ENDF,
3093 };
3096 /*
3097 * bci_action_ip_between
3098 *
3099 * Handle `ip_between' data to align points located between two edges.
3100 *
3101 * in: loop_counter (M)
3102 * before_edge_1 (in twilight zone)
3103 * after_edge_1 (in twilight zone)
3104 * loop_counter (N_1)
3105 * point_1
3106 * point_2
3107 * ...
3108 * point_N_1
3109 * before_edge_2 (in twilight zone)
3110 * after_edge_2 (in twilight zone)
3111 * loop_counter (N_2)
3112 * point_1
3113 * point_2
3114 * ...
3115 * point_N_2
3116 * ...
3117 * before_edge_M (in twilight zone)
3118 * after_edge_M (in twilight zone)
3119 * loop_counter (N_M)
3120 * point_1
3121 * point_2
3122 * ...
3123 * point_N_M
3124 *
3125 * uses: bci_ip_between_align_points
3126 */
3129 {
3131 PUSHB_1,
3132 bci_action_ip_between,
3133 FDEF,
3135 PUSHB_1,
3136 bci_ip_between_align_points,
3137 LOOPCALL,
3139 ENDF,
3141 };
3144 /*
3145 * bci_adjust_common
3146 *
3147 * Common code for bci_action_adjust routines.
3148 *
3149 * uses: func[sal_stem_width_function]
3150 */
3153 {
3155 PUSHB_1,
3156 bci_adjust_common,
3157 FDEF,
3159 PUSHB_1,
3163 PUSHB_1,
3166 PUSHB_1,
3171 PUSHB_1,
3172 sal_stem_width_function,
3173 RS,
3174 CALL,
3179 SWAP,
3180 DUP,
3183 ROLL,
3186 ENDF,
3188 };
3191 /*
3192 * bci_adjust_bound
3193 *
3194 * Handle the ADJUST_BOUND action to align an edge of a stem if the other
3195 * edge of the stem has already been moved, then moving it again if
3196 * necessary to stay bound.
3197 *
3198 * in: edge2_is_serif
3199 * edge_is_round
3200 * edge_point (in twilight zone)
3201 * edge2_point (in twilight zone)
3202 * edge[-1] (in twilight zone)
3203 * ... stuff for bci_align_segments (edge) ...
3204 *
3205 * uses: bci_adjust_common
3206 * bci_align_segments
3207 */
3210 {
3212 PUSHB_1,
3213 bci_adjust_bound,
3214 FDEF,
3216 PUSHB_1,
3217 bci_adjust_common,
3218 CALL,
3221 DUP,
3223 GC_cur,
3224 PUSHB_1,
3226 CINDEX,
3229 IF,
3230 DUP,
3232 EIF,
3236 PUSHB_2,
3237 bci_align_segments,
3240 CALL,
3242 ENDF,
3244 };
3247 /*
3248 * bci_action_adjust_bound
3249 * bci_action_adjust_bound_serif
3250 * bci_action_adjust_bound_round
3251 * bci_action_adjust_bound_round_serif
3252 *
3253 * Higher-level routines for calling `bci_adjust_bound'.
3254 */
3257 {
3259 PUSHB_1,
3260 bci_action_adjust_bound,
3261 FDEF,
3263 PUSHB_3,
3266 bci_adjust_bound,
3267 CALL,
3269 ENDF,
3271 };
3274 {
3276 PUSHB_1,
3277 bci_action_adjust_bound_serif,
3278 FDEF,
3280 PUSHB_3,
3283 bci_adjust_bound,
3284 CALL,
3286 ENDF,
3288 };
3291 {
3293 PUSHB_1,
3294 bci_action_adjust_bound_round,
3295 FDEF,
3297 PUSHB_3,
3300 bci_adjust_bound,
3301 CALL,
3303 ENDF,
3305 };
3308 {
3310 PUSHB_1,
3311 bci_action_adjust_bound_round_serif,
3312 FDEF,
3314 PUSHB_3,
3317 bci_adjust_bound,
3318 CALL,
3320 ENDF,
3322 };
3325 /*
3326 * bci_adjust
3327 *
3328 * Handle the ADJUST action to align an edge of a stem if the other edge
3329 * of the stem has already been moved.
3330 *
3331 * in: edge2_is_serif
3332 * edge_is_round
3333 * edge_point (in twilight zone)
3334 * edge2_point (in twilight zone)
3335 * ... stuff for bci_align_segments (edge) ...
3336 *
3337 * uses: bci_adjust_common
3338 * bci_align_segments
3339 */
3342 {
3344 PUSHB_1,
3345 bci_adjust,
3346 FDEF,
3348 PUSHB_1,
3349 bci_adjust_common,
3350 CALL,
3354 PUSHB_2,
3355 bci_align_segments,
3358 CALL,
3360 ENDF,
3362 };
3365 /*
3366 * bci_action_adjust
3367 * bci_action_adjust_serif
3368 * bci_action_adjust_round
3369 * bci_action_adjust_round_serif
3370 *
3371 * Higher-level routines for calling `bci_adjust'.
3372 */
3375 {
3377 PUSHB_1,
3378 bci_action_adjust,
3379 FDEF,
3381 PUSHB_3,
3384 bci_adjust,
3385 CALL,
3387 ENDF,
3389 };
3392 {
3394 PUSHB_1,
3395 bci_action_adjust_serif,
3396 FDEF,
3398 PUSHB_3,
3401 bci_adjust,
3402 CALL,
3404 ENDF,
3406 };
3409 {
3411 PUSHB_1,
3412 bci_action_adjust_round,
3413 FDEF,
3415 PUSHB_3,
3418 bci_adjust,
3419 CALL,
3421 ENDF,
3423 };
3426 {
3428 PUSHB_1,
3429 bci_action_adjust_round_serif,
3430 FDEF,
3432 PUSHB_3,
3435 bci_adjust,
3436 CALL,
3438 ENDF,
3440 };
3443 /*
3444 * bci_stem_common
3445 *
3446 * Common code for bci_action_stem routines.
3447 *
3448 * sal: sal_anchor
3449 * sal_temp1
3450 * sal_temp2
3451 * sal_temp3
3452 *
3453 * uses: func[sal_stem_width_function]
3454 * bci_round
3455 */
3457 #undef sal_u_off
3458 #define sal_u_off sal_temp1
3459 #undef sal_d_off
3460 #define sal_d_off sal_temp2
3461 #undef sal_org_len
3462 #define sal_org_len sal_temp3
3463 #undef sal_edge2
3464 #define sal_edge2 sal_temp3
3467 {
3469 PUSHB_1,
3470 bci_stem_common,
3471 FDEF,
3473 PUSHB_1,
3477 PUSHB_1,
3479 CINDEX,
3480 PUSHB_1,
3482 CINDEX,
3487 DUP,
3488 PUSHB_1,
3489 sal_org_len,
3490 SWAP,
3491 WS,
3493 PUSHB_1,
3494 sal_stem_width_function,
3495 RS,
3498 DUP,
3499 PUSHB_1,
3502 IF,
3503 DUP,
3504 PUSHB_1,
3507 IF,
3508 PUSHB_4,
3509 sal_u_off,
3511 sal_d_off,
3514 ELSE,
3515 PUSHB_4,
3516 sal_u_off,
3518 sal_d_off,
3520 EIF,
3521 WS,
3522 WS,
3525 DUP,
3526 PUSHB_1,
3527 sal_anchor,
3528 RS,
3530 ROLL,
3531 SWAP,
3532 MD_orig_ZP2_0,
3533 SWAP,
3534 GC_cur,
3536 PUSHB_1,
3537 sal_org_len,
3538 RS,
3539 DIV_BY_2,
3542 DUP,
3543 PUSHB_1,
3544 bci_round,
3547 DUP,
3548 ROLL,
3549 ROLL,
3552 DUP,
3553 PUSHB_1,
3554 sal_u_off,
3555 RS,
3556 ADD,
3559 SWAP,
3560 PUSHB_1,
3561 sal_d_off,
3562 RS,
3563 SUB,
3567 IF,
3568 PUSHB_1,
3569 sal_u_off,
3570 RS,
3573 ELSE,
3574 PUSHB_1,
3575 sal_d_off,
3576 RS,
3580 PUSHB_1,
3582 CINDEX,
3583 DIV_BY_2,
3587 DUP,
3588 DUP,
3589 PUSHB_1,
3591 MINDEX,
3593 GC_cur,
3594 SUB,
3597 ELSE,
3599 PUSHB_1,
3600 sal_anchor,
3601 RS,
3603 PUSHB_1,
3605 CINDEX,
3606 PUSHB_1,
3607 sal_anchor,
3608 RS,
3609 MD_orig_ZP2_0,
3612 DUP,
3613 PUSHB_1,
3614 sal_org_len,
3615 RS,
3616 DIV_BY_2,
3619 SWAP,
3620 DUP,
3621 PUSHB_1,
3622 bci_round,
3624 SWAP,
3625 PUSHB_1,
3626 sal_org_len,
3627 RS,
3628 ADD,
3629 PUSHB_1,
3630 bci_round,
3631 CALL,
3632 PUSHB_1,
3634 CINDEX,
3637 PUSHB_1,
3639 CINDEX,
3640 DIV_BY_2,
3641 PUSHB_1,
3643 MINDEX,
3646 DUP,
3647 PUSHB_1,
3649 CINDEX,
3650 ADD,
3652 SWAP,
3653 PUSHB_1,
3655 CINDEX,
3656 ADD,
3659 IF,
3662 ELSE,
3663 SWAP,
3666 SWAP,
3667 DUP,
3668 DUP,
3669 PUSHB_1,
3671 MINDEX,
3673 GC_cur,
3674 SUB,
3678 ENDF,
3680 };
3683 /*
3684 * bci_stem_bound
3685 *
3686 * Handle the STEM action to align two edges of a stem, then moving one
3687 * edge again if necessary to stay bound.
3688 *
3689 * The code after computing `cur_len' to shift `edge' and `edge2'
3690 * is equivalent to the snippet below (part of `ta_latin_hint_edges'):
3691 *
3692 * if cur_len < 96:
3693 * if cur_len < = 64:
3694 * u_off = 32
3695 * d_off = 32
3696 * else:
3697 * u_off = 38
3698 * d_off = 26
3699 *
3700 * org_pos = anchor + (edge_orig - anchor_orig)
3701 * org_center = org_pos + org_len / 2
3702 *
3703 * cur_pos1 = ROUND(org_center)
3704 * delta1 = ABS(org_center - (cur_pos1 - u_off))
3705 * delta2 = ABS(org_center - (cur_pos1 + d_off))
3706 * if (delta1 < delta2):
3707 * cur_pos1 = cur_pos1 - u_off
3708 * else:
3709 * cur_pos1 = cur_pos1 + d_off
3710 *
3711 * edge = cur_pos1 - cur_len / 2
3712 *
3713 * else:
3714 * org_pos = anchor + (edge_orig - anchor_orig)
3715 * org_center = org_pos + org_len / 2
3716 *
3717 * cur_pos1 = ROUND(org_pos)
3718 * delta1 = ABS(cur_pos1 + cur_len / 2 - org_center)
3719 * cur_pos2 = ROUND(org_pos + org_len) - cur_len
3720 * delta2 = ABS(cur_pos2 + cur_len / 2 - org_center)
3721 *
3722 * if (delta1 < delta2):
3723 * edge = cur_pos1
3724 * else:
3725 * edge = cur_pos2
3726 *
3727 * edge2 = edge + cur_len
3728 *
3729 * in: edge2_is_serif
3730 * edge_is_round
3731 * edge_point (in twilight zone)
3732 * edge2_point (in twilight zone)
3733 * edge[-1] (in twilight zone)
3734 * ... stuff for bci_align_segments (edge) ...
3735 * ... stuff for bci_align_segments (edge2)...
3736 *
3737 * sal: sal_anchor
3738 * sal_temp1
3739 * sal_temp2
3740 * sal_temp3
3741 *
3742 * uses: bci_stem_common
3743 * bci_align_segments
3744 */
3747 {
3749 PUSHB_1,
3750 bci_stem_bound,
3751 FDEF,
3753 PUSHB_1,
3754 bci_stem_common,
3755 CALL,
3758 DUP,
3759 DUP,
3761 PUSHB_1,
3762 sal_edge2,
3763 SWAP,
3765 ROLL,
3769 DUP,
3771 GC_cur,
3772 PUSHB_1,
3774 CINDEX,
3777 IF,
3778 DUP,
3780 EIF,
3784 PUSHB_2,
3785 bci_align_segments,
3788 CALL,
3790 PUSHB_1,
3791 sal_edge2,
3792 RS,
3795 PUSHB_1,
3796 bci_align_segments,
3797 CALL,
3799 ENDF,
3801 };
3804 /*
3805 * bci_action_stem_bound
3806 * bci_action_stem_bound_serif
3807 * bci_action_stem_bound_round
3808 * bci_action_stem_bound_round_serif
3809 *
3810 * Higher-level routines for calling `bci_stem_bound'.
3811 */
3814 {
3816 PUSHB_1,
3817 bci_action_stem_bound,
3818 FDEF,
3820 PUSHB_3,
3823 bci_stem_bound,
3824 CALL,
3826 ENDF,
3828 };
3831 {
3833 PUSHB_1,
3834 bci_action_stem_bound_serif,
3835 FDEF,
3837 PUSHB_3,
3840 bci_stem_bound,
3841 CALL,
3843 ENDF,
3845 };
3848 {
3850 PUSHB_1,
3851 bci_action_stem_bound_round,
3852 FDEF,
3854 PUSHB_3,
3857 bci_stem_bound,
3858 CALL,
3860 ENDF,
3862 };
3865 {
3867 PUSHB_1,
3868 bci_action_stem_bound_round_serif,
3869 FDEF,
3871 PUSHB_3,
3874 bci_stem_bound,
3875 CALL,
3877 ENDF,
3879 };
3882 /*
3883 * bci_stem
3884 *
3885 * Handle the STEM action to align two edges of a stem.
3886 *
3887 * See `bci_stem_bound' for more details.
3888 *
3889 * in: edge2_is_serif
3890 * edge_is_round
3891 * edge_point (in twilight zone)
3892 * edge2_point (in twilight zone)
3893 * ... stuff for bci_align_segments (edge) ...
3894 * ... stuff for bci_align_segments (edge2)...
3895 *
3896 * sal: sal_anchor
3897 * sal_temp1
3898 * sal_temp2
3899 * sal_temp3
3900 *
3901 * uses: bci_stem_common
3902 * bci_align_segments
3903 */
3906 {
3908 PUSHB_1,
3909 bci_stem,
3910 FDEF,
3912 PUSHB_1,
3913 bci_stem_common,
3914 CALL,
3916 POP,
3918 DUP,
3919 DUP,
3921 PUSHB_1,
3922 sal_edge2,
3923 SWAP,
3925 SWAP,
3928 PUSHB_2,
3929 bci_align_segments,
3932 CALL,
3934 PUSHB_1,
3935 sal_edge2,
3936 RS,
3939 PUSHB_1,
3940 bci_align_segments,
3941 CALL,
3942 ENDF,
3944 };
3947 /*
3948 * bci_action_stem
3949 * bci_action_stem_serif
3950 * bci_action_stem_round
3951 * bci_action_stem_round_serif
3952 *
3953 * Higher-level routines for calling `bci_stem'.
3954 */
3957 {
3959 PUSHB_1,
3960 bci_action_stem,
3961 FDEF,
3963 PUSHB_3,
3966 bci_stem,
3967 CALL,
3969 ENDF,
3971 };
3974 {
3976 PUSHB_1,
3977 bci_action_stem_serif,
3978 FDEF,
3980 PUSHB_3,
3983 bci_stem,
3984 CALL,
3986 ENDF,
3988 };
3991 {
3993 PUSHB_1,
3994 bci_action_stem_round,
3995 FDEF,
3997 PUSHB_3,
4000 bci_stem,
4001 CALL,
4003 ENDF,
4005 };
4008 {
4010 PUSHB_1,
4011 bci_action_stem_round_serif,
4012 FDEF,
4014 PUSHB_3,
4017 bci_stem,
4018 CALL,
4020 ENDF,
4022 };
4025 /*
4026 * bci_link
4027 *
4028 * Handle the LINK action to link an edge to another one.
4029 *
4030 * in: stem_is_serif
4031 * base_is_round
4032 * base_point (in twilight zone)
4033 * stem_point (in twilight zone)
4034 * ... stuff for bci_align_segments (base) ...
4035 *
4036 * uses: func[sal_stem_width_function]
4037 * bci_align_segments
4038 */
4041 {
4043 PUSHB_1,
4044 bci_link,
4045 FDEF,
4047 PUSHB_1,
4051 PUSHB_1,
4053 CINDEX,
4054 PUSHB_1,
4056 MINDEX,
4062 PUSHB_1,
4063 sal_stem_width_function,
4064 RS,
4067 SWAP,
4068 DUP,
4070 DUP,
4072 SWAP,
4075 PUSHB_2,
4076 bci_align_segments,
4079 CALL,
4081 ENDF,
4083 };
4086 /*
4087 * bci_action_link
4088 * bci_action_link_serif
4089 * bci_action_link_round
4090 * bci_action_link_round_serif
4091 *
4092 * Higher-level routines for calling `bci_link'.
4093 */
4096 {
4098 PUSHB_1,
4099 bci_action_link,
4100 FDEF,
4102 PUSHB_3,
4105 bci_link,
4106 CALL,
4108 ENDF,
4110 };
4113 {
4115 PUSHB_1,
4116 bci_action_link_serif,
4117 FDEF,
4119 PUSHB_3,
4122 bci_link,
4123 CALL,
4125 ENDF,
4127 };
4130 {
4132 PUSHB_1,
4133 bci_action_link_round,
4134 FDEF,
4136 PUSHB_3,
4139 bci_link,
4140 CALL,
4142 ENDF,
4144 };
4147 {
4149 PUSHB_1,
4150 bci_action_link_round_serif,
4151 FDEF,
4153 PUSHB_3,
4156 bci_link,
4157 CALL,
4159 ENDF,
4161 };
4164 /*
4165 * bci_anchor
4166 *
4167 * Handle the ANCHOR action to align two edges
4168 * and to set the edge anchor.
4169 *
4170 * The code after computing `cur_len' to shift `edge' and `edge2'
4171 * is equivalent to the snippet below (part of `ta_latin_hint_edges'):
4172 *
4173 * if cur_len < 96:
4174 * if cur_len < = 64:
4175 * u_off = 32
4176 * d_off = 32
4177 * else:
4178 * u_off = 38
4179 * d_off = 26
4180 *
4181 * org_center = edge_orig + org_len / 2
4182 * cur_pos1 = ROUND(org_center)
4183 *
4184 * error1 = ABS(org_center - (cur_pos1 - u_off))
4185 * error2 = ABS(org_center - (cur_pos1 + d_off))
4186 * if (error1 < error2):
4187 * cur_pos1 = cur_pos1 - u_off
4188 * else:
4189 * cur_pos1 = cur_pos1 + d_off
4190 *
4191 * edge = cur_pos1 - cur_len / 2
4192 * edge2 = edge + cur_len
4193 *
4194 * else:
4195 * edge = ROUND(edge_orig)
4196 *
4197 * in: edge2_is_serif
4198 * edge_is_round
4199 * edge_point (in twilight zone)
4200 * edge2_point (in twilight zone)
4201 * ... stuff for bci_align_segments (edge) ...
4202 *
4203 * sal: sal_anchor
4204 * sal_temp1
4205 * sal_temp2
4206 * sal_temp3
4207 *
4208 * uses: func[sal_stem_width_function]
4209 * bci_round
4210 * bci_align_segments
4211 */
4213 #undef sal_u_off
4214 #define sal_u_off sal_temp1
4215 #undef sal_d_off
4216 #define sal_d_off sal_temp2
4217 #undef sal_org_len
4218 #define sal_org_len sal_temp3
4221 {
4223 PUSHB_1,
4224 bci_anchor,
4225 FDEF,
4227 /* store anchor point number in `sal_anchor' */
4228 PUSHB_2,
4229 sal_anchor,
4231 CINDEX,
4234 PUSHB_1,
4238 PUSHB_1,
4240 CINDEX,
4241 PUSHB_1,
4243 CINDEX,
4248 DUP,
4249 PUSHB_1,
4250 sal_org_len,
4251 SWAP,
4252 WS,
4254 PUSHB_1,
4255 sal_stem_width_function,
4256 RS,
4259 DUP,
4260 PUSHB_1,
4263 IF,
4264 DUP,
4265 PUSHB_1,
4268 IF,
4269 PUSHB_4,
4270 sal_u_off,
4272 sal_d_off,
4275 ELSE,
4276 PUSHB_4,
4277 sal_u_off,
4279 sal_d_off,
4281 EIF,
4282 WS,
4283 WS,
4288 GC_orig,
4289 PUSHB_1,
4290 sal_org_len,
4291 RS,
4292 DIV_BY_2,
4295 DUP,
4296 PUSHB_1,
4297 bci_round,
4300 DUP,
4301 ROLL,
4302 ROLL,
4305 DUP,
4306 PUSHB_1,
4307 sal_u_off,
4308 RS,
4309 ADD,
4312 SWAP,
4313 PUSHB_1,
4314 sal_d_off,
4315 RS,
4316 SUB,
4320 IF,
4321 PUSHB_1,
4322 sal_u_off,
4323 RS,
4326 ELSE,
4327 PUSHB_1,
4328 sal_d_off,
4329 RS,
4333 PUSHB_1,
4335 CINDEX,
4336 DIV_BY_2,
4339 PUSHB_1,
4342 GC_cur,
4343 SUB,
4347 DUP,
4349 SWAP,
4352 ELSE,
4354 DUP,
4355 DUP,
4356 GC_cur,
4357 SWAP,
4358 GC_orig,
4359 PUSHB_1,
4360 bci_round,
4362 SWAP,
4363 SUB,
4366 /* clean up stack */
4367 POP,
4368 EIF,
4370 PUSHB_2,
4371 bci_align_segments,
4374 CALL,
4376 ENDF,
4378 };
4381 /*
4382 * bci_action_anchor
4383 * bci_action_anchor_serif
4384 * bci_action_anchor_round
4385 * bci_action_anchor_round_serif
4386 *
4387 * Higher-level routines for calling `bci_anchor'.
4388 */
4391 {
4393 PUSHB_1,
4394 bci_action_anchor,
4395 FDEF,
4397 PUSHB_3,
4400 bci_anchor,
4401 CALL,
4403 ENDF,
4405 };
4408 {
4410 PUSHB_1,
4411 bci_action_anchor_serif,
4412 FDEF,
4414 PUSHB_3,
4417 bci_anchor,
4418 CALL,
4420 ENDF,
4422 };
4425 {
4427 PUSHB_1,
4428 bci_action_anchor_round,
4429 FDEF,
4431 PUSHB_3,
4434 bci_anchor,
4435 CALL,
4437 ENDF,
4439 };
4442 {
4444 PUSHB_1,
4445 bci_action_anchor_round_serif,
4446 FDEF,
4448 PUSHB_3,
4451 bci_anchor,
4452 CALL,
4454 ENDF,
4456 };
4459 /*
4460 * bci_action_blue_anchor
4461 *
4462 * Handle the BLUE_ANCHOR action to align an edge with a blue zone
4463 * and to set the edge anchor.
4464 *
4465 * in: anchor_point (in twilight zone)
4466 * blue_cvt_idx
4467 * edge_point (in twilight zone)
4468 * ... stuff for bci_align_segments (edge) ...
4469 *
4470 * sal: sal_anchor
4471 *
4472 * uses: bci_action_blue
4473 */
4476 {
4478 PUSHB_1,
4479 bci_action_blue_anchor,
4480 FDEF,
4482 /* store anchor point number in `sal_anchor' */
4483 PUSHB_1,
4484 sal_anchor,
4485 SWAP,
4486 WS,
4488 PUSHB_1,
4489 bci_action_blue,
4490 CALL,
4492 ENDF,
4494 };
4497 /*
4498 * bci_action_blue
4499 *
4500 * Handle the BLUE action to align an edge with a blue zone.
4501 *
4502 * in: blue_cvt_idx
4503 * edge_point (in twilight zone)
4504 * ... stuff for bci_align_segments (edge) ...
4505 *
4506 * uses: bci_align_segments
4507 */
4510 {
4512 PUSHB_1,
4513 bci_action_blue,
4514 FDEF,
4516 PUSHB_1,
4520 /* move `edge_point' to `blue_cvt_idx' position; */
4521 /* note that we can't use MIAP since this would modify */
4522 /* the twilight point's original coordinates also */
4523 RCVT,
4524 SWAP,
4525 DUP,
4527 DUP,
4529 ROLL,
4530 SWAP,
4532 SHPIX,
4534 PUSHB_2,
4535 bci_align_segments,
4538 CALL,
4540 ENDF,
4542 };
4545 /*
4546 * bci_serif_common
4547 *
4548 * Common code for bci_action_serif routines.
4549 */
4552 {
4554 PUSHB_1,
4555 bci_serif_common,
4556 FDEF,
4558 PUSHB_1,
4562 DUP,
4563 DUP,
4564 DUP,
4565 PUSHB_1,
4568 DUP,
4570 MD_orig_ZP2_0,
4571 SWAP,
4575 ENDF,
4577 };
4580 /*
4581 * bci_lower_bound
4582 *
4583 * Move an edge if necessary to stay within a lower bound.
4584 *
4585 * in: edge
4586 * bound
4587 *
4588 * uses: bci_align_segments
4589 */
4592 {
4594 PUSHB_1,
4595 bci_lower_bound,
4596 FDEF,
4599 DUP,
4601 GC_cur,
4602 PUSHB_1,
4604 CINDEX,
4607 IF,
4608 DUP,
4610 EIF,
4614 PUSHB_2,
4615 bci_align_segments,
4618 CALL,
4620 ENDF,
4622 };
4625 /*
4626 * bci_upper_bound
4627 *
4628 * Move an edge if necessary to stay within an upper bound.
4629 *
4630 * in: edge
4631 * bound
4632 *
4633 * uses: bci_align_segments
4634 */
4637 {
4639 PUSHB_1,
4640 bci_upper_bound,
4641 FDEF,
4644 DUP,
4646 GC_cur,
4647 PUSHB_1,
4649 CINDEX,
4652 IF,
4653 DUP,
4655 EIF,
4659 PUSHB_2,
4660 bci_align_segments,
4663 CALL,
4665 ENDF,
4667 };
4670 /*
4671 * bci_upper_lower_bound
4672 *
4673 * Move an edge if necessary to stay within a lower and lower bound.
4674 *
4675 * in: edge
4676 * lower
4677 * upper
4678 *
4679 * uses: bci_align_segments
4680 */
4683 {
4685 PUSHB_1,
4686 bci_upper_lower_bound,
4687 FDEF,
4690 DUP,
4692 GC_cur,
4693 PUSHB_1,
4695 CINDEX,
4698 IF,
4699 DUP,
4701 EIF,
4704 DUP,
4706 GC_cur,
4707 PUSHB_1,
4709 CINDEX,
4712 IF,
4713 DUP,
4715 EIF,
4719 PUSHB_2,
4720 bci_align_segments,
4723 CALL,
4725 ENDF,
4727 };
4730 /*
4731 * bci_action_serif
4732 *
4733 * Handle the SERIF action to align a serif with its base.
4734 *
4735 * in: serif_point (in twilight zone)
4736 * base_point (in twilight zone)
4737 * ... stuff for bci_align_segments (serif) ...
4738 *
4739 * uses: bci_serif_common
4740 * bci_align_segments
4741 */
4744 {
4746 PUSHB_1,
4747 bci_action_serif,
4748 FDEF,
4750 PUSHB_1,
4751 bci_serif_common,
4752 CALL,
4756 PUSHB_2,
4757 bci_align_segments,
4760 CALL,
4762 ENDF,
4764 };
4767 /*
4768 * bci_action_serif_lower_bound
4769 *
4770 * Handle the SERIF action to align a serif with its base, then moving it
4771 * again if necessary to stay within a lower bound.
4772 *
4773 * in: serif_point (in twilight zone)
4774 * base_point (in twilight zone)
4775 * edge[-1] (in twilight zone)
4776 * ... stuff for bci_align_segments (serif) ...
4777 *
4778 * uses: bci_serif_common
4779 * bci_lower_bound
4780 */
4783 {
4785 PUSHB_1,
4786 bci_action_serif_lower_bound,
4787 FDEF,
4789 PUSHB_1,
4790 bci_serif_common,
4791 CALL,
4793 PUSHB_1,
4794 bci_lower_bound,
4795 CALL,
4797 ENDF,
4799 };
4802 /*
4803 * bci_action_serif_upper_bound
4804 *
4805 * Handle the SERIF action to align a serif with its base, then moving it
4806 * again if necessary to stay within an upper bound.
4807 *
4808 * in: serif_point (in twilight zone)
4809 * base_point (in twilight zone)
4810 * edge[1] (in twilight zone)
4811 * ... stuff for bci_align_segments (serif) ...
4812 *
4813 * uses: bci_serif_common
4814 * bci_upper_bound
4815 */
4818 {
4820 PUSHB_1,
4821 bci_action_serif_upper_bound,
4822 FDEF,
4824 PUSHB_1,
4825 bci_serif_common,
4826 CALL,
4828 PUSHB_1,
4829 bci_upper_bound,
4830 CALL,
4832 ENDF,
4834 };
4837 /*
4838 * bci_action_serif_upper_lower_bound
4839 *
4840 * Handle the SERIF action to align a serif with its base, then moving it
4841 * again if necessary to stay within a lower and upper bound.
4842 *
4843 * in: serif_point (in twilight zone)
4844 * base_point (in twilight zone)
4845 * edge[-1] (in twilight zone)
4846 * edge[1] (in twilight zone)
4847 * ... stuff for bci_align_segments (serif) ...
4848 *
4849 * uses: bci_serif_common
4850 * bci_upper_lower_bound
4851 */
4854 {
4856 PUSHB_1,
4857 bci_action_serif_upper_lower_bound,
4858 FDEF,
4860 PUSHB_1,
4864 PUSHB_1,
4865 bci_serif_common,
4866 CALL,
4868 PUSHB_1,
4869 bci_upper_lower_bound,
4870 CALL,
4872 ENDF,
4874 };
4877 /*
4878 * bci_serif_anchor_common
4879 *
4880 * Common code for bci_action_serif_anchor routines.
4881 *
4882 * sal: sal_anchor
4883 *
4884 * uses: bci_round
4885 */
4888 {
4890 PUSHB_1,
4891 bci_serif_anchor_common,
4892 FDEF,
4894 PUSHB_1,
4898 DUP,
4899 PUSHB_1,
4900 sal_anchor,
4901 SWAP,
4904 DUP,
4905 DUP,
4906 DUP,
4907 GC_cur,
4908 SWAP,
4909 GC_orig,
4910 PUSHB_1,
4911 bci_round,
4913 SWAP,
4914 SUB,
4917 ENDF,
4919 };
4922 /*
4923 * bci_action_serif_anchor
4924 *
4925 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
4926 * anchor.
4927 *
4928 * in: edge_point (in twilight zone)
4929 * ... stuff for bci_align_segments (edge) ...
4930 *
4931 * uses: bci_serif_anchor_common
4932 * bci_align_segments
4933 */
4936 {
4938 PUSHB_1,
4939 bci_action_serif_anchor,
4940 FDEF,
4942 PUSHB_1,
4943 bci_serif_anchor_common,
4944 CALL,
4948 PUSHB_2,
4949 bci_align_segments,
4952 CALL,
4954 ENDF,
4956 };
4959 /*
4960 * bci_action_serif_anchor_lower_bound
4961 *
4962 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
4963 * anchor, then moving it again if necessary to stay within a lower
4964 * bound.
4965 *
4966 * in: edge_point (in twilight zone)
4967 * edge[-1] (in twilight zone)
4968 * ... stuff for bci_align_segments (edge) ...
4969 *
4970 * uses: bci_serif_anchor_common
4971 * bci_lower_bound
4972 */
4975 {
4977 PUSHB_1,
4978 bci_action_serif_anchor_lower_bound,
4979 FDEF,
4981 PUSHB_1,
4982 bci_serif_anchor_common,
4983 CALL,
4985 PUSHB_1,
4986 bci_lower_bound,
4987 CALL,
4989 ENDF,
4991 };
4994 /*
4995 * bci_action_serif_anchor_upper_bound
4996 *
4997 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
4998 * anchor, then moving it again if necessary to stay within an upper
4999 * bound.
5000 *
5001 * in: edge_point (in twilight zone)
5002 * edge[1] (in twilight zone)
5003 * ... stuff for bci_align_segments (edge) ...
5004 *
5005 * uses: bci_serif_anchor_common
5006 * bci_upper_bound
5007 */
5010 {
5012 PUSHB_1,
5013 bci_action_serif_anchor_upper_bound,
5014 FDEF,
5016 PUSHB_1,
5017 bci_serif_anchor_common,
5018 CALL,
5020 PUSHB_1,
5021 bci_upper_bound,
5022 CALL,
5024 ENDF,
5026 };
5029 /*
5030 * bci_action_serif_anchor_upper_lower_bound
5031 *
5032 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
5033 * anchor, then moving it again if necessary to stay within a lower and
5034 * upper bound.
5035 *
5036 * in: edge_point (in twilight zone)
5037 * edge[-1] (in twilight zone)
5038 * edge[1] (in twilight zone)
5039 * ... stuff for bci_align_segments (edge) ...
5040 *
5041 * uses: bci_serif_anchor_common
5042 * bci_upper_lower_bound
5043 */
5046 {
5048 PUSHB_1,
5049 bci_action_serif_anchor_upper_lower_bound,
5050 FDEF,
5052 PUSHB_1,
5053 bci_serif_anchor_common,
5054 CALL,
5056 PUSHB_1,
5057 bci_upper_lower_bound,
5058 CALL,
5060 ENDF,
5062 };
5065 /*
5066 * bci_serif_link1_common
5067 *
5068 * Common code for bci_action_serif_link1 routines.
5069 */
5072 {
5074 PUSHB_1,
5075 bci_serif_link1_common,
5076 FDEF,
5078 PUSHB_1,
5082 PUSHB_1,
5085 PUSHB_1,
5088 MD_orig_ZP2_0,
5089 PUSHB_1,
5094 DUP,
5096 SWAP,
5097 POP,
5099 ELSE,
5100 /* we have to execute `a*b/c', with b/c very near to 1: */
5101 /* to avoid overflow while retaining precision, */
5102 /* we transform this to `a + a * (b-c)/c' */
5104 PUSHB_1,
5107 PUSHB_1,
5112 DUP,
5113 PUSHB_1,
5116 PUSHB_1,
5121 PUSHB_1,
5124 PUSHB_1,
5129 PUSHB_1,
5134 PUSHW_2,
5141 SWAP,
5143 DUP,
5146 ELSE,
5148 EIF,
5154 SWAP,
5157 DUP,
5158 DUP,
5160 ROLL,
5164 POP,
5165 EIF,
5167 ENDF,
5169 };
5172 /*
5173 * bci_action_serif_link1
5174 *
5175 * Handle the SERIF_LINK1 action to align a serif, depending on edges
5176 * before and after.
5177 *
5178 * in: before_point (in twilight zone)
5179 * edge_point (in twilight zone)
5180 * after_point (in twilight zone)
5181 * ... stuff for bci_align_segments (edge) ...
5182 *
5183 * uses: bci_serif_link1_common
5184 * bci_align_segments
5185 */
5188 {
5190 PUSHB_1,
5191 bci_action_serif_link1,
5192 FDEF,
5194 PUSHB_1,
5195 bci_serif_link1_common,
5196 CALL,
5200 PUSHB_2,
5201 bci_align_segments,
5204 CALL,
5206 ENDF,
5208 };
5211 /*
5212 * bci_action_serif_link1_lower_bound
5213 *
5214 * Handle the SERIF_LINK1 action to align a serif, depending on edges
5215 * before and after. Additionally, move the serif again if necessary to
5216 * stay within a lower bound.
5217 *
5218 * in: before_point (in twilight zone)
5219 * edge_point (in twilight zone)
5220 * after_point (in twilight zone)
5221 * edge[-1] (in twilight zone)
5222 * ... stuff for bci_align_segments (edge) ...
5223 *
5224 * uses: bci_serif_link1_common
5225 * bci_lower_bound
5226 */
5229 {
5231 PUSHB_1,
5232 bci_action_serif_link1_lower_bound,
5233 FDEF,
5235 PUSHB_1,
5236 bci_serif_link1_common,
5237 CALL,
5239 PUSHB_1,
5240 bci_lower_bound,
5241 CALL,
5243 ENDF,
5245 };
5248 /*
5249 * bci_action_serif_link1_upper_bound
5250 *
5251 * Handle the SERIF_LINK1 action to align a serif, depending on edges
5252 * before and after. Additionally, move the serif again if necessary to
5253 * stay within an upper bound.
5254 *
5255 * in: before_point (in twilight zone)
5256 * edge_point (in twilight zone)
5257 * after_point (in twilight zone)
5258 * edge[1] (in twilight zone)
5259 * ... stuff for bci_align_segments (edge) ...
5260 *
5261 * uses: bci_serif_link1_common
5262 * bci_upper_bound
5263 */
5266 {
5268 PUSHB_1,
5269 bci_action_serif_link1_upper_bound,
5270 FDEF,
5272 PUSHB_1,
5273 bci_serif_link1_common,
5274 CALL,
5276 PUSHB_1,
5277 bci_upper_bound,
5278 CALL,
5280 ENDF,
5282 };
5285 /*
5286 * bci_action_serif_link1_upper_lower_bound
5287 *
5288 * Handle the SERIF_LINK1 action to align a serif, depending on edges
5289 * before and after. Additionally, move the serif again if necessary to
5290 * stay within a lower and upper bound.
5291 *
5292 * in: before_point (in twilight zone)
5293 * edge_point (in twilight zone)
5294 * after_point (in twilight zone)
5295 * edge[-1] (in twilight zone)
5296 * edge[1] (in twilight zone)
5297 * ... stuff for bci_align_segments (edge) ...
5298 *
5299 * uses: bci_serif_link1_common
5300 * bci_upper_lower_bound
5301 */
5304 {
5306 PUSHB_1,
5307 bci_action_serif_link1_upper_lower_bound,
5308 FDEF,
5310 PUSHB_1,
5311 bci_serif_link1_common,
5312 CALL,
5314 PUSHB_1,
5315 bci_upper_lower_bound,
5316 CALL,
5318 ENDF,
5320 };
5323 /*
5324 * bci_serif_link2_common
5325 *
5326 * Common code for bci_action_serif_link2 routines.
5327 *
5328 * sal: sal_anchor
5329 */
5332 {
5334 PUSHB_1,
5335 bci_serif_link2_common,
5336 FDEF,
5338 PUSHB_1,
5343 PUSHB_1,
5344 sal_anchor,
5345 RS,
5349 MD_orig_ZP2_0,
5350 DUP,
5351 ADD,
5352 PUSHB_1,
5354 ADD,
5355 FLOOR,
5358 SWAP,
5359 DUP,
5360 DUP,
5362 ROLL,
5365 ENDF,
5367 };
5370 /*
5371 * bci_action_serif_link2
5372 *
5373 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
5374 *
5375 * in: edge_point (in twilight zone)
5376 * ... stuff for bci_align_segments (edge) ...
5377 *
5378 * uses: bci_serif_link2_common
5379 * bci_align_segments
5380 */
5383 {
5385 PUSHB_1,
5386 bci_action_serif_link2,
5387 FDEF,
5389 PUSHB_1,
5390 bci_serif_link2_common,
5391 CALL,
5395 PUSHB_2,
5396 bci_align_segments,
5399 CALL,
5401 ENDF,
5403 };
5406 /*
5407 * bci_action_serif_link2_lower_bound
5408 *
5409 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
5410 * Additionally, move the serif again if necessary to stay within a lower
5411 * bound.
5412 *
5413 * in: edge_point (in twilight zone)
5414 * edge[-1] (in twilight zone)
5415 * ... stuff for bci_align_segments (edge) ...
5416 *
5417 * uses: bci_serif_link2_common
5418 * bci_lower_bound
5419 */
5422 {
5424 PUSHB_1,
5425 bci_action_serif_link2_lower_bound,
5426 FDEF,
5428 PUSHB_1,
5429 bci_serif_link2_common,
5430 CALL,
5432 PUSHB_1,
5433 bci_lower_bound,
5434 CALL,
5436 ENDF,
5438 };
5441 /*
5442 * bci_action_serif_link2_upper_bound
5443 *
5444 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
5445 * Additionally, move the serif again if necessary to stay within an upper
5446 * bound.
5447 *
5448 * in: edge_point (in twilight zone)
5449 * edge[1] (in twilight zone)
5450 * ... stuff for bci_align_segments (edge) ...
5451 *
5452 * uses: bci_serif_link2_common
5453 * bci_upper_bound
5454 */
5457 {
5459 PUSHB_1,
5460 bci_action_serif_link2_upper_bound,
5461 FDEF,
5463 PUSHB_1,
5464 bci_serif_link2_common,
5465 CALL,
5467 PUSHB_1,
5468 bci_upper_bound,
5469 CALL,
5471 ENDF,
5473 };
5476 /*
5477 * bci_action_serif_link2_upper_lower_bound
5478 *
5479 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
5480 * Additionally, move the serif again if necessary to stay within a lower
5481 * and upper bound.
5482 *
5483 * in: edge_point (in twilight zone)
5484 * edge[-1] (in twilight zone)
5485 * edge[1] (in twilight zone)
5486 * ... stuff for bci_align_segments (edge) ...
5487 *
5488 * uses: bci_serif_link2_common
5489 * bci_upper_lower_bound
5490 */
5493 {
5495 PUSHB_1,
5496 bci_action_serif_link2_upper_lower_bound,
5497 FDEF,
5499 PUSHB_1,
5500 bci_serif_link2_common,
5501 CALL,
5503 PUSHB_1,
5504 bci_upper_lower_bound,
5505 CALL,
5507 ENDF,
5509 };
5512 /*
5513 * bci_hint_glyph
5514 *
5515 * This is the top-level glyph hinting function which parses the arguments
5516 * on the stack and calls subroutines.
5517 *
5518 * in: action_0_func_idx
5519 * ... data ...
5520 * action_1_func_idx
5521 * ... data ...
5522 * ...
5523 *
5524 * CVT: cvtl_is_subglyph
5525 * cvtl_use_strong_functions
5526 *
5527 * sal: sal_stem_width_function
5528 *
5529 * uses: bci_action_ip_before
5530 * bci_action_ip_after
5531 * bci_action_ip_on
5532 * bci_action_ip_between
5533 *
5534 * bci_action_adjust_bound
5535 * bci_action_adjust_bound_serif
5536 * bci_action_adjust_bound_round
5537 * bci_action_adjust_bound_round_serif
5538 *
5539 * bci_action_stem_bound
5540 * bci_action_stem_bound_serif
5541 * bci_action_stem_bound_round
5542 * bci_action_stem_bound_round_serif
5543 *
5544 * bci_action_link
5545 * bci_action_link_serif
5546 * bci_action_link_round
5547 * bci_action_link_round_serif
5548 *
5549 * bci_action_anchor
5550 * bci_action_anchor_serif
5551 * bci_action_anchor_round
5552 * bci_action_anchor_round_serif
5553 *
5554 * bci_action_blue_anchor
5555 *
5556 * bci_action_adjust
5557 * bci_action_adjust_serif
5558 * bci_action_adjust_round
5559 * bci_action_adjust_round_serif
5560 *
5561 * bci_action_stem
5562 * bci_action_stem_serif
5563 * bci_action_stem_round
5564 * bci_action_stem_round_serif
5565 *
5566 * bci_action_blue
5567 *
5568 * bci_action_serif
5569 * bci_action_serif_lower_bound
5570 * bci_action_serif_upper_bound
5571 * bci_action_serif_upper_lower_bound
5572 *
5573 * bci_action_serif_anchor
5574 * bci_action_serif_anchor_lower_bound
5575 * bci_action_serif_anchor_upper_bound
5576 * bci_action_serif_anchor_upper_lower_bound
5577 *
5578 * bci_action_serif_link1
5579 * bci_action_serif_link1_lower_bound
5580 * bci_action_serif_link1_upper_bound
5581 * bci_action_serif_link1_upper_lower_bound
5582 *
5583 * bci_action_serif_link2
5584 * bci_action_serif_link2_lower_bound
5585 * bci_action_serif_link2_upper_bound
5586 * bci_action_serif_link2_upper_lower_bound
5587 */
5590 {
5592 PUSHB_1,
5593 bci_hint_glyph,
5594 FDEF,
5596 /* set up stem width function based on flag in CVT */
5597 PUSHB_4,
5598 sal_stem_width_function,
5599 bci_strong_stem_width,
5600 bci_smooth_stem_width,
5601 cvtl_use_strong_functions,
5602 RCVT,
5603 IF,
5604 POP,
5606 ELSE,
5607 SWAP,
5608 POP,
5610 EIF,
5611 WS,
5613 /* start_loop: */
5614 /* loop until all data on stack is used */
5615 CALL,
5616 PUSHB_1,
5618 NEG,
5619 PUSHB_1,
5621 DEPTH,
5622 LT,
5625 PUSHB_1,
5628 IUP_y,
5630 ENDF,
5632 };
5635 #define COPY_FPGM(func_name) \
5636 do \
5637 { \
5638 memcpy(bufp, fpgm_ ## func_name, \
5639 sizeof (fpgm_ ## func_name)); \
5640 bufp += sizeof (fpgm_ ## func_name); \
5641 } while (0)
5643 static FT_Error
5648 {
5652 FT_UInt buf_len;
5653 FT_UInt len;
5658 /* for compatibility with dumb bytecode interpreters or analyzers, */
5659 /* FDEFs are stored in ascending index order, without holes -- */
5660 /* note that some FDEFs are not always needed */
5661 /* (depending on options of `TTFautohint'), */
5662 /* but implementing dynamic FDEF indices would be a lot of work */
5825 /* buffer length must be a multiple of four */
5831 /* pad end of buffer with zeros */
5836 /* copy font program into buffer and fill in the missing variables */
5841 {
5846 }
5847 else
6006 }
6009 FT_Error
6012 {
6013 FT_Error error;
6019 FT_ULong fpgm_len;
6026 /* `glyf', `cvt', `fpgm', and `prep' are always used in parallel */
6028 {
6031 }
6040 /* in case of success, `fpgm_buf' gets linked */
6041 /* and is eventually freed in `TA_font_unload' */
6047 else
6050 Exit:
6052 }
6054 /* end of tafpgm.c */