?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use constants for default values.
[ttfautohint.git] / lib / tafpgm.c
blob8f4113a327fe06627069ffbddf73c32dc5d6e09a
1 /* tafpgm.c */
2
3 /*
4 * Copyright (C) 2011-2012 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 */
14
15
16 #include "ta.h"
17
18
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') */
22
23 #define FPGM(func_name) fpgm_ ## func_name
24
25
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
37
38 #define MD_orig_ZP2_0 \
39 MD_orig_fixed
40
41 #define MD_orig_ZP2_1 \
42 PUSHB_1, \
43 0, \
44 SZP2, \
45 MD_orig_fixed, \
46 PUSHB_1, \
47 1, \
48 SZP2
49
50
51 /* a convenience shorthand for scaling; see `bci_cvt_rescale' for details */
52 #define DO_SCALE \
53 DUP, /* s: a a */ \
54 PUSHB_1, \
55 cvtl_scale, \
56 RCVT, \
57 MUL, /* delta * 2^10 */ \
58 PUSHB_1, \
59 cvtl_0x10000, \
60 RCVT, \
61 DIV, /* delta */ \
62 ADD /* a + delta */
63
64
65 /* in the comments below, the top of the stack (`s:') */
66 /* is the rightmost element; the stack is shown */
67 /* after the instruction on the same line has been executed */
68
69
70 /*
71 * bci_round
72 *
73 * Round a 26.6 number. Contrary to the ROUND bytecode instruction, no
74 * engine specific corrections are applied.
75 *
76 * in: val
77 * out: ROUND(val)
78 */
79
80 unsigned char FPGM(bci_round) [] =
81 {
82
83 PUSHB_1,
84 bci_round,
85 FDEF,
86
87 DUP,
88 ABS,
89 PUSHB_1,
90 32,
91 ADD,
92 FLOOR,
93 SWAP,
94 PUSHB_1,
95 0,
96 LT,
97 IF,
98 NEG,
99 EIF,
100
101 ENDF,
102
103 };
104
105
106 /*
107 * bci_compute_stem_width
108 *
109 * This is the equivalent to the following code from function
110 * `ta_latin_compute_stem_width':
111 *
112 * dist = ABS(width)
113 *
114 * if (stem_is_serif
115 * && dist < 3*64)
116 * || is_extra_light:
117 * return width
118 * else if base_is_round:
119 * if dist < 80
120 * dist = 64
121 * else if dist < 56:
122 * dist = 56
123 *
124 * delta = ABS(dist - std_width)
125 *
126 * if delta < 40:
127 * dist = std_width
128 * if dist < 48
129 * dist = 48
130 * goto End
131 *
132 * if dist < 3*64:
133 * delta = dist
134 * dist = FLOOR(dist)
135 * delta = delta - dist
136 *
137 * if delta < 10:
138 * dist = dist + delta
139 * else if delta < 32:
140 * dist = dist + 10
141 * else if delta < 54:
142 * dist = dist + 54
143 * else
144 * dist = dist + delta
145 * else
146 * dist = ROUND(dist)
147 *
148 * End:
149 * if width < 0:
150 * dist = -dist
151 * return dist
152 *
153 *
154 * in: width
155 * stem_is_serif
156 * base_is_round
157 *
158 * out: new_width
159 *
160 * CVT: cvtl_is_extra_light
161 * std_width
162 */
163
164 unsigned char FPGM(bci_compute_stem_width_a) [] =
165 {
166
167 PUSHB_1,
168 bci_compute_stem_width,
169 FDEF,
170
171 DUP,
172 ABS, /* s: base_is_round stem_is_serif width dist */
173
174 DUP,
175 PUSHB_1,
176 3*64,
177 LT, /* dist < 3*64 */
178
179 PUSHB_1,
180 4,
181 MINDEX, /* s: base_is_round width dist (dist<3*64) stem_is_serif */
182 AND, /* stem_is_serif && dist < 3*64 */
183
184 PUSHB_1,
185 cvtl_is_extra_light,
186 RCVT,
187 OR, /* (stem_is_serif && dist < 3*64) || is_extra_light */
188
189 IF, /* s: base_is_round width dist */
190 POP,
191 SWAP,
192 POP, /* s: width */
193
194 ELSE,
195 ROLL, /* s: width dist base_is_round */
196 IF, /* s: width dist */
197 DUP,
198 PUSHB_1,
199 80,
200 LT, /* dist < 80 */
201 IF, /* s: width dist */
202 POP,
203 PUSHB_1,
204 64, /* dist = 64 */
205 EIF,
206
207 ELSE,
208 DUP,
209 PUSHB_1,
210 56,
211 LT, /* dist < 56 */
212 IF, /* s: width dist */
213 POP,
214 PUSHB_1,
215 56, /* dist = 56 */
216 EIF,
217 EIF,
218
219 DUP, /* s: width dist dist */
220 PUSHB_1,
221
222 };
223
224 /* %c, index of std_width */
225
226 unsigned char FPGM(bci_compute_stem_width_b) [] =
227 {
228
229 RCVT,
230 SUB,
231 ABS, /* s: width dist delta */
232
233 PUSHB_1,
234 40,
235 LT, /* delta < 40 */
236 IF, /* s: width dist */
237 POP,
238 PUSHB_1,
239
240 };
241
242 /* %c, index of std_width */
243
244 unsigned char FPGM(bci_compute_stem_width_c) [] =
245 {
246
247 RCVT, /* dist = std_width */
248 DUP,
249 PUSHB_1,
250 48,
251 LT, /* dist < 48 */
252 IF,
253 POP,
254 PUSHB_1,
255 48, /* dist = 48 */
256 EIF,
257
258 ELSE,
259 DUP, /* s: width dist dist */
260 PUSHB_1,
261 3*64,
262 LT, /* dist < 3*64 */
263 IF,
264 DUP, /* s: width delta dist */
265 FLOOR, /* dist = FLOOR(dist) */
266 DUP, /* s: width delta dist dist */
267 ROLL,
268 ROLL, /* s: width dist delta dist */
269 SUB, /* delta = delta - dist */
270
271 DUP, /* s: width dist delta delta */
272 PUSHB_1,
273 10,
274 LT, /* delta < 10 */
275 IF, /* s: width dist delta */
276 ADD, /* dist = dist + delta */
277
278 ELSE,
279 DUP,
280 PUSHB_1,
281 32,
282 LT, /* delta < 32 */
283 IF,
284 POP,
285 PUSHB_1,
286 10,
287 ADD, /* dist = dist + 10 */
288
289 ELSE,
290 DUP,
291 PUSHB_1,
292 54,
293 LT, /* delta < 54 */
294 IF,
295 POP,
296 PUSHB_1,
297 54,
298 ADD, /* dist = dist + 54 */
299
300 ELSE,
301 ADD, /* dist = dist + delta */
302
303 EIF,
304 EIF,
305 EIF,
306
307 ELSE,
308 PUSHB_1,
309 bci_round,
310 CALL, /* dist = round(dist) */
311
312 EIF,
313 EIF,
314
315 SWAP, /* s: dist width */
316 PUSHB_1,
317 0,
318 LT, /* width < 0 */
319 IF,
320 NEG, /* dist = -dist */
321 EIF,
322 EIF,
323
324 ENDF,
325
326 };
327
328
329 /*
330 * bci_loop
331 *
332 * Take a range and a function number and apply the function to all
333 * elements of the range.
334 *
335 * in: func_num
336 * end
337 * start
338 *
339 * sal: sal_i (counter initialized with `start')
340 * sal_limit (`end')
341 * sal_func (`func_num')
342 */
343
344 unsigned char FPGM(bci_loop) [] =
345 {
346
347 PUSHB_1,
348 bci_loop,
349 FDEF,
350
351 PUSHB_1,
352 sal_func,
353 SWAP,
354 WS, /* sal_func = func_num */
355 PUSHB_1,
356 sal_limit,
357 SWAP,
358 WS, /* sal_limit = end */
359 PUSHB_1,
360 sal_i,
361 SWAP,
362 WS, /* sal_i = start */
363
364 /* start_loop: */
365 PUSHB_1,
366 sal_i,
367 RS,
368 PUSHB_1,
369 sal_limit,
370 RS,
371 LTEQ, /* start <= end */
372 IF,
373 PUSHB_1,
374 sal_func,
375 RS,
376 CALL,
377 PUSHB_3,
378 sal_i,
379 1,
380 sal_i,
381 RS,
382 ADD, /* start = start + 1 */
383 WS,
384
385 PUSHB_1,
386 22,
387 NEG,
388 JMPR, /* goto start_loop */
389 EIF,
390
391 ENDF,
392
393 };
394
395
396 /*
397 * bci_cvt_rescale
398 *
399 * Rescale CVT value by `cvtl_scale' (in 16.16 format).
400 *
401 * The scaling factor `cvtl_scale' isn't stored as `b/c' but as `(b-c)/c';
402 * consequently, the calculation `a * b/c' is done as `a + delta' with
403 * `delta = a * (b-c)/c'. This avoids overflow.
404 *
405 * sal: sal_i (CVT index)
406 *
407 * CVT: cvtl_scale
408 * cvtl_0x10000
409 */
410
411 unsigned char FPGM(bci_cvt_rescale) [] =
412 {
413
414 PUSHB_1,
415 bci_cvt_rescale,
416 FDEF,
417
418 PUSHB_1,
419 sal_i,
420 RS,
421 DUP,
422 RCVT,
423 DO_SCALE,
424 WCVTP,
425
426 ENDF,
427
428 };
429
430
431 /*
432 * bci_blue_round
433 *
434 * Round a blue ref value and adjust its corresponding shoot value.
435 *
436 * sal: sal_i (CVT index)
437 *
438 */
439
440 unsigned char FPGM(bci_blue_round_a) [] =
441 {
442
443 PUSHB_1,
444 bci_blue_round,
445 FDEF,
446
447 PUSHB_1,
448 sal_i,
449 RS,
450 DUP,
451 RCVT, /* s: ref_idx ref */
452
453 DUP,
454 PUSHB_1,
455 bci_round,
456 CALL,
457 SWAP, /* s: ref_idx round(ref) ref */
458
459 PUSHB_2,
460
461 };
462
463 /* %c, blue_count */
464
465 unsigned char FPGM(bci_blue_round_b) [] =
466 {
467
468 4,
469 CINDEX,
470 ADD, /* s: ref_idx round(ref) ref shoot_idx */
471 DUP,
472 RCVT, /* s: ref_idx round(ref) ref shoot_idx shoot */
473
474 ROLL, /* s: ref_idx round(ref) shoot_idx shoot ref */
475 SWAP,
476 SUB, /* s: ref_idx round(ref) shoot_idx dist */
477 DUP,
478 ABS, /* s: ref_idx round(ref) shoot_idx dist delta */
479
480 DUP,
481 PUSHB_1,
482 32,
483 LT, /* delta < 32 */
484 IF,
485 POP,
486 PUSHB_1,
487 0, /* delta = 0 */
488
489 ELSE,
490 PUSHB_1,
491 48,
492 LT, /* delta < 48 */
493 IF,
494 PUSHB_1,
495 32, /* delta = 32 */
496
497 ELSE,
498 PUSHB_1,
499 64, /* delta = 64 */
500 EIF,
501 EIF,
502
503 SWAP, /* s: ref_idx round(ref) shoot_idx delta dist */
504 PUSHB_1,
505 0,
506 LT, /* dist < 0 */
507 IF,
508 NEG, /* delta = -delta */
509 EIF,
510
511 PUSHB_1,
512 3,
513 CINDEX,
514 SWAP,
515 SUB, /* s: ref_idx round(ref) shoot_idx (round(ref) - delta) */
516
517 WCVTP,
518 WCVTP,
519
520 ENDF,
521
522 };
523
524
525 /*
526 * bci_decrement_component_counter
527 *
528 * An auxiliary function for composite glyphs.
529 *
530 * CVT: cvtl_is_subglyph
531 */
532
533 unsigned char FPGM(bci_decrement_component_counter) [] =
534 {
535
536 PUSHB_1,
537 bci_decrement_component_counter,
538 FDEF,
539
540 /* decrement `cvtl_is_subglyph' counter */
541 PUSHB_2,
542 cvtl_is_subglyph,
543 cvtl_is_subglyph,
544 RCVT,
545 PUSHB_1,
546 1,
547 SUB,
548 WCVTP,
549
550 ENDF,
551
552 };
553
554
555 /*
556 * bci_get_point_extrema
557 *
558 * An auxiliary function for `bci_create_segment'.
559 *
560 * in: point-1
561 * out: point
562 *
563 * sal: sal_point_min
564 * sal_point_max
565 */
566
567 unsigned char FPGM(bci_get_point_extrema) [] =
568 {
569
570 PUSHB_1,
571 bci_get_point_extrema,
572 FDEF,
573
574 PUSHB_1,
575 1,
576 ADD, /* s: point */
577 DUP,
578 DUP,
579
580 /* check whether `point' is a new minimum */
581 PUSHB_1,
582 sal_point_min,
583 RS, /* s: point point point point_min */
584 MD_orig,
585 /* if distance is negative, we have a new minimum */
586 PUSHB_1,
587 0,
588 LT,
589 IF, /* s: point point */
590 DUP,
591 PUSHB_1,
592 sal_point_min,
593 SWAP,
594 WS,
595 EIF,
596
597 /* check whether `point' is a new maximum */
598 PUSHB_1,
599 sal_point_max,
600 RS, /* s: point point point_max */
601 MD_orig,
602 /* if distance is positive, we have a new maximum */
603 PUSHB_1,
604 0,
605 GT,
606 IF, /* s: point */
607 DUP,
608 PUSHB_1,
609 sal_point_max,
610 SWAP,
611 WS,
612 EIF, /* s: point */
613
614 ENDF,
615
616 };
617
618
619 /*
620 * bci_create_segment
621 *
622 * Store start and end point of a segment in the storage area,
623 * then construct a point in the twilight zone to represent it.
624 *
625 * This function is used by `bci_create_segment_points'.
626 *
627 * in: start
628 * end
629 * [last (if wrap-around segment)]
630 * [first (if wrap-around segment)]
631 *
632 * uses: bci_get_point_extrema
633 *
634 * sal: sal_i (start of current segment)
635 * sal_j (current twilight point)
636 * sal_point_min
637 * sal_point_max
638 *
639 * CVT: cvtl_scale
640 * cvtl_0x10000
641 * cvtl_temp
642 */
643
644 unsigned char FPGM(bci_create_segment) [] =
645 {
646
647 PUSHB_1,
648 bci_create_segment,
649 FDEF,
650
651 PUSHB_1,
652 sal_i,
653 RS,
654 PUSHB_1,
655 2,
656 CINDEX,
657 WS, /* sal[sal_i] = start */
658
659 /* increase `sal_i'; together with the outer loop, this makes sal_i += 2 */
660 PUSHB_3,
661 sal_i,
662 1,
663 sal_i,
664 RS,
665 ADD, /* sal_i = sal_i + 1 */
666 WS,
667
668 /* initialize inner loop(s) */
669 PUSHB_2,
670 sal_point_min,
671 2,
672 CINDEX,
673 WS, /* sal_point_min = start */
674 PUSHB_2,
675 sal_point_max,
676 2,
677 CINDEX,
678 WS, /* sal_point_max = start */
679
680 PUSHB_1,
681 1,
682 SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
683
684 SWAP,
685 DUP,
686 PUSHB_1,
687 3,
688 CINDEX, /* s: start end end start */
689 LT, /* start > end */
690 IF,
691 /* we have a wrap-around segment with two more arguments */
692 /* to give the last and first point of the contour, respectively; */
693 /* our job is to store a segment `start'-`last', */
694 /* and to get extrema for the two segments */
695 /* `start'-`last' and `first'-`end' */
696
697 /* s: first last start end */
698 PUSHB_1,
699 sal_i,
700 RS,
701 PUSHB_1,
702 4,
703 CINDEX,
704 WS, /* sal[sal_i] = last */
705
706 ROLL,
707 ROLL, /* s: first end last start */
708 DUP,
709 ROLL,
710 SWAP, /* s: first end start last start */
711 SUB, /* s: first end start loop_count */
712
713 PUSHB_1,
714 bci_get_point_extrema,
715 LOOPCALL,
716 /* clean up stack */
717 POP,
718
719 SWAP, /* s: end first */
720 PUSHB_1,
721 1,
722 SUB,
723 DUP,
724 ROLL, /* s: (first - 1) (first - 1) end */
725 SWAP,
726 SUB, /* s: (first - 1) loop_count */
727
728 PUSHB_1,
729 bci_get_point_extrema,
730 LOOPCALL,
731 /* clean up stack */
732 POP,
733
734 ELSE, /* s: start end */
735 PUSHB_1,
736 sal_i,
737 RS,
738 PUSHB_1,
739 2,
740 CINDEX,
741 WS, /* sal[sal_i] = end */
742
743 PUSHB_1,
744 2,
745 CINDEX,
746 SUB, /* s: start loop_count */
747
748 PUSHB_1,
749 bci_get_point_extrema,
750 LOOPCALL,
751 /* clean up stack */
752 POP,
753 EIF,
754
755 /* the twilight point representing a segment */
756 /* is in the middle between the minimum and maximum */
757 PUSHB_1,
758 sal_point_min,
759 RS,
760 GC_orig,
761 PUSHB_1,
762 sal_point_max,
763 RS,
764 GC_orig,
765 ADD,
766 PUSHB_1,
767 2*64,
768 DIV, /* s: middle_pos */
769
770 DO_SCALE, /* middle_pos = middle_pos * scale */
771
772 /* write it to temporary CVT location */
773 PUSHB_2,
774 cvtl_temp,
775 0,
776 SZP0, /* set zp0 to twilight zone 0 */
777 SWAP,
778 WCVTP,
779
780 /* create twilight point with index `sal_j' */
781 PUSHB_1,
782 sal_j,
783 RS,
784 PUSHB_1,
785 cvtl_temp,
786 MIAP_noround,
787
788 PUSHB_3,
789 sal_j,
790 1,
791 sal_j,
792 RS,
793 ADD, /* twilight_point = twilight_point + 1 */
794 WS,
795
796 ENDF,
797
798 };
799
800
801 /*
802 * bci_create_segments
803 *
804 * Set up segments by defining point ranges which defines them
805 * and computing twilight points to represent them.
806 *
807 * in: num_segments (N)
808 * segment_start_0
809 * segment_end_0
810 * [contour_last 0 (if wrap-around segment)]
811 * [contour_first 0 (if wrap-around segment)]
812 * segment_start_1
813 * segment_end_1
814 * [contour_last 0 (if wrap-around segment)]
815 * [contour_first 0 (if wrap-around segment)]
816 * ...
817 * segment_start_(N-1)
818 * segment_end_(N-1)
819 * [contour_last (N-1) (if wrap-around segment)]
820 * [contour_first (N-1) (if wrap-around segment)]
821 *
822 * uses: bci_create_segment
823 *
824 * sal: sal_i (start of current segment)
825 * sal_j (current twilight point)
826 *
827 * CVT: cvtl_is_subglyph
828 */
829
830 unsigned char FPGM(bci_create_segments) [] =
831 {
832
833 PUSHB_1,
834 bci_create_segments,
835 FDEF,
836
837 /* only do something if we are not a subglyph */
838 PUSHB_2,
839 0,
840 cvtl_is_subglyph,
841 RCVT,
842 EQ,
843 IF,
844 /* all our measurements are taken along the y axis */
845 SVTCA_y,
846
847 DUP,
848 ADD,
849 PUSHB_1,
850 1,
851 SUB, /* delta = (2*num_segments - 1) */
852
853 PUSHB_4,
854 sal_segment_offset,
855 sal_segment_offset,
856
857 sal_j,
858 0,
859 WS, /* sal_j = 0 (point offset) */
860
861 ROLL,
862 ADD, /* s: ... sal_segment_offset (sal_segment_offset + delta) */
863
864 /* `bci_create_segment_point' also increases the loop counter by 1; */
865 /* this effectively means we have a loop step of 2 */
866 PUSHB_2,
867 bci_create_segment,
868 bci_loop,
869 CALL,
870
871 ELSE,
872 CLEAR,
873 EIF,
874
875 ENDF,
876
877 };
878
879
880 /*
881 * bci_create_segments_composite
882 *
883 * The same as `bci_create_composite'.
884 * It also decrements the composite component counter.
885 *
886 * uses: bci_decrement_composite_counter
887 *
888 * CVT: cvtl_is_subglyph
889 */
890
891 unsigned char FPGM(bci_create_segments_composite) [] =
892 {
893
894 PUSHB_1,
895 bci_create_segments_composite,
896 FDEF,
897
898 PUSHB_1,
899 bci_decrement_component_counter,
900 CALL,
901
902 /* only do something if we are not a subglyph */
903 PUSHB_2,
904 0,
905 cvtl_is_subglyph,
906 RCVT,
907 EQ,
908 IF,
909 /* all our measurements are taken along the y axis */
910 SVTCA_y,
911
912 DUP,
913 ADD,
914 PUSHB_1,
915 1,
916 SUB, /* delta = (2*num_segments - 1) */
917
918 PUSHB_4,
919 sal_segment_offset,
920 sal_segment_offset,
921
922 sal_j,
923 0,
924 WS, /* sal_j = 0 (point offset) */
925
926 ROLL,
927 ADD, /* s: ... sal_segment_offset (sal_segment_offset + delta) */
928
929 /* `bci_create_segment_point' also increases the loop counter by 1; */
930 /* this effectively means we have a loop step of 2 */
931 PUSHB_2,
932 bci_create_segment,
933 bci_loop,
934 CALL,
935
936 ELSE,
937 CLEAR,
938 EIF,
939
940 ENDF,
941
942 };
943
944
945 /*
946 * bci_align_segment
947 *
948 * Align all points in a segment to the twilight point in rp0.
949 * zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
950 *
951 * in: segment_index
952 */
953
954 unsigned char FPGM(bci_align_segment) [] =
955 {
956
957 PUSHB_1,
958 bci_align_segment,
959 FDEF,
960
961 /* we need the values of `sal_segment_offset + 2*segment_index' */
962 /* and `sal_segment_offset + 2*segment_index + 1' */
963 DUP,
964 ADD,
965 PUSHB_1,
966 sal_segment_offset,
967 ADD,
968 DUP,
969 RS,
970 SWAP,
971 PUSHB_1,
972 1,
973 ADD,
974 RS, /* s: first last */
975
976 /* start_loop: */
977 PUSHB_1,
978 2,
979 CINDEX, /* s: first last first */
980 PUSHB_1,
981 2,
982 CINDEX, /* s: first last first last */
983 LTEQ, /* first <= end */
984 IF, /* s: first last */
985 SWAP,
986 DUP, /* s: last first first */
987 ALIGNRP, /* align point with index `first' with rp0 */
988
989 PUSHB_1,
990 1,
991 ADD, /* first = first + 1 */
992 SWAP, /* s: first last */
993
994 PUSHB_1,
995 18,
996 NEG,
997 JMPR, /* goto start_loop */
998
999 ELSE,
1000 POP,
1001 POP,
1002 EIF,
1003
1004 ENDF,
1005
1006 };
1007
1008
1009 /*
1010 * bci_align_segments
1011 *
1012 * Align segments to the twilight point in rp0.
1013 * zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
1014 *
1015 * in: first_segment
1016 * loop_counter (N)
1017 * segment_1
1018 * segment_2
1019 * ...
1020 * segment_N
1021 *
1022 * uses: handle_segment
1023 *
1024 */
1025
1026 unsigned char FPGM(bci_align_segments) [] =
1027 {
1028
1029 PUSHB_1,
1030 bci_align_segments,
1031 FDEF,
1032
1033 PUSHB_1,
1034 bci_align_segment,
1035 CALL,
1036
1037 PUSHB_1,
1038 bci_align_segment,
1039 LOOPCALL,
1040
1041 ENDF,
1042
1043 };
1044
1045
1046 /*
1047 * bci_scale_contour
1048 *
1049 * Scale a contour using two points giving the maximum and minimum
1050 * coordinates.
1051 *
1052 * It expects that no point on the contour is touched.
1053 *
1054 * in: min_point
1055 * max_point
1056 *
1057 * CVT: cvtl_scale
1058 * cvtl_0x10000
1059 */
1060
1061 unsigned char FPGM(bci_scale_contour) [] =
1062 {
1063
1064 PUSHB_1,
1065 bci_scale_contour,
1066 FDEF,
1067
1068 DUP,
1069 DUP,
1070 GC_orig,
1071 DUP,
1072 DO_SCALE, /* min_pos_new = min_pos * scale */
1073 SWAP,
1074 SUB,
1075 SHPIX,
1076
1077 /* don't scale a single-point contour twice */
1078 SWAP,
1079 DUP,
1080 ROLL,
1081 NEQ,
1082 IF,
1083 DUP,
1084 GC_orig,
1085 DUP,
1086 DO_SCALE, /* max_pos_new = max_pos * scale */
1087 SWAP,
1088 SUB,
1089 SHPIX,
1090
1091 ELSE,
1092 POP,
1093 EIF,
1094
1095 ENDF,
1096
1097 };
1098
1099
1100 /*
1101 * bci_scale_glyph
1102 *
1103 * Scale a glyph using a list of points (two points per contour, giving
1104 * the maximum and mininum coordinates).
1105 *
1106 * It expects that no point in the glyph is touched.
1107 *
1108 * in: num_contours (N)
1109 * min_point_1
1110 * max_point_1
1111 * min_point_2
1112 * max_point_2
1113 * ...
1114 * min_point_N
1115 * max_point_N
1116 *
1117 * uses: bci_scale_contour
1118 *
1119 * CVT: cvtl_is_subglyph
1120 */
1121
1122 unsigned char FPGM(bci_scale_glyph) [] =
1123 {
1124
1125 PUSHB_1,
1126 bci_scale_glyph,
1127 FDEF,
1128
1129 /* only do something if we are not a subglyph */
1130 PUSHB_2,
1131 0,
1132 cvtl_is_subglyph,
1133 RCVT,
1134 EQ,
1135 IF,
1136 /* all our measurements are taken along the y axis */
1137 SVTCA_y,
1138
1139 PUSHB_1,
1140 1,
1141 SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
1142
1143 PUSHB_1,
1144 bci_scale_contour,
1145 LOOPCALL,
1146
1147 PUSHB_1,
1148 1,
1149 SZP2, /* set zp2 to normal zone 1 */
1150 IUP_y,
1151
1152 ELSE,
1153 CLEAR,
1154 EIF,
1155
1156 ENDF,
1157
1158 };
1159
1160
1161 /*
1162 * bci_scale_composite_glyph
1163 *
1164 * The same as `bci_scale_composite_glyph'.
1165 * It also decrements the composite component counter.
1166 *
1167 * uses: bci_decrement_component_counter
1168 *
1169 * CVT: cvtl_is_subglyph
1170 */
1171
1172 unsigned char FPGM(bci_scale_composite_glyph) [] =
1173 {
1174
1175 PUSHB_1,
1176 bci_scale_composite_glyph,
1177 FDEF,
1178
1179 PUSHB_1,
1180 bci_decrement_component_counter,
1181 CALL,
1182
1183 /* only do something if we are not a subglyph */
1184 PUSHB_2,
1185 0,
1186 cvtl_is_subglyph,
1187 RCVT,
1188 EQ,
1189 IF,
1190 /* all our measurements are taken along the y axis */
1191 SVTCA_y,
1192
1193 PUSHB_1,
1194 1,
1195 SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
1196
1197 PUSHB_1,
1198 bci_scale_contour,
1199 LOOPCALL,
1200
1201 PUSHB_1,
1202 1,
1203 SZP2, /* set zp2 to normal zone 1 */
1204 IUP_y,
1205
1206 ELSE,
1207 CLEAR,
1208 EIF,
1209
1210 ENDF,
1211
1212 };
1213
1214
1215 /*
1216 * bci_shift_contour
1217 *
1218 * Shift a contour by a given amount.
1219 *
1220 * It expects that rp1 (pointed to by zp0) is set up properly; zp2 must
1221 * point to the normal zone 1.
1222 *
1223 * in: contour
1224 * out: contour + 1
1225 */
1226
1227 unsigned char FPGM(bci_shift_contour) [] =
1228 {
1229
1230 PUSHB_1,
1231 bci_shift_contour,
1232 FDEF,
1233
1234 DUP,
1235 SHC_rp1, /* shift `contour' by (rp1_pos - rp1_orig_pos) */
1236
1237 PUSHB_1,
1238 1,
1239 ADD,
1240
1241 ENDF,
1242
1243 };
1244
1245
1246 /*
1247 * bci_shift_subglyph
1248 *
1249 * Shift a subglyph. To be more specific, it corrects the already applied
1250 * subglyph offset (if any) from the `glyf' table which needs to be scaled
1251 * also.
1252 *
1253 * If this function is called, a point `x' in the subglyph has been scaled
1254 * already (during the hinting of the subglyph itself), and `offset' has
1255 * been applied also:
1256 *
1257 * x -> x * scale + offset (1)
1258 *
1259 * However, the offset should be applied first, then the scaling:
1260 *
1261 * x -> (x + offset) * scale (2)
1262 *
1263 * Our job is now to transform (1) to (2); a simple calculation shows that
1264 * we have to shift all points of the subglyph by
1265 *
1266 * offset * scale - offset = offset * (scale - 1)
1267 *
1268 * Note that `cvtl_scale' is equal to the above `scale - 1'.
1269 *
1270 * in: offset (in FUnits)
1271 * num_contours
1272 * first_contour
1273 *
1274 * CVT: cvtl_funits_to_pixels
1275 * cvtl_0x10000
1276 * cvtl_scale
1277 */
1278
1279 unsigned char FPGM(bci_shift_subglyph) [] =
1280 {
1281
1282 PUSHB_1,
1283 bci_shift_subglyph,
1284 FDEF,
1285
1286 SVTCA_y,
1287
1288 PUSHB_1,
1289 cvtl_funits_to_pixels,
1290 RCVT, /* scaling factor FUnits -> pixels */
1291 MUL,
1292 PUSHB_1,
1293 cvtl_0x10000,
1294 RCVT,
1295 DIV,
1296
1297 /* the autohinter always rounds offsets */
1298 PUSHB_1,
1299 bci_round,
1300 CALL, /* offset = round(offset) */
1301
1302 PUSHB_1,
1303 cvtl_scale,
1304 RCVT,
1305 MUL,
1306 PUSHB_1,
1307 cvtl_0x10000,
1308 RCVT,
1309 DIV, /* delta = offset * (scale - 1) */
1310
1311 /* and round again */
1312 PUSHB_1,
1313 bci_round,
1314 CALL, /* offset = round(offset) */
1315
1316 PUSHB_1,
1317 0,
1318 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1319
1320 /* we create twilight point 0 as a reference point, */
1321 /* setting the original position to zero (using `cvtl_temp') */
1322 PUSHB_5,
1323 0,
1324 0,
1325 cvtl_temp,
1326 cvtl_temp,
1327 0,
1328 WCVTP,
1329 MIAP_noround, /* rp0 and rp1 now point to twilight point 0 */
1330
1331 SWAP, /* s: first_contour num_contours 0 delta */
1332 SHPIX, /* rp1_pos - rp1_orig_pos = delta */
1333
1334 PUSHB_2,
1335 bci_shift_contour,
1336 1,
1337 SZP2, /* set zp2 to normal zone 1 */
1338 LOOPCALL,
1339
1340 ENDF,
1341
1342 };
1343
1344
1345 /*
1346 * bci_ip_outer_align_point
1347 *
1348 * Auxiliary function for `bci_action_ip_before' and
1349 * `bci_action_ip_after'.
1350 *
1351 * It expects rp0 to contain the edge for alignment, zp0 set to twilight
1352 * zone, and both zp1 and zp2 set to normal zone.
1353 *
1354 * in: point
1355 *
1356 * sal: sal_i (edge_orig_pos)
1357 *
1358 * CVT: cvtl_scale
1359 * cvtl_0x10000
1360 */
1361
1362 unsigned char FPGM(bci_ip_outer_align_point) [] =
1363 {
1364
1365 PUSHB_1,
1366 bci_ip_outer_align_point,
1367 FDEF,
1368
1369 DUP,
1370 ALIGNRP, /* align `point' with `edge' */
1371 DUP,
1372 GC_orig,
1373 DO_SCALE, /* point_orig_pos = point_orig_pos * scale */
1374
1375 PUSHB_1,
1376 sal_i,
1377 RS,
1378 SUB, /* s: point (point_orig_pos - edge_orig_pos) */
1379 SHPIX,
1380
1381 ENDF,
1382
1383 };
1384
1385
1386 /*
1387 * bci_ip_on_align_points
1388 *
1389 * Auxiliary function for `bci_action_ip_on'.
1390 *
1391 * in: edge (in twilight zone)
1392 * loop_counter (N)
1393 * point_1
1394 * point_2
1395 * ...
1396 * point_N
1397 */
1398
1399 unsigned char FPGM(bci_ip_on_align_points) [] =
1400 {
1401
1402 PUSHB_1,
1403 bci_ip_on_align_points,
1404 FDEF,
1405
1406 MDAP_noround, /* set rp0 and rp1 to `edge' */
1407
1408 SLOOP,
1409 ALIGNRP,
1410
1411 ENDF,
1412
1413 };
1414
1415
1416 /*
1417 * bci_ip_between_align_point
1418 *
1419 * Auxiliary function for `bci_ip_between_align_points'.
1420 *
1421 * It expects rp0 to contain the edge for alignment, zp0 set to twilight
1422 * zone, and both zp1 and zp2 set to normal zone.
1423 *
1424 * in: point
1425 *
1426 * sal: sal_i (edge_orig_pos)
1427 * sal_j (stretch_factor)
1428 *
1429 * CVT: cvtl_scale
1430 * cvtl_0x10000
1431 */
1432
1433 unsigned char FPGM(bci_ip_between_align_point) [] =
1434 {
1435
1436 PUSHB_1,
1437 bci_ip_between_align_point,
1438 FDEF,
1439
1440 DUP,
1441 ALIGNRP, /* align `point' with `edge' */
1442 DUP,
1443 GC_orig,
1444 DO_SCALE, /* point_orig_pos = point_orig_pos * scale */
1445
1446 PUSHB_1,
1447 sal_i,
1448 RS,
1449 SUB, /* s: point (point_orig_pos - edge_orig_pos) */
1450 PUSHB_1,
1451 sal_j,
1452 RS,
1453 MUL, /* s: point delta */
1454 SHPIX,
1455
1456 ENDF,
1457
1458 };
1459
1460
1461 /*
1462 * bci_ip_between_align_points
1463 *
1464 * Auxiliary function for `bci_action_ip_between'.
1465 *
1466 * in: after_edge (in twilight zone)
1467 * before_edge (in twilight zone)
1468 * loop_counter (N)
1469 * point_1
1470 * point_2
1471 * ...
1472 * point_N
1473 *
1474 * sal: sal_i (before_orig_pos)
1475 * sal_j (stretch_factor)
1476 *
1477 * uses: bci_ip_between_align_point
1478 */
1479
1480 unsigned char FPGM(bci_ip_between_align_points) [] =
1481 {
1482
1483 PUSHB_1,
1484 bci_ip_between_align_points,
1485 FDEF,
1486
1487 PUSHB_2,
1488 2,
1489 0,
1490 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1491 CINDEX,
1492 DUP, /* s: ... before after before before */
1493 MDAP_noround, /* set rp0 and rp1 to `before' */
1494 DUP,
1495 GC_orig, /* s: ... before after before before_orig_pos */
1496 PUSHB_1,
1497 sal_i,
1498 SWAP,
1499 WS, /* sal_i = before_orig_pos */
1500 PUSHB_1,
1501 2,
1502 CINDEX, /* s: ... before after before after */
1503 MD_cur, /* b = after_pos - before_pos */
1504 ROLL,
1505 ROLL,
1506 MD_orig_ZP2_0, /* a = after_orig_pos - before_orig_pos */
1507 DIV, /* s: a/b */
1508 PUSHB_1,
1509 sal_j,
1510 SWAP,
1511 WS, /* sal_j = stretch_factor */
1512
1513 PUSHB_3,
1514 bci_ip_between_align_point,
1515 1,
1516 1,
1517 SZP2, /* set zp2 to normal zone 1 */
1518 SZP1, /* set zp1 to normal zone 1 */
1519 LOOPCALL,
1520
1521 ENDF,
1522
1523 };
1524
1525
1526 /*
1527 * bci_action_ip_before
1528 *
1529 * Handle `ip_before' data to align points located before the first edge.
1530 *
1531 * in: first_edge (in twilight zone)
1532 * loop_counter (N)
1533 * point_1
1534 * point_2
1535 * ...
1536 * point_N
1537 *
1538 * sal: sal_i (first_edge_orig_pos)
1539 *
1540 * uses: bci_ip_outer_align_point
1541 */
1542
1543 unsigned char FPGM(bci_action_ip_before) [] =
1544 {
1545
1546 PUSHB_1,
1547 bci_action_ip_before,
1548 FDEF,
1549
1550 PUSHB_1,
1551 0,
1552 SZP2, /* set zp2 to twilight zone 0 */
1553
1554 DUP,
1555 GC_orig,
1556 PUSHB_1,
1557 sal_i,
1558 SWAP,
1559 WS, /* sal_i = first_edge_orig_pos */
1560
1561 PUSHB_3,
1562 0,
1563 1,
1564 1,
1565 SZP2, /* set zp2 to normal zone 1 */
1566 SZP1, /* set zp1 to normal zone 1 */
1567 SZP0, /* set zp0 to twilight zone 0 */
1568
1569 MDAP_noround, /* set rp0 and rp1 to `first_edge' */
1570
1571 PUSHB_1,
1572 bci_ip_outer_align_point,
1573 LOOPCALL,
1574
1575 ENDF,
1576
1577 };
1578
1579
1580 /*
1581 * bci_action_ip_after
1582 *
1583 * Handle `ip_after' data to align points located after the last edge.
1584 *
1585 * in: last_edge (in twilight zone)
1586 * loop_counter (N)
1587 * point_1
1588 * point_2
1589 * ...
1590 * point_N
1591 *
1592 * sal: sal_i (last_edge_orig_pos)
1593 *
1594 * uses: bci_ip_outer_align_point
1595 */
1596
1597 unsigned char FPGM(bci_action_ip_after) [] =
1598 {
1599
1600 PUSHB_1,
1601 bci_action_ip_after,
1602 FDEF,
1603
1604 PUSHB_1,
1605 0,
1606 SZP2, /* set zp2 to twilight zone 0 */
1607
1608 DUP,
1609 GC_orig,
1610 PUSHB_1,
1611 sal_i,
1612 SWAP,
1613 WS, /* sal_i = last_edge_orig_pos */
1614
1615 PUSHB_3,
1616 0,
1617 1,
1618 1,
1619 SZP2, /* set zp2 to normal zone 1 */
1620 SZP1, /* set zp1 to normal zone 1 */
1621 SZP0, /* set zp0 to twilight zone 0 */
1622
1623 MDAP_noround, /* set rp0 and rp1 to `last_edge' */
1624
1625 PUSHB_1,
1626 bci_ip_outer_align_point,
1627 LOOPCALL,
1628
1629 ENDF,
1630
1631 };
1632
1633
1634 /*
1635 * bci_action_ip_on
1636 *
1637 * Handle `ip_on' data to align points located on an edge coordinate (but
1638 * not part of an edge).
1639 *
1640 * in: loop_counter (M)
1641 * edge_1 (in twilight zone)
1642 * loop_counter (N_1)
1643 * point_1
1644 * point_2
1645 * ...
1646 * point_N_1
1647 * edge_2 (in twilight zone)
1648 * loop_counter (N_2)
1649 * point_1
1650 * point_2
1651 * ...
1652 * point_N_2
1653 * ...
1654 * edge_M (in twilight zone)
1655 * loop_counter (N_M)
1656 * point_1
1657 * point_2
1658 * ...
1659 * point_N_M
1660 *
1661 * uses: bci_ip_on_align_points
1662 */
1663
1664 unsigned char FPGM(bci_action_ip_on) [] =
1665 {
1666
1667 PUSHB_1,
1668 bci_action_ip_on,
1669 FDEF,
1670
1671 PUSHB_2,
1672 0,
1673 1,
1674 SZP1, /* set zp1 to normal zone 1 */
1675 SZP0, /* set zp0 to twilight zone 0 */
1676
1677 PUSHB_1,
1678 bci_ip_on_align_points,
1679 LOOPCALL,
1680
1681 ENDF,
1682
1683 };
1684
1685
1686 /*
1687 * bci_action_ip_between
1688 *
1689 * Handle `ip_between' data to align points located between two edges.
1690 *
1691 * in: loop_counter (M)
1692 * before_edge_1 (in twilight zone)
1693 * after_edge_1 (in twilight zone)
1694 * loop_counter (N_1)
1695 * point_1
1696 * point_2
1697 * ...
1698 * point_N_1
1699 * before_edge_2 (in twilight zone)
1700 * after_edge_2 (in twilight zone)
1701 * loop_counter (N_2)
1702 * point_1
1703 * point_2
1704 * ...
1705 * point_N_2
1706 * ...
1707 * before_edge_M (in twilight zone)
1708 * after_edge_M (in twilight zone)
1709 * loop_counter (N_M)
1710 * point_1
1711 * point_2
1712 * ...
1713 * point_N_M
1714 *
1715 * uses: bci_ip_between_align_points
1716 */
1717
1718 unsigned char FPGM(bci_action_ip_between) [] =
1719 {
1720
1721 PUSHB_1,
1722 bci_action_ip_between,
1723 FDEF,
1724
1725 PUSHB_1,
1726 bci_ip_between_align_points,
1727 LOOPCALL,
1728
1729 ENDF,
1730
1731 };
1732
1733
1734 /*
1735 * bci_action_adjust_common
1736 *
1737 * Common code for bci_action_adjust routines.
1738 */
1739
1740 unsigned char FPGM(bci_action_adjust_common) [] =
1741 {
1742
1743 PUSHB_1,
1744 bci_action_adjust_common,
1745 FDEF,
1746
1747 PUSHB_1,
1748 0,
1749 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1750
1751 PUSHB_1,
1752 4,
1753 CINDEX, /* s: [...] edge2 edge is_round is_serif edge2 */
1754 PUSHB_1,
1755 4,
1756 CINDEX, /* s: [...] edge2 edge is_round is_serif edge2 edge */
1757 MD_orig_ZP2_0, /* s: [...] edge2 edge is_round is_serif org_len */
1758
1759 PUSHB_1,
1760 bci_compute_stem_width,
1761 CALL,
1762 NEG, /* s: [...] edge2 edge -cur_len */
1763
1764 ROLL, /* s: [...] edge -cur_len edge2 */
1765 MDAP_noround, /* set rp0 and rp1 to `edge2' */
1766 SWAP,
1767 DUP,
1768 DUP, /* s: [...] -cur_len edge edge edge */
1769 ALIGNRP, /* align `edge' with `edge2' */
1770 ROLL,
1771 SHPIX, /* shift `edge' by -cur_len */
1772
1773 ENDF,
1774
1775 };
1776
1777
1778 /*
1779 * bci_action_adjust_bound
1780 *
1781 * Handle the ADJUST_BOUND action to align an edge of a stem if the other
1782 * edge of the stem has already been moved, then moving it again if
1783 * necessary to stay bound.
1784 *
1785 * in: edge2_is_serif
1786 * edge_is_round
1787 * edge_point (in twilight zone)
1788 * edge2_point (in twilight zone)
1789 * edge[-1] (in twilight zone)
1790 * ... stuff for bci_align_segments (edge) ...
1791 *
1792 * uses: bci_action_adjust_common
1793 */
1794
1795 unsigned char FPGM(bci_action_adjust_bound) [] =
1796 {
1797
1798 PUSHB_1,
1799 bci_action_adjust_bound,
1800 FDEF,
1801
1802 PUSHB_1,
1803 bci_action_adjust_common,
1804 CALL,
1805
1806 SWAP, /* s: edge edge[-1] */
1807 DUP,
1808 MDAP_noround, /* set rp0 and rp1 to `edge[-1]' */
1809 GC_cur,
1810 PUSHB_1,
1811 2,
1812 CINDEX,
1813 GC_cur, /* s: edge edge[-1]_pos edge_pos */
1814 GT, /* edge_pos < edge[-1]_pos */
1815 IF,
1816 DUP,
1817 ALIGNRP, /* align `edge' to `edge[-1]' */
1818 EIF,
1819
1820 MDAP_noround, /* set rp0 and rp1 to `edge' */
1821
1822 PUSHB_2,
1823 bci_align_segments,
1824 1,
1825 SZP1, /* set zp1 to normal zone 1 */
1826 CALL,
1827
1828 ENDF,
1829
1830 };
1831
1832
1833 /*
1834 * bci_action_adjust
1835 *
1836 * Handle the ADJUST action to align an edge of a stem if the other edge
1837 * of the stem has already been moved.
1838 *
1839 * in: edge2_is_serif
1840 * edge_is_round
1841 * edge_point (in twilight zone)
1842 * edge2_point (in twilight zone)
1843 * ... stuff for bci_align_segments (edge) ...
1844 *
1845 * uses: bci_action_adjust_common
1846 */
1847
1848 unsigned char FPGM(bci_action_adjust) [] =
1849 {
1850
1851 PUSHB_1,
1852 bci_action_adjust,
1853 FDEF,
1854
1855 PUSHB_1,
1856 bci_action_adjust_common,
1857 CALL,
1858
1859 MDAP_noround, /* set rp0 and rp1 to `edge' */
1860
1861 PUSHB_2,
1862 bci_align_segments,
1863 1,
1864 SZP1, /* set zp1 to normal zone 1 */
1865 CALL,
1866
1867 ENDF,
1868
1869 };
1870
1871
1872 /*
1873 * bci_action_stem_common
1874 *
1875 * Common code for bci_action_stem routines.
1876 */
1877
1878 #undef sal_u_off
1879 #define sal_u_off sal_temp1
1880 #undef sal_d_off
1881 #define sal_d_off sal_temp2
1882 #undef sal_org_len
1883 #define sal_org_len sal_temp3
1884 #undef sal_edge2
1885 #define sal_edge2 sal_temp3
1886
1887 unsigned char FPGM(bci_action_stem_common) [] =
1888 {
1889
1890 PUSHB_1,
1891 bci_action_stem_common,
1892 FDEF,
1893
1894 PUSHB_1,
1895 0,
1896 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1897
1898 PUSHB_1,
1899 4,
1900 CINDEX,
1901 PUSHB_1,
1902 4,
1903 CINDEX,
1904 DUP, /* s: [...] edge2 edge is_round is_serif edge2 edge edge */
1905 MDAP_noround, /* set rp0 and rp1 to `edge_point' (for ALIGNRP below) */
1906
1907 MD_orig_ZP2_0, /* s: [...] edge2 edge is_round is_serif org_len */
1908 DUP,
1909 PUSHB_1,
1910 sal_org_len,
1911 SWAP,
1912 WS,
1913
1914 PUSHB_1,
1915 bci_compute_stem_width,
1916 CALL, /* s: [...] edge2 edge cur_len */
1917
1918 DUP,
1919 PUSHB_1,
1920 96,
1921 LT, /* cur_len < 96 */
1922 IF,
1923 DUP,
1924 PUSHB_1,
1925 64,
1926 LTEQ, /* cur_len <= 64 */
1927 IF,
1928 PUSHB_4,
1929 sal_u_off,
1930 32,
1931 sal_d_off,
1932 32,
1933
1934 ELSE,
1935 PUSHB_4,
1936 sal_u_off,
1937 38,
1938 sal_d_off,
1939 26,
1940 EIF,
1941 WS,
1942 WS,
1943
1944 SWAP, /* s: [...] edge2 cur_len edge */
1945 DUP,
1946 PUSHB_1,
1947 sal_anchor,
1948 RS,
1949 DUP, /* s: [...] edge2 cur_len edge edge anchor anchor */
1950 ROLL,
1951 SWAP,
1952 MD_orig_ZP2_0,
1953 SWAP,
1954 GC_cur,
1955 ADD, /* s: [...] edge2 cur_len edge org_pos */
1956 PUSHB_1,
1957 sal_org_len,
1958 RS,
1959 PUSHB_1,
1960 2*64,
1961 DIV,
1962 ADD, /* s: [...] edge2 cur_len edge org_center */
1963
1964 DUP,
1965 PUSHB_1,
1966 bci_round,
1967 CALL, /* s: [...] edge2 cur_len edge org_center cur_pos1 */
1968
1969 DUP,
1970 ROLL,
1971 ROLL,
1972 SUB, /* s: ... cur_len edge cur_pos1 (org_center - cur_pos1) */
1973
1974 DUP,
1975 PUSHB_1,
1976 sal_u_off,
1977 RS,
1978 ADD,
1979 ABS, /* s: ... cur_len edge cur_pos1 (org_center - cur_pos1) delta1 */
1980
1981 SWAP,
1982 PUSHB_1,
1983 sal_d_off,
1984 RS,
1985 SUB,
1986 ABS, /* s: [...] edge2 cur_len edge cur_pos1 delta1 delta2 */
1987
1988 LT, /* delta1 < delta2 */
1989 IF,
1990 PUSHB_1,
1991 sal_u_off,
1992 RS,
1993 SUB, /* cur_pos1 = cur_pos1 - u_off */
1994
1995 ELSE,
1996 PUSHB_1,
1997 sal_d_off,
1998 RS,
1999 ADD, /* cur_pos1 = cur_pos1 + d_off */
2000 EIF, /* s: [...] edge2 cur_len edge cur_pos1 */
2001
2002 PUSHB_1,
2003 3,
2004 CINDEX,
2005 PUSHB_1,
2006 2*64,
2007 DIV,
2008 SUB, /* arg = cur_pos1 - cur_len/2 */
2009
2010 SWAP, /* s: [...] edge2 cur_len arg edge */
2011 DUP,
2012 DUP,
2013 PUSHB_1,
2014 4,
2015 MINDEX,
2016 SWAP, /* s: [...] edge2 cur_len edge edge arg edge */
2017 GC_cur,
2018 SUB,
2019 SHPIX, /* edge = cur_pos1 - cur_len/2 */
2020
2021 ELSE,
2022 SWAP, /* s: [...] edge2 cur_len edge */
2023 PUSHB_1,
2024 sal_anchor,
2025 RS,
2026 GC_cur, /* s: [...] edge2 cur_len edge anchor_pos */
2027 PUSHB_1,
2028 2,
2029 CINDEX,
2030 PUSHB_1,
2031 sal_anchor,
2032 RS,
2033 MD_orig_ZP2_0,
2034 ADD, /* s: [...] edge2 cur_len edge org_pos */
2035
2036 DUP,
2037 PUSHB_1,
2038 sal_org_len,
2039 RS,
2040 PUSHB_1,
2041 2*64,
2042 DIV,
2043 ADD, /* s: [...] edge2 cur_len edge org_pos org_center */
2044
2045 SWAP,
2046 DUP,
2047 PUSHB_1,
2048 bci_round,
2049 CALL, /* cur_pos1 = ROUND(org_pos) */
2050 SWAP,
2051 PUSHB_1,
2052 sal_org_len,
2053 RS,
2054 ADD,
2055 PUSHB_1,
2056 bci_round,
2057 CALL,
2058 PUSHB_1,
2059 5,
2060 CINDEX,
2061 SUB, /* s: [...] edge2 cur_len edge org_center cur_pos1 cur_pos2 */
2062
2063 PUSHB_1,
2064 5,
2065 CINDEX,
2066 PUSHB_1,
2067 2*64,
2068 DIV,
2069 PUSHB_1,
2070 4,
2071 MINDEX,
2072 SUB, /* s: ... cur_len edge cur_pos1 cur_pos2 (cur_len/2 - org_center) */
2073
2074 DUP,
2075 PUSHB_1,
2076 4,
2077 CINDEX,
2078 ADD,
2079 ABS, /* delta1 = ABS(cur_pos1 + cur_len / 2 - org_center) */
2080 SWAP,
2081 PUSHB_1,
2082 3,
2083 CINDEX,
2084 ADD,
2085 ABS, /* s: ... edge2 cur_len edge cur_pos1 cur_pos2 delta1 delta2 */
2086 LT, /* delta1 < delta2 */
2087 IF,
2088 POP, /* arg = cur_pos1 */
2089
2090 ELSE,
2091 SWAP,
2092 POP, /* arg = cur_pos2 */
2093 EIF, /* s: [...] edge2 cur_len edge arg */
2094 SWAP,
2095 DUP,
2096 DUP,
2097 PUSHB_1,
2098 4,
2099 MINDEX,
2100 SWAP, /* s: [...] edge2 cur_len edge edge arg edge */
2101 GC_cur,
2102 SUB,
2103 SHPIX, /* edge = arg */
2104 EIF, /* s: [...] edge2 cur_len edge */
2105
2106 ENDF,
2107
2108 };
2109
2110
2111 /*
2112 * bci_action_stem_bound
2113 *
2114 * Handle the STEM action to align two edges of a stem, then moving one
2115 * edge again if necessary to stay bound.
2116 *
2117 * The code after computing `cur_len' to shift `edge' and `edge2'
2118 * is equivalent to the snippet below (part of `ta_latin_hint_edges'):
2119 *
2120 * if cur_len < 96:
2121 * if cur_len < = 64:
2122 * u_off = 32
2123 * d_off = 32
2124 * else:
2125 * u_off = 38
2126 * d_off = 26
2127 *
2128 * org_pos = anchor + (edge_orig - anchor_orig);
2129 * org_center = org_pos + org_len / 2;
2130 *
2131 * cur_pos1 = ROUND(org_center)
2132 * delta1 = ABS(org_center - (cur_pos1 - u_off))
2133 * delta2 = ABS(org_center - (cur_pos1 + d_off))
2134 * if (delta1 < delta2):
2135 * cur_pos1 = cur_pos1 - u_off
2136 * else:
2137 * cur_pos1 = cur_pos1 + d_off
2138 *
2139 * edge = cur_pos1 - cur_len / 2
2140 *
2141 * else:
2142 * org_pos = anchor + (edge_orig - anchor_orig)
2143 * org_center = org_pos + org_len / 2;
2144 *
2145 * cur_pos1 = ROUND(org_pos)
2146 * delta1 = ABS(cur_pos1 + cur_len / 2 - org_center)
2147 * cur_pos2 = ROUND(org_pos + org_len) - cur_len
2148 * delta2 = ABS(cur_pos2 + cur_len / 2 - org_center)
2149 *
2150 * if (delta1 < delta2):
2151 * edge = cur_pos1
2152 * else:
2153 * edge = cur_pos2
2154 *
2155 * edge2 = edge + cur_len
2156 *
2157 * in: edge2_is_serif
2158 * edge_is_round
2159 * edge_point (in twilight zone)
2160 * edge2_point (in twilight zone)
2161 * edge[-1] (in twilight zone)
2162 * ... stuff for bci_align_segments (edge) ...
2163 * ... stuff for bci_align_segments (edge2)...
2164 *
2165 * sal: sal_anchor
2166 * sal_temp1
2167 * sal_temp2
2168 * sal_temp3
2169 *
2170 * uses: bci_action_stem_common
2171 */
2172
2173 unsigned char FPGM(bci_action_stem_bound) [] =
2174 {
2175
2176 PUSHB_1,
2177 bci_action_stem_bound,
2178 FDEF,
2179
2180 PUSHB_1,
2181 bci_action_stem_common,
2182 CALL,
2183
2184 ROLL, /* s: edge[-1] cur_len edge edge2 */
2185 DUP,
2186 DUP,
2187 ALIGNRP, /* align `edge2' with rp0 (still `edge') */
2188 PUSHB_1,
2189 sal_edge2,
2190 SWAP,
2191 WS, /* s: edge[-1] cur_len edge edge2 */
2192 ROLL,
2193 SHPIX, /* edge2 = edge + cur_len */
2194
2195 SWAP, /* s: edge edge[-1] */
2196 DUP,
2197 MDAP_noround, /* set rp0 and rp1 to `edge[-1]' */
2198 GC_cur,
2199 PUSHB_1,
2200 2,
2201 CINDEX,
2202 GC_cur, /* s: edge edge[-1]_pos edge_pos */
2203 GT, /* edge_pos < edge[-1]_pos */
2204 IF,
2205 DUP,
2206 ALIGNRP, /* align `edge' to `edge[-1]' */
2207 EIF,
2208
2209 MDAP_noround, /* set rp0 and rp1 to `edge' */
2210
2211 PUSHB_2,
2212 bci_align_segments,
2213 1,
2214 SZP1, /* set zp1 to normal zone 1 */
2215 CALL,
2216
2217 PUSHB_1,
2218 sal_edge2,
2219 RS,
2220 MDAP_noround, /* set rp0 and rp1 to `edge2' */
2221
2222 PUSHB_1,
2223 bci_align_segments,
2224 CALL,
2225
2226 ENDF,
2227
2228 };
2229
2230
2231 /*
2232 * bci_action_stem
2233 *
2234 * Handle the STEM action to align two edges of a stem.
2235 *
2236 * See `bci_action_stem_bound' for more details.
2237 *
2238 * in: edge2_is_serif
2239 * edge_is_round
2240 * edge_point (in twilight zone)
2241 * edge2_point (in twilight zone)
2242 * ... stuff for bci_align_segments (edge) ...
2243 * ... stuff for bci_align_segments (edge2)...
2244 *
2245 * sal: sal_anchor
2246 * sal_temp1
2247 * sal_temp2
2248 * sal_temp3
2249 *
2250 * uses: bci_action_stem_common
2251 */
2252
2253 unsigned char FPGM(bci_action_stem) [] =
2254 {
2255
2256 PUSHB_1,
2257 bci_action_stem,
2258 FDEF,
2259
2260 PUSHB_1,
2261 bci_action_stem_common,
2262 CALL,
2263
2264 POP,
2265 SWAP, /* s: cur_len edge2 */
2266 DUP,
2267 DUP,
2268 ALIGNRP, /* align `edge2' with rp0 (still `edge') */
2269 PUSHB_1,
2270 sal_edge2,
2271 SWAP,
2272 WS, /* s: cur_len edge2 */
2273 SWAP,
2274 SHPIX, /* edge2 = edge + cur_len */
2275
2276 PUSHB_2,
2277 bci_align_segments,
2278 1,
2279 SZP1, /* set zp1 to normal zone 1 */
2280 CALL,
2281
2282 PUSHB_1,
2283 sal_edge2,
2284 RS,
2285 MDAP_noround, /* set rp0 and rp1 to `edge2' */
2286
2287 PUSHB_1,
2288 bci_align_segments,
2289 CALL,
2290 ENDF,
2291
2292 };
2293
2294
2295 /*
2296 * bci_action_link
2297 *
2298 * Handle the LINK action to link an edge to another one.
2299 *
2300 * in: stem_is_serif
2301 * base_is_round
2302 * base_point (in twilight zone)
2303 * stem_point (in twilight zone)
2304 * ... stuff for bci_align_segments (base) ...
2305 */
2306
2307 unsigned char FPGM(bci_action_link) [] =
2308 {
2309
2310 PUSHB_1,
2311 bci_action_link,
2312 FDEF,
2313
2314 PUSHB_1,
2315 0,
2316 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2317
2318 PUSHB_1,
2319 4,
2320 CINDEX,
2321 PUSHB_1,
2322 4,
2323 MINDEX,
2324 DUP, /* s: stem is_round is_serif stem base base */
2325 MDAP_noround, /* set rp0 and rp1 to `base_point' (for ALIGNRP below) */
2326
2327 MD_orig_ZP2_0, /* s: stem is_round is_serif dist_orig */
2328
2329 PUSHB_1,
2330 bci_compute_stem_width,
2331 CALL, /* s: stem new_dist */
2332
2333 SWAP,
2334 DUP,
2335 ALIGNRP, /* align `stem_point' with `base_point' */
2336 DUP,
2337 MDAP_noround, /* set rp0 and rp1 to `stem_point' */
2338 SWAP,
2339 SHPIX, /* stem_point = base_point + new_dist */
2340
2341 PUSHB_2,
2342 bci_align_segments,
2343 1,
2344 SZP1, /* set zp1 to normal zone 1 */
2345 CALL,
2346
2347 ENDF,
2348
2349 };
2350
2351
2352 /*
2353 * bci_action_anchor
2354 *
2355 * Handle the ANCHOR action to align two edges
2356 * and to set the edge anchor.
2357 *
2358 * The code after computing `cur_len' to shift `edge' and `edge2'
2359 * is equivalent to the snippet below (part of `ta_latin_hint_edges'):
2360 *
2361 * if cur_len < 96:
2362 * if cur_len < = 64:
2363 * u_off = 32
2364 * d_off = 32
2365 * else:
2366 * u_off = 38
2367 * d_off = 26
2368 *
2369 * org_center = edge_orig + org_len / 2
2370 * cur_pos1 = ROUND(org_center)
2371 *
2372 * error1 = ABS(org_center - (cur_pos1 - u_off))
2373 * error2 = ABS(org_center - (cur_pos1 + d_off))
2374 * if (error1 < error2):
2375 * cur_pos1 = cur_pos1 - u_off
2376 * else:
2377 * cur_pos1 = cur_pos1 + d_off
2378 *
2379 * edge = cur_pos1 - cur_len / 2
2380 * edge2 = edge + cur_len
2381 *
2382 * else:
2383 * edge = ROUND(edge_orig)
2384 *
2385 * in: edge2_is_serif
2386 * edge_is_round
2387 * edge_point (in twilight zone)
2388 * edge2_point (in twilight zone)
2389 * ... stuff for bci_align_segments (edge) ...
2390 *
2391 * sal: sal_anchor
2392 * sal_temp1
2393 * sal_temp2
2394 * sal_temp3
2395 */
2396
2397 #undef sal_u_off
2398 #define sal_u_off sal_temp1
2399 #undef sal_d_off
2400 #define sal_d_off sal_temp2
2401 #undef sal_org_len
2402 #define sal_org_len sal_temp3
2403
2404 unsigned char FPGM(bci_action_anchor) [] =
2405 {
2406
2407 PUSHB_1,
2408 bci_action_anchor,
2409 FDEF,
2410
2411 /* store anchor point number in `sal_anchor' */
2412 PUSHB_2,
2413 sal_anchor,
2414 4,
2415 CINDEX,
2416 WS, /* sal_anchor = edge_point */
2417
2418 PUSHB_1,
2419 0,
2420 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2421
2422 PUSHB_1,
2423 4,
2424 CINDEX,
2425 PUSHB_1,
2426 4,
2427 CINDEX,
2428 DUP, /* s: edge2 edge is_round is_serif edge2 edge edge */
2429 MDAP_noround, /* set rp0 and rp1 to `edge_point' (for ALIGNRP below) */
2430
2431 MD_orig_ZP2_0, /* s: edge2 edge is_round is_serif org_len */
2432 DUP,
2433 PUSHB_1,
2434 sal_org_len,
2435 SWAP,
2436 WS,
2437
2438 PUSHB_1,
2439 bci_compute_stem_width,
2440 CALL, /* s: edge2 edge cur_len */
2441
2442 DUP,
2443 PUSHB_1,
2444 96,
2445 LT, /* cur_len < 96 */
2446 IF,
2447 DUP,
2448 PUSHB_1,
2449 64,
2450 LTEQ, /* cur_len <= 64 */
2451 IF,
2452 PUSHB_4,
2453 sal_u_off,
2454 32,
2455 sal_d_off,
2456 32,
2457
2458 ELSE,
2459 PUSHB_4,
2460 sal_u_off,
2461 38,
2462 sal_d_off,
2463 26,
2464 EIF,
2465 WS,
2466 WS,
2467
2468 SWAP, /* s: edge2 cur_len edge */
2469 DUP, /* s: edge2 cur_len edge edge */
2470
2471 GC_orig,
2472 PUSHB_1,
2473 sal_org_len,
2474 RS,
2475 PUSHB_1,
2476 2*64,
2477 DIV,
2478 ADD, /* s: edge2 cur_len edge org_center */
2479
2480 DUP,
2481 PUSHB_1,
2482 bci_round,
2483 CALL, /* s: edge2 cur_len edge org_center cur_pos1 */
2484
2485 DUP,
2486 ROLL,
2487 ROLL,
2488 SUB, /* s: edge2 cur_len edge cur_pos1 (org_center - cur_pos1) */
2489
2490 DUP,
2491 PUSHB_1,
2492 sal_u_off,
2493 RS,
2494 ADD,
2495 ABS, /* s: edge2 cur_len edge cur_pos1 (org_center - cur_pos1) error1 */
2496
2497 SWAP,
2498 PUSHB_1,
2499 sal_d_off,
2500 RS,
2501 SUB,
2502 ABS, /* s: edge2 cur_len edge cur_pos1 error1 error2 */
2503
2504 LT, /* error1 < error2 */
2505 IF,
2506 PUSHB_1,
2507 sal_u_off,
2508 RS,
2509 SUB, /* cur_pos1 = cur_pos1 - u_off */
2510
2511 ELSE,
2512 PUSHB_1,
2513 sal_d_off,
2514 RS,
2515 ADD, /* cur_pos1 = cur_pos1 + d_off */
2516 EIF, /* s: edge2 cur_len edge cur_pos1 */
2517
2518 PUSHB_1,
2519 3,
2520 CINDEX,
2521 PUSHB_1,
2522 2*64,
2523 DIV,
2524 SUB, /* s: edge2 cur_len edge (cur_pos1 - cur_len/2) */
2525
2526 PUSHB_1,
2527 2,
2528 CINDEX, /* s: edge2 cur_len edge (cur_pos1 - cur_len/2) edge */
2529 GC_cur,
2530 SUB,
2531 SHPIX, /* edge = cur_pos1 - cur_len/2 */
2532
2533 SWAP, /* s: cur_len edge2 */
2534 DUP,
2535 ALIGNRP, /* align `edge2' with rp0 (still `edge') */
2536 SWAP,
2537 SHPIX, /* edge2 = edge1 + cur_len */
2538
2539 ELSE,
2540 POP, /* s: edge2 edge */
2541 DUP,
2542 DUP,
2543 GC_cur,
2544 SWAP,
2545 GC_orig,
2546 PUSHB_1,
2547 bci_round,
2548 CALL, /* s: edge2 edge edge_pos round(edge_orig_pos) */
2549 SWAP,
2550 SUB,
2551 SHPIX, /* edge = round(edge_orig) */
2552
2553 /* clean up stack */
2554 POP,
2555 EIF,
2556
2557 PUSHB_2,
2558 bci_align_segments,
2559 1,
2560 SZP1, /* set zp1 to normal zone 1 */
2561 CALL,
2562
2563 ENDF,
2564
2565 };
2566
2567
2568 /*
2569 * bci_action_blue_anchor
2570 *
2571 * Handle the BLUE_ANCHOR action to align an edge with a blue zone
2572 * and to set the edge anchor.
2573 *
2574 * in: anchor_point (in twilight zone)
2575 * blue_cvt_idx
2576 * edge_point (in twilight zone)
2577 * ... stuff for bci_align_segments (edge) ...
2578 *
2579 * sal: sal_anchor
2580 *
2581 * uses: bci_action_blue
2582 */
2583
2584 unsigned char FPGM(bci_action_blue_anchor) [] =
2585 {
2586
2587 PUSHB_1,
2588 bci_action_blue_anchor,
2589 FDEF,
2590
2591 /* store anchor point number in `sal_anchor' */
2592 PUSHB_1,
2593 sal_anchor,
2594 SWAP,
2595 WS,
2596
2597 PUSHB_1,
2598 bci_action_blue,
2599 CALL,
2600
2601 ENDF,
2602
2603 };
2604
2605
2606 /*
2607 * bci_action_blue
2608 *
2609 * Handle the BLUE action to align an edge with a blue zone.
2610 *
2611 * in: blue_cvt_idx
2612 * edge_point (in twilight zone)
2613 * ... stuff for bci_align_segments (edge) ...
2614 */
2615
2616 unsigned char FPGM(bci_action_blue) [] =
2617 {
2618
2619 PUSHB_1,
2620 bci_action_blue,
2621 FDEF,
2622
2623 PUSHB_1,
2624 0,
2625 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2626
2627 /* move `edge_point' to `blue_cvt_idx' position; */
2628 /* note that we can't use MIAP since this would modify */
2629 /* the twilight point's original coordinates also */
2630 RCVT,
2631 SWAP,
2632 DUP,
2633 MDAP_noround, /* set rp0 and rp1 to `edge' */
2634 DUP,
2635 GC_cur, /* s: new_pos edge edge_pos */
2636 ROLL,
2637 SWAP,
2638 SUB, /* s: edge (new_pos - edge_pos) */
2639 SHPIX,
2640
2641 PUSHB_2,
2642 bci_align_segments,
2643 1,
2644 SZP1, /* set zp1 to normal zone 1 */
2645 CALL,
2646
2647 ENDF,
2648
2649 };
2650
2651
2652 /*
2653 * bci_action_serif_common
2654 *
2655 * Common code for bci_action_serif routines.
2656 */
2657
2658 unsigned char FPGM(bci_action_serif_common) [] =
2659 {
2660
2661 PUSHB_1,
2662 bci_action_serif_common,
2663 FDEF,
2664
2665 PUSHB_1,
2666 0,
2667 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2668
2669 DUP,
2670 DUP,
2671 DUP,
2672 PUSHB_1,
2673 5,
2674 MINDEX, /* s: [...] serif serif serif serif base */
2675 DUP,
2676 MDAP_noround, /* set rp0 and rp1 to `base_point' */
2677 MD_orig_ZP2_0,
2678 SWAP,
2679 ALIGNRP, /* align `serif_point' with `base_point' */
2680 SHPIX, /* serif = base + (serif_orig_pos - base_orig_pos) */
2681
2682 ENDF,
2683
2684 };
2685
2686
2687 /*
2688 * bci_lower_bound
2689 *
2690 * Move an edge if necessary to stay within a lower bound.
2691 *
2692 * in: edge
2693 * bound
2694 */
2695
2696 unsigned char FPGM(bci_lower_bound) [] =
2697 {
2698
2699 PUSHB_1,
2700 bci_lower_bound,
2701 FDEF,
2702
2703 SWAP, /* s: edge bound */
2704 DUP,
2705 MDAP_noround, /* set rp0 and rp1 to `bound' */
2706 GC_cur,
2707 PUSHB_1,
2708 2,
2709 CINDEX,
2710 GC_cur, /* s: edge bound_pos edge_pos */
2711 GT, /* edge_pos < bound_pos */
2712 IF,
2713 DUP,
2714 ALIGNRP, /* align `edge' to `bound' */
2715 EIF,
2716
2717 MDAP_noround, /* set rp0 and rp1 to `edge_point' */
2718
2719 PUSHB_2,
2720 bci_align_segments,
2721 1,
2722 SZP1, /* set zp1 to normal zone 1 */
2723 CALL,
2724
2725 ENDF,
2726
2727 };
2728
2729
2730 /*
2731 * bci_upper_bound
2732 *
2733 * Move an edge if necessary to stay within an upper bound.
2734 *
2735 * in: edge
2736 * bound
2737 */
2738
2739 unsigned char FPGM(bci_upper_bound) [] =
2740 {
2741
2742 PUSHB_1,
2743 bci_upper_bound,
2744 FDEF,
2745
2746 SWAP, /* s: edge bound */
2747 DUP,
2748 MDAP_noround, /* set rp0 and rp1 to `bound' */
2749 GC_cur,
2750 PUSHB_1,
2751 2,
2752 CINDEX,
2753 GC_cur, /* s: edge bound_pos edge_pos */
2754 LT, /* edge_pos > bound_pos */
2755 IF,
2756 DUP,
2757 ALIGNRP, /* align `edge' to `bound' */
2758 EIF,
2759
2760 MDAP_noround, /* set rp0 and rp1 to `edge_point' */
2761
2762 PUSHB_2,
2763 bci_align_segments,
2764 1,
2765 SZP1, /* set zp1 to normal zone 1 */
2766 CALL,
2767
2768 ENDF,
2769
2770 };
2771
2772
2773 /*
2774 * bci_lower_upper_bound
2775 *
2776 * Move an edge if necessary to stay within a lower and lower bound.
2777 *
2778 * in: edge
2779 * lower
2780 * upper
2781 */
2782
2783 unsigned char FPGM(bci_lower_upper_bound) [] =
2784 {
2785
2786 PUSHB_1,
2787 bci_lower_upper_bound,
2788 FDEF,
2789
2790 SWAP, /* s: upper serif lower */
2791 DUP,
2792 MDAP_noround, /* set rp0 and rp1 to `lower' */
2793 GC_cur,
2794 PUSHB_1,
2795 2,
2796 CINDEX,
2797 GC_cur, /* s: upper serif lower_pos serif_pos */
2798 GT, /* serif_pos < lower_pos */
2799 IF,
2800 DUP,
2801 ALIGNRP, /* align `serif' to `lower' */
2802 EIF,
2803
2804 SWAP, /* s: serif upper */
2805 DUP,
2806 MDAP_noround, /* set rp0 and rp1 to `upper' */
2807 GC_cur,
2808 PUSHB_1,
2809 2,
2810 CINDEX,
2811 GC_cur, /* s: serif upper_pos serif_pos */
2812 LT, /* serif_pos > upper_pos */
2813 IF,
2814 DUP,
2815 ALIGNRP, /* align `serif' to `upper' */
2816 EIF,
2817
2818 MDAP_noround, /* set rp0 and rp1 to `serif_point' */
2819
2820 PUSHB_2,
2821 bci_align_segments,
2822 1,
2823 SZP1, /* set zp1 to normal zone 1 */
2824 CALL,
2825
2826 ENDF,
2827
2828 };
2829
2830
2831 /*
2832 * bci_action_serif
2833 *
2834 * Handle the SERIF action to align a serif with its base.
2835 *
2836 * in: serif_point (in twilight zone)
2837 * base_point (in twilight zone)
2838 * ... stuff for bci_align_segments (serif) ...
2839 *
2840 * uses: bci_action_serif_common
2841 */
2842
2843 unsigned char FPGM(bci_action_serif) [] =
2844 {
2845
2846 PUSHB_1,
2847 bci_action_serif,
2848 FDEF,
2849
2850 PUSHB_1,
2851 bci_action_serif_common,
2852 CALL,
2853
2854 MDAP_noround, /* set rp0 and rp1 to `serif_point' */
2855
2856 PUSHB_2,
2857 bci_align_segments,
2858 1,
2859 SZP1, /* set zp1 to normal zone 1 */
2860 CALL,
2861
2862 ENDF,
2863
2864 };
2865
2866
2867 /*
2868 * bci_action_serif_lower_bound
2869 *
2870 * Handle the SERIF action to align a serif with its base, then moving it
2871 * again if necessary to stay within a lower bound.
2872 *
2873 * in: serif_point (in twilight zone)
2874 * base_point (in twilight zone)
2875 * edge[-1] (in twilight zone)
2876 * ... stuff for bci_align_segments (serif) ...
2877 *
2878 * uses: bci_action_serif_common
2879 * bci_lower_bound
2880 */
2881
2882 unsigned char FPGM(bci_action_serif_lower_bound) [] =
2883 {
2884
2885 PUSHB_1,
2886 bci_action_serif_lower_bound,
2887 FDEF,
2888
2889 PUSHB_1,
2890 bci_action_serif_common,
2891 CALL,
2892
2893 PUSHB_1,
2894 bci_lower_bound,
2895 CALL,
2896
2897 ENDF,
2898
2899 };
2900
2901
2902 /*
2903 * bci_action_serif_upper_bound
2904 *
2905 * Handle the SERIF action to align a serif with its base, then moving it
2906 * again if necessary to stay within an upper bound.
2907 *
2908 * in: serif_point (in twilight zone)
2909 * base_point (in twilight zone)
2910 * edge[1] (in twilight zone)
2911 * ... stuff for bci_align_segments (serif) ...
2912 *
2913 * uses: bci_action_serif_common
2914 * bci_upper_bound
2915 */
2916
2917 unsigned char FPGM(bci_action_serif_upper_bound) [] =
2918 {
2919
2920 PUSHB_1,
2921 bci_action_serif_upper_bound,
2922 FDEF,
2923
2924 PUSHB_1,
2925 bci_action_serif_common,
2926 CALL,
2927
2928 PUSHB_1,
2929 bci_upper_bound,
2930 CALL,
2931
2932 ENDF,
2933
2934 };
2935
2936
2937 /*
2938 * bci_action_serif_lower_upper_bound
2939 *
2940 * Handle the SERIF action to align a serif with its base, then moving it
2941 * again if necessary to stay within a lower and upper bound.
2942 *
2943 * in: serif_point (in twilight zone)
2944 * base_point (in twilight zone)
2945 * edge[-1] (in twilight zone)
2946 * edge[1] (in twilight zone)
2947 * ... stuff for bci_align_segments (serif) ...
2948 *
2949 * uses: bci_action_serif_common
2950 * bci_lower_upper_bound
2951 */
2952
2953 unsigned char FPGM(bci_action_serif_lower_upper_bound) [] =
2954 {
2955
2956 PUSHB_1,
2957 bci_action_serif_lower_upper_bound,
2958 FDEF,
2959
2960 PUSHB_1,
2961 0,
2962 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2963
2964 PUSHB_1,
2965 bci_action_serif_common,
2966 CALL,
2967
2968 PUSHB_1,
2969 bci_lower_upper_bound,
2970 CALL,
2971
2972 ENDF,
2973
2974 };
2975
2976
2977 /*
2978 * bci_action_serif_anchor_common
2979 *
2980 * Common code for bci_action_serif_anchor routines.
2981 */
2982
2983 unsigned char FPGM(bci_action_serif_anchor_common) [] =
2984 {
2985
2986 PUSHB_1,
2987 bci_action_serif_anchor_common,
2988 FDEF,
2989
2990 PUSHB_1,
2991 0,
2992 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2993
2994 DUP,
2995 PUSHB_1,
2996 sal_anchor,
2997 SWAP,
2998 WS, /* sal_anchor = edge_point */
2999
3000 DUP,
3001 DUP,
3002 DUP,
3003 GC_cur,
3004 SWAP,
3005 GC_orig,
3006 PUSHB_1,
3007 bci_round,
3008 CALL, /* s: [...] edge edge edge_pos round(edge_orig_pos) */
3009 SWAP,
3010 SUB,
3011 SHPIX, /* edge = round(edge_orig) */
3012
3013 ENDF,
3014
3015 };
3016
3017
3018 /*
3019 * bci_action_serif_anchor
3020 *
3021 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
3022 * anchor.
3023 *
3024 * in: edge_point (in twilight zone)
3025 * ... stuff for bci_align_segments (edge) ...
3026 *
3027 * uses: bci_action_serif_anchor_common
3028 */
3029
3030 unsigned char FPGM(bci_action_serif_anchor) [] =
3031 {
3032
3033 PUSHB_1,
3034 bci_action_serif_anchor,
3035 FDEF,
3036
3037 PUSHB_1,
3038 bci_action_serif_anchor_common,
3039 CALL,
3040
3041 MDAP_noround, /* set rp0 and rp1 to `edge' */
3042
3043 PUSHB_2,
3044 bci_align_segments,
3045 1,
3046 SZP1, /* set zp1 to normal zone 1 */
3047 CALL,
3048
3049 ENDF,
3050
3051 };
3052
3053
3054 /*
3055 * bci_action_serif_anchor_lower_bound
3056 *
3057 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
3058 * anchor, then moving it again if necessary to stay within a lower
3059 * bound.
3060 *
3061 * in: edge_point (in twilight zone)
3062 * edge[-1] (in twilight zone)
3063 * ... stuff for bci_align_segments (edge) ...
3064 *
3065 * uses: bci_action_serif_anchor_common
3066 * bci_lower_bound
3067 */
3068
3069 unsigned char FPGM(bci_action_serif_anchor_lower_bound) [] =
3070 {
3071
3072 PUSHB_1,
3073 bci_action_serif_anchor_lower_bound,
3074 FDEF,
3075
3076 PUSHB_1,
3077 bci_action_serif_anchor_common,
3078 CALL,
3079
3080 PUSHB_1,
3081 bci_lower_bound,
3082 CALL,
3083
3084 ENDF,
3085
3086 };
3087
3088
3089 /*
3090 * bci_action_serif_anchor_upper_bound
3091 *
3092 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
3093 * anchor, then moving it again if necessary to stay within an upper
3094 * bound.
3095 *
3096 * in: edge_point (in twilight zone)
3097 * edge[1] (in twilight zone)
3098 * ... stuff for bci_align_segments (edge) ...
3099 *
3100 * uses: bci_action_serif_anchor_common
3101 * bci_upper_bound
3102 */
3103
3104 unsigned char FPGM(bci_action_serif_anchor_upper_bound) [] =
3105 {
3106
3107 PUSHB_1,
3108 bci_action_serif_anchor_upper_bound,
3109 FDEF,
3110
3111 PUSHB_1,
3112 bci_action_serif_anchor_common,
3113 CALL,
3114
3115 PUSHB_1,
3116 bci_upper_bound,
3117 CALL,
3118
3119 ENDF,
3120
3121 };
3122
3123
3124 /*
3125 * bci_action_serif_anchor_lower_upper_bound
3126 *
3127 * Handle the SERIF_ANCHOR action to align a serif and to set the edge
3128 * anchor, then moving it again if necessary to stay within a lower and
3129 * upper bound.
3130 *
3131 * in: edge_point (in twilight zone)
3132 * edge[-1] (in twilight zone)
3133 * edge[1] (in twilight zone)
3134 * ... stuff for bci_align_segments (edge) ...
3135 *
3136 * uses: bci_action_serif_anchor_common
3137 * bci_lower_upper_bound
3138 */
3139
3140 unsigned char FPGM(bci_action_serif_anchor_lower_upper_bound) [] =
3141 {
3142
3143 PUSHB_1,
3144 bci_action_serif_anchor_lower_upper_bound,
3145 FDEF,
3146
3147 PUSHB_1,
3148 bci_action_serif_anchor_common,
3149 CALL,
3150
3151 PUSHB_1,
3152 bci_lower_upper_bound,
3153 CALL,
3154
3155 ENDF,
3156
3157 };
3158
3159
3160 /*
3161 * bci_action_serif_link1_common
3162 *
3163 * Common code for bci_action_serif_link1 routines.
3164 */
3165
3166 unsigned char FPGM(bci_action_serif_link1_common) [] =
3167 {
3168
3169 PUSHB_1,
3170 bci_action_serif_link1_common,
3171 FDEF,
3172
3173 PUSHB_1,
3174 0,
3175 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3176
3177 PUSHB_1,
3178 3,
3179 CINDEX, /* s: [...] after edge before after */
3180 PUSHB_1,
3181 2,
3182 CINDEX, /* s: [...] after edge before after before */
3183 MD_orig_ZP2_0,
3184 PUSHB_1,
3185 0,
3186 EQ, /* after_orig_pos == before_orig_pos */
3187 IF, /* s: [...] after edge before */
3188 MDAP_noround, /* set rp0 and rp1 to `before' */
3189 DUP,
3190 ALIGNRP, /* align `edge' with `before' */
3191 SWAP,
3192 POP,
3193
3194 ELSE,
3195 /* we have to execute `a*b/c', with b/c very near to 1: */
3196 /* to avoid overflow while retaining precision, */
3197 /* we transform this to `a + a * (b-c)/c' */
3198
3199 PUSHB_1,
3200 2,
3201 CINDEX, /* s: [...] after edge before edge */
3202 PUSHB_1,
3203 2,
3204 CINDEX, /* s: [...] after edge before edge before */
3205 MD_orig_ZP2_0, /* a = edge_orig_pos - before_orig_pos */
3206
3207 DUP,
3208 PUSHB_1,
3209 5,
3210 CINDEX, /* s: [...] after edge before a a after */
3211 PUSHB_1,
3212 4,
3213 CINDEX, /* s: [...] after edge before a a after before */
3214 MD_orig_ZP2_0, /* c = after_orig_pos - before_orig_pos */
3215
3216 PUSHB_1,
3217 6,
3218 CINDEX, /* s: [...] after edge before a a c after */
3219 PUSHB_1,
3220 5,
3221 CINDEX, /* s: [...] after edge before a a c after before */
3222 MD_cur, /* b = after_pos - before_pos */
3223
3224 PUSHB_1,
3225 2,
3226 CINDEX, /* s: [...] after edge before a a c b c */
3227 SUB, /* b-c */
3228
3229 PUSHB_1,
3230 cvtl_0x10000,
3231 RCVT,
3232 MUL, /* (b-c) in 16.16 format */
3233 SWAP,
3234 DIV, /* s: [...] after edge before a a (b-c)/c */
3235
3236 MUL, /* a * (b-c)/c * 2^10 */
3237 PUSHB_1,
3238 cvtl_0x10000,
3239 RCVT,
3240 DIV, /* a * (b-c)/c */
3241 ADD, /* a*b/c */
3242
3243 SWAP,
3244 MDAP_noround, /* set rp0 and rp1 to `before' */
3245 SWAP, /* s: [...] after a*b/c edge */
3246 DUP,
3247 DUP,
3248 ALIGNRP, /* align `edge' with `before' */
3249 ROLL,
3250 SHPIX, /* shift `edge' by `a*b/c' */
3251
3252 SWAP, /* s: [...] edge after */
3253 POP,
3254 EIF,
3255
3256 ENDF,
3257
3258 };
3259
3260
3261 /*
3262 * bci_action_serif_link1
3263 *
3264 * Handle the SERIF_LINK1 action to align a serif, depending on edges
3265 * before and after.
3266 *
3267 * in: before_point (in twilight zone)
3268 * edge_point (in twilight zone)
3269 * after_point (in twilight zone)
3270 * ... stuff for bci_align_segments (edge) ...
3271 *
3272 * uses: bci_action_serif_link1_common
3273 */
3274
3275 unsigned char FPGM(bci_action_serif_link1) [] =
3276 {
3277
3278 PUSHB_1,
3279 bci_action_serif_link1,
3280 FDEF,
3281
3282 PUSHB_1,
3283 bci_action_serif_link1_common,
3284 CALL,
3285
3286 MDAP_noround, /* set rp0 and rp1 to `edge' */
3287
3288 PUSHB_2,
3289 bci_align_segments,
3290 1,
3291 SZP1, /* set zp1 to normal zone 1 */
3292 CALL,
3293
3294 ENDF,
3295
3296 };
3297
3298
3299 /*
3300 * bci_action_serif_link1_lower_bound
3301 *
3302 * Handle the SERIF_LINK1 action to align a serif, depending on edges
3303 * before and after. Additionally, move the serif again if necessary to
3304 * stay within a lower bound.
3305 *
3306 * in: before_point (in twilight zone)
3307 * edge_point (in twilight zone)
3308 * after_point (in twilight zone)
3309 * edge[-1] (in twilight zone)
3310 * ... stuff for bci_align_segments (edge) ...
3311 *
3312 * uses: bci_action_serif_link1_common
3313 * bci_lower_bound
3314 */
3315
3316 unsigned char FPGM(bci_action_serif_link1_lower_bound) [] =
3317 {
3318
3319 PUSHB_1,
3320 bci_action_serif_link1_lower_bound,
3321 FDEF,
3322
3323 PUSHB_1,
3324 bci_action_serif_link1_common,
3325 CALL,
3326
3327 PUSHB_1,
3328 bci_lower_bound,
3329 CALL,
3330
3331 ENDF,
3332
3333 };
3334
3335
3336 /*
3337 * bci_action_serif_link1_upper_bound
3338 *
3339 * Handle the SERIF_LINK1 action to align a serif, depending on edges
3340 * before and after. Additionally, move the serif again if necessary to
3341 * stay within an upper bound.
3342 *
3343 * in: before_point (in twilight zone)
3344 * edge_point (in twilight zone)
3345 * after_point (in twilight zone)
3346 * edge[1] (in twilight zone)
3347 * ... stuff for bci_align_segments (edge) ...
3348 *
3349 * uses: bci_action_serif_link1_common
3350 * bci_upper_bound
3351 */
3352
3353 unsigned char FPGM(bci_action_serif_link1_upper_bound) [] =
3354 {
3355
3356 PUSHB_1,
3357 bci_action_serif_link1_upper_bound,
3358 FDEF,
3359
3360 PUSHB_1,
3361 bci_action_serif_link1_common,
3362 CALL,
3363
3364 PUSHB_1,
3365 bci_upper_bound,
3366 CALL,
3367
3368 ENDF,
3369
3370 };
3371
3372
3373 /*
3374 * bci_action_serif_link1_lower_upper_bound
3375 *
3376 * Handle the SERIF_LINK1 action to align a serif, depending on edges
3377 * before and after. Additionally, move the serif again if necessary to
3378 * stay within a lower and upper bound.
3379 *
3380 * in: before_point (in twilight zone)
3381 * edge_point (in twilight zone)
3382 * after_point (in twilight zone)
3383 * edge[-1] (in twilight zone)
3384 * edge[1] (in twilight zone)
3385 * ... stuff for bci_align_segments (edge) ...
3386 *
3387 * uses: bci_action_serif_link1_common
3388 * bci_lower_upper_bound
3389 */
3390
3391 unsigned char FPGM(bci_action_serif_link1_lower_upper_bound) [] =
3392 {
3393
3394 PUSHB_1,
3395 bci_action_serif_link1_lower_upper_bound,
3396 FDEF,
3397
3398 PUSHB_1,
3399 bci_action_serif_link1_common,
3400 CALL,
3401
3402 PUSHB_1,
3403 bci_lower_upper_bound,
3404 CALL,
3405
3406 ENDF,
3407
3408 };
3409
3410
3411 /*
3412 * bci_action_serif_link2_common
3413 *
3414 * Common code for bci_action_serif_link2 routines.
3415 */
3416
3417 unsigned char FPGM(bci_action_serif_link2_common) [] =
3418 {
3419
3420 PUSHB_1,
3421 bci_action_serif_link2_common,
3422 FDEF,
3423
3424 PUSHB_1,
3425 0,
3426 SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3427
3428 DUP, /* s: [...] edge edge */
3429 PUSHB_1,
3430 sal_anchor,
3431 RS,
3432 DUP, /* s: [...] edge edge anchor anchor */
3433 MDAP_noround, /* set rp0 and rp1 to `sal_anchor' */
3434
3435 MD_orig_ZP2_0,
3436 DUP,
3437 ADD,
3438 PUSHB_1,
3439 32,
3440 ADD,
3441 FLOOR,
3442 PUSHB_1,
3443 2*64,
3444 DIV, /* delta = (edge_orig_pos - anchor_orig_pos + 16) & ~31 */
3445
3446 SWAP,
3447 DUP,
3448 DUP,
3449 ALIGNRP, /* align `edge' with `sal_anchor' */
3450 ROLL,
3451 SHPIX, /* shift `edge' by `delta' */
3452
3453 ENDF,
3454
3455 };
3456
3457
3458 /*
3459 * bci_action_serif_link2
3460 *
3461 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3462 *
3463 * in: edge_point (in twilight zone)
3464 * ... stuff for bci_align_segments (edge) ...
3465 *
3466 * uses: bci_action_serif_link2_common
3467 */
3468
3469 unsigned char FPGM(bci_action_serif_link2) [] =
3470 {
3471
3472 PUSHB_1,
3473 bci_action_serif_link2,
3474 FDEF,
3475
3476 PUSHB_1,
3477 bci_action_serif_link2_common,
3478 CALL,
3479
3480 MDAP_noround, /* set rp0 and rp1 to `edge' */
3481
3482 PUSHB_2,
3483 bci_align_segments,
3484 1,
3485 SZP1, /* set zp1 to normal zone 1 */
3486 CALL,
3487
3488 ENDF,
3489
3490 };
3491
3492
3493 /*
3494 * bci_action_serif_link2_lower_bound
3495 *
3496 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3497 * Additionally, move the serif again if necessary to stay within a lower
3498 * bound.
3499 *
3500 * in: edge_point (in twilight zone)
3501 * edge[-1] (in twilight zone)
3502 * ... stuff for bci_align_segments (edge) ...
3503 *
3504 * uses: bci_action_serif_link2_common
3505 * bci_lower_bound
3506 */
3507
3508 unsigned char FPGM(bci_action_serif_link2_lower_bound) [] =
3509 {
3510
3511 PUSHB_1,
3512 bci_action_serif_link2_lower_bound,
3513 FDEF,
3514
3515 PUSHB_1,
3516 bci_action_serif_link2_common,
3517 CALL,
3518
3519 PUSHB_1,
3520 bci_lower_bound,
3521 CALL,
3522
3523 ENDF,
3524
3525 };
3526
3527
3528 /*
3529 * bci_action_serif_link2_upper_bound
3530 *
3531 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3532 * Additionally, move the serif again if necessary to stay within an upper
3533 * bound.
3534 *
3535 * in: edge_point (in twilight zone)
3536 * edge[1] (in twilight zone)
3537 * ... stuff for bci_align_segments (edge) ...
3538 *
3539 * uses: bci_action_serif_link2_common
3540 * bci_upper_bound
3541 */
3542
3543 unsigned char FPGM(bci_action_serif_link2_upper_bound) [] =
3544 {
3545
3546 PUSHB_1,
3547 bci_action_serif_link2_upper_bound,
3548 FDEF,
3549
3550 PUSHB_1,
3551 bci_action_serif_link2_common,
3552 CALL,
3553
3554 PUSHB_1,
3555 bci_upper_bound,
3556 CALL,
3557
3558 ENDF,
3559
3560 };
3561
3562
3563 /*
3564 * bci_action_serif_link2_lower_upper_bound
3565 *
3566 * Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3567 * Additionally, move the serif again if necessary to stay within a lower
3568 * and upper bound.
3569 *
3570 * in: edge_point (in twilight zone)
3571 * edge[-1] (in twilight zone)
3572 * edge[1] (in twilight zone)
3573 * ... stuff for bci_align_segments (edge) ...
3574 *
3575 * uses: bci_action_serif_link2_common
3576 * bci_lower_upper_bound
3577 */
3578
3579 unsigned char FPGM(bci_action_serif_link2_lower_upper_bound) [] =
3580 {
3581
3582 PUSHB_1,
3583 bci_action_serif_link2_lower_upper_bound,
3584 FDEF,
3585
3586 PUSHB_1,
3587 bci_action_serif_link2_common,
3588 CALL,
3589
3590 PUSHB_1,
3591 bci_lower_upper_bound,
3592 CALL,
3593
3594 ENDF,
3595
3596 };
3597
3598
3599 /*
3600 * bci_handle_action
3601 *
3602 * Execute function.
3603 *
3604 * in: function_index
3605 */
3606
3607 unsigned char FPGM(bci_handle_action) [] =
3608 {
3609
3610 PUSHB_1,
3611 bci_handle_action,
3612 FDEF,
3613
3614 CALL,
3615
3616 ENDF,
3617
3618 };
3619
3620
3621 /*
3622 * bci_hint_glyph
3623 *
3624 * This is the top-level glyph hinting function
3625 * which parses the arguments on the stack and calls subroutines.
3626 *
3627 * in: num_actions (M)
3628 * action_0_func_idx
3629 * ... data ...
3630 * action_1_func_idx
3631 * ... data ...
3632 * ...
3633 * action_M_func_idx
3634 * ... data ...
3635 *
3636 * uses: bci_handle_action
3637 *
3638 * bci_action_ip_before
3639 * bci_action_ip_after
3640 * bci_action_ip_on
3641 * bci_action_ip_between
3642 *
3643 * bci_action_adjust_bound
3644 * bci_action_stem_bound
3645 *
3646 * bci_action_link
3647 * bci_action_anchor
3648 * bci_action_blue_anchor
3649 * bci_action_adjust
3650 * bci_action_stem
3651 * bci_action_blue
3652 *
3653 * bci_action_serif
3654 * bci_action_serif_lower_bound
3655 * bci_action_serif_upper_bound
3656 * bci_action_serif_lower_upper_bound
3657 *
3658 * bci_action_serif_anchor
3659 * bci_action_serif_anchor_lower_bound
3660 * bci_action_serif_anchor_upper_bound
3661 * bci_action_serif_anchor_lower_upper_bound
3662 *
3663 * bci_action_serif_link1
3664 * bci_action_serif_link1_lower_bound
3665 * bci_action_serif_link1_upper_bound
3666 * bci_action_serif_link1_lower_upper_bound
3667 *
3668 * bci_action_serif_link2
3669 * bci_action_serif_link2_lower_bound
3670 * bci_action_serif_link2_upper_bound
3671 * bci_action_serif_link2_lower_upper_bound
3672 *
3673 * CVT: cvtl_is_subglyph
3674 */
3675
3676 unsigned char FPGM(bci_hint_glyph) [] =
3677 {
3678
3679 PUSHB_1,
3680 bci_hint_glyph,
3681 FDEF,
3682
3683 PUSHB_2,
3684 0,
3685 cvtl_is_subglyph,
3686 RCVT,
3687 EQ,
3688 IF,
3689 /* only do something if we are not a subglyph */
3690 PUSHB_1,
3691 bci_handle_action,
3692 LOOPCALL,
3693
3694 PUSHB_1,
3695 1,
3696 SZP2, /* set zp2 to normal zone 1 */
3697 IUP_y,
3698
3699 ELSE,
3700 CLEAR,
3701 EIF,
3702
3703 ENDF,
3704
3705 };
3706
3707
3708 #define COPY_FPGM(func_name) \
3709 memcpy(buf_p, fpgm_ ## func_name, \
3710 sizeof (fpgm_ ## func_name)); \
3711 buf_p += sizeof (fpgm_ ## func_name) \
3712
3713 static FT_Error
3714 TA_table_build_fpgm(FT_Byte** fpgm,
3715 FT_ULong* fpgm_len,
3716 FONT* font)
3717 {
3718 FT_UInt buf_len;
3719 FT_UInt len;
3720 FT_Byte* buf;
3721 FT_Byte* buf_p;
3722
3723
3724 buf_len = sizeof (FPGM(bci_round))
3725 + sizeof (FPGM(bci_compute_stem_width_a))
3726 + 1
3727 + sizeof (FPGM(bci_compute_stem_width_b))
3728 + 1
3729 + sizeof (FPGM(bci_compute_stem_width_c))
3730 + sizeof (FPGM(bci_loop))
3731 + sizeof (FPGM(bci_cvt_rescale))
3732 + sizeof (FPGM(bci_blue_round_a))
3733 + 1
3734 + sizeof (FPGM(bci_blue_round_b))
3735 + sizeof (FPGM(bci_decrement_component_counter))
3736 + sizeof (FPGM(bci_get_point_extrema))
3737
3738 + sizeof (FPGM(bci_create_segment))
3739 + sizeof (FPGM(bci_create_segments))
3740 + sizeof (FPGM(bci_create_segments_composite))
3741 + sizeof (FPGM(bci_align_segment))
3742 + sizeof (FPGM(bci_align_segments))
3743
3744 + sizeof (FPGM(bci_scale_contour))
3745 + sizeof (FPGM(bci_scale_glyph))
3746 + sizeof (FPGM(bci_scale_composite_glyph))
3747 + sizeof (FPGM(bci_shift_contour))
3748 + sizeof (FPGM(bci_shift_subglyph))
3749
3750 + sizeof (FPGM(bci_ip_outer_align_point))
3751 + sizeof (FPGM(bci_ip_on_align_points))
3752 + sizeof (FPGM(bci_ip_between_align_point))
3753 + sizeof (FPGM(bci_ip_between_align_points))
3754
3755 + sizeof (FPGM(bci_action_adjust_common))
3756 + sizeof (FPGM(bci_action_stem_common))
3757 + sizeof (FPGM(bci_action_serif_common))
3758 + sizeof (FPGM(bci_action_serif_anchor_common))
3759 + sizeof (FPGM(bci_action_serif_link1_common))
3760 + sizeof (FPGM(bci_action_serif_link2_common))
3761
3762 + sizeof (FPGM(bci_lower_bound))
3763 + sizeof (FPGM(bci_upper_bound))
3764 + sizeof (FPGM(bci_lower_upper_bound))
3765
3766 + sizeof (FPGM(bci_action_ip_before))
3767 + sizeof (FPGM(bci_action_ip_after))
3768 + sizeof (FPGM(bci_action_ip_on))
3769 + sizeof (FPGM(bci_action_ip_between))
3770
3771 + sizeof (FPGM(bci_action_adjust_bound))
3772 + sizeof (FPGM(bci_action_stem_bound))
3773 + sizeof (FPGM(bci_action_link))
3774 + sizeof (FPGM(bci_action_anchor))
3775 + sizeof (FPGM(bci_action_blue_anchor))
3776 + sizeof (FPGM(bci_action_adjust))
3777 + sizeof (FPGM(bci_action_stem))
3778 + sizeof (FPGM(bci_action_blue))
3779 + sizeof (FPGM(bci_action_serif))
3780 + sizeof (FPGM(bci_action_serif_lower_bound))
3781 + sizeof (FPGM(bci_action_serif_upper_bound))
3782 + sizeof (FPGM(bci_action_serif_lower_upper_bound))
3783 + sizeof (FPGM(bci_action_serif_anchor))
3784 + sizeof (FPGM(bci_action_serif_anchor_lower_bound))
3785 + sizeof (FPGM(bci_action_serif_anchor_upper_bound))
3786 + sizeof (FPGM(bci_action_serif_anchor_lower_upper_bound))
3787 + sizeof (FPGM(bci_action_serif_link1))
3788 + sizeof (FPGM(bci_action_serif_link1_lower_bound))
3789 + sizeof (FPGM(bci_action_serif_link1_upper_bound))
3790 + sizeof (FPGM(bci_action_serif_link1_lower_upper_bound))
3791 + sizeof (FPGM(bci_action_serif_link2))
3792 + sizeof (FPGM(bci_action_serif_link2_lower_bound))
3793 + sizeof (FPGM(bci_action_serif_link2_upper_bound))
3794 + sizeof (FPGM(bci_action_serif_link2_lower_upper_bound))
3795
3796 + sizeof (FPGM(bci_handle_action))
3797 + sizeof (FPGM(bci_hint_glyph));
3798
3799 /* buffer length must be a multiple of four */
3800 len = (buf_len + 3) & ~3;
3801 buf = (FT_Byte*)malloc(len);
3802 if (!buf)
3803 return FT_Err_Out_Of_Memory;
3804
3805 /* pad end of buffer with zeros */
3806 buf[len - 1] = 0x00;
3807 buf[len - 2] = 0x00;
3808 buf[len - 3] = 0x00;
3809
3810 /* copy font program into buffer and fill in the missing variables */
3811 buf_p = buf;
3812
3813 COPY_FPGM(bci_round);
3814 COPY_FPGM(bci_compute_stem_width_a);
3815 *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
3816 COPY_FPGM(bci_compute_stem_width_b);
3817 *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
3818 COPY_FPGM(bci_compute_stem_width_c);
3819 COPY_FPGM(bci_loop);
3820 COPY_FPGM(bci_cvt_rescale);
3821 COPY_FPGM(bci_blue_round_a);
3822 *(buf_p++) = (unsigned char)CVT_BLUES_SIZE(font);
3823 COPY_FPGM(bci_blue_round_b);
3824 COPY_FPGM(bci_decrement_component_counter);
3825 COPY_FPGM(bci_get_point_extrema);
3826
3827 COPY_FPGM(bci_create_segment);
3828 COPY_FPGM(bci_create_segments);
3829 COPY_FPGM(bci_create_segments_composite);
3830 COPY_FPGM(bci_align_segment);
3831 COPY_FPGM(bci_align_segments);
3832
3833 COPY_FPGM(bci_scale_contour);
3834 COPY_FPGM(bci_scale_glyph);
3835 COPY_FPGM(bci_scale_composite_glyph);
3836 COPY_FPGM(bci_shift_contour);
3837 COPY_FPGM(bci_shift_subglyph);
3838
3839 COPY_FPGM(bci_ip_outer_align_point);
3840 COPY_FPGM(bci_ip_on_align_points);
3841 COPY_FPGM(bci_ip_between_align_point);
3842 COPY_FPGM(bci_ip_between_align_points);
3843
3844 COPY_FPGM(bci_action_adjust_common);
3845 COPY_FPGM(bci_action_stem_common);
3846 COPY_FPGM(bci_action_serif_common);
3847 COPY_FPGM(bci_action_serif_anchor_common);
3848 COPY_FPGM(bci_action_serif_link1_common);
3849 COPY_FPGM(bci_action_serif_link2_common);
3850
3851 COPY_FPGM(bci_lower_bound);
3852 COPY_FPGM(bci_upper_bound);
3853 COPY_FPGM(bci_lower_upper_bound);
3854
3855 COPY_FPGM(bci_action_ip_before);
3856 COPY_FPGM(bci_action_ip_after);
3857 COPY_FPGM(bci_action_ip_on);
3858 COPY_FPGM(bci_action_ip_between);
3859
3860 COPY_FPGM(bci_action_adjust_bound);
3861 COPY_FPGM(bci_action_stem_bound);
3862 COPY_FPGM(bci_action_link);
3863 COPY_FPGM(bci_action_anchor);
3864 COPY_FPGM(bci_action_blue_anchor);
3865 COPY_FPGM(bci_action_adjust);
3866 COPY_FPGM(bci_action_stem);
3867 COPY_FPGM(bci_action_blue);
3868 COPY_FPGM(bci_action_serif);
3869 COPY_FPGM(bci_action_serif_lower_bound);
3870 COPY_FPGM(bci_action_serif_upper_bound);
3871 COPY_FPGM(bci_action_serif_lower_upper_bound);
3872 COPY_FPGM(bci_action_serif_anchor);
3873 COPY_FPGM(bci_action_serif_anchor_lower_bound);
3874 COPY_FPGM(bci_action_serif_anchor_upper_bound);
3875 COPY_FPGM(bci_action_serif_anchor_lower_upper_bound);
3876 COPY_FPGM(bci_action_serif_link1);
3877 COPY_FPGM(bci_action_serif_link1_lower_bound);
3878 COPY_FPGM(bci_action_serif_link1_upper_bound);
3879 COPY_FPGM(bci_action_serif_link1_lower_upper_bound);
3880 COPY_FPGM(bci_action_serif_link2);
3881 COPY_FPGM(bci_action_serif_link2_lower_bound);
3882 COPY_FPGM(bci_action_serif_link2_upper_bound);
3883 COPY_FPGM(bci_action_serif_link2_lower_upper_bound);
3884
3885 COPY_FPGM(bci_handle_action);
3886 COPY_FPGM(bci_hint_glyph);
3887
3888 *fpgm = buf;
3889 *fpgm_len = buf_len;
3890
3891 return FT_Err_Ok;
3892 }
3893
3894
3895 FT_Error
3896 TA_sfnt_build_fpgm_table(SFNT* sfnt,
3897 FONT* font)
3898 {
3899 FT_Error error;
3900
3901 FT_Byte* fpgm_buf;
3902 FT_ULong fpgm_len;
3903
3904
3905 error = TA_sfnt_add_table_info(sfnt);
3906 if (error)
3907 return error;
3908
3909 error = TA_table_build_fpgm(&fpgm_buf, &fpgm_len, font);
3910 if (error)
3911 return error;
3912
3913 if (fpgm_len > sfnt->max_instructions)
3914 sfnt->max_instructions = fpgm_len;
3915
3916 /* in case of success, `fpgm_buf' gets linked */
3917 /* and is eventually freed in `TA_font_unload' */
3918 error = TA_font_add_table(font,
3919 &sfnt->table_infos[sfnt->num_table_infos - 1],
3920 TTAG_fpgm, fpgm_len, fpgm_buf);
3921 if (error)
3922 {
3923 free(fpgm_buf);
3924 return error;
3925 }
3926
3927 return FT_Err_Ok;
3928 }
3929
3930 /* end of tafpgm.c */
A library to autohint TrueType fonts