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