lib/tafpgm.c

   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   PUSHB_1,
  88     32,
  89   ADD,
  90   FLOOR,
  91
  92   ENDF,
  93
  94 };
  95
  96
  97 /*
  98  * bci_smooth_stem_width
  99  *
 100  *   This is the equivalent to the following code from function
 101  *   `ta_latin_compute_stem_width':
 102  *
 103  *      dist = ABS(width)
 104  *
 105  *      if (stem_is_serif
 106  *          && dist < 3*64)
 107  *         || is_extra_light:
 108  *        return width
 109  *      else if base_is_round:
 110  *        if dist < 80
 111  *          dist = 64
 112  *      else if dist < 56:
 113  *        dist = 56
 114  *
 115  *      delta = ABS(dist - std_width)
 116  *
 117  *      if delta < 40:
 118  *        dist = std_width
 119  *        if dist < 48
 120  *          dist = 48
 121  *        goto End
 122  *
 123  *      if dist < 3*64:
 124  *        delta = dist
 125  *        dist = FLOOR(dist)
 126  *        delta = delta - dist
 127  *
 128  *        if delta < 10:
 129  *          dist = dist + delta
 130  *        else if delta < 32:
 131  *          dist = dist + 10
 132  *        else if delta < 54:
 133  *          dist = dist + 54
 134  *        else
 135  *          dist = dist + delta
 136  *      else
 137  *        dist = ROUND(dist)
 138  *
 139  *    End:
 140  *      if width < 0:
 141  *        dist = -dist
 142  *      return dist
 143  *
 144  *
 145  * in: width
 146  *     stem_is_serif
 147  *     base_is_round
 148  *
 149  * out: new_width
 150  *
 151  * CVT: cvtl_is_extra_light
 152  *      std_width
 153  *
 154  * uses: bci_round
 155  */
 156
 157 unsigned char FPGM(bci_smooth_stem_width_a) [] =
 158 {
 159
 160   PUSHB_1,
 161     bci_smooth_stem_width,
 162   FDEF,
 163
 164   DUP,
 165   ABS, /* s: base_is_round stem_is_serif width dist */
 166
 167   DUP,
 168   PUSHB_1,
 169     3*64,
 170   LT, /* dist < 3*64 */
 171
 172   PUSHB_1,
 173     4,
 174   MINDEX, /* s: base_is_round width dist (dist<3*64) stem_is_serif */
 175   AND, /* stem_is_serif && dist < 3*64 */
 176
 177   PUSHB_1,
 178     cvtl_is_extra_light,
 179   RCVT,
 180   OR, /* (stem_is_serif && dist < 3*64) || is_extra_light */
 181
 182   IF, /* s: base_is_round width dist */
 183     POP,
 184     SWAP,
 185     POP, /* s: width */
 186
 187   ELSE,
 188     ROLL, /* s: width dist base_is_round */
 189     IF, /* s: width dist */
 190       DUP,
 191       PUSHB_1,
 192         80,
 193       LT, /* dist < 80 */
 194       IF, /* s: width dist */
 195         POP,
 196         PUSHB_1,
 197           64, /* dist = 64 */
 198       EIF,
 199
 200     ELSE,
 201       DUP,
 202       PUSHB_1,
 203         56,
 204       LT, /* dist < 56 */
 205       IF, /* s: width dist */
 206         POP,
 207         PUSHB_1,
 208           56, /* dist = 56 */
 209       EIF,
 210     EIF,
 211
 212     DUP, /* s: width dist dist */
 213     PUSHB_1,
 214
 215 };
 216
 217 /*    %c, index of std_width */
 218
 219 unsigned char FPGM(bci_smooth_stem_width_b) [] =
 220 {
 221
 222     RCVT,
 223     SUB,
 224     ABS, /* s: width dist delta */
 225
 226     PUSHB_1,
 227       40,
 228     LT, /* delta < 40 */
 229     IF, /* s: width dist */
 230       POP,
 231       PUSHB_1,
 232
 233 };
 234
 235 /*      %c, index of std_width */
 236
 237 unsigned char FPGM(bci_smooth_stem_width_c) [] =
 238 {
 239
 240       RCVT, /* dist = std_width */
 241       DUP,
 242       PUSHB_1,
 243         48,
 244       LT, /* dist < 48 */
 245       IF,
 246         POP,
 247         PUSHB_1,
 248           48, /* dist = 48 */
 249       EIF,
 250
 251     ELSE,
 252       DUP, /* s: width dist dist */
 253       PUSHB_1,
 254         3*64,
 255       LT, /* dist < 3*64 */
 256       IF,
 257         DUP, /* s: width delta dist */
 258         FLOOR, /* dist = FLOOR(dist) */
 259         DUP, /* s: width delta dist dist */
 260         ROLL,
 261         ROLL, /* s: width dist delta dist */
 262         SUB, /* delta = delta - dist */
 263
 264         DUP, /* s: width dist delta delta */
 265         PUSHB_1,
 266           10,
 267         LT, /* delta < 10 */
 268         IF, /* s: width dist delta */
 269           ADD, /* dist = dist + delta */
 270
 271         ELSE,
 272           DUP,
 273           PUSHB_1,
 274             32,
 275           LT, /* delta < 32 */
 276           IF,
 277             POP,
 278             PUSHB_1,
 279               10,
 280             ADD, /* dist = dist + 10 */
 281
 282           ELSE,
 283             DUP,
 284             PUSHB_1,
 285               54,
 286             LT, /* delta < 54 */
 287             IF,
 288               POP,
 289               PUSHB_1,
 290                 54,
 291               ADD, /* dist = dist + 54 */
 292
 293             ELSE,
 294               ADD, /* dist = dist + delta */
 295
 296             EIF,
 297           EIF,
 298         EIF,
 299
 300       ELSE,
 301         PUSHB_1,
 302           bci_round,
 303         CALL, /* dist = round(dist) */
 304
 305       EIF,
 306     EIF,
 307
 308     SWAP, /* s: dist width */
 309     PUSHB_1,
 310       0,
 311     LT, /* width < 0 */
 312     IF,
 313       NEG, /* dist = -dist */
 314     EIF,
 315   EIF,
 316
 317   ENDF,
 318
 319 };
 320
 321
 322 /*
 323  * bci_get_best_width
 324  *
 325  *   An auxiliary function for `bci_strong_stem_width'.
 326  *
 327  * in: n (initialized with CVT index for first vertical width)
 328  *     dist
 329  *
 330  * out: n+1
 331  *      dist
 332  *
 333  * sal: sal_best
 334  *      sal_ref
 335  *
 336  * CVT: widths[]
 337  */
 338
 339 unsigned char FPGM(bci_get_best_width) [] =
 340 {
 341
 342   PUSHB_1,
 343     bci_get_best_width,
 344   FDEF,
 345
 346   DUP,
 347   RCVT, /* s: dist n w */
 348   DUP,
 349   PUSHB_1,
 350     4,
 351   CINDEX, /* s: dist n w w dist */
 352   SUB,
 353   ABS, /* s: dist n w d */
 354   DUP,
 355   PUSHB_1,
 356     sal_best,
 357   RS, /* s: dist n w d d best */
 358   LT, /* d < best */
 359   IF,
 360     PUSHB_1,
 361       sal_best,
 362     SWAP,
 363     WS, /* best = d */
 364     PUSHB_1,
 365       sal_ref,
 366     SWAP,
 367     WS, /* reference = w */
 368
 369   ELSE,
 370     POP,
 371     POP,
 372   EIF,
 373
 374   PUSHB_1,
 375     1,
 376   ADD, /* n = n + 1 */
 377
 378   ENDF,
 379
 380 };
 381
 382
 383 /*
 384  * bci_strong_stem_width
 385  *
 386  *   This is the equivalent to the following code (function
 387  *   `ta_latin_snap_width' and some lines from
 388  *   `ta_latin_compute_stem_width'):
 389  *
 390  *     best = 64 + 32 + 2;
 391  *     reference = width
 392  *     dist = ABS(width)
 393  *
 394  *     for n in 0 .. num_widths:
 395  *       w = widths[n]
 396  *       d = ABS(dist - w)
 397  *
 398  *       if d < best:
 399  *         best = d
 400  *         reference = w;
 401  *
 402  *     if dist >= reference:
 403  *       if dist < ROUND(reference) + 48:
 404  *         dist = reference
 405  *     else
 406  *       if dist > ROUND(reference) - 48:
 407  *         dist = reference
 408  *
 409  *     if dist >= 64:
 410  *       dist = ROUND(dist)
 411  *     else
 412  *       dist = 64
 413  *
 414  *     if width < 0:
 415  *       dist = -dist
 416  *     return dist
 417  *
 418  * in: width
 419  *     stem_is_serif (unused)
 420  *     base_is_round (unused)
 421  *
 422  * out: new_width
 423  *
 424  * sal: sal_best
 425  *      sal_ref
 426  *
 427  * CVT: widths[]
 428  *
 429  * uses: bci_get_best_width
 430  *       bci_round
 431  */
 432
 433 unsigned char FPGM(bci_strong_stem_width_a) [] =
 434 {
 435
 436   PUSHB_1,
 437     bci_strong_stem_width,
 438   FDEF,
 439
 440   SWAP,
 441   POP,
 442   SWAP,
 443   POP,
 444   DUP,
 445   ABS, /* s: width dist */
 446
 447   PUSHB_2,
 448     sal_best,
 449     64 + 32 + 2,
 450   WS, /* sal_best = 98 */
 451
 452   DUP,
 453   PUSHB_1,
 454     sal_ref,
 455   SWAP,
 456   WS, /* sal_ref = width */
 457
 458   PUSHB_3,
 459 };
 460
 461 /*  %c, first index of vertical widths */
 462 /*  %c, number of vertical widths */
 463
 464 unsigned char FPGM(bci_strong_stem_width_b) [] =
 465 {
 466
 467     bci_get_best_width,
 468   LOOPCALL,
 469
 470   POP, /* s: width dist */
 471   DUP,
 472   PUSHB_1,
 473     sal_ref,
 474   RS, /* s: width dist dist reference */
 475   DUP,
 476   ROLL,
 477   DUP,
 478   ROLL,
 479   PUSHB_1,
 480     bci_round,
 481   CALL, /* s: width dist reference dist dist ROUND(reference) */
 482   PUSHB_2,
 483     48,
 484     5,
 485   CINDEX,
 486   ROLL, /* s: width dist reference dist ROUND(reference) 48 reference dist */
 487
 488   LTEQ, /* dist >= reference */
 489   IF, /* s: width dist reference dist ROUND(reference) 48 */
 490     ADD,
 491     LT, /* dist < ROUND(reference) + 48 */
 492
 493   ELSE,
 494     SUB,
 495     GT, /* dist > ROUND(reference) - 48 */
 496   EIF,
 497
 498   IF,
 499     SWAP, /* s: width reference dist */
 500   EIF,
 501   POP,
 502
 503   DUP,
 504   PUSHB_1,
 505     64,
 506   GTEQ, /* dist >= 64 */
 507   IF,
 508     PUSHB_1,
 509       bci_round,
 510     CALL, /* dist = ROUND(dist) */
 511
 512   ELSE,
 513     POP,
 514     PUSHB_1,
 515       64, /* dist = 64 */
 516   EIF,
 517
 518   SWAP, /* s: dist width */
 519   PUSHB_1,
 520     0,
 521   LT, /* width < 0 */
 522   IF,
 523     NEG, /* dist = -dist */
 524   EIF,
 525
 526   ENDF,
 527
 528 };
 529
 530
 531 /*
 532  * bci_loop
 533  *
 534  *   Take a range and a function number and apply the function to all
 535  *   elements of the range.
 536  *
 537  * in: func_num
 538  *     end
 539  *     start
 540  *
 541  * sal: sal_i (counter initialized with `start')
 542  *      sal_limit (`end')
 543  *      sal_func (`func_num')
 544  */
 545
 546 unsigned char FPGM(bci_loop) [] =
 547 {
 548
 549   PUSHB_1,
 550     bci_loop,
 551   FDEF,
 552
 553   PUSHB_1,
 554     sal_func,
 555   SWAP,
 556   WS, /* sal_func = func_num */
 557   PUSHB_1,
 558     sal_limit,
 559   SWAP,
 560   WS, /* sal_limit = end */
 561   PUSHB_1,
 562     sal_i,
 563   SWAP,
 564   WS, /* sal_i = start */
 565
 566 /* start_loop: */
 567   PUSHB_1,
 568     sal_i,
 569   RS,
 570   PUSHB_1,
 571     sal_limit,
 572   RS,
 573   LTEQ, /* start <= end */
 574   IF,
 575     PUSHB_1,
 576       sal_func,
 577     RS,
 578     CALL,
 579     PUSHB_3,
 580       sal_i,
 581       1,
 582       sal_i,
 583     RS,
 584     ADD, /* start = start + 1 */
 585     WS,
 586
 587     PUSHB_1,
 588       22,
 589     NEG,
 590     JMPR, /* goto start_loop */
 591   EIF,
 592
 593   ENDF,
 594
 595 };
 596
 597
 598 /*
 599  * bci_cvt_rescale
 600  *
 601  *   Rescale CVT value by `cvtl_scale' (in 16.16 format).
 602  *
 603  *   The scaling factor `cvtl_scale' isn't stored as `b/c' but as `(b-c)/c';
 604  *   consequently, the calculation `a * b/c' is done as `a + delta' with
 605  *   `delta = a * (b-c)/c'.  This avoids overflow.
 606  *
 607  * in: cvt_idx
 608  *
 609  * out: cvt_idx+1
 610  *
 611  * CVT: cvtl_scale
 612  *      cvtl_0x10000
 613  */
 614
 615 unsigned char FPGM(bci_cvt_rescale) [] =
 616 {
 617
 618   PUSHB_1,
 619     bci_cvt_rescale,
 620   FDEF,
 621
 622   DUP,
 623   DUP,
 624   RCVT,
 625   DO_SCALE,
 626   WCVTP,
 627
 628   PUSHB_1,
 629     1,
 630   ADD,
 631
 632   ENDF,
 633
 634 };
 635
 636
 637 /*
 638  * bci_blue_round
 639  *
 640  *   Round a blue ref value and adjust its corresponding shoot value.
 641  *
 642  * in: ref_idx
 643  *
 644  * out: ref_idx+1
 645  *
 646  * uses: bci_round
 647  */
 648
 649 unsigned char FPGM(bci_blue_round_a) [] =
 650 {
 651
 652   PUSHB_1,
 653     bci_blue_round,
 654   FDEF,
 655
 656   DUP,
 657   DUP,
 658   RCVT, /* s: ref_idx ref_idx ref */
 659
 660   DUP,
 661   PUSHB_1,
 662     bci_round,
 663   CALL,
 664   SWAP, /* s: ref_idx ref_idx round(ref) ref */
 665
 666   PUSHB_2,
 667
 668 };
 669
 670 /*  %c, blue_count */
 671
 672 unsigned char FPGM(bci_blue_round_b) [] =
 673 {
 674
 675     4,
 676   CINDEX,
 677   ADD, /* s: ref_idx ref_idx round(ref) ref shoot_idx */
 678   DUP,
 679   RCVT, /* s: ref_idx ref_idx round(ref) ref shoot_idx shoot */
 680
 681   ROLL, /* s: ref_idx ref_idx round(ref) shoot_idx shoot ref */
 682   SWAP,
 683   SUB, /* s: ref_idx ref_idx round(ref) shoot_idx dist */
 684   DUP,
 685   ABS, /* s: ref_idx ref_idx round(ref) shoot_idx dist delta */
 686
 687   DUP,
 688   PUSHB_1,
 689     32,
 690   LT, /* delta < 32 */
 691   IF,
 692     POP,
 693     PUSHB_1,
 694       0, /* delta = 0 */
 695
 696   ELSE,
 697     PUSHB_1,
 698       48,
 699     LT, /* delta < 48 */
 700     IF,
 701       PUSHB_1,
 702         32, /* delta = 32 */
 703
 704     ELSE,
 705       PUSHB_1,
 706         64, /* delta = 64 */
 707     EIF,
 708   EIF,
 709
 710   SWAP, /* s: ref_idx ref_idx round(ref) shoot_idx delta dist */
 711   PUSHB_1,
 712     0,
 713   LT, /* dist < 0 */
 714   IF,
 715     NEG, /* delta = -delta */
 716   EIF,
 717
 718   PUSHB_1,
 719     3,
 720   CINDEX,
 721   SWAP,
 722   SUB, /* s: ref_idx ref_idx round(ref) shoot_idx (round(ref) - delta) */
 723
 724   WCVTP,
 725   WCVTP,
 726
 727   PUSHB_1,
 728     1,
 729   ADD, /* s: (ref_idx + 1) */
 730
 731   ENDF,
 732
 733 };
 734
 735
 736 /*
 737  * bci_decrement_component_counter
 738  *
 739  *   An auxiliary function for composite glyphs.
 740  *
 741  * CVT: cvtl_is_subglyph
 742  */
 743
 744 unsigned char FPGM(bci_decrement_component_counter) [] =
 745 {
 746
 747   PUSHB_1,
 748     bci_decrement_component_counter,
 749   FDEF,
 750
 751   /* decrement `cvtl_is_subglyph' counter */
 752   PUSHB_2,
 753     cvtl_is_subglyph,
 754     cvtl_is_subglyph,
 755   RCVT,
 756   PUSHB_1,
 757     1,
 758   SUB,
 759   WCVTP,
 760
 761   ENDF,
 762
 763 };
 764
 765
 766 /*
 767  * bci_get_point_extrema
 768  *
 769  *   An auxiliary function for `bci_create_segment'.
 770  *
 771  * in: point-1
 772  * out: point
 773  *
 774  * sal: sal_point_min
 775  *      sal_point_max
 776  */
 777
 778 unsigned char FPGM(bci_get_point_extrema) [] =
 779 {
 780
 781   PUSHB_1,
 782     bci_get_point_extrema,
 783   FDEF,
 784
 785   PUSHB_1,
 786     1,
 787   ADD, /* s: point */
 788   DUP,
 789   DUP,
 790
 791   /* check whether `point' is a new minimum */
 792   PUSHB_1,
 793     sal_point_min,
 794   RS, /* s: point point point point_min */
 795   MD_orig,
 796   /* if distance is negative, we have a new minimum */
 797   PUSHB_1,
 798     0,
 799   LT,
 800   IF, /* s: point point */
 801     DUP,
 802     PUSHB_1,
 803       sal_point_min,
 804     SWAP,
 805     WS,
 806   EIF,
 807
 808   /* check whether `point' is a new maximum */
 809   PUSHB_1,
 810     sal_point_max,
 811   RS, /* s: point point point_max */
 812   MD_orig,
 813   /* if distance is positive, we have a new maximum */
 814   PUSHB_1,
 815     0,
 816   GT,
 817   IF, /* s: point */
 818     DUP,
 819     PUSHB_1,
 820       sal_point_max,
 821     SWAP,
 822     WS,
 823   EIF, /* s: point */
 824
 825   ENDF,
 826
 827 };
 828
 829
 830 /*
 831  * bci_nibbles
 832  *
 833  *   Pop a byte with two delta arguments in its nibbles and push the
 834  *   expanded arguments separately as two bytes.
 835  *
 836  * in: 16 * (end - start) + (start - base)
 837  *
 838  * out: start
 839  *      end
 840  *
 841  * sal: sal_base (set to `end' at return)
 842  */
 843
 844
 845 unsigned char FPGM(bci_nibbles) [] =
 846 {
 847   PUSHB_1,
 848     bci_nibbles,
 849   FDEF,
 850
 851   DUP,
 852   PUSHW_1,
 853     0x04, /* 16*64 */
 854     0x00,
 855   DIV, /* s: in hnibble */
 856   DUP,
 857   PUSHW_1,
 858     0x04, /* 16*64 */
 859     0x00,
 860   MUL, /* s: in hnibble (hnibble * 16) */
 861   ROLL,
 862   SWAP,
 863   SUB, /* s: hnibble lnibble */
 864
 865   PUSHB_1,
 866     sal_base,
 867   RS,
 868   ADD, /* s: hnibble start */
 869   DUP,
 870   ROLL,
 871   ADD, /* s: start end */
 872
 873   DUP,
 874   PUSHB_1,
 875     sal_base,
 876   SWAP,
 877   WS, /* sal_base = end */
 878
 879   SWAP,
 880
 881   ENDF,
 882
 883 };
 884
 885
 886 /*
 887  * bci_number_set_is_element
 888  *
 889  *   Pop values from stack until it is empty.  If one of them is equal to
 890  *   the current PPEM value, set `cvtl_is_element' to 1 (and to 0
 891  *   otherwise).
 892  *
 893  * in: ppem_value_1
 894  *     ppem_value_2
 895  *     ...
 896  *
 897  * CVT: cvtl_is_element
 898  */
 899
 900 unsigned char FPGM(bci_number_set_is_element) [] =
 901 {
 902
 903   PUSHB_1,
 904     bci_number_set_is_element,
 905   FDEF,
 906
 907 /* start_loop: */
 908   MPPEM,
 909   EQ,
 910   IF,
 911     PUSHB_2,
 912       cvtl_is_element,
 913       1,
 914     WCVTP,
 915   EIF,
 916
 917   DEPTH,
 918   PUSHB_1,
 919     13,
 920   NEG,
 921   SWAP,
 922   JROT, /* goto start_loop if stack depth != 0 */
 923
 924   ENDF,
 925
 926 };
 927
 928
 929 /*
 930  * bci_number_set_is_element2
 931  *
 932  *   Pop value ranges from stack until it is empty.  If one of them contains
 933  *   the current PPEM value, set `cvtl_is_element' to 1 (and to 0
 934  *   otherwise).
 935  *
 936  * in: ppem_range_1_start
 937  *     ppem_range_1_end
 938  *     ppem_range_2_start
 939  *     ppem_range_2_end
 940  *     ...
 941  *
 942  * CVT: cvtl_is_element
 943  */
 944
 945 unsigned char FPGM(bci_number_set_is_element2) [] =
 946 {
 947
 948   PUSHB_1,
 949     bci_number_set_is_element2,
 950   FDEF,
 951
 952 /* start_loop: */
 953   MPPEM,
 954   LTEQ,
 955   IF,
 956     MPPEM,
 957     GTEQ,
 958     IF,
 959       PUSHB_2,
 960         cvtl_is_element,
 961         1,
 962       WCVTP,
 963     EIF,
 964   ELSE,
 965     POP,
 966   EIF,
 967
 968   DEPTH,
 969   PUSHB_1,
 970     19,
 971   NEG,
 972   SWAP,
 973   JROT, /* goto start_loop if stack depth != 0 */
 974
 975   ENDF,
 976
 977 };
 978
 979
 980 /*
 981  * bci_create_segment
 982  *
 983  *   Store start and end point of a segment in the storage area,
 984  *   then construct a point in the twilight zone to represent it.
 985  *
 986  *   This function is used by `bci_create_segment_points'.
 987  *
 988  * in: start
 989  *     end
 990  *       [last (if wrap-around segment)]
 991  *       [first (if wrap-around segment)]
 992  *
 993  * sal: sal_i (start of current segment)
 994  *      sal_j (current twilight point)
 995  *      sal_point_min
 996  *      sal_point_max
 997  *      sal_base
 998  *      sal_num_packed_segments
 999  *
1000  * CVT: cvtl_scale
1001  *      cvtl_0x10000
1002  *      cvtl_temp
1003  *
1004  * uses: bci_get_point_extrema
1005  *       bci_nibbles
1006  *
1007  * If `sal_num_packed_segments' is > 0, the start/end pair is stored as
1008  * delta values in nibbles (without a wrap-around segment).
1009  */
1010
1011 unsigned char FPGM(bci_create_segment) [] =
1012 {
1013
1014   PUSHB_1,
1015     bci_create_segment,
1016   FDEF,
1017
1018   PUSHB_2,
1019     0,
1020     sal_num_packed_segments,
1021   RS,
1022   NEQ,
1023   IF,
1024     PUSHB_2,
1025       sal_num_packed_segments,
1026       sal_num_packed_segments,
1027     RS,
1028     PUSHB_1,
1029       1,
1030     SUB,
1031     WS, /* sal_num_packed_segments = sal_num_packed_segments - 1 */
1032
1033     PUSHB_1,
1034       bci_nibbles,
1035     CALL,
1036   EIF,
1037
1038   PUSHB_1,
1039     sal_i,
1040   RS,
1041   PUSHB_1,
1042     2,
1043   CINDEX,
1044   WS, /* sal[sal_i] = start */
1045
1046   /* increase `sal_i'; together with the outer loop, this makes sal_i += 2 */
1047   PUSHB_3,
1048     sal_i,
1049     1,
1050     sal_i,
1051   RS,
1052   ADD, /* sal_i = sal_i + 1 */
1053   WS,
1054
1055   /* initialize inner loop(s) */
1056   PUSHB_2,
1057     sal_point_min,
1058     2,
1059   CINDEX,
1060   WS, /* sal_point_min = start */
1061   PUSHB_2,
1062     sal_point_max,
1063     2,
1064   CINDEX,
1065   WS, /* sal_point_max = start */
1066
1067   PUSHB_1,
1068     1,
1069   SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
1070
1071   SWAP,
1072   DUP,
1073   PUSHB_1,
1074     3,
1075   CINDEX, /* s: start end end start */
1076   LT, /* start > end */
1077   IF,
1078     /* we have a wrap-around segment with two more arguments */
1079     /* to give the last and first point of the contour, respectively; */
1080     /* our job is to store a segment `start'-`last', */
1081     /* and to get extrema for the two segments */
1082     /* `start'-`last' and `first'-`end' */
1083
1084     /* s: first last start end */
1085     PUSHB_1,
1086       sal_i,
1087     RS,
1088     PUSHB_1,
1089       4,
1090     CINDEX,
1091     WS, /* sal[sal_i] = last */
1092
1093     ROLL,
1094     ROLL, /* s: first end last start */
1095     DUP,
1096     ROLL,
1097     SWAP, /* s: first end start last start */
1098     SUB, /* s: first end start loop_count */
1099
1100     PUSHB_1,
1101       bci_get_point_extrema,
1102     LOOPCALL,
1103     /* clean up stack */
1104     POP,
1105
1106     SWAP, /* s: end first */
1107     PUSHB_1,
1108       1,
1109     SUB,
1110     DUP,
1111     ROLL, /* s: (first - 1) (first - 1) end */
1112     SWAP,
1113     SUB, /* s: (first - 1) loop_count */
1114
1115     PUSHB_1,
1116       bci_get_point_extrema,
1117     LOOPCALL,
1118     /* clean up stack */
1119     POP,
1120
1121   ELSE, /* s: start end */
1122     PUSHB_1,
1123       sal_i,
1124     RS,
1125     PUSHB_1,
1126       2,
1127     CINDEX,
1128     WS, /* sal[sal_i] = end */
1129
1130     PUSHB_1,
1131       2,
1132     CINDEX,
1133     SUB, /* s: start loop_count */
1134
1135     PUSHB_1,
1136       bci_get_point_extrema,
1137     LOOPCALL,
1138     /* clean up stack */
1139     POP,
1140   EIF,
1141
1142   /* the twilight point representing a segment */
1143   /* is in the middle between the minimum and maximum */
1144   PUSHB_1,
1145     sal_point_min,
1146   RS,
1147   GC_orig,
1148   PUSHB_1,
1149     sal_point_max,
1150   RS,
1151   GC_orig,
1152   ADD,
1153   PUSHB_1,
1154     2*64,
1155   DIV, /* s: middle_pos */
1156
1157   DO_SCALE, /* middle_pos = middle_pos * scale */
1158
1159   /* write it to temporary CVT location */
1160   PUSHB_2,
1161     cvtl_temp,
1162     0,
1163   SZP0, /* set zp0 to twilight zone 0 */
1164   SWAP,
1165   WCVTP,
1166
1167   /* create twilight point with index `sal_j' */
1168   PUSHB_1,
1169     sal_j,
1170   RS,
1171   PUSHB_1,
1172     cvtl_temp,
1173   MIAP_noround,
1174
1175   PUSHB_3,
1176     sal_j,
1177     1,
1178     sal_j,
1179   RS,
1180   ADD, /* twilight_point = twilight_point + 1 */
1181   WS,
1182
1183   ENDF,
1184
1185 };
1186
1187
1188 /*
1189  * bci_create_segments
1190  *
1191  *   This is the top-level entry function.
1192  *
1193  *   It pops point ranges from the stack to define segments, computes
1194  *   twilight points to represent segments, and finally calls
1195  *   `bci_hint_glyph' to handle the rest.
1196  *
1197  * in: num_packed_segments
1198  *     num_segments (N)
1199  *     segment_start_0
1200  *     segment_end_0
1201  *       [contour_last 0 (if wrap-around segment)]
1202  *       [contour_first 0 (if wrap-around segment)]
1203  *     segment_start_1
1204  *     segment_end_1
1205  *       [contour_last 0 (if wrap-around segment)]
1206  *       [contour_first 0 (if wrap-around segment)]
1207  *     ...
1208  *     segment_start_(N-1)
1209  *     segment_end_(N-1)
1210  *       [contour_last (N-1) (if wrap-around segment)]
1211  *       [contour_first (N-1) (if wrap-around segment)]
1212  *     ... stuff for bci_hint_glyph ...
1213  *
1214  * sal: sal_i (start of current segment)
1215  *      sal_j (current twilight point)
1216  *      sal_num_packed_segments
1217  *      sal_base (the base for delta values in nibbles)
1218  *
1219  * CVT: cvtl_is_subglyph
1220  *
1221  * uses: bci_create_segment
1222  *       bci_loop
1223  *       bci_hint_glyph
1224  *
1225  * If `num_packed_segments' is set to p, the first p start/end pairs are
1226  * stored as delta values in nibbles, with the `start' delta in the lower
1227  * nibble (and there are no wrap-around segments).  For example, if the
1228  * first three pairs are 1/3, 5/8, and 12/13, the topmost three bytes on the
1229  * stack are 0x21, 0x32, and 0x14.
1230  *
1231  */
1232
1233 unsigned char FPGM(bci_create_segments) [] =
1234 {
1235
1236   PUSHB_1,
1237     bci_create_segments,
1238   FDEF,
1239
1240   /* only do something if we are not a subglyph */
1241   PUSHB_2,
1242     0,
1243     cvtl_is_subglyph,
1244   RCVT,
1245   EQ,
1246   IF,
1247     /* all our measurements are taken along the y axis */
1248     SVTCA_y,
1249
1250     PUSHB_1,
1251       sal_num_packed_segments,
1252     SWAP,
1253     WS,
1254
1255     DUP,
1256     ADD,
1257     PUSHB_1,
1258       1,
1259     SUB, /* delta = (2*num_segments - 1) */
1260
1261     PUSHB_6,
1262       sal_segment_offset,
1263       sal_segment_offset,
1264
1265       sal_j,
1266       0,
1267       sal_base,
1268       0,
1269     WS, /* sal_base = 0 */
1270     WS, /* sal_j = 0 (point offset) */
1271
1272     ROLL,
1273     ADD, /* s: ... sal_segment_offset (sal_segment_offset + delta) */
1274
1275     /* `bci_create_segment_point' also increases the loop counter by 1; */
1276     /* this effectively means we have a loop step of 2 */
1277     PUSHB_2,
1278       bci_create_segment,
1279       bci_loop,
1280     CALL,
1281
1282     PUSHB_1,
1283       bci_hint_glyph,
1284     CALL,
1285
1286   ELSE,
1287     CLEAR,
1288   EIF,
1289
1290   ENDF,
1291
1292 };
1293
1294
1295 /*
1296  * bci_create_segments_X
1297  *
1298  * Top-level routines for calling `bci_create_segments'.
1299  */
1300
1301 unsigned char FPGM(bci_create_segments_0) [] =
1302 {
1303
1304   PUSHB_1,
1305     bci_create_segments_0,
1306   FDEF,
1307
1308   PUSHB_2,
1309     0,
1310     bci_create_segments,
1311   CALL,
1312
1313   ENDF,
1314
1315 };
1316
1317 unsigned char FPGM(bci_create_segments_1) [] =
1318 {
1319
1320   PUSHB_1,
1321     bci_create_segments_1,
1322   FDEF,
1323
1324   PUSHB_2,
1325     1,
1326     bci_create_segments,
1327   CALL,
1328
1329   ENDF,
1330
1331 };
1332
1333 unsigned char FPGM(bci_create_segments_2) [] =
1334 {
1335
1336   PUSHB_1,
1337     bci_create_segments_2,
1338   FDEF,
1339
1340   PUSHB_2,
1341     2,
1342     bci_create_segments,
1343   CALL,
1344
1345   ENDF,
1346
1347 };
1348
1349 unsigned char FPGM(bci_create_segments_3) [] =
1350 {
1351
1352   PUSHB_1,
1353     bci_create_segments_3,
1354   FDEF,
1355
1356   PUSHB_2,
1357     3,
1358     bci_create_segments,
1359   CALL,
1360
1361   ENDF,
1362
1363 };
1364
1365 unsigned char FPGM(bci_create_segments_4) [] =
1366 {
1367
1368   PUSHB_1,
1369     bci_create_segments_4,
1370   FDEF,
1371
1372   PUSHB_2,
1373     4,
1374     bci_create_segments,
1375   CALL,
1376
1377   ENDF,
1378
1379 };
1380
1381 unsigned char FPGM(bci_create_segments_5) [] =
1382 {
1383
1384   PUSHB_1,
1385     bci_create_segments_5,
1386   FDEF,
1387
1388   PUSHB_2,
1389     5,
1390     bci_create_segments,
1391   CALL,
1392
1393   ENDF,
1394
1395 };
1396
1397 unsigned char FPGM(bci_create_segments_6) [] =
1398 {
1399
1400   PUSHB_1,
1401     bci_create_segments_6,
1402   FDEF,
1403
1404   PUSHB_2,
1405     6,
1406     bci_create_segments,
1407   CALL,
1408
1409   ENDF,
1410
1411 };
1412
1413 unsigned char FPGM(bci_create_segments_7) [] =
1414 {
1415
1416   PUSHB_1,
1417     bci_create_segments_7,
1418   FDEF,
1419
1420   PUSHB_2,
1421     7,
1422     bci_create_segments,
1423   CALL,
1424
1425   ENDF,
1426
1427 };
1428
1429 unsigned char FPGM(bci_create_segments_8) [] =
1430 {
1431
1432   PUSHB_1,
1433     bci_create_segments_8,
1434   FDEF,
1435
1436   PUSHB_2,
1437     8,
1438     bci_create_segments,
1439   CALL,
1440
1441   ENDF,
1442
1443 };
1444
1445 unsigned char FPGM(bci_create_segments_9) [] =
1446 {
1447
1448   PUSHB_1,
1449     bci_create_segments_9,
1450   FDEF,
1451
1452   PUSHB_2,
1453     9,
1454     bci_create_segments,
1455   CALL,
1456
1457   ENDF,
1458
1459 };
1460
1461
1462 /*
1463  * bci_create_segments_composite
1464  *
1465  *   The same as `bci_create_segments'.
1466  *   It also decrements the composite component counter.
1467  *
1468  * sal: sal_num_packed_segments
1469  *      sal_segment_offset
1470  *
1471  * CVT: cvtl_is_subglyph
1472  *
1473  * uses: bci_decrement_component_counter
1474  *       bci_create_segment
1475  *       bci_loop
1476  *       bci_hint_glyph
1477  */
1478
1479 unsigned char FPGM(bci_create_segments_composite) [] =
1480 {
1481
1482   PUSHB_1,
1483     bci_create_segments_composite,
1484   FDEF,
1485
1486   PUSHB_1,
1487     bci_decrement_component_counter,
1488   CALL,
1489
1490   /* only do something if we are not a subglyph */
1491   PUSHB_2,
1492     0,
1493     cvtl_is_subglyph,
1494   RCVT,
1495   EQ,
1496   IF,
1497     /* all our measurements are taken along the y axis */
1498     SVTCA_y,
1499
1500     PUSHB_1,
1501       sal_num_packed_segments,
1502     SWAP,
1503     WS,
1504
1505     DUP,
1506     ADD,
1507     PUSHB_1,
1508       1,
1509     SUB, /* delta = (2*num_segments - 1) */
1510
1511     PUSHB_6,
1512       sal_segment_offset,
1513       sal_segment_offset,
1514
1515       sal_j,
1516       0,
1517       sal_base,
1518       0,
1519     WS, /* sal_base = 0 */
1520     WS, /* sal_j = 0 (point offset) */
1521
1522     ROLL,
1523     ADD, /* s: ... sal_segment_offset (sal_segment_offset + delta) */
1524
1525     /* `bci_create_segment_point' also increases the loop counter by 1; */
1526     /* this effectively means we have a loop step of 2 */
1527     PUSHB_2,
1528       bci_create_segment,
1529       bci_loop,
1530     CALL,
1531
1532     PUSHB_1,
1533       bci_hint_glyph,
1534     CALL,
1535
1536   ELSE,
1537     CLEAR,
1538   EIF,
1539
1540   ENDF,
1541
1542 };
1543
1544
1545 /*
1546  * bci_create_segments_composite_X
1547  *
1548  * Top-level routines for calling `bci_create_segments_composite'.
1549  */
1550
1551 unsigned char FPGM(bci_create_segments_composite_0) [] =
1552 {
1553
1554   PUSHB_1,
1555     bci_create_segments_composite_0,
1556   FDEF,
1557
1558   PUSHB_2,
1559     0,
1560     bci_create_segments_composite,
1561   CALL,
1562
1563   ENDF,
1564
1565 };
1566
1567 unsigned char FPGM(bci_create_segments_composite_1) [] =
1568 {
1569
1570   PUSHB_1,
1571     bci_create_segments_composite_1,
1572   FDEF,
1573
1574   PUSHB_2,
1575     1,
1576     bci_create_segments_composite,
1577   CALL,
1578
1579   ENDF,
1580
1581 };
1582
1583 unsigned char FPGM(bci_create_segments_composite_2) [] =
1584 {
1585
1586   PUSHB_1,
1587     bci_create_segments_composite_2,
1588   FDEF,
1589
1590   PUSHB_2,
1591     2,
1592     bci_create_segments_composite,
1593   CALL,
1594
1595   ENDF,
1596
1597 };
1598
1599 unsigned char FPGM(bci_create_segments_composite_3) [] =
1600 {
1601
1602   PUSHB_1,
1603     bci_create_segments_composite_3,
1604   FDEF,
1605
1606   PUSHB_2,
1607     3,
1608     bci_create_segments_composite,
1609   CALL,
1610
1611   ENDF,
1612
1613 };
1614
1615 unsigned char FPGM(bci_create_segments_composite_4) [] =
1616 {
1617
1618   PUSHB_1,
1619     bci_create_segments_composite_4,
1620   FDEF,
1621
1622   PUSHB_2,
1623     4,
1624     bci_create_segments_composite,
1625   CALL,
1626
1627   ENDF,
1628
1629 };
1630
1631 unsigned char FPGM(bci_create_segments_composite_5) [] =
1632 {
1633
1634   PUSHB_1,
1635     bci_create_segments_composite_5,
1636   FDEF,
1637
1638   PUSHB_2,
1639     5,
1640     bci_create_segments_composite,
1641   CALL,
1642
1643   ENDF,
1644
1645 };
1646
1647 unsigned char FPGM(bci_create_segments_composite_6) [] =
1648 {
1649
1650   PUSHB_1,
1651     bci_create_segments_composite_6,
1652   FDEF,
1653
1654   PUSHB_2,
1655     6,
1656     bci_create_segments_composite,
1657   CALL,
1658
1659   ENDF,
1660
1661 };
1662
1663 unsigned char FPGM(bci_create_segments_composite_7) [] =
1664 {
1665
1666   PUSHB_1,
1667     bci_create_segments_composite_7,
1668   FDEF,
1669
1670   PUSHB_2,
1671     7,
1672     bci_create_segments_composite,
1673   CALL,
1674
1675   ENDF,
1676
1677 };
1678
1679 unsigned char FPGM(bci_create_segments_composite_8) [] =
1680 {
1681
1682   PUSHB_1,
1683     bci_create_segments_composite_8,
1684   FDEF,
1685
1686   PUSHB_2,
1687     8,
1688     bci_create_segments_composite,
1689   CALL,
1690
1691   ENDF,
1692
1693 };
1694
1695 unsigned char FPGM(bci_create_segments_composite_9) [] =
1696 {
1697
1698   PUSHB_1,
1699     bci_create_segments_composite_9,
1700   FDEF,
1701
1702   PUSHB_2,
1703     9,
1704     bci_create_segments_composite,
1705   CALL,
1706
1707   ENDF,
1708
1709 };
1710
1711
1712 /*
1713  * bci_align_segment
1714  *
1715  *   Align all points in a segment to the twilight point in rp0.
1716  *   zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
1717  *
1718  * in: segment_index
1719  *
1720  * sal: sal_segment_offset
1721  */
1722
1723 unsigned char FPGM(bci_align_segment) [] =
1724 {
1725
1726   PUSHB_1,
1727     bci_align_segment,
1728   FDEF,
1729
1730   /* we need the values of `sal_segment_offset + 2*segment_index' */
1731   /* and `sal_segment_offset + 2*segment_index + 1' */
1732   DUP,
1733   ADD,
1734   PUSHB_1,
1735     sal_segment_offset,
1736   ADD,
1737   DUP,
1738   RS,
1739   SWAP,
1740   PUSHB_1,
1741     1,
1742   ADD,
1743   RS, /* s: first last */
1744
1745 /* start_loop: */
1746   PUSHB_1,
1747     2,
1748   CINDEX, /* s: first last first */
1749   PUSHB_1,
1750     2,
1751   CINDEX, /* s: first last first last */
1752   LTEQ, /* first <= end */
1753   IF, /* s: first last */
1754     SWAP,
1755     DUP, /* s: last first first */
1756     ALIGNRP, /* align point with index `first' with rp0 */
1757
1758     PUSHB_1,
1759       1,
1760     ADD, /* first = first + 1 */
1761     SWAP, /* s: first last */
1762
1763     PUSHB_1,
1764       18,
1765     NEG,
1766     JMPR, /* goto start_loop */
1767
1768   ELSE,
1769     POP,
1770     POP,
1771   EIF,
1772
1773   ENDF,
1774
1775 };
1776
1777
1778 /*
1779  * bci_align_segments
1780  *
1781  *   Align segments to the twilight point in rp0.
1782  *   zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
1783  *
1784  * in: first_segment
1785  *     loop_counter (N)
1786  *       segment_1
1787  *       segment_2
1788  *       ...
1789  *       segment_N
1790  *
1791  * uses: bci_align_segment
1792  */
1793
1794 unsigned char FPGM(bci_align_segments) [] =
1795 {
1796
1797   PUSHB_1,
1798     bci_align_segments,
1799   FDEF,
1800
1801   PUSHB_1,
1802     bci_align_segment,
1803   CALL,
1804
1805   PUSHB_1,
1806     bci_align_segment,
1807   LOOPCALL,
1808
1809   ENDF,
1810
1811 };
1812
1813
1814 /*
1815  * bci_scale_contour
1816  *
1817  *   Scale a contour using two points giving the maximum and minimum
1818  *   coordinates.
1819  *
1820  *   It expects that no point on the contour is touched.
1821  *
1822  * in: min_point
1823  *     max_point
1824  *
1825  * CVT: cvtl_scale
1826  *      cvtl_0x10000
1827  */
1828
1829 unsigned char FPGM(bci_scale_contour) [] =
1830 {
1831
1832   PUSHB_1,
1833     bci_scale_contour,
1834   FDEF,
1835
1836   DUP,
1837   DUP,
1838   GC_orig,
1839   DUP,
1840   DO_SCALE, /* min_pos_new = min_pos * scale */
1841   SWAP,
1842   SUB,
1843   SHPIX,
1844
1845   /* don't scale a single-point contour twice */
1846   SWAP,
1847   DUP,
1848   ROLL,
1849   NEQ,
1850   IF,
1851     DUP,
1852     GC_orig,
1853     DUP,
1854     DO_SCALE, /* max_pos_new = max_pos * scale */
1855     SWAP,
1856     SUB,
1857     SHPIX,
1858
1859   ELSE,
1860     POP,
1861   EIF,
1862
1863   ENDF,
1864
1865 };
1866
1867
1868 /*
1869  * bci_scale_glyph
1870  *
1871  *   Scale a glyph using a list of points (two points per contour, giving
1872  *   the maximum and mininum coordinates).
1873  *
1874  *   It expects that no point in the glyph is touched.
1875  *
1876  *   Note that the point numbers are sorted in ascending order;
1877  *   `min_point_X' and `max_point_X' thus refer to the two extrema of a
1878  *   contour without specifying which one is the minimum and maximum.
1879  *
1880  * in: num_contours (N)
1881  *       min_point_1
1882  *       max_point_1
1883  *       min_point_2
1884  *       max_point_2
1885  *       ...
1886  *       min_point_N
1887  *       max_point_N
1888  *
1889  * CVT: cvtl_is_subglyph
1890  *
1891  * uses: bci_scale_contour
1892  */
1893
1894 unsigned char FPGM(bci_scale_glyph) [] =
1895 {
1896
1897   PUSHB_1,
1898     bci_scale_glyph,
1899   FDEF,
1900
1901   /* only do something if we are not a subglyph */
1902   PUSHB_2,
1903     0,
1904     cvtl_is_subglyph,
1905   RCVT,
1906   EQ,
1907   IF,
1908     /* all our measurements are taken along the y axis */
1909     SVTCA_y,
1910
1911     PUSHB_1,
1912       1,
1913     SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
1914
1915     PUSHB_1,
1916       bci_scale_contour,
1917     LOOPCALL,
1918
1919     PUSHB_1,
1920       1,
1921     SZP2, /* set zp2 to normal zone 1 */
1922     IUP_y,
1923
1924   ELSE,
1925     CLEAR,
1926   EIF,
1927
1928   ENDF,
1929
1930 };
1931
1932
1933 /*
1934  * bci_scale_composite_glyph
1935  *
1936  *   The same as `bci_scale_composite_glyph'.
1937  *   It also decrements the composite component counter.
1938  *
1939  * CVT: cvtl_is_subglyph
1940  *
1941  * uses: bci_decrement_component_counter
1942  *       bci_scale_contour
1943  */
1944
1945 unsigned char FPGM(bci_scale_composite_glyph) [] =
1946 {
1947
1948   PUSHB_1,
1949     bci_scale_composite_glyph,
1950   FDEF,
1951
1952   PUSHB_1,
1953     bci_decrement_component_counter,
1954   CALL,
1955
1956   /* only do something if we are not a subglyph */
1957   PUSHB_2,
1958     0,
1959     cvtl_is_subglyph,
1960   RCVT,
1961   EQ,
1962   IF,
1963     /* all our measurements are taken along the y axis */
1964     SVTCA_y,
1965
1966     PUSHB_1,
1967       1,
1968     SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
1969
1970     PUSHB_1,
1971       bci_scale_contour,
1972     LOOPCALL,
1973
1974     PUSHB_1,
1975       1,
1976     SZP2, /* set zp2 to normal zone 1 */
1977     IUP_y,
1978
1979   ELSE,
1980     CLEAR,
1981   EIF,
1982
1983   ENDF,
1984
1985 };
1986
1987
1988 /*
1989  * bci_shift_contour
1990  *
1991  *   Shift a contour by a given amount.
1992  *
1993  *   It expects that rp1 (pointed to by zp0) is set up properly; zp2 must
1994  *   point to the normal zone 1.
1995  *
1996  * in:  contour
1997  * out: contour + 1
1998  */
1999
2000 unsigned char FPGM(bci_shift_contour) [] =
2001 {
2002
2003   PUSHB_1,
2004     bci_shift_contour,
2005   FDEF,
2006
2007   DUP,
2008   SHC_rp1, /* shift `contour' by (rp1_pos - rp1_orig_pos) */
2009
2010   PUSHB_1,
2011     1,
2012   ADD,
2013
2014   ENDF,
2015
2016 };
2017
2018
2019 /*
2020  * bci_shift_subglyph
2021  *
2022  *   Shift a subglyph.  To be more specific, it corrects the already applied
2023  *   subglyph offset (if any) from the `glyf' table which needs to be scaled
2024  *   also.
2025  *
2026  *   If this function is called, a point `x' in the subglyph has been scaled
2027  *   already (during the hinting of the subglyph itself), and `offset' has
2028  *   been applied also:
2029  *
2030  *     x  ->  x * scale + offset         (1)
2031  *
2032  *   However, the offset should be applied first, then the scaling:
2033  *
2034  *     x  ->  (x + offset) * scale       (2)
2035  *
2036  *   Our job is now to transform (1) to (2); a simple calculation shows that
2037  *   we have to shift all points of the subglyph by
2038  *
2039  *     offset * scale - offset = offset * (scale - 1)
2040  *
2041  *   Note that `cvtl_scale' is equal to the above `scale - 1'.
2042  *
2043  * in: offset (in FUnits)
2044  *     num_contours
2045  *     first_contour
2046  *
2047  * CVT: cvtl_funits_to_pixels
2048  *      cvtl_0x10000
2049  *      cvtl_scale
2050  *
2051  * uses: bci_round
2052  *       bci_shift_contour
2053  */
2054
2055 unsigned char FPGM(bci_shift_subglyph) [] =
2056 {
2057
2058   PUSHB_1,
2059     bci_shift_subglyph,
2060   FDEF,
2061
2062   SVTCA_y,
2063
2064   PUSHB_1,
2065     cvtl_funits_to_pixels,
2066   RCVT, /* scaling factor FUnits -> pixels */
2067   MUL,
2068   PUSHB_1,
2069     cvtl_0x10000,
2070   RCVT,
2071   DIV,
2072
2073   /* the autohinter always rounds offsets */
2074   PUSHB_1,
2075     bci_round,
2076   CALL, /* offset = round(offset) */
2077
2078   PUSHB_1,
2079     cvtl_scale,
2080   RCVT,
2081   MUL,
2082   PUSHB_1,
2083     cvtl_0x10000,
2084   RCVT,
2085   DIV, /* delta = offset * (scale - 1) */
2086
2087   /* and round again */
2088   PUSHB_1,
2089     bci_round,
2090   CALL, /* offset = round(offset) */
2091
2092   PUSHB_1,
2093     0,
2094   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2095
2096   /* we create twilight point 0 as a reference point, */
2097   /* setting the original position to zero (using `cvtl_temp') */
2098   PUSHB_5,
2099     0,
2100     0,
2101     cvtl_temp,
2102     cvtl_temp,
2103     0,
2104   WCVTP,
2105   MIAP_noround, /* rp0 and rp1 now point to twilight point 0 */
2106
2107   SWAP, /* s: first_contour num_contours 0 delta */
2108   SHPIX, /* rp1_pos - rp1_orig_pos = delta */
2109
2110   PUSHB_2,
2111     bci_shift_contour,
2112     1,
2113   SZP2, /* set zp2 to normal zone 1 */
2114   LOOPCALL,
2115
2116   ENDF,
2117
2118 };
2119
2120
2121 /*
2122  * bci_ip_outer_align_point
2123  *
2124  *   Auxiliary function for `bci_action_ip_before' and
2125  *   `bci_action_ip_after'.
2126  *
2127  *   It expects rp0 to contain the edge for alignment, zp0 set to twilight
2128  *   zone, and both zp1 and zp2 set to normal zone.
2129  *
2130  * in: point
2131  *
2132  * sal: sal_i (edge_orig_pos)
2133  *
2134  * CVT: cvtl_scale
2135  *      cvtl_0x10000
2136  */
2137
2138 unsigned char FPGM(bci_ip_outer_align_point) [] =
2139 {
2140
2141   PUSHB_1,
2142     bci_ip_outer_align_point,
2143   FDEF,
2144
2145   DUP,
2146   ALIGNRP, /* align `point' with `edge' */
2147   DUP,
2148   GC_orig,
2149   DO_SCALE, /* point_orig_pos = point_orig_pos * scale */
2150
2151   PUSHB_1,
2152     sal_i,
2153   RS,
2154   SUB, /* s: point (point_orig_pos - edge_orig_pos) */
2155   SHPIX,
2156
2157   ENDF,
2158
2159 };
2160
2161
2162 /*
2163  * bci_ip_on_align_points
2164  *
2165  *   Auxiliary function for `bci_action_ip_on'.
2166  *
2167  * in: edge (in twilight zone)
2168  *     loop_counter (N)
2169  *       point_1
2170  *       point_2
2171  *       ...
2172  *       point_N
2173  */
2174
2175 unsigned char FPGM(bci_ip_on_align_points) [] =
2176 {
2177
2178   PUSHB_1,
2179     bci_ip_on_align_points,
2180   FDEF,
2181
2182   MDAP_noround, /* set rp0 and rp1 to `edge' */
2183
2184   SLOOP,
2185   ALIGNRP,
2186
2187   ENDF,
2188
2189 };
2190
2191
2192 /*
2193  * bci_ip_between_align_point
2194  *
2195  *   Auxiliary function for `bci_ip_between_align_points'.
2196  *
2197  *   It expects rp0 to contain the edge for alignment, zp0 set to twilight
2198  *   zone, and both zp1 and zp2 set to normal zone.
2199  *
2200  * in: point
2201  *
2202  * sal: sal_i (edge_orig_pos)
2203  *      sal_j (stretch_factor)
2204  *
2205  * CVT: cvtl_scale
2206  *      cvtl_0x10000
2207  */
2208
2209 unsigned char FPGM(bci_ip_between_align_point) [] =
2210 {
2211
2212   PUSHB_1,
2213     bci_ip_between_align_point,
2214   FDEF,
2215
2216   DUP,
2217   ALIGNRP, /* align `point' with `edge' */
2218   DUP,
2219   GC_orig,
2220   DO_SCALE, /* point_orig_pos = point_orig_pos * scale */
2221
2222   PUSHB_1,
2223     sal_i,
2224   RS,
2225   SUB, /* s: point (point_orig_pos - edge_orig_pos) */
2226   PUSHB_1,
2227     sal_j,
2228   RS,
2229   MUL, /* s: point delta */
2230   SHPIX,
2231
2232   ENDF,
2233
2234 };
2235
2236
2237 /*
2238  * bci_ip_between_align_points
2239  *
2240  *   Auxiliary function for `bci_action_ip_between'.
2241  *
2242  * in: after_edge (in twilight zone)
2243  *     before_edge (in twilight zone)
2244  *     loop_counter (N)
2245  *       point_1
2246  *       point_2
2247  *       ...
2248  *       point_N
2249  *
2250  * sal: sal_i (before_orig_pos)
2251  *      sal_j (stretch_factor)
2252  *
2253  * uses: bci_ip_between_align_point
2254  */
2255
2256 unsigned char FPGM(bci_ip_between_align_points) [] =
2257 {
2258
2259   PUSHB_1,
2260     bci_ip_between_align_points,
2261   FDEF,
2262
2263   PUSHB_2,
2264     2,
2265     0,
2266   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2267   CINDEX,
2268   DUP, /* s: ... before after before before */
2269   MDAP_noround, /* set rp0 and rp1 to `before' */
2270   DUP,
2271   GC_orig, /* s: ... before after before before_orig_pos */
2272   PUSHB_1,
2273     sal_i,
2274   SWAP,
2275   WS, /* sal_i = before_orig_pos */
2276   PUSHB_1,
2277     2,
2278   CINDEX, /* s: ... before after before after */
2279   MD_cur, /* a = after_pos - before_pos */
2280   ROLL,
2281   ROLL,
2282   MD_orig_ZP2_0, /* b = after_orig_pos - before_orig_pos */
2283
2284   DUP,
2285   IF, /* b != 0 ? */
2286     DIV, /* s: a/b */
2287   ELSE,
2288     POP, /* avoid division by zero */
2289   EIF,
2290
2291   PUSHB_1,
2292     sal_j,
2293   SWAP,
2294   WS, /* sal_j = stretch_factor */
2295
2296   PUSHB_3,
2297     bci_ip_between_align_point,
2298     1,
2299     1,
2300   SZP2, /* set zp2 to normal zone 1 */
2301   SZP1, /* set zp1 to normal zone 1 */
2302   LOOPCALL,
2303
2304   ENDF,
2305
2306 };
2307
2308
2309 /*
2310  * bci_action_ip_before
2311  *
2312  *   Handle `ip_before' data to align points located before the first edge.
2313  *
2314  * in: first_edge (in twilight zone)
2315  *     loop_counter (N)
2316  *       point_1
2317  *       point_2
2318  *       ...
2319  *       point_N
2320  *
2321  * sal: sal_i (first_edge_orig_pos)
2322  *
2323  * uses: bci_ip_outer_align_point
2324  */
2325
2326 unsigned char FPGM(bci_action_ip_before) [] =
2327 {
2328
2329   PUSHB_1,
2330     bci_action_ip_before,
2331   FDEF,
2332
2333   PUSHB_1,
2334     0,
2335   SZP2, /* set zp2 to twilight zone 0 */
2336
2337   DUP,
2338   GC_orig,
2339   PUSHB_1,
2340     sal_i,
2341   SWAP,
2342   WS, /* sal_i = first_edge_orig_pos */
2343
2344   PUSHB_3,
2345     0,
2346     1,
2347     1,
2348   SZP2, /* set zp2 to normal zone 1 */
2349   SZP1, /* set zp1 to normal zone 1 */
2350   SZP0, /* set zp0 to twilight zone 0 */
2351
2352   MDAP_noround, /* set rp0 and rp1 to `first_edge' */
2353
2354   PUSHB_1,
2355     bci_ip_outer_align_point,
2356   LOOPCALL,
2357
2358   ENDF,
2359
2360 };
2361
2362
2363 /*
2364  * bci_action_ip_after
2365  *
2366  *   Handle `ip_after' data to align points located after the last edge.
2367  *
2368  * in: last_edge (in twilight zone)
2369  *     loop_counter (N)
2370  *       point_1
2371  *       point_2
2372  *       ...
2373  *       point_N
2374  *
2375  * sal: sal_i (last_edge_orig_pos)
2376  *
2377  * uses: bci_ip_outer_align_point
2378  */
2379
2380 unsigned char FPGM(bci_action_ip_after) [] =
2381 {
2382
2383   PUSHB_1,
2384     bci_action_ip_after,
2385   FDEF,
2386
2387   PUSHB_1,
2388     0,
2389   SZP2, /* set zp2 to twilight zone 0 */
2390
2391   DUP,
2392   GC_orig,
2393   PUSHB_1,
2394     sal_i,
2395   SWAP,
2396   WS, /* sal_i = last_edge_orig_pos */
2397
2398   PUSHB_3,
2399     0,
2400     1,
2401     1,
2402   SZP2, /* set zp2 to normal zone 1 */
2403   SZP1, /* set zp1 to normal zone 1 */
2404   SZP0, /* set zp0 to twilight zone 0 */
2405
2406   MDAP_noround, /* set rp0 and rp1 to `last_edge' */
2407
2408   PUSHB_1,
2409     bci_ip_outer_align_point,
2410   LOOPCALL,
2411
2412   ENDF,
2413
2414 };
2415
2416
2417 /*
2418  * bci_action_ip_on
2419  *
2420  *   Handle `ip_on' data to align points located on an edge coordinate (but
2421  *   not part of an edge).
2422  *
2423  * in: loop_counter (M)
2424  *       edge_1 (in twilight zone)
2425  *       loop_counter (N_1)
2426  *         point_1
2427  *         point_2
2428  *         ...
2429  *         point_N_1
2430  *       edge_2 (in twilight zone)
2431  *       loop_counter (N_2)
2432  *         point_1
2433  *         point_2
2434  *         ...
2435  *         point_N_2
2436  *       ...
2437  *       edge_M (in twilight zone)
2438  *       loop_counter (N_M)
2439  *         point_1
2440  *         point_2
2441  *         ...
2442  *         point_N_M
2443  *
2444  * uses: bci_ip_on_align_points
2445  */
2446
2447 unsigned char FPGM(bci_action_ip_on) [] =
2448 {
2449
2450   PUSHB_1,
2451     bci_action_ip_on,
2452   FDEF,
2453
2454   PUSHB_2,
2455     0,
2456     1,
2457   SZP1, /* set zp1 to normal zone 1 */
2458   SZP0, /* set zp0 to twilight zone 0 */
2459
2460   PUSHB_1,
2461     bci_ip_on_align_points,
2462   LOOPCALL,
2463
2464   ENDF,
2465
2466 };
2467
2468
2469 /*
2470  * bci_action_ip_between
2471  *
2472  *   Handle `ip_between' data to align points located between two edges.
2473  *
2474  * in: loop_counter (M)
2475  *       before_edge_1 (in twilight zone)
2476  *       after_edge_1 (in twilight zone)
2477  *       loop_counter (N_1)
2478  *         point_1
2479  *         point_2
2480  *         ...
2481  *         point_N_1
2482  *       before_edge_2 (in twilight zone)
2483  *       after_edge_2 (in twilight zone)
2484  *       loop_counter (N_2)
2485  *         point_1
2486  *         point_2
2487  *         ...
2488  *         point_N_2
2489  *       ...
2490  *       before_edge_M (in twilight zone)
2491  *       after_edge_M (in twilight zone)
2492  *       loop_counter (N_M)
2493  *         point_1
2494  *         point_2
2495  *         ...
2496  *         point_N_M
2497  *
2498  * uses: bci_ip_between_align_points
2499  */
2500
2501 unsigned char FPGM(bci_action_ip_between) [] =
2502 {
2503
2504   PUSHB_1,
2505     bci_action_ip_between,
2506   FDEF,
2507
2508   PUSHB_1,
2509     bci_ip_between_align_points,
2510   LOOPCALL,
2511
2512   ENDF,
2513
2514 };
2515
2516
2517 /*
2518  * bci_adjust_common
2519  *
2520  *   Common code for bci_action_adjust routines.
2521  *
2522  * uses: func[cvtl_stem_width_function]
2523  */
2524
2525 unsigned char FPGM(bci_adjust_common) [] =
2526 {
2527
2528   PUSHB_1,
2529     bci_adjust_common,
2530   FDEF,
2531
2532   PUSHB_1,
2533     0,
2534   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2535
2536   PUSHB_1,
2537     4,
2538   CINDEX, /* s: [...] edge2 edge is_round is_serif edge2 */
2539   PUSHB_1,
2540     4,
2541   CINDEX, /* s: [...] edge2 edge is_round is_serif edge2 edge */
2542   MD_orig_ZP2_0, /* s: [...] edge2 edge is_round is_serif org_len */
2543
2544   PUSHB_1,
2545     cvtl_stem_width_function,
2546   RCVT,
2547   CALL,
2548   NEG, /* s: [...] edge2 edge -cur_len */
2549
2550   ROLL, /* s: [...] edge -cur_len edge2 */
2551   MDAP_noround, /* set rp0 and rp1 to `edge2' */
2552   SWAP,
2553   DUP,
2554   DUP, /* s: [...] -cur_len edge edge edge */
2555   ALIGNRP, /* align `edge' with `edge2' */
2556   ROLL,
2557   SHPIX, /* shift `edge' by -cur_len */
2558
2559   ENDF,
2560
2561 };
2562
2563
2564 /*
2565  * bci_adjust_bound
2566  *
2567  *   Handle the ADJUST_BOUND action to align an edge of a stem if the other
2568  *   edge of the stem has already been moved, then moving it again if
2569  *   necessary to stay bound.
2570  *
2571  * in: edge2_is_serif
2572  *     edge_is_round
2573  *     edge_point (in twilight zone)
2574  *     edge2_point (in twilight zone)
2575  *     edge[-1] (in twilight zone)
2576  *     ... stuff for bci_align_segments (edge) ...
2577  *
2578  * uses: bci_adjust_common
2579  *       bci_align_segments
2580  */
2581
2582 unsigned char FPGM(bci_adjust_bound) [] =
2583 {
2584
2585   PUSHB_1,
2586     bci_adjust_bound,
2587   FDEF,
2588
2589   PUSHB_1,
2590     bci_adjust_common,
2591   CALL,
2592
2593   SWAP, /* s: edge edge[-1] */
2594   DUP,
2595   MDAP_noround, /* set rp0 and rp1 to `edge[-1]' */
2596   GC_cur,
2597   PUSHB_1,
2598     2,
2599   CINDEX,
2600   GC_cur, /* s: edge edge[-1]_pos edge_pos */
2601   GT, /* edge_pos < edge[-1]_pos */
2602   IF,
2603     DUP,
2604     ALIGNRP, /* align `edge' to `edge[-1]' */
2605   EIF,
2606
2607   MDAP_noround, /* set rp0 and rp1 to `edge' */
2608
2609   PUSHB_2,
2610     bci_align_segments,
2611     1,
2612   SZP1, /* set zp1 to normal zone 1 */
2613   CALL,
2614
2615   ENDF,
2616
2617 };
2618
2619
2620 /*
2621  * bci_action_adjust_bound
2622  * bci_action_adjust_bound_serif
2623  * bci_action_adjust_bound_round
2624  * bci_action_adjust_bound_round_serif
2625  *
2626  * Higher-level routines for calling `bci_adjust_bound'.
2627  */
2628
2629 unsigned char FPGM(bci_action_adjust_bound) [] =
2630 {
2631
2632   PUSHB_1,
2633     bci_action_adjust_bound,
2634   FDEF,
2635
2636   PUSHB_3,
2637     0,
2638     0,
2639     bci_adjust_bound,
2640   CALL,
2641
2642   ENDF,
2643
2644 };
2645
2646 unsigned char FPGM(bci_action_adjust_bound_serif) [] =
2647 {
2648
2649   PUSHB_1,
2650     bci_action_adjust_bound_serif,
2651   FDEF,
2652
2653   PUSHB_3,
2654     0,
2655     1,
2656     bci_adjust_bound,
2657   CALL,
2658
2659   ENDF,
2660
2661 };
2662
2663 unsigned char FPGM(bci_action_adjust_bound_round) [] =
2664 {
2665
2666   PUSHB_1,
2667     bci_action_adjust_bound_round,
2668   FDEF,
2669
2670   PUSHB_3,
2671     1,
2672     0,
2673     bci_adjust_bound,
2674   CALL,
2675
2676   ENDF,
2677
2678 };
2679
2680 unsigned char FPGM(bci_action_adjust_bound_round_serif) [] =
2681 {
2682
2683   PUSHB_1,
2684     bci_action_adjust_bound_round_serif,
2685   FDEF,
2686
2687   PUSHB_3,
2688     1,
2689     1,
2690     bci_adjust_bound,
2691   CALL,
2692
2693   ENDF,
2694
2695 };
2696
2697
2698 /*
2699  * bci_adjust
2700  *
2701  *   Handle the ADJUST action to align an edge of a stem if the other edge
2702  *   of the stem has already been moved.
2703  *
2704  * in: edge2_is_serif
2705  *     edge_is_round
2706  *     edge_point (in twilight zone)
2707  *     edge2_point (in twilight zone)
2708  *     ... stuff for bci_align_segments (edge) ...
2709  *
2710  * uses: bci_adjust_common
2711  *       bci_align_segments
2712  */
2713
2714 unsigned char FPGM(bci_adjust) [] =
2715 {
2716
2717   PUSHB_1,
2718     bci_adjust,
2719   FDEF,
2720
2721   PUSHB_1,
2722     bci_adjust_common,
2723   CALL,
2724
2725   MDAP_noround, /* set rp0 and rp1 to `edge' */
2726
2727   PUSHB_2,
2728     bci_align_segments,
2729     1,
2730   SZP1, /* set zp1 to normal zone 1 */
2731   CALL,
2732
2733   ENDF,
2734
2735 };
2736
2737
2738 /*
2739  * bci_action_adjust
2740  * bci_action_adjust_serif
2741  * bci_action_adjust_round
2742  * bci_action_adjust_round_serif
2743  *
2744  * Higher-level routines for calling `bci_adjust'.
2745  */
2746
2747 unsigned char FPGM(bci_action_adjust) [] =
2748 {
2749
2750   PUSHB_1,
2751     bci_action_adjust,
2752   FDEF,
2753
2754   PUSHB_3,
2755     0,
2756     0,
2757     bci_adjust,
2758   CALL,
2759
2760   ENDF,
2761
2762 };
2763
2764 unsigned char FPGM(bci_action_adjust_serif) [] =
2765 {
2766
2767   PUSHB_1,
2768     bci_action_adjust_serif,
2769   FDEF,
2770
2771   PUSHB_3,
2772     0,
2773     1,
2774     bci_adjust,
2775   CALL,
2776
2777   ENDF,
2778
2779 };
2780
2781 unsigned char FPGM(bci_action_adjust_round) [] =
2782 {
2783
2784   PUSHB_1,
2785     bci_action_adjust_round,
2786   FDEF,
2787
2788   PUSHB_3,
2789     1,
2790     0,
2791     bci_adjust,
2792   CALL,
2793
2794   ENDF,
2795
2796 };
2797
2798 unsigned char FPGM(bci_action_adjust_round_serif) [] =
2799 {
2800
2801   PUSHB_1,
2802     bci_action_adjust_round_serif,
2803   FDEF,
2804
2805   PUSHB_3,
2806     1,
2807     1,
2808     bci_adjust,
2809   CALL,
2810
2811   ENDF,
2812
2813 };
2814
2815
2816 /*
2817  * bci_stem_common
2818  *
2819  *   Common code for bci_action_stem routines.
2820  *
2821  * sal: sal_anchor
2822  *      sal_temp1
2823  *      sal_temp2
2824  *      sal_temp3
2825  *
2826  * uses: func[cvtl_stem_width_function]
2827  *       bci_round
2828  */
2829
2830 #undef sal_u_off
2831 #define sal_u_off sal_temp1
2832 #undef sal_d_off
2833 #define sal_d_off sal_temp2
2834 #undef sal_org_len
2835 #define sal_org_len sal_temp3
2836 #undef sal_edge2
2837 #define sal_edge2 sal_temp3
2838
2839 unsigned char FPGM(bci_stem_common) [] =
2840 {
2841
2842   PUSHB_1,
2843     bci_stem_common,
2844   FDEF,
2845
2846   PUSHB_1,
2847     0,
2848   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2849
2850   PUSHB_1,
2851     4,
2852   CINDEX,
2853   PUSHB_1,
2854     4,
2855   CINDEX,
2856   DUP, /* s: [...] edge2 edge is_round is_serif edge2 edge edge */
2857   MDAP_noround, /* set rp0 and rp1 to `edge_point' (for ALIGNRP below) */
2858
2859   MD_orig_ZP2_0, /* s: [...] edge2 edge is_round is_serif org_len */
2860   DUP,
2861   PUSHB_1,
2862     sal_org_len,
2863   SWAP,
2864   WS,
2865
2866   PUSHB_1,
2867     cvtl_stem_width_function,
2868   RCVT,
2869   CALL, /* s: [...] edge2 edge cur_len */
2870
2871   DUP,
2872   PUSHB_1,
2873     96,
2874   LT, /* cur_len < 96 */
2875   IF,
2876     DUP,
2877     PUSHB_1,
2878       64,
2879     LTEQ, /* cur_len <= 64 */
2880     IF,
2881       PUSHB_4,
2882         sal_u_off,
2883         32,
2884         sal_d_off,
2885         32,
2886
2887     ELSE,
2888       PUSHB_4,
2889         sal_u_off,
2890         38,
2891         sal_d_off,
2892         26,
2893     EIF,
2894     WS,
2895     WS,
2896
2897     SWAP, /* s: [...] edge2 cur_len edge */
2898     DUP,
2899     PUSHB_1,
2900       sal_anchor,
2901     RS,
2902     DUP, /* s: [...] edge2 cur_len edge edge anchor anchor */
2903     ROLL,
2904     SWAP,
2905     MD_orig_ZP2_0,
2906     SWAP,
2907     GC_cur,
2908     ADD, /* s: [...] edge2 cur_len edge org_pos */
2909     PUSHB_1,
2910       sal_org_len,
2911     RS,
2912     PUSHB_1,
2913       2*64,
2914     DIV,
2915     ADD, /* s: [...] edge2 cur_len edge org_center */
2916
2917     DUP,
2918     PUSHB_1,
2919       bci_round,
2920     CALL, /* s: [...] edge2 cur_len edge org_center cur_pos1 */
2921
2922     DUP,
2923     ROLL,
2924     ROLL,
2925     SUB, /* s: ... cur_len edge cur_pos1 (org_center - cur_pos1) */
2926
2927     DUP,
2928     PUSHB_1,
2929       sal_u_off,
2930     RS,
2931     ADD,
2932     ABS, /* s: ... cur_len edge cur_pos1 (org_center - cur_pos1) delta1 */
2933
2934     SWAP,
2935     PUSHB_1,
2936       sal_d_off,
2937     RS,
2938     SUB,
2939     ABS, /* s: [...] edge2 cur_len edge cur_pos1 delta1 delta2 */
2940
2941     LT, /* delta1 < delta2 */
2942     IF,
2943       PUSHB_1,
2944         sal_u_off,
2945       RS,
2946       SUB, /* cur_pos1 = cur_pos1 - u_off */
2947
2948     ELSE,
2949       PUSHB_1,
2950         sal_d_off,
2951       RS,
2952       ADD, /* cur_pos1 = cur_pos1 + d_off */
2953     EIF, /* s: [...] edge2 cur_len edge cur_pos1 */
2954
2955     PUSHB_1,
2956       3,
2957     CINDEX,
2958     PUSHB_1,
2959       2*64,
2960     DIV,
2961     SUB, /* arg = cur_pos1 - cur_len/2 */
2962
2963     SWAP, /* s: [...] edge2 cur_len arg edge */
2964     DUP,
2965     DUP,
2966     PUSHB_1,
2967       4,
2968     MINDEX,
2969     SWAP, /* s: [...] edge2 cur_len edge edge arg edge */
2970     GC_cur,
2971     SUB,
2972     SHPIX, /* edge = cur_pos1 - cur_len/2 */
2973
2974   ELSE,
2975     SWAP, /* s: [...] edge2 cur_len edge */
2976     PUSHB_1,
2977       sal_anchor,
2978     RS,
2979     GC_cur, /* s: [...] edge2 cur_len edge anchor_pos */
2980     PUSHB_1,
2981       2,
2982     CINDEX,
2983     PUSHB_1,
2984       sal_anchor,
2985     RS,
2986     MD_orig_ZP2_0,
2987     ADD, /* s: [...] edge2 cur_len edge org_pos */
2988
2989     DUP,
2990     PUSHB_1,
2991       sal_org_len,
2992     RS,
2993     PUSHB_1,
2994       2*64,
2995     DIV,
2996     ADD, /* s: [...] edge2 cur_len edge org_pos org_center */
2997
2998     SWAP,
2999     DUP,
3000     PUSHB_1,
3001       bci_round,
3002     CALL, /* cur_pos1 = ROUND(org_pos) */
3003     SWAP,
3004     PUSHB_1,
3005       sal_org_len,
3006     RS,
3007     ADD,
3008     PUSHB_1,
3009       bci_round,
3010     CALL,
3011     PUSHB_1,
3012       5,
3013     CINDEX,
3014     SUB, /* s: [...] edge2 cur_len edge org_center cur_pos1 cur_pos2 */
3015
3016     PUSHB_1,
3017       5,
3018     CINDEX,
3019     PUSHB_1,
3020       2*64,
3021     DIV,
3022     PUSHB_1,
3023       4,
3024     MINDEX,
3025     SUB, /* s: ... cur_len edge cur_pos1 cur_pos2 (cur_len/2 - org_center) */
3026
3027     DUP,
3028     PUSHB_1,
3029       4,
3030     CINDEX,
3031     ADD,
3032     ABS, /* delta1 = ABS(cur_pos1 + cur_len / 2 - org_center) */
3033     SWAP,
3034     PUSHB_1,
3035       3,
3036     CINDEX,
3037     ADD,
3038     ABS, /* s: ... edge2 cur_len edge cur_pos1 cur_pos2 delta1 delta2 */
3039     LT, /* delta1 < delta2 */
3040     IF,
3041       POP, /* arg = cur_pos1 */
3042
3043     ELSE,
3044       SWAP,
3045       POP, /* arg = cur_pos2 */
3046     EIF, /* s: [...] edge2 cur_len edge arg */
3047     SWAP,
3048     DUP,
3049     DUP,
3050     PUSHB_1,
3051       4,
3052     MINDEX,
3053     SWAP, /* s: [...] edge2 cur_len edge edge arg edge */
3054     GC_cur,
3055     SUB,
3056     SHPIX, /* edge = arg */
3057   EIF, /* s: [...] edge2 cur_len edge */
3058
3059   ENDF,
3060
3061 };
3062
3063
3064 /*
3065  * bci_stem_bound
3066  *
3067  *   Handle the STEM action to align two edges of a stem, then moving one
3068  *   edge again if necessary to stay bound.
3069  *
3070  *   The code after computing `cur_len' to shift `edge' and `edge2'
3071  *   is equivalent to the snippet below (part of `ta_latin_hint_edges'):
3072  *
3073  *      if cur_len < 96:
3074  *        if cur_len < = 64:
3075  *          u_off = 32
3076  *          d_off = 32
3077  *        else:
3078  *          u_off = 38
3079  *          d_off = 26
3080  *
3081  *        org_pos = anchor + (edge_orig - anchor_orig);
3082  *        org_center = org_pos + org_len / 2;
3083  *
3084  *        cur_pos1 = ROUND(org_center)
3085  *        delta1 = ABS(org_center - (cur_pos1 - u_off))
3086  *        delta2 = ABS(org_center - (cur_pos1 + d_off))
3087  *        if (delta1 < delta2):
3088  *          cur_pos1 = cur_pos1 - u_off
3089  *        else:
3090  *          cur_pos1 = cur_pos1 + d_off
3091  *
3092  *        edge = cur_pos1 - cur_len / 2
3093  *
3094  *      else:
3095  *        org_pos = anchor + (edge_orig - anchor_orig)
3096  *        org_center = org_pos + org_len / 2;
3097  *
3098  *        cur_pos1 = ROUND(org_pos)
3099  *        delta1 = ABS(cur_pos1 + cur_len / 2 - org_center)
3100  *        cur_pos2 = ROUND(org_pos + org_len) - cur_len
3101  *        delta2 = ABS(cur_pos2 + cur_len / 2 - org_center)
3102  *
3103  *        if (delta1 < delta2):
3104  *          edge = cur_pos1
3105  *        else:
3106  *          edge = cur_pos2
3107  *
3108  *      edge2 = edge + cur_len
3109  *
3110  * in: edge2_is_serif
3111  *     edge_is_round
3112  *     edge_point (in twilight zone)
3113  *     edge2_point (in twilight zone)
3114  *     edge[-1] (in twilight zone)
3115  *     ... stuff for bci_align_segments (edge) ...
3116  *     ... stuff for bci_align_segments (edge2)...
3117  *
3118  * sal: sal_anchor
3119  *      sal_temp1
3120  *      sal_temp2
3121  *      sal_temp3
3122  *
3123  * uses: bci_stem_common
3124  *       bci_align_segments
3125  */
3126
3127 unsigned char FPGM(bci_stem_bound) [] =
3128 {
3129
3130   PUSHB_1,
3131     bci_stem_bound,
3132   FDEF,
3133
3134   PUSHB_1,
3135     bci_stem_common,
3136   CALL,
3137
3138   ROLL, /* s: edge[-1] cur_len edge edge2 */
3139   DUP,
3140   DUP,
3141   ALIGNRP, /* align `edge2' with rp0 (still `edge') */
3142   PUSHB_1,
3143     sal_edge2,
3144   SWAP,
3145   WS, /* s: edge[-1] cur_len edge edge2 */
3146   ROLL,
3147   SHPIX, /* edge2 = edge + cur_len */
3148
3149   SWAP, /* s: edge edge[-1] */
3150   DUP,
3151   MDAP_noround, /* set rp0 and rp1 to `edge[-1]' */
3152   GC_cur,
3153   PUSHB_1,
3154     2,
3155   CINDEX,
3156   GC_cur, /* s: edge edge[-1]_pos edge_pos */
3157   GT, /* edge_pos < edge[-1]_pos */
3158   IF,
3159     DUP,
3160     ALIGNRP, /* align `edge' to `edge[-1]' */
3161   EIF,
3162
3163   MDAP_noround, /* set rp0 and rp1 to `edge' */
3164
3165   PUSHB_2,
3166     bci_align_segments,
3167     1,
3168   SZP1, /* set zp1 to normal zone 1 */
3169   CALL,
3170
3171   PUSHB_1,
3172     sal_edge2,
3173   RS,
3174   MDAP_noround, /* set rp0 and rp1 to `edge2' */
3175
3176   PUSHB_1,
3177     bci_align_segments,
3178   CALL,
3179
3180   ENDF,
3181
3182 };
3183
3184
3185 /*
3186  * bci_action_stem_bound
3187  * bci_action_stem_bound_serif
3188  * bci_action_stem_bound_round
3189  * bci_action_stem_bound_round_serif
3190  *
3191  * Higher-level routines for calling `bci_stem_bound'.
3192  */
3193
3194 unsigned char FPGM(bci_action_stem_bound) [] =
3195 {
3196
3197   PUSHB_1,
3198     bci_action_stem_bound,
3199   FDEF,
3200
3201   PUSHB_3,
3202     0,
3203     0,
3204     bci_stem_bound,
3205   CALL,
3206
3207   ENDF,
3208
3209 };
3210
3211 unsigned char FPGM(bci_action_stem_bound_serif) [] =
3212 {
3213
3214   PUSHB_1,
3215     bci_action_stem_bound_serif,
3216   FDEF,
3217
3218   PUSHB_3,
3219     0,
3220     1,
3221     bci_stem_bound,
3222   CALL,
3223
3224   ENDF,
3225
3226 };
3227
3228 unsigned char FPGM(bci_action_stem_bound_round) [] =
3229 {
3230
3231   PUSHB_1,
3232     bci_action_stem_bound_round,
3233   FDEF,
3234
3235   PUSHB_3,
3236     1,
3237     0,
3238     bci_stem_bound,
3239   CALL,
3240
3241   ENDF,
3242
3243 };
3244
3245 unsigned char FPGM(bci_action_stem_bound_round_serif) [] =
3246 {
3247
3248   PUSHB_1,
3249     bci_action_stem_bound_round_serif,
3250   FDEF,
3251
3252   PUSHB_3,
3253     1,
3254     1,
3255     bci_stem_bound,
3256   CALL,
3257
3258   ENDF,
3259
3260 };
3261
3262
3263 /*
3264  * bci_stem
3265  *
3266  *   Handle the STEM action to align two edges of a stem.
3267  *
3268  *   See `bci_stem_bound' for more details.
3269  *
3270  * in: edge2_is_serif
3271  *     edge_is_round
3272  *     edge_point (in twilight zone)
3273  *     edge2_point (in twilight zone)
3274  *     ... stuff for bci_align_segments (edge) ...
3275  *     ... stuff for bci_align_segments (edge2)...
3276  *
3277  * sal: sal_anchor
3278  *      sal_temp1
3279  *      sal_temp2
3280  *      sal_temp3
3281  *
3282  * uses: bci_stem_common
3283  *       bci_align_segments
3284  */
3285
3286 unsigned char FPGM(bci_stem) [] =
3287 {
3288
3289   PUSHB_1,
3290     bci_stem,
3291   FDEF,
3292
3293   PUSHB_1,
3294     bci_stem_common,
3295   CALL,
3296
3297   POP,
3298   SWAP, /* s: cur_len edge2 */
3299   DUP,
3300   DUP,
3301   ALIGNRP, /* align `edge2' with rp0 (still `edge') */
3302   PUSHB_1,
3303     sal_edge2,
3304   SWAP,
3305   WS, /* s: cur_len edge2 */
3306   SWAP,
3307   SHPIX, /* edge2 = edge + cur_len */
3308
3309   PUSHB_2,
3310     bci_align_segments,
3311     1,
3312   SZP1, /* set zp1 to normal zone 1 */
3313   CALL,
3314
3315   PUSHB_1,
3316     sal_edge2,
3317   RS,
3318   MDAP_noround, /* set rp0 and rp1 to `edge2' */
3319
3320   PUSHB_1,
3321     bci_align_segments,
3322   CALL,
3323   ENDF,
3324
3325 };
3326
3327
3328 /*
3329  * bci_action_stem
3330  * bci_action_stem_serif
3331  * bci_action_stem_round
3332  * bci_action_stem_round_serif
3333  *
3334  * Higher-level routines for calling `bci_stem'.
3335  */
3336
3337 unsigned char FPGM(bci_action_stem) [] =
3338 {
3339
3340   PUSHB_1,
3341     bci_action_stem,
3342   FDEF,
3343
3344   PUSHB_3,
3345     0,
3346     0,
3347     bci_stem,
3348   CALL,
3349
3350   ENDF,
3351
3352 };
3353
3354 unsigned char FPGM(bci_action_stem_serif) [] =
3355 {
3356
3357   PUSHB_1,
3358     bci_action_stem_serif,
3359   FDEF,
3360
3361   PUSHB_3,
3362     0,
3363     1,
3364     bci_stem,
3365   CALL,
3366
3367   ENDF,
3368
3369 };
3370
3371 unsigned char FPGM(bci_action_stem_round) [] =
3372 {
3373
3374   PUSHB_1,
3375     bci_action_stem_round,
3376   FDEF,
3377
3378   PUSHB_3,
3379     1,
3380     0,
3381     bci_stem,
3382   CALL,
3383
3384   ENDF,
3385
3386 };
3387
3388 unsigned char FPGM(bci_action_stem_round_serif) [] =
3389 {
3390
3391   PUSHB_1,
3392     bci_action_stem_round_serif,
3393   FDEF,
3394
3395   PUSHB_3,
3396     1,
3397     1,
3398     bci_stem,
3399   CALL,
3400
3401   ENDF,
3402
3403 };
3404
3405
3406 /*
3407  * bci_link
3408  *
3409  *   Handle the LINK action to link an edge to another one.
3410  *
3411  * in: stem_is_serif
3412  *     base_is_round
3413  *     base_point (in twilight zone)
3414  *     stem_point (in twilight zone)
3415  *     ... stuff for bci_align_segments (base) ...
3416  *
3417  * uses: func[cvtl_stem_width_function]
3418  *       bci_align_segments
3419  */
3420
3421 unsigned char FPGM(bci_link) [] =
3422 {
3423
3424   PUSHB_1,
3425     bci_link,
3426   FDEF,
3427
3428   PUSHB_1,
3429     0,
3430   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3431
3432   PUSHB_1,
3433     4,
3434   CINDEX,
3435   PUSHB_1,
3436     4,
3437   MINDEX,
3438   DUP, /* s: stem is_round is_serif stem base base */
3439   MDAP_noround, /* set rp0 and rp1 to `base_point' (for ALIGNRP below) */
3440
3441   MD_orig_ZP2_0, /* s: stem is_round is_serif dist_orig */
3442
3443   PUSHB_1,
3444     cvtl_stem_width_function,
3445   RCVT,
3446   CALL, /* s: stem new_dist */
3447
3448   SWAP,
3449   DUP,
3450   ALIGNRP, /* align `stem_point' with `base_point' */
3451   DUP,
3452   MDAP_noround, /* set rp0 and rp1 to `stem_point' */
3453   SWAP,
3454   SHPIX, /* stem_point = base_point + new_dist */
3455
3456   PUSHB_2,
3457     bci_align_segments,
3458     1,
3459   SZP1, /* set zp1 to normal zone 1 */
3460   CALL,
3461
3462   ENDF,
3463
3464 };
3465
3466
3467 /*
3468  * bci_action_link
3469  * bci_action_link_serif
3470  * bci_action_link_round
3471  * bci_action_link_round_serif
3472  *
3473  * Higher-level routines for calling `bci_link'.
3474  */
3475
3476 unsigned char FPGM(bci_action_link) [] =
3477 {
3478
3479   PUSHB_1,
3480     bci_action_link,
3481   FDEF,
3482
3483   PUSHB_3,
3484     0,
3485     0,
3486     bci_link,
3487   CALL,
3488
3489   ENDF,
3490
3491 };
3492
3493 unsigned char FPGM(bci_action_link_serif) [] =
3494 {
3495
3496   PUSHB_1,
3497     bci_action_link_serif,
3498   FDEF,
3499
3500   PUSHB_3,
3501     0,
3502     1,
3503     bci_link,
3504   CALL,
3505
3506   ENDF,
3507
3508 };
3509
3510 unsigned char FPGM(bci_action_link_round) [] =
3511 {
3512
3513   PUSHB_1,
3514     bci_action_link_round,
3515   FDEF,
3516
3517   PUSHB_3,
3518     1,
3519     0,
3520     bci_link,
3521   CALL,
3522
3523   ENDF,
3524
3525 };
3526
3527 unsigned char FPGM(bci_action_link_round_serif) [] =
3528 {
3529
3530   PUSHB_1,
3531     bci_action_link_round_serif,
3532   FDEF,
3533
3534   PUSHB_3,
3535     1,
3536     1,
3537     bci_link,
3538   CALL,
3539
3540   ENDF,
3541
3542 };
3543
3544
3545 /*
3546  * bci_anchor
3547  *
3548  *   Handle the ANCHOR action to align two edges
3549  *   and to set the edge anchor.
3550  *
3551  *   The code after computing `cur_len' to shift `edge' and `edge2'
3552  *   is equivalent to the snippet below (part of `ta_latin_hint_edges'):
3553  *
3554  *      if cur_len < 96:
3555  *        if cur_len < = 64:
3556  *          u_off = 32
3557  *          d_off = 32
3558  *        else:
3559  *          u_off = 38
3560  *          d_off = 26
3561  *
3562  *        org_center = edge_orig + org_len / 2
3563  *        cur_pos1 = ROUND(org_center)
3564  *
3565  *        error1 = ABS(org_center - (cur_pos1 - u_off))
3566  *        error2 = ABS(org_center - (cur_pos1 + d_off))
3567  *        if (error1 < error2):
3568  *          cur_pos1 = cur_pos1 - u_off
3569  *        else:
3570  *          cur_pos1 = cur_pos1 + d_off
3571  *
3572  *        edge = cur_pos1 - cur_len / 2
3573  *        edge2 = edge + cur_len
3574  *
3575  *      else:
3576  *        edge = ROUND(edge_orig)
3577  *
3578  * in: edge2_is_serif
3579  *     edge_is_round
3580  *     edge_point (in twilight zone)
3581  *     edge2_point (in twilight zone)
3582  *     ... stuff for bci_align_segments (edge) ...
3583  *
3584  * sal: sal_anchor
3585  *      sal_temp1
3586  *      sal_temp2
3587  *      sal_temp3
3588  *
3589  * uses: func[cvtl_stem_width_function]
3590  *       bci_round
3591  *       bci_align_segments
3592  */
3593
3594 #undef sal_u_off
3595 #define sal_u_off sal_temp1
3596 #undef sal_d_off
3597 #define sal_d_off sal_temp2
3598 #undef sal_org_len
3599 #define sal_org_len sal_temp3
3600
3601 unsigned char FPGM(bci_anchor) [] =
3602 {
3603
3604   PUSHB_1,
3605     bci_anchor,
3606   FDEF,
3607
3608   /* store anchor point number in `sal_anchor' */
3609   PUSHB_2,
3610     sal_anchor,
3611     4,
3612   CINDEX,
3613   WS, /* sal_anchor = edge_point */
3614
3615   PUSHB_1,
3616     0,
3617   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3618
3619   PUSHB_1,
3620     4,
3621   CINDEX,
3622   PUSHB_1,
3623     4,
3624   CINDEX,
3625   DUP, /* s: edge2 edge is_round is_serif edge2 edge edge */
3626   MDAP_noround, /* set rp0 and rp1 to `edge_point' (for ALIGNRP below) */
3627
3628   MD_orig_ZP2_0, /* s: edge2 edge is_round is_serif org_len */
3629   DUP,
3630   PUSHB_1,
3631     sal_org_len,
3632   SWAP,
3633   WS,
3634
3635   PUSHB_1,
3636     cvtl_stem_width_function,
3637   RCVT,
3638   CALL, /* s: edge2 edge cur_len */
3639
3640   DUP,
3641   PUSHB_1,
3642     96,
3643   LT, /* cur_len < 96 */
3644   IF,
3645     DUP,
3646     PUSHB_1,
3647       64,
3648     LTEQ, /* cur_len <= 64 */
3649     IF,
3650       PUSHB_4,
3651         sal_u_off,
3652         32,
3653         sal_d_off,
3654         32,
3655
3656     ELSE,
3657       PUSHB_4,
3658         sal_u_off,
3659         38,
3660         sal_d_off,
3661         26,
3662     EIF,
3663     WS,
3664     WS,
3665
3666     SWAP, /* s: edge2 cur_len edge */
3667     DUP, /* s: edge2 cur_len edge edge */
3668
3669     GC_orig,
3670     PUSHB_1,
3671       sal_org_len,
3672     RS,
3673     PUSHB_1,
3674       2*64,
3675     DIV,
3676     ADD, /* s: edge2 cur_len edge org_center */
3677
3678     DUP,
3679     PUSHB_1,
3680       bci_round,
3681     CALL, /* s: edge2 cur_len edge org_center cur_pos1 */
3682
3683     DUP,
3684     ROLL,
3685     ROLL,
3686     SUB, /* s: edge2 cur_len edge cur_pos1 (org_center - cur_pos1) */
3687
3688     DUP,
3689     PUSHB_1,
3690       sal_u_off,
3691     RS,
3692     ADD,
3693     ABS, /* s: edge2 cur_len edge cur_pos1 (org_center - cur_pos1) error1 */
3694
3695     SWAP,
3696     PUSHB_1,
3697       sal_d_off,
3698     RS,
3699     SUB,
3700     ABS, /* s: edge2 cur_len edge cur_pos1 error1 error2 */
3701
3702     LT, /* error1 < error2 */
3703     IF,
3704       PUSHB_1,
3705         sal_u_off,
3706       RS,
3707       SUB, /* cur_pos1 = cur_pos1 - u_off */
3708
3709     ELSE,
3710       PUSHB_1,
3711         sal_d_off,
3712       RS,
3713       ADD, /* cur_pos1 = cur_pos1 + d_off */
3714     EIF, /* s: edge2 cur_len edge cur_pos1 */
3715
3716     PUSHB_1,
3717       3,
3718     CINDEX,
3719     PUSHB_1,
3720       2*64,
3721     DIV,
3722     SUB, /* s: edge2 cur_len edge (cur_pos1 - cur_len/2) */
3723
3724     PUSHB_1,
3725       2,
3726     CINDEX, /* s: edge2 cur_len edge (cur_pos1 - cur_len/2) edge */
3727     GC_cur,
3728     SUB,
3729     SHPIX, /* edge = cur_pos1 - cur_len/2 */
3730
3731     SWAP, /* s: cur_len edge2 */
3732     DUP,
3733     ALIGNRP, /* align `edge2' with rp0 (still `edge') */
3734     SWAP,
3735     SHPIX, /* edge2 = edge1 + cur_len */
3736
3737   ELSE,
3738     POP, /* s: edge2 edge */
3739     DUP,
3740     DUP,
3741     GC_cur,
3742     SWAP,
3743     GC_orig,
3744     PUSHB_1,
3745       bci_round,
3746     CALL, /* s: edge2 edge edge_pos round(edge_orig_pos) */
3747     SWAP,
3748     SUB,
3749     SHPIX, /* edge = round(edge_orig) */
3750
3751     /* clean up stack */
3752     POP,
3753   EIF,
3754
3755   PUSHB_2,
3756     bci_align_segments,
3757     1,
3758   SZP1, /* set zp1 to normal zone 1 */
3759   CALL,
3760
3761   ENDF,
3762
3763 };
3764
3765
3766 /*
3767  * bci_action_anchor
3768  * bci_action_anchor_serif
3769  * bci_action_anchor_round
3770  * bci_action_anchor_round_serif
3771  *
3772  * Higher-level routines for calling `bci_anchor'.
3773  */
3774
3775 unsigned char FPGM(bci_action_anchor) [] =
3776 {
3777
3778   PUSHB_1,
3779     bci_action_anchor,
3780   FDEF,
3781
3782   PUSHB_3,
3783     0,
3784     0,
3785     bci_anchor,
3786   CALL,
3787
3788   ENDF,
3789
3790 };
3791
3792 unsigned char FPGM(bci_action_anchor_serif) [] =
3793 {
3794
3795   PUSHB_1,
3796     bci_action_anchor_serif,
3797   FDEF,
3798
3799   PUSHB_3,
3800     0,
3801     1,
3802     bci_anchor,
3803   CALL,
3804
3805   ENDF,
3806
3807 };
3808
3809 unsigned char FPGM(bci_action_anchor_round) [] =
3810 {
3811
3812   PUSHB_1,
3813     bci_action_anchor_round,
3814   FDEF,
3815
3816   PUSHB_3,
3817     1,
3818     0,
3819     bci_anchor,
3820   CALL,
3821
3822   ENDF,
3823
3824 };
3825
3826 unsigned char FPGM(bci_action_anchor_round_serif) [] =
3827 {
3828
3829   PUSHB_1,
3830     bci_action_anchor_round_serif,
3831   FDEF,
3832
3833   PUSHB_3,
3834     1,
3835     1,
3836     bci_anchor,
3837   CALL,
3838
3839   ENDF,
3840
3841 };
3842
3843
3844 /*
3845  * bci_action_blue_anchor
3846  *
3847  *   Handle the BLUE_ANCHOR action to align an edge with a blue zone
3848  *   and to set the edge anchor.
3849  *
3850  * in: anchor_point (in twilight zone)
3851  *     blue_cvt_idx
3852  *     edge_point (in twilight zone)
3853  *     ... stuff for bci_align_segments (edge) ...
3854  *
3855  * sal: sal_anchor
3856  *
3857  * uses: bci_action_blue
3858  */
3859
3860 unsigned char FPGM(bci_action_blue_anchor) [] =
3861 {
3862
3863   PUSHB_1,
3864     bci_action_blue_anchor,
3865   FDEF,
3866
3867   /* store anchor point number in `sal_anchor' */
3868   PUSHB_1,
3869     sal_anchor,
3870   SWAP,
3871   WS,
3872
3873   PUSHB_1,
3874     bci_action_blue,
3875   CALL,
3876
3877   ENDF,
3878
3879 };
3880
3881
3882 /*
3883  * bci_action_blue
3884  *
3885  *   Handle the BLUE action to align an edge with a blue zone.
3886  *
3887  * in: blue_cvt_idx
3888  *     edge_point (in twilight zone)
3889  *     ... stuff for bci_align_segments (edge) ...
3890  *
3891  * uses: bci_align_segments
3892  */
3893
3894 unsigned char FPGM(bci_action_blue) [] =
3895 {
3896
3897   PUSHB_1,
3898     bci_action_blue,
3899   FDEF,
3900
3901   PUSHB_1,
3902     0,
3903   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3904
3905   /* move `edge_point' to `blue_cvt_idx' position; */
3906   /* note that we can't use MIAP since this would modify */
3907   /* the twilight point's original coordinates also */
3908   RCVT,
3909   SWAP,
3910   DUP,
3911   MDAP_noround, /* set rp0 and rp1 to `edge' */
3912   DUP,
3913   GC_cur, /* s: new_pos edge edge_pos */
3914   ROLL,
3915   SWAP,
3916   SUB, /* s: edge (new_pos - edge_pos) */
3917   SHPIX,
3918
3919   PUSHB_2,
3920     bci_align_segments,
3921     1,
3922   SZP1, /* set zp1 to normal zone 1 */
3923   CALL,
3924
3925   ENDF,
3926
3927 };
3928
3929
3930 /*
3931  * bci_serif_common
3932  *
3933  *   Common code for bci_action_serif routines.
3934  */
3935
3936 unsigned char FPGM(bci_serif_common) [] =
3937 {
3938
3939   PUSHB_1,
3940     bci_serif_common,
3941   FDEF,
3942
3943   PUSHB_1,
3944     0,
3945   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3946
3947   DUP,
3948   DUP,
3949   DUP,
3950   PUSHB_1,
3951     5,
3952   MINDEX, /* s: [...] serif serif serif serif base */
3953   DUP,
3954   MDAP_noround, /* set rp0 and rp1 to `base_point' */
3955   MD_orig_ZP2_0,
3956   SWAP,
3957   ALIGNRP, /* align `serif_point' with `base_point' */
3958   SHPIX, /* serif = base + (serif_orig_pos - base_orig_pos) */
3959
3960   ENDF,
3961
3962 };
3963
3964
3965 /*
3966  * bci_lower_bound
3967  *
3968  *   Move an edge if necessary to stay within a lower bound.
3969  *
3970  * in: edge
3971  *     bound
3972  *
3973  * uses: bci_align_segments
3974  */
3975
3976 unsigned char FPGM(bci_lower_bound) [] =
3977 {
3978
3979   PUSHB_1,
3980     bci_lower_bound,
3981   FDEF,
3982
3983   SWAP, /* s: edge bound */
3984   DUP,
3985   MDAP_noround, /* set rp0 and rp1 to `bound' */
3986   GC_cur,
3987   PUSHB_1,
3988     2,
3989   CINDEX,
3990   GC_cur, /* s: edge bound_pos edge_pos */
3991   GT, /* edge_pos < bound_pos */
3992   IF,
3993     DUP,
3994     ALIGNRP, /* align `edge' to `bound' */
3995   EIF,
3996
3997   MDAP_noround, /* set rp0 and rp1 to `edge_point' */
3998
3999   PUSHB_2,
4000     bci_align_segments,
4001     1,
4002   SZP1, /* set zp1 to normal zone 1 */
4003   CALL,
4004
4005   ENDF,
4006
4007 };
4008
4009
4010 /*
4011  * bci_upper_bound
4012  *
4013  *   Move an edge if necessary to stay within an upper bound.
4014  *
4015  * in: edge
4016  *     bound
4017  *
4018  * uses: bci_align_segments
4019  */
4020
4021 unsigned char FPGM(bci_upper_bound) [] =
4022 {
4023
4024   PUSHB_1,
4025     bci_upper_bound,
4026   FDEF,
4027
4028   SWAP, /* s: edge bound */
4029   DUP,
4030   MDAP_noround, /* set rp0 and rp1 to `bound' */
4031   GC_cur,
4032   PUSHB_1,
4033     2,
4034   CINDEX,
4035   GC_cur, /* s: edge bound_pos edge_pos */
4036   LT, /* edge_pos > bound_pos */
4037   IF,
4038     DUP,
4039     ALIGNRP, /* align `edge' to `bound' */
4040   EIF,
4041
4042   MDAP_noround, /* set rp0 and rp1 to `edge_point' */
4043
4044   PUSHB_2,
4045     bci_align_segments,
4046     1,
4047   SZP1, /* set zp1 to normal zone 1 */
4048   CALL,
4049
4050   ENDF,
4051
4052 };
4053
4054
4055 /*
4056  * bci_upper_lower_bound
4057  *
4058  *   Move an edge if necessary to stay within a lower and lower bound.
4059  *
4060  * in: edge
4061  *     lower
4062  *     upper
4063  *
4064  * uses: bci_align_segments
4065  */
4066
4067 unsigned char FPGM(bci_upper_lower_bound) [] =
4068 {
4069
4070   PUSHB_1,
4071     bci_upper_lower_bound,
4072   FDEF,
4073
4074   SWAP, /* s: upper serif lower */
4075   DUP,
4076   MDAP_noround, /* set rp0 and rp1 to `lower' */
4077   GC_cur,
4078   PUSHB_1,
4079     2,
4080   CINDEX,
4081   GC_cur, /* s: upper serif lower_pos serif_pos */
4082   GT, /* serif_pos < lower_pos */
4083   IF,
4084     DUP,
4085     ALIGNRP, /* align `serif' to `lower' */
4086   EIF,
4087
4088   SWAP, /* s: serif upper */
4089   DUP,
4090   MDAP_noround, /* set rp0 and rp1 to `upper' */
4091   GC_cur,
4092   PUSHB_1,
4093     2,
4094   CINDEX,
4095   GC_cur, /* s: serif upper_pos serif_pos */
4096   LT, /* serif_pos > upper_pos */
4097   IF,
4098     DUP,
4099     ALIGNRP, /* align `serif' to `upper' */
4100   EIF,
4101
4102   MDAP_noround, /* set rp0 and rp1 to `serif_point' */
4103
4104   PUSHB_2,
4105     bci_align_segments,
4106     1,
4107   SZP1, /* set zp1 to normal zone 1 */
4108   CALL,
4109
4110   ENDF,
4111
4112 };
4113
4114
4115 /*
4116  * bci_action_serif
4117  *
4118  *   Handle the SERIF action to align a serif with its base.
4119  *
4120  * in: serif_point (in twilight zone)
4121  *     base_point (in twilight zone)
4122  *     ... stuff for bci_align_segments (serif) ...
4123  *
4124  * uses: bci_serif_common
4125  *       bci_align_segments
4126  */
4127
4128 unsigned char FPGM(bci_action_serif) [] =
4129 {
4130
4131   PUSHB_1,
4132     bci_action_serif,
4133   FDEF,
4134
4135   PUSHB_1,
4136     bci_serif_common,
4137   CALL,
4138
4139   MDAP_noround, /* set rp0 and rp1 to `serif_point' */
4140
4141   PUSHB_2,
4142     bci_align_segments,
4143     1,
4144   SZP1, /* set zp1 to normal zone 1 */
4145   CALL,
4146
4147   ENDF,
4148
4149 };
4150
4151
4152 /*
4153  * bci_action_serif_lower_bound
4154  *
4155  *   Handle the SERIF action to align a serif with its base, then moving it
4156  *   again if necessary to stay within a lower bound.
4157  *
4158  * in: serif_point (in twilight zone)
4159  *     base_point (in twilight zone)
4160  *     edge[-1] (in twilight zone)
4161  *     ... stuff for bci_align_segments (serif) ...
4162  *
4163  * uses: bci_serif_common
4164  *       bci_lower_bound
4165  */
4166
4167 unsigned char FPGM(bci_action_serif_lower_bound) [] =
4168 {
4169
4170   PUSHB_1,
4171     bci_action_serif_lower_bound,
4172   FDEF,
4173
4174   PUSHB_1,
4175     bci_serif_common,
4176   CALL,
4177
4178   PUSHB_1,
4179     bci_lower_bound,
4180   CALL,
4181
4182   ENDF,
4183
4184 };
4185
4186
4187 /*
4188  * bci_action_serif_upper_bound
4189  *
4190  *   Handle the SERIF action to align a serif with its base, then moving it
4191  *   again if necessary to stay within an upper bound.
4192  *
4193  * in: serif_point (in twilight zone)
4194  *     base_point (in twilight zone)
4195  *     edge[1] (in twilight zone)
4196  *     ... stuff for bci_align_segments (serif) ...
4197  *
4198  * uses: bci_serif_common
4199  *       bci_upper_bound
4200  */
4201
4202 unsigned char FPGM(bci_action_serif_upper_bound) [] =
4203 {
4204
4205   PUSHB_1,
4206     bci_action_serif_upper_bound,
4207   FDEF,
4208
4209   PUSHB_1,
4210     bci_serif_common,
4211   CALL,
4212
4213   PUSHB_1,
4214     bci_upper_bound,
4215   CALL,
4216
4217   ENDF,
4218
4219 };
4220
4221
4222 /*
4223  * bci_action_serif_upper_lower_bound
4224  *
4225  *   Handle the SERIF action to align a serif with its base, then moving it
4226  *   again if necessary to stay within a lower and upper bound.
4227  *
4228  * in: serif_point (in twilight zone)
4229  *     base_point (in twilight zone)
4230  *     edge[-1] (in twilight zone)
4231  *     edge[1] (in twilight zone)
4232  *     ... stuff for bci_align_segments (serif) ...
4233  *
4234  * uses: bci_serif_common
4235  *       bci_upper_lower_bound
4236  */
4237
4238 unsigned char FPGM(bci_action_serif_upper_lower_bound) [] =
4239 {
4240
4241   PUSHB_1,
4242     bci_action_serif_upper_lower_bound,
4243   FDEF,
4244
4245   PUSHB_1,
4246     0,
4247   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
4248
4249   PUSHB_1,
4250     bci_serif_common,
4251   CALL,
4252
4253   PUSHB_1,
4254     bci_upper_lower_bound,
4255   CALL,
4256
4257   ENDF,
4258
4259 };
4260
4261
4262 /*
4263  * bci_serif_anchor_common
4264  *
4265  *   Common code for bci_action_serif_anchor routines.
4266  *
4267  * sal: sal_anchor
4268  *
4269  * uses: bci_round
4270  */
4271
4272 unsigned char FPGM(bci_serif_anchor_common) [] =
4273 {
4274
4275   PUSHB_1,
4276     bci_serif_anchor_common,
4277   FDEF,
4278
4279   PUSHB_1,
4280     0,
4281   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
4282
4283   DUP,
4284   PUSHB_1,
4285     sal_anchor,
4286   SWAP,
4287   WS, /* sal_anchor = edge_point */
4288
4289   DUP,
4290   DUP,
4291   DUP,
4292   GC_cur,
4293   SWAP,
4294   GC_orig,
4295   PUSHB_1,
4296     bci_round,
4297   CALL, /* s: [...] edge edge edge_pos round(edge_orig_pos) */
4298   SWAP,
4299   SUB,
4300   SHPIX, /* edge = round(edge_orig) */
4301
4302   ENDF,
4303
4304 };
4305
4306
4307 /*
4308  * bci_action_serif_anchor
4309  *
4310  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
4311  *   anchor.
4312  *
4313  * in: edge_point (in twilight zone)
4314  *     ... stuff for bci_align_segments (edge) ...
4315  *
4316  * uses: bci_serif_anchor_common
4317  *       bci_align_segments
4318  */
4319
4320 unsigned char FPGM(bci_action_serif_anchor) [] =
4321 {
4322
4323   PUSHB_1,
4324     bci_action_serif_anchor,
4325   FDEF,
4326
4327   PUSHB_1,
4328     bci_serif_anchor_common,
4329   CALL,
4330
4331   MDAP_noround, /* set rp0 and rp1 to `edge' */
4332
4333   PUSHB_2,
4334     bci_align_segments,
4335     1,
4336   SZP1, /* set zp1 to normal zone 1 */
4337   CALL,
4338
4339   ENDF,
4340
4341 };
4342
4343
4344 /*
4345  * bci_action_serif_anchor_lower_bound
4346  *
4347  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
4348  *   anchor, then moving it again if necessary to stay within a lower
4349  *   bound.
4350  *
4351  * in: edge_point (in twilight zone)
4352  *     edge[-1] (in twilight zone)
4353  *     ... stuff for bci_align_segments (edge) ...
4354  *
4355  * uses: bci_serif_anchor_common
4356  *       bci_lower_bound
4357  */
4358
4359 unsigned char FPGM(bci_action_serif_anchor_lower_bound) [] =
4360 {
4361
4362   PUSHB_1,
4363     bci_action_serif_anchor_lower_bound,
4364   FDEF,
4365
4366   PUSHB_1,
4367     bci_serif_anchor_common,
4368   CALL,
4369
4370   PUSHB_1,
4371     bci_lower_bound,
4372   CALL,
4373
4374   ENDF,
4375
4376 };
4377
4378
4379 /*
4380  * bci_action_serif_anchor_upper_bound
4381  *
4382  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
4383  *   anchor, then moving it again if necessary to stay within an upper
4384  *   bound.
4385  *
4386  * in: edge_point (in twilight zone)
4387  *     edge[1] (in twilight zone)
4388  *     ... stuff for bci_align_segments (edge) ...
4389  *
4390  * uses: bci_serif_anchor_common
4391  *       bci_upper_bound
4392  */
4393
4394 unsigned char FPGM(bci_action_serif_anchor_upper_bound) [] =
4395 {
4396
4397   PUSHB_1,
4398     bci_action_serif_anchor_upper_bound,
4399   FDEF,
4400
4401   PUSHB_1,
4402     bci_serif_anchor_common,
4403   CALL,
4404
4405   PUSHB_1,
4406     bci_upper_bound,
4407   CALL,
4408
4409   ENDF,
4410
4411 };
4412
4413
4414 /*
4415  * bci_action_serif_anchor_upper_lower_bound
4416  *
4417  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
4418  *   anchor, then moving it again if necessary to stay within a lower and
4419  *   upper bound.
4420  *
4421  * in: edge_point (in twilight zone)
4422  *     edge[-1] (in twilight zone)
4423  *     edge[1] (in twilight zone)
4424  *     ... stuff for bci_align_segments (edge) ...
4425  *
4426  * uses: bci_serif_anchor_common
4427  *       bci_upper_lower_bound
4428  */
4429
4430 unsigned char FPGM(bci_action_serif_anchor_upper_lower_bound) [] =
4431 {
4432
4433   PUSHB_1,
4434     bci_action_serif_anchor_upper_lower_bound,
4435   FDEF,
4436
4437   PUSHB_1,
4438     bci_serif_anchor_common,
4439   CALL,
4440
4441   PUSHB_1,
4442     bci_upper_lower_bound,
4443   CALL,
4444
4445   ENDF,
4446
4447 };
4448
4449
4450 /*
4451  * bci_serif_link1_common
4452  *
4453  *   Common code for bci_action_serif_link1 routines.
4454  *
4455  * CVT: cvtl_0x10000
4456  */
4457
4458 unsigned char FPGM(bci_serif_link1_common) [] =
4459 {
4460
4461   PUSHB_1,
4462     bci_serif_link1_common,
4463   FDEF,
4464
4465   PUSHB_1,
4466     0,
4467   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
4468
4469   PUSHB_1,
4470     3,
4471   CINDEX, /* s: [...] after edge before after */
4472   PUSHB_1,
4473     2,
4474   CINDEX, /* s: [...] after edge before after before */
4475   MD_orig_ZP2_0,
4476   PUSHB_1,
4477     0,
4478   EQ, /* after_orig_pos == before_orig_pos */
4479   IF, /* s: [...] after edge before */
4480     MDAP_noround, /* set rp0 and rp1 to `before' */
4481     DUP,
4482     ALIGNRP, /* align `edge' with `before' */
4483     SWAP,
4484     POP,
4485
4486   ELSE,
4487     /* we have to execute `a*b/c', with b/c very near to 1: */
4488     /* to avoid overflow while retaining precision, */
4489     /* we transform this to `a + a * (b-c)/c' */
4490
4491     PUSHB_1,
4492       2,
4493     CINDEX, /* s: [...] after edge before edge */
4494     PUSHB_1,
4495       2,
4496     CINDEX, /* s: [...] after edge before edge before */
4497     MD_orig_ZP2_0, /* a = edge_orig_pos - before_orig_pos */
4498
4499     DUP,
4500     PUSHB_1,
4501       5,
4502     CINDEX, /* s: [...] after edge before a a after */
4503     PUSHB_1,
4504       4,
4505     CINDEX, /* s: [...] after edge before a a after before */
4506     MD_orig_ZP2_0, /* c = after_orig_pos - before_orig_pos */
4507
4508     PUSHB_1,
4509       6,
4510     CINDEX, /* s: [...] after edge before a a c after */
4511     PUSHB_1,
4512       5,
4513     CINDEX, /* s: [...] after edge before a a c after before */
4514     MD_cur, /* b = after_pos - before_pos */
4515
4516     PUSHB_1,
4517       2,
4518     CINDEX, /* s: [...] after edge before a a c b c */
4519     SUB, /* b-c */
4520
4521     PUSHB_1,
4522       cvtl_0x10000,
4523     RCVT,
4524     MUL, /* (b-c) in 16.16 format */
4525     SWAP,
4526
4527     DUP,
4528     IF, /* c != 0 ? */
4529       DIV, /* s: [...] after edge before a a (b-c)/c */
4530     ELSE,
4531       POP, /* avoid division by zero */
4532     EIF,
4533
4534     MUL, /* a * (b-c)/c * 2^10 */
4535     PUSHB_1,
4536       cvtl_0x10000,
4537     RCVT,
4538     DIV, /* a * (b-c)/c */
4539     ADD, /* a*b/c */
4540
4541     SWAP,
4542     MDAP_noround, /* set rp0 and rp1 to `before' */
4543     SWAP, /* s: [...] after a*b/c edge */
4544     DUP,
4545     DUP,
4546     ALIGNRP, /* align `edge' with `before' */
4547     ROLL,
4548     SHPIX, /* shift `edge' by `a*b/c' */
4549
4550     SWAP, /* s: [...] edge after */
4551     POP,
4552   EIF,
4553
4554   ENDF,
4555
4556 };
4557
4558
4559 /*
4560  * bci_action_serif_link1
4561  *
4562  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
4563  *   before and after.
4564  *
4565  * in: before_point (in twilight zone)
4566  *     edge_point (in twilight zone)
4567  *     after_point (in twilight zone)
4568  *     ... stuff for bci_align_segments (edge) ...
4569  *
4570  * uses: bci_serif_link1_common
4571  *       bci_align_segments
4572  */
4573
4574 unsigned char FPGM(bci_action_serif_link1) [] =
4575 {
4576
4577   PUSHB_1,
4578     bci_action_serif_link1,
4579   FDEF,
4580
4581   PUSHB_1,
4582     bci_serif_link1_common,
4583   CALL,
4584
4585   MDAP_noround, /* set rp0 and rp1 to `edge' */
4586
4587   PUSHB_2,
4588     bci_align_segments,
4589     1,
4590   SZP1, /* set zp1 to normal zone 1 */
4591   CALL,
4592
4593   ENDF,
4594
4595 };
4596
4597
4598 /*
4599  * bci_action_serif_link1_lower_bound
4600  *
4601  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
4602  *   before and after.  Additionally, move the serif again if necessary to
4603  *   stay within a lower bound.
4604  *
4605  * in: before_point (in twilight zone)
4606  *     edge_point (in twilight zone)
4607  *     after_point (in twilight zone)
4608  *     edge[-1] (in twilight zone)
4609  *     ... stuff for bci_align_segments (edge) ...
4610  *
4611  * uses: bci_serif_link1_common
4612  *       bci_lower_bound
4613  */
4614
4615 unsigned char FPGM(bci_action_serif_link1_lower_bound) [] =
4616 {
4617
4618   PUSHB_1,
4619     bci_action_serif_link1_lower_bound,
4620   FDEF,
4621
4622   PUSHB_1,
4623     bci_serif_link1_common,
4624   CALL,
4625
4626   PUSHB_1,
4627     bci_lower_bound,
4628   CALL,
4629
4630   ENDF,
4631
4632 };
4633
4634
4635 /*
4636  * bci_action_serif_link1_upper_bound
4637  *
4638  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
4639  *   before and after.  Additionally, move the serif again if necessary to
4640  *   stay within an upper bound.
4641  *
4642  * in: before_point (in twilight zone)
4643  *     edge_point (in twilight zone)
4644  *     after_point (in twilight zone)
4645  *     edge[1] (in twilight zone)
4646  *     ... stuff for bci_align_segments (edge) ...
4647  *
4648  * uses: bci_serif_link1_common
4649  *       bci_upper_bound
4650  */
4651
4652 unsigned char FPGM(bci_action_serif_link1_upper_bound) [] =
4653 {
4654
4655   PUSHB_1,
4656     bci_action_serif_link1_upper_bound,
4657   FDEF,
4658
4659   PUSHB_1,
4660     bci_serif_link1_common,
4661   CALL,
4662
4663   PUSHB_1,
4664     bci_upper_bound,
4665   CALL,
4666
4667   ENDF,
4668
4669 };
4670
4671
4672 /*
4673  * bci_action_serif_link1_upper_lower_bound
4674  *
4675  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
4676  *   before and after.  Additionally, move the serif again if necessary to
4677  *   stay within a lower and upper bound.
4678  *
4679  * in: before_point (in twilight zone)
4680  *     edge_point (in twilight zone)
4681  *     after_point (in twilight zone)
4682  *     edge[-1] (in twilight zone)
4683  *     edge[1] (in twilight zone)
4684  *     ... stuff for bci_align_segments (edge) ...
4685  *
4686  * uses: bci_serif_link1_common
4687  *       bci_upper_lower_bound
4688  */
4689
4690 unsigned char FPGM(bci_action_serif_link1_upper_lower_bound) [] =
4691 {
4692
4693   PUSHB_1,
4694     bci_action_serif_link1_upper_lower_bound,
4695   FDEF,
4696
4697   PUSHB_1,
4698     bci_serif_link1_common,
4699   CALL,
4700
4701   PUSHB_1,
4702     bci_upper_lower_bound,
4703   CALL,
4704
4705   ENDF,
4706
4707 };
4708
4709
4710 /*
4711  * bci_serif_link2_common
4712  *
4713  *   Common code for bci_action_serif_link2 routines.
4714  *
4715  * sal: sal_anchor
4716  */
4717
4718 unsigned char FPGM(bci_serif_link2_common) [] =
4719 {
4720
4721   PUSHB_1,
4722     bci_serif_link2_common,
4723   FDEF,
4724
4725   PUSHB_1,
4726     0,
4727   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
4728
4729   DUP, /* s: [...] edge edge */
4730   PUSHB_1,
4731     sal_anchor,
4732   RS,
4733   DUP, /* s: [...] edge edge anchor anchor */
4734   MDAP_noround, /* set rp0 and rp1 to `sal_anchor' */
4735
4736   MD_orig_ZP2_0,
4737   DUP,
4738   ADD,
4739   PUSHB_1,
4740     32,
4741   ADD,
4742   FLOOR,
4743   PUSHB_1,
4744     2*64,
4745   DIV, /* delta = (edge_orig_pos - anchor_orig_pos + 16) & ~31 */
4746
4747   SWAP,
4748   DUP,
4749   DUP,
4750   ALIGNRP, /* align `edge' with `sal_anchor' */
4751   ROLL,
4752   SHPIX, /* shift `edge' by `delta' */
4753
4754   ENDF,
4755
4756 };
4757
4758
4759 /*
4760  * bci_action_serif_link2
4761  *
4762  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
4763  *
4764  * in: edge_point (in twilight zone)
4765  *     ... stuff for bci_align_segments (edge) ...
4766  *
4767  * uses: bci_serif_link2_common
4768  *       bci_align_segments
4769  */
4770
4771 unsigned char FPGM(bci_action_serif_link2) [] =
4772 {
4773
4774   PUSHB_1,
4775     bci_action_serif_link2,
4776   FDEF,
4777
4778   PUSHB_1,
4779     bci_serif_link2_common,
4780   CALL,
4781
4782   MDAP_noround, /* set rp0 and rp1 to `edge' */
4783
4784   PUSHB_2,
4785     bci_align_segments,
4786     1,
4787   SZP1, /* set zp1 to normal zone 1 */
4788   CALL,
4789
4790   ENDF,
4791
4792 };
4793
4794
4795 /*
4796  * bci_action_serif_link2_lower_bound
4797  *
4798  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
4799  *   Additionally, move the serif again if necessary to stay within a lower
4800  *   bound.
4801  *
4802  * in: edge_point (in twilight zone)
4803  *     edge[-1] (in twilight zone)
4804  *     ... stuff for bci_align_segments (edge) ...
4805  *
4806  * uses: bci_serif_link2_common
4807  *       bci_lower_bound
4808  */
4809
4810 unsigned char FPGM(bci_action_serif_link2_lower_bound) [] =
4811 {
4812
4813   PUSHB_1,
4814     bci_action_serif_link2_lower_bound,
4815   FDEF,
4816
4817   PUSHB_1,
4818     bci_serif_link2_common,
4819   CALL,
4820
4821   PUSHB_1,
4822     bci_lower_bound,
4823   CALL,
4824
4825   ENDF,
4826
4827 };
4828
4829
4830 /*
4831  * bci_action_serif_link2_upper_bound
4832  *
4833  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
4834  *   Additionally, move the serif again if necessary to stay within an upper
4835  *   bound.
4836  *
4837  * in: edge_point (in twilight zone)
4838  *     edge[1] (in twilight zone)
4839  *     ... stuff for bci_align_segments (edge) ...
4840  *
4841  * uses: bci_serif_link2_common
4842  *       bci_upper_bound
4843  */
4844
4845 unsigned char FPGM(bci_action_serif_link2_upper_bound) [] =
4846 {
4847
4848   PUSHB_1,
4849     bci_action_serif_link2_upper_bound,
4850   FDEF,
4851
4852   PUSHB_1,
4853     bci_serif_link2_common,
4854   CALL,
4855
4856   PUSHB_1,
4857     bci_upper_bound,
4858   CALL,
4859
4860   ENDF,
4861
4862 };
4863
4864
4865 /*
4866  * bci_action_serif_link2_upper_lower_bound
4867  *
4868  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
4869  *   Additionally, move the serif again if necessary to stay within a lower
4870  *   and upper bound.
4871  *
4872  * in: edge_point (in twilight zone)
4873  *     edge[-1] (in twilight zone)
4874  *     edge[1] (in twilight zone)
4875  *     ... stuff for bci_align_segments (edge) ...
4876  *
4877  * uses: bci_serif_link2_common
4878  *       bci_upper_lower_bound
4879  */
4880
4881 unsigned char FPGM(bci_action_serif_link2_upper_lower_bound) [] =
4882 {
4883
4884   PUSHB_1,
4885     bci_action_serif_link2_upper_lower_bound,
4886   FDEF,
4887
4888   PUSHB_1,
4889     bci_serif_link2_common,
4890   CALL,
4891
4892   PUSHB_1,
4893     bci_upper_lower_bound,
4894   CALL,
4895
4896   ENDF,
4897
4898 };
4899
4900
4901 /*
4902  * bci_hint_glyph
4903  *
4904  *   This is the top-level glyph hinting function which parses the arguments
4905  *   on the stack and calls subroutines.
4906  *
4907  * in: action_0_func_idx
4908  *       ... data ...
4909  *     action_1_func_idx
4910  *       ... data ...
4911  *     ...
4912  *
4913  * CVT: cvtl_is_subglyph
4914  *
4915  * uses: bci_action_ip_before
4916  *       bci_action_ip_after
4917  *       bci_action_ip_on
4918  *       bci_action_ip_between
4919  *
4920  *       bci_action_adjust_bound
4921  *       bci_action_adjust_bound_serif
4922  *       bci_action_adjust_bound_round
4923  *       bci_action_adjust_bound_round_serif
4924  *
4925  *       bci_action_stem_bound
4926  *       bci_action_stem_bound_serif
4927  *       bci_action_stem_bound_round
4928  *       bci_action_stem_bound_round_serif
4929  *
4930  *       bci_action_link
4931  *       bci_action_link_serif
4932  *       bci_action_link_round
4933  *       bci_action_link_round_serif
4934  *
4935  *       bci_action_anchor
4936  *       bci_action_anchor_serif
4937  *       bci_action_anchor_round
4938  *       bci_action_anchor_round_serif
4939  *
4940  *       bci_action_blue_anchor
4941  *
4942  *       bci_action_adjust
4943  *       bci_action_adjust_serif
4944  *       bci_action_adjust_round
4945  *       bci_action_adjust_round_serif
4946  *
4947  *       bci_action_stem
4948  *       bci_action_stem_serif
4949  *       bci_action_stem_round
4950  *       bci_action_stem_round_serif
4951  *
4952  *       bci_action_blue
4953  *
4954  *       bci_action_serif
4955  *       bci_action_serif_lower_bound
4956  *       bci_action_serif_upper_bound
4957  *       bci_action_serif_upper_lower_bound
4958  *
4959  *       bci_action_serif_anchor
4960  *       bci_action_serif_anchor_lower_bound
4961  *       bci_action_serif_anchor_upper_bound
4962  *       bci_action_serif_anchor_upper_lower_bound
4963  *
4964  *       bci_action_serif_link1
4965  *       bci_action_serif_link1_lower_bound
4966  *       bci_action_serif_link1_upper_bound
4967  *       bci_action_serif_link1_upper_lower_bound
4968  *
4969  *       bci_action_serif_link2
4970  *       bci_action_serif_link2_lower_bound
4971  *       bci_action_serif_link2_upper_bound
4972  *       bci_action_serif_link2_upper_lower_bound
4973  */
4974
4975 unsigned char FPGM(bci_hint_glyph) [] =
4976 {
4977
4978   PUSHB_1,
4979     bci_hint_glyph,
4980   FDEF,
4981
4982 /* start_loop: */
4983   /* loop until all data on stack is used */
4984   CALL,
4985   PUSHB_1,
4986     8,
4987   NEG,
4988   PUSHB_1,
4989     3,
4990   DEPTH,
4991   LT,
4992   JROT, /* goto start_loop */
4993
4994   PUSHB_1,
4995     1,
4996   SZP2, /* set zp2 to normal zone 1 */
4997   IUP_y,
4998
4999   ENDF,
5000
5001 };
5002
5003
5004 #define COPY_FPGM(func_name) \
5005           memcpy(buf_p, fpgm_ ## func_name, \
5006                  sizeof (fpgm_ ## func_name)); \
5007           buf_p += sizeof (fpgm_ ## func_name) \
5008
5009 static FT_Error
5010 TA_table_build_fpgm(FT_Byte** fpgm,
5011                     FT_ULong* fpgm_len,
5012                     FONT* font)
5013 {
5014   FT_UInt buf_len;
5015   FT_UInt len;
5016   FT_Byte* buf;
5017   FT_Byte* buf_p;
5018
5019
5020   /* for compatibility with dumb bytecode interpreters or analyzers, */
5021   /* FDEFs are stored in ascending index order, without holes -- */
5022   /* note that some FDEFs are not always needed */
5023   /* (depending on options of `TTFautohint'), */
5024   /* but implementing dynamic FDEF indices would be a lot of work */
5025
5026   buf_len = sizeof (FPGM(bci_round))
5027             + sizeof (FPGM(bci_smooth_stem_width_a))
5028             + 1
5029             + sizeof (FPGM(bci_smooth_stem_width_b))
5030             + 1
5031             + sizeof (FPGM(bci_smooth_stem_width_c))
5032             + sizeof (FPGM(bci_get_best_width))
5033             + sizeof (FPGM(bci_strong_stem_width_a))
5034             + 2
5035             + sizeof (FPGM(bci_strong_stem_width_b))
5036             + sizeof (FPGM(bci_loop))
5037             + sizeof (FPGM(bci_cvt_rescale))
5038             + sizeof (FPGM(bci_blue_round_a))
5039             + 1
5040             + sizeof (FPGM(bci_blue_round_b))
5041             + sizeof (FPGM(bci_decrement_component_counter))
5042             + sizeof (FPGM(bci_get_point_extrema))
5043             + sizeof (FPGM(bci_nibbles))
5044             + sizeof (FPGM(bci_number_set_is_element))
5045             + sizeof (FPGM(bci_number_set_is_element2))
5046
5047             + sizeof (FPGM(bci_create_segment))
5048             + sizeof (FPGM(bci_create_segments))
5049
5050             + sizeof (FPGM(bci_create_segments_0))
5051             + sizeof (FPGM(bci_create_segments_1))
5052             + sizeof (FPGM(bci_create_segments_2))
5053             + sizeof (FPGM(bci_create_segments_3))
5054             + sizeof (FPGM(bci_create_segments_4))
5055             + sizeof (FPGM(bci_create_segments_5))
5056             + sizeof (FPGM(bci_create_segments_6))
5057             + sizeof (FPGM(bci_create_segments_7))
5058             + sizeof (FPGM(bci_create_segments_8))
5059             + sizeof (FPGM(bci_create_segments_9))
5060
5061             + sizeof (FPGM(bci_create_segments_composite))
5062
5063             + sizeof (FPGM(bci_create_segments_composite_0))
5064             + sizeof (FPGM(bci_create_segments_composite_1))
5065             + sizeof (FPGM(bci_create_segments_composite_2))
5066             + sizeof (FPGM(bci_create_segments_composite_3))
5067             + sizeof (FPGM(bci_create_segments_composite_4))
5068             + sizeof (FPGM(bci_create_segments_composite_5))
5069             + sizeof (FPGM(bci_create_segments_composite_6))
5070             + sizeof (FPGM(bci_create_segments_composite_7))
5071             + sizeof (FPGM(bci_create_segments_composite_8))
5072             + sizeof (FPGM(bci_create_segments_composite_9))
5073
5074             + sizeof (FPGM(bci_align_segment))
5075             + sizeof (FPGM(bci_align_segments))
5076
5077             + sizeof (FPGM(bci_scale_contour))
5078             + sizeof (FPGM(bci_scale_glyph))
5079             + sizeof (FPGM(bci_scale_composite_glyph))
5080             + sizeof (FPGM(bci_shift_contour))
5081             + sizeof (FPGM(bci_shift_subglyph))
5082
5083             + sizeof (FPGM(bci_ip_outer_align_point))
5084             + sizeof (FPGM(bci_ip_on_align_points))
5085             + sizeof (FPGM(bci_ip_between_align_point))
5086             + sizeof (FPGM(bci_ip_between_align_points))
5087
5088             + sizeof (FPGM(bci_adjust_common))
5089             + sizeof (FPGM(bci_stem_common))
5090             + sizeof (FPGM(bci_serif_common))
5091             + sizeof (FPGM(bci_serif_anchor_common))
5092             + sizeof (FPGM(bci_serif_link1_common))
5093             + sizeof (FPGM(bci_serif_link2_common))
5094
5095             + sizeof (FPGM(bci_lower_bound))
5096             + sizeof (FPGM(bci_upper_bound))
5097             + sizeof (FPGM(bci_upper_lower_bound))
5098
5099             + sizeof (FPGM(bci_adjust_bound))
5100             + sizeof (FPGM(bci_stem_bound))
5101             + sizeof (FPGM(bci_link))
5102             + sizeof (FPGM(bci_anchor))
5103             + sizeof (FPGM(bci_adjust))
5104             + sizeof (FPGM(bci_stem))
5105
5106             + sizeof (FPGM(bci_action_ip_before))
5107             + sizeof (FPGM(bci_action_ip_after))
5108             + sizeof (FPGM(bci_action_ip_on))
5109             + sizeof (FPGM(bci_action_ip_between))
5110
5111             + sizeof (FPGM(bci_action_blue))
5112             + sizeof (FPGM(bci_action_blue_anchor))
5113
5114             + sizeof (FPGM(bci_action_anchor))
5115             + sizeof (FPGM(bci_action_anchor_serif))
5116             + sizeof (FPGM(bci_action_anchor_round))
5117             + sizeof (FPGM(bci_action_anchor_round_serif))
5118
5119             + sizeof (FPGM(bci_action_adjust))
5120             + sizeof (FPGM(bci_action_adjust_serif))
5121             + sizeof (FPGM(bci_action_adjust_round))
5122             + sizeof (FPGM(bci_action_adjust_round_serif))
5123             + sizeof (FPGM(bci_action_adjust_bound))
5124             + sizeof (FPGM(bci_action_adjust_bound_serif))
5125             + sizeof (FPGM(bci_action_adjust_bound_round))
5126             + sizeof (FPGM(bci_action_adjust_bound_round_serif))
5127
5128             + sizeof (FPGM(bci_action_link))
5129             + sizeof (FPGM(bci_action_link_serif))
5130             + sizeof (FPGM(bci_action_link_round))
5131             + sizeof (FPGM(bci_action_link_round_serif))
5132
5133             + sizeof (FPGM(bci_action_stem))
5134             + sizeof (FPGM(bci_action_stem_serif))
5135             + sizeof (FPGM(bci_action_stem_round))
5136             + sizeof (FPGM(bci_action_stem_round_serif))
5137             + sizeof (FPGM(bci_action_stem_bound))
5138             + sizeof (FPGM(bci_action_stem_bound_serif))
5139             + sizeof (FPGM(bci_action_stem_bound_round))
5140             + sizeof (FPGM(bci_action_stem_bound_round_serif))
5141
5142             + sizeof (FPGM(bci_action_serif))
5143             + sizeof (FPGM(bci_action_serif_lower_bound))
5144             + sizeof (FPGM(bci_action_serif_upper_bound))
5145             + sizeof (FPGM(bci_action_serif_upper_lower_bound))
5146
5147             + sizeof (FPGM(bci_action_serif_anchor))
5148             + sizeof (FPGM(bci_action_serif_anchor_lower_bound))
5149             + sizeof (FPGM(bci_action_serif_anchor_upper_bound))
5150             + sizeof (FPGM(bci_action_serif_anchor_upper_lower_bound))
5151
5152             + sizeof (FPGM(bci_action_serif_link1))
5153             + sizeof (FPGM(bci_action_serif_link1_lower_bound))
5154             + sizeof (FPGM(bci_action_serif_link1_upper_bound))
5155             + sizeof (FPGM(bci_action_serif_link1_upper_lower_bound))
5156
5157             + sizeof (FPGM(bci_action_serif_link2))
5158             + sizeof (FPGM(bci_action_serif_link2_lower_bound))
5159             + sizeof (FPGM(bci_action_serif_link2_upper_bound))
5160             + sizeof (FPGM(bci_action_serif_link2_upper_lower_bound))
5161
5162             + sizeof (FPGM(bci_hint_glyph));
5163
5164   /* buffer length must be a multiple of four */
5165   len = (buf_len + 3) & ~3;
5166   buf = (FT_Byte*)malloc(len);
5167   if (!buf)
5168     return FT_Err_Out_Of_Memory;
5169
5170   /* pad end of buffer with zeros */
5171   buf[len - 1] = 0x00;
5172   buf[len - 2] = 0x00;
5173   buf[len - 3] = 0x00;
5174
5175   /* copy font program into buffer and fill in the missing variables */
5176   buf_p = buf;
5177
5178   COPY_FPGM(bci_round);
5179   COPY_FPGM(bci_smooth_stem_width_a);
5180   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
5181   COPY_FPGM(bci_smooth_stem_width_b);
5182   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
5183   COPY_FPGM(bci_smooth_stem_width_c);
5184   COPY_FPGM(bci_get_best_width);
5185   COPY_FPGM(bci_strong_stem_width_a);
5186   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
5187   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_SIZE(font);
5188   COPY_FPGM(bci_strong_stem_width_b);
5189   COPY_FPGM(bci_loop);
5190   COPY_FPGM(bci_cvt_rescale);
5191   COPY_FPGM(bci_blue_round_a);
5192   *(buf_p++) = (unsigned char)CVT_BLUES_SIZE(font);
5193   COPY_FPGM(bci_blue_round_b);
5194   COPY_FPGM(bci_decrement_component_counter);
5195   COPY_FPGM(bci_get_point_extrema);
5196   COPY_FPGM(bci_nibbles);
5197   COPY_FPGM(bci_number_set_is_element);
5198   COPY_FPGM(bci_number_set_is_element2);
5199
5200   COPY_FPGM(bci_create_segment);
5201   COPY_FPGM(bci_create_segments);
5202
5203   COPY_FPGM(bci_create_segments_0);
5204   COPY_FPGM(bci_create_segments_1);
5205   COPY_FPGM(bci_create_segments_2);
5206   COPY_FPGM(bci_create_segments_3);
5207   COPY_FPGM(bci_create_segments_4);
5208   COPY_FPGM(bci_create_segments_5);
5209   COPY_FPGM(bci_create_segments_6);
5210   COPY_FPGM(bci_create_segments_7);
5211   COPY_FPGM(bci_create_segments_8);
5212   COPY_FPGM(bci_create_segments_9);
5213
5214   COPY_FPGM(bci_create_segments_composite);
5215
5216   COPY_FPGM(bci_create_segments_composite_0);
5217   COPY_FPGM(bci_create_segments_composite_1);
5218   COPY_FPGM(bci_create_segments_composite_2);
5219   COPY_FPGM(bci_create_segments_composite_3);
5220   COPY_FPGM(bci_create_segments_composite_4);
5221   COPY_FPGM(bci_create_segments_composite_5);
5222   COPY_FPGM(bci_create_segments_composite_6);
5223   COPY_FPGM(bci_create_segments_composite_7);
5224   COPY_FPGM(bci_create_segments_composite_8);
5225   COPY_FPGM(bci_create_segments_composite_9);
5226
5227   COPY_FPGM(bci_align_segment);
5228   COPY_FPGM(bci_align_segments);
5229
5230   COPY_FPGM(bci_scale_contour);
5231   COPY_FPGM(bci_scale_glyph);
5232   COPY_FPGM(bci_scale_composite_glyph);
5233   COPY_FPGM(bci_shift_contour);
5234   COPY_FPGM(bci_shift_subglyph);
5235
5236   COPY_FPGM(bci_ip_outer_align_point);
5237   COPY_FPGM(bci_ip_on_align_points);
5238   COPY_FPGM(bci_ip_between_align_point);
5239   COPY_FPGM(bci_ip_between_align_points);
5240
5241   COPY_FPGM(bci_adjust_common);
5242   COPY_FPGM(bci_stem_common);
5243   COPY_FPGM(bci_serif_common);
5244   COPY_FPGM(bci_serif_anchor_common);
5245   COPY_FPGM(bci_serif_link1_common);
5246   COPY_FPGM(bci_serif_link2_common);
5247
5248   COPY_FPGM(bci_lower_bound);
5249   COPY_FPGM(bci_upper_bound);
5250   COPY_FPGM(bci_upper_lower_bound);
5251
5252   COPY_FPGM(bci_adjust_bound);
5253   COPY_FPGM(bci_stem_bound);
5254   COPY_FPGM(bci_link);
5255   COPY_FPGM(bci_anchor);
5256   COPY_FPGM(bci_adjust);
5257   COPY_FPGM(bci_stem);
5258
5259   COPY_FPGM(bci_action_ip_before);
5260   COPY_FPGM(bci_action_ip_after);
5261   COPY_FPGM(bci_action_ip_on);
5262   COPY_FPGM(bci_action_ip_between);
5263
5264   COPY_FPGM(bci_action_blue);
5265   COPY_FPGM(bci_action_blue_anchor);
5266
5267   COPY_FPGM(bci_action_anchor);
5268   COPY_FPGM(bci_action_anchor_serif);
5269   COPY_FPGM(bci_action_anchor_round);
5270   COPY_FPGM(bci_action_anchor_round_serif);
5271
5272   COPY_FPGM(bci_action_adjust);
5273   COPY_FPGM(bci_action_adjust_serif);
5274   COPY_FPGM(bci_action_adjust_round);
5275   COPY_FPGM(bci_action_adjust_round_serif);
5276   COPY_FPGM(bci_action_adjust_bound);
5277   COPY_FPGM(bci_action_adjust_bound_serif);
5278   COPY_FPGM(bci_action_adjust_bound_round);
5279   COPY_FPGM(bci_action_adjust_bound_round_serif);
5280
5281   COPY_FPGM(bci_action_link);
5282   COPY_FPGM(bci_action_link_serif);
5283   COPY_FPGM(bci_action_link_round);
5284   COPY_FPGM(bci_action_link_round_serif);
5285
5286   COPY_FPGM(bci_action_stem);
5287   COPY_FPGM(bci_action_stem_serif);
5288   COPY_FPGM(bci_action_stem_round);
5289   COPY_FPGM(bci_action_stem_round_serif);
5290   COPY_FPGM(bci_action_stem_bound);
5291   COPY_FPGM(bci_action_stem_bound_serif);
5292   COPY_FPGM(bci_action_stem_bound_round);
5293   COPY_FPGM(bci_action_stem_bound_round_serif);
5294
5295   COPY_FPGM(bci_action_serif);
5296   COPY_FPGM(bci_action_serif_lower_bound);
5297   COPY_FPGM(bci_action_serif_upper_bound);
5298   COPY_FPGM(bci_action_serif_upper_lower_bound);
5299
5300   COPY_FPGM(bci_action_serif_anchor);
5301   COPY_FPGM(bci_action_serif_anchor_lower_bound);
5302   COPY_FPGM(bci_action_serif_anchor_upper_bound);
5303   COPY_FPGM(bci_action_serif_anchor_upper_lower_bound);
5304
5305   COPY_FPGM(bci_action_serif_link1);
5306   COPY_FPGM(bci_action_serif_link1_lower_bound);
5307   COPY_FPGM(bci_action_serif_link1_upper_bound);
5308   COPY_FPGM(bci_action_serif_link1_upper_lower_bound);
5309
5310   COPY_FPGM(bci_action_serif_link2);
5311   COPY_FPGM(bci_action_serif_link2_lower_bound);
5312   COPY_FPGM(bci_action_serif_link2_upper_bound);
5313   COPY_FPGM(bci_action_serif_link2_upper_lower_bound);
5314
5315   COPY_FPGM(bci_hint_glyph);
5316
5317   *fpgm = buf;
5318   *fpgm_len = buf_len;
5319
5320   return FT_Err_Ok;
5321 }
5322
5323
5324 FT_Error
5325 TA_sfnt_build_fpgm_table(SFNT* sfnt,
5326                          FONT* font)
5327 {
5328   FT_Error error = FT_Err_Ok;
5329
5330   SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
5331   glyf_Data* data = (glyf_Data*)glyf_table->data;
5332
5333   FT_Byte* fpgm_buf;
5334   FT_ULong fpgm_len;
5335
5336
5337   error = TA_sfnt_add_table_info(sfnt);
5338   if (error)
5339     goto Exit;
5340
5341   /* `glyf', `cvt', `fpgm', and `prep' are always used in parallel */
5342   if (glyf_table->processed)
5343   {
5344     sfnt->table_infos[sfnt->num_table_infos - 1] = data->fpgm_idx;
5345     goto Exit;
5346   }
5347
5348   error = TA_table_build_fpgm(&fpgm_buf, &fpgm_len, font);
5349   if (error)
5350     goto Exit;
5351
5352   if (fpgm_len > sfnt->max_instructions)
5353     sfnt->max_instructions = fpgm_len;
5354
5355   /* in case of success, `fpgm_buf' gets linked */
5356   /* and is eventually freed in `TA_font_unload' */
5357   error = TA_font_add_table(font,
5358                             &sfnt->table_infos[sfnt->num_table_infos - 1],
5359                             TTAG_fpgm, fpgm_len, fpgm_buf);
5360   if (error)
5361     free(fpgm_buf);
5362   else
5363     data->fpgm_idx = sfnt->table_infos[sfnt->num_table_infos - 1];
5364
5365 Exit:
5366   return error;
5367 }
5368
5369 /* end of tafpgm.c */