lib/tafpgm.c

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