lib/tafpgm.c

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