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