src/tafpgm.c

   1 /* tafpgm.c */
   2
   3 /*
   4  * Copyright (C) 2011 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 "tabytecode.h"
  17
  18
  19 /* we need the following macro */
  20 /* so that `func_name' doesn't get replaced with its #defined value */
  21 /* (as defined in `tabytecode.h') */
  22
  23 #define FPGM(func_name) fpgm_ ## func_name
  24
  25
  26 /*
  27  * Due to a bug in FreeType up to and including version 2.4.7,
  28  * it is not possible to use MD_orig with twilight points.
  29  * We circumvent this by using GC_orig.
  30  */
  31 #define MD_orig_fixed \
  32   GC_orig, \
  33   SWAP, \
  34   GC_orig, \
  35   SWAP, \
  36   SUB
  37
  38 #define MD_orig_ZP2_0 \
  39   MD_orig_fixed
  40
  41 #define MD_orig_ZP2_1 \
  42   PUSHB_1, \
  43     0, \
  44   SZP2, \
  45   MD_orig_fixed, \
  46   PUSHB_1, \
  47     1, \
  48   SZP2
  49
  50
  51 /* in the comments below, the top of the stack (`s:') */
  52 /* is the rightmost element; the stack is shown */
  53 /* after the instruction on the same line has been executed */
  54
  55
  56 /*
  57  * bci_round
  58  *
  59  *   Round a 26.6 number.  Contrary to the ROUND bytecode instruction, no
  60  *   engine specific corrections are applied.
  61  *
  62  * in: val
  63  * out: ROUND(val)
  64  */
  65
  66 unsigned char FPGM(bci_round) [] = {
  67
  68   PUSHB_1,
  69     bci_round,
  70   FDEF,
  71
  72   DUP,
  73   ABS,
  74   PUSHB_1,
  75     32,
  76   ADD,
  77   FLOOR,
  78   SWAP,
  79   PUSHB_1,
  80     0,
  81   LT,
  82   IF,
  83     NEG,
  84   EIF,
  85
  86   ENDF,
  87
  88 };
  89
  90
  91 /*
  92  * bci_compute_stem_width
  93  *
  94  *   This is the equivalent to the following code from function
  95  *   `ta_latin_compute_stem_width':
  96  *
  97  *      dist = ABS(width)
  98  *
  99  *      if (stem_is_serif
 100  *          && dist < 3*64)
 101  *         || is_extra_light:
 102  *        return width
 103  *      else if base_is_round:
 104  *        if dist < 80
 105  *          dist = 64
 106  *      else if dist < 56:
 107  *        dist = 56
 108  *
 109  *      delta = ABS(dist - std_width)
 110  *
 111  *      if delta < 40:
 112  *        dist = std_width
 113  *        if dist < 48
 114  *          dist = 48
 115  *        goto End
 116  *
 117  *      if dist < 3*64:
 118  *        delta = dist
 119  *        dist = FLOOR(dist)
 120  *        delta = delta - dist
 121  *
 122  *        if delta < 10:
 123  *          dist = dist + delta
 124  *        else if delta < 32:
 125  *          dist = dist + 10
 126  *        else if delta < 54:
 127  *          dist = dist + 54
 128  *        else
 129  *          dist = dist + delta
 130  *      else
 131  *        dist = ROUND(dist)
 132  *
 133  *    End:
 134  *      if width < 0:
 135  *        dist = -dist
 136  *      return dist
 137  *
 138  *
 139  * in: width
 140  *     stem_is_serif
 141  *     base_is_round
 142  *
 143  * out: new_width
 144  *
 145  * CVT: cvtl_is_extra_light
 146  *      std_width
 147  */
 148
 149 unsigned char FPGM(bci_compute_stem_width_a) [] = {
 150
 151   PUSHB_1,
 152     bci_compute_stem_width,
 153   FDEF,
 154
 155   DUP,
 156   ABS, /* s: base_is_round stem_is_serif width dist */
 157
 158   DUP,
 159   PUSHB_1,
 160     3*64,
 161   LT, /* dist < 3*64 */
 162
 163   PUSHB_1,
 164     4,
 165   MINDEX, /* s: base_is_round width dist (dist<3*64) stem_is_serif */
 166   AND, /* stem_is_serif && dist < 3*64 */
 167
 168   PUSHB_1,
 169     cvtl_is_extra_light,
 170   RCVT,
 171   OR, /* (stem_is_serif && dist < 3*64) || is_extra_light */
 172
 173   IF, /* s: base_is_round width dist */
 174     POP,
 175     SWAP,
 176     POP, /* s: width */
 177
 178   ELSE,
 179     ROLL, /* s: width dist base_is_round */
 180     IF, /* s: width dist */
 181       DUP,
 182       PUSHB_1,
 183         80,
 184       LT, /* dist < 80 */
 185       IF, /* s: width dist */
 186         POP,
 187         PUSHB_1,
 188           64, /* dist = 64 */
 189       EIF,
 190
 191     ELSE,
 192       DUP,
 193       PUSHB_1,
 194         56,
 195       LT, /* dist < 56 */
 196       IF, /* s: width dist */
 197         POP,
 198         PUSHB_1,
 199           56, /* dist = 56 */
 200       EIF,
 201     EIF,
 202
 203     DUP, /* s: width dist dist */
 204     PUSHB_1,
 205
 206 };
 207
 208 /*    %c, index of std_width */
 209
 210 unsigned char FPGM(bci_compute_stem_width_b) [] = {
 211
 212     RCVT,
 213     SUB,
 214     ABS, /* s: width dist delta */
 215
 216     PUSHB_1,
 217       40,
 218     LT, /* delta < 40 */
 219     IF, /* s: width dist */
 220       POP,
 221       PUSHB_1,
 222
 223 };
 224
 225 /*      %c, index of std_width */
 226
 227 unsigned char FPGM(bci_compute_stem_width_c) [] = {
 228
 229       RCVT, /* dist = std_width */
 230       DUP,
 231       PUSHB_1,
 232         48,
 233       LT, /* dist < 48 */
 234       IF,
 235         POP,
 236         PUSHB_1,
 237           48, /* dist = 48 */
 238       EIF,
 239
 240     ELSE,
 241       DUP, /* s: width dist dist */
 242       PUSHB_1,
 243         3*64,
 244       LT, /* dist < 3*64 */
 245       IF,
 246         DUP, /* s: width delta dist */
 247         FLOOR, /* dist = FLOOR(dist) */
 248         DUP, /* s: width delta dist dist */
 249         ROLL,
 250         ROLL, /* s: width dist delta dist */
 251         SUB, /* delta = delta - dist */
 252
 253         DUP, /* s: width dist delta delta */
 254         PUSHB_1,
 255           10,
 256         LT, /* delta < 10 */
 257         IF, /* s: width dist delta */
 258           ADD, /* dist = dist + delta */
 259
 260         ELSE,
 261           DUP,
 262           PUSHB_1,
 263             32,
 264           LT, /* delta < 32 */
 265           IF,
 266             POP,
 267             PUSHB_1,
 268               10,
 269             ADD, /* dist = dist + 10 */
 270
 271           ELSE,
 272             DUP,
 273             PUSHB_1,
 274               54,
 275             LT, /* delta < 54 */
 276             IF,
 277               POP,
 278               PUSHB_1,
 279                 54,
 280               ADD, /* dist = dist + 54 */
 281
 282             ELSE,
 283               ADD, /* dist = dist + delta */
 284
 285             EIF,
 286           EIF,
 287         EIF,
 288
 289       ELSE,
 290         PUSHB_1,
 291           bci_round,
 292         CALL, /* dist = round(dist) */
 293
 294       EIF,
 295     EIF,
 296
 297     SWAP, /* s: dist width */
 298     PUSHB_1,
 299       0,
 300     LT, /* width < 0 */
 301     IF,
 302       NEG, /* dist = -dist */
 303     EIF,
 304   EIF,
 305
 306   ENDF,
 307
 308 };
 309
 310
 311 /*
 312  * bci_loop
 313  *
 314  *   Take a range and a function number and apply the function to all
 315  *   elements of the range.
 316  *
 317  * in: func_num
 318  *     end
 319  *     start
 320  *
 321  * sal: sal_i (counter initialized with `start')
 322  *      sal_limit (`end')
 323  *      sal_func (`func_num')
 324  */
 325
 326 unsigned char FPGM(bci_loop) [] = {
 327
 328   PUSHB_1,
 329     bci_loop,
 330   FDEF,
 331
 332   PUSHB_1,
 333     sal_func,
 334   SWAP,
 335   WS, /* sal_func = func_num */
 336   PUSHB_1,
 337     sal_limit,
 338   SWAP,
 339   WS, /* sal_limit = end */
 340   PUSHB_1,
 341     sal_i,
 342   SWAP,
 343   WS, /* sal_i = start */
 344
 345 /* start_loop: */
 346   PUSHB_1,
 347     sal_i,
 348   RS,
 349   PUSHB_1,
 350     sal_limit,
 351   RS,
 352   LTEQ, /* start <= end */
 353   IF,
 354     PUSHB_1,
 355       sal_func,
 356     RS,
 357     CALL,
 358     PUSHB_3,
 359       sal_i,
 360       1,
 361       sal_i,
 362     RS,
 363     ADD, /* start = start + 1 */
 364     WS,
 365
 366     PUSHB_1,
 367       22,
 368     NEG,
 369     JMPR, /* goto start_loop */
 370   EIF,
 371
 372   ENDF,
 373
 374 };
 375
 376
 377 /*
 378  * bci_cvt_rescale
 379  *
 380  *   Rescale CVT value by `cvtl_scale' (in 16.16 format).
 381  *
 382  * sal: sal_i (CVT index)
 383  *
 384  * CVT: cvtl_scale
 385  *      cvtl_0x10000
 386  */
 387
 388 unsigned char FPGM(bci_cvt_rescale) [] = {
 389
 390   PUSHB_1,
 391     bci_cvt_rescale,
 392   FDEF,
 393
 394   PUSHB_1,
 395     sal_i,
 396   RS,
 397   DUP,
 398   RCVT,
 399   PUSHB_1,
 400     cvtl_scale,
 401   RCVT,
 402   MUL, /* CVT * scale * 2^10 */
 403   PUSHB_1,
 404     cvtl_0x10000,
 405   RCVT,
 406   DIV, /* CVT * scale */
 407
 408   WCVTP,
 409
 410   ENDF,
 411
 412 };
 413
 414
 415 /*
 416  * bci_blue_round
 417  *
 418  *   Round a blue ref value and adjust its corresponding shoot value.
 419  *
 420  * sal: sal_i (CVT index)
 421  *
 422  */
 423
 424 unsigned char FPGM(bci_blue_round_a) [] = {
 425
 426   PUSHB_1,
 427     bci_blue_round,
 428   FDEF,
 429
 430   PUSHB_1,
 431     sal_i,
 432   RS,
 433   DUP,
 434   RCVT, /* s: ref_idx ref */
 435
 436   DUP,
 437   PUSHB_1,
 438     bci_round,
 439   CALL,
 440   SWAP, /* s: ref_idx round(ref) ref */
 441
 442   PUSHB_2,
 443
 444 };
 445
 446 /*  %c, blue_count */
 447
 448 unsigned char FPGM(bci_blue_round_b) [] = {
 449
 450     4,
 451   CINDEX,
 452   ADD, /* s: ref_idx round(ref) ref shoot_idx */
 453   DUP,
 454   RCVT, /* s: ref_idx round(ref) ref shoot_idx shoot */
 455
 456   ROLL, /* s: ref_idx round(ref) shoot_idx shoot ref */
 457   SWAP,
 458   SUB, /* s: ref_idx round(ref) shoot_idx dist */
 459   DUP,
 460   ABS, /* s: ref_idx round(ref) shoot_idx dist delta */
 461
 462   DUP,
 463   PUSHB_1,
 464     32,
 465   LT, /* delta < 32 */
 466   IF,
 467     POP,
 468     PUSHB_1,
 469       0, /* delta = 0 */
 470
 471   ELSE,
 472     PUSHB_1,
 473       48,
 474     LT, /* delta < 48 */
 475     IF,
 476       PUSHB_1,
 477         32, /* delta = 32 */
 478
 479     ELSE,
 480       PUSHB_1,
 481         64, /* delta = 64 */
 482     EIF,
 483   EIF,
 484
 485   SWAP, /* s: ref_idx round(ref) shoot_idx delta dist */
 486   PUSHB_1,
 487     0,
 488   LT, /* dist < 0 */
 489   IF,
 490     NEG, /* delta = -delta */
 491   EIF,
 492
 493   PUSHB_1,
 494     3,
 495   CINDEX,
 496   SWAP,
 497   SUB, /* s: ref_idx round(ref) shoot_idx (round(ref) - delta) */
 498
 499   WCVTP,
 500   WCVTP,
 501
 502   ENDF,
 503
 504 };
 505
 506
 507 /*
 508  * bci_get_point_extrema
 509  *
 510  *   An auxiliary function for `bci_create_segment'.
 511  *
 512  * in: point-1
 513  * out: point
 514  *
 515  * sal: sal_point_min
 516  *      sal_point_max
 517  */
 518
 519 unsigned char FPGM(bci_get_point_extrema) [] = {
 520
 521   PUSHB_1,
 522     bci_get_point_extrema,
 523   FDEF,
 524
 525   PUSHB_1,
 526     1,
 527   ADD, /* s: point */
 528   DUP,
 529   DUP,
 530
 531   /* check whether `point' is a new minimum */
 532   PUSHB_1,
 533     sal_point_min,
 534   RS, /* s: point point point point_min */
 535   MD_orig,
 536   /* if distance is negative, we have a new minimum */
 537   PUSHB_1,
 538     0,
 539   LT,
 540   IF, /* s: point point */
 541     DUP,
 542     PUSHB_1,
 543       sal_point_min,
 544     SWAP,
 545     WS,
 546   EIF,
 547
 548   /* check whether `point' is a new maximum */
 549   PUSHB_1,
 550     sal_point_max,
 551   RS, /* s: point point point_max */
 552   MD_orig,
 553   /* if distance is positive, we have a new maximum */
 554   PUSHB_1,
 555     0,
 556   GT,
 557   IF, /* s: point */
 558     DUP,
 559     PUSHB_1,
 560       sal_point_max,
 561     SWAP,
 562     WS,
 563   EIF, /* s: point */
 564
 565   ENDF,
 566
 567 };
 568
 569
 570 /*
 571  * bci_create_segment
 572  *
 573  *   Store start and end point of a segment in the storage area,
 574  *   then construct a point in the twilight zone to represent it.
 575  *
 576  *   This function is used by `bci_create_segment_points'.
 577  *
 578  * in: start
 579  *     end
 580  *       [last (if wrap-around segment)]
 581  *       [first (if wrap-around segment)]
 582  *
 583  * uses: bci_get_point_extrema
 584  *
 585  * sal: sal_i (start of current segment)
 586  *      sal_j (current twilight point)
 587  *      sal_point_min
 588  *      sal_point_max
 589  *
 590  * CVT: cvtl_scale
 591  *      cvtl_0x10000
 592  *      cvtl_temp
 593  */
 594
 595 unsigned char FPGM(bci_create_segment) [] = {
 596
 597   PUSHB_1,
 598     bci_create_segment,
 599   FDEF,
 600
 601   PUSHB_1,
 602     sal_i,
 603   RS,
 604   PUSHB_1,
 605     2,
 606   CINDEX,
 607   WS, /* sal[sal_i] = start */
 608
 609   /* increase `sal_i'; together with the outer loop, this makes sal_i += 2 */
 610   PUSHB_3,
 611     sal_i,
 612     1,
 613     sal_i,
 614   RS,
 615   ADD, /* sal_i = sal_i + 1 */
 616   WS,
 617
 618   /* initialize inner loop(s) */
 619   PUSHB_2,
 620     sal_point_min,
 621     2,
 622   CINDEX,
 623   WS, /* sal_point_min = start */
 624   PUSHB_2,
 625     sal_point_max,
 626     2,
 627   CINDEX,
 628   WS, /* sal_point_max = start */
 629
 630   PUSHB_1,
 631     1,
 632   SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
 633
 634   SWAP,
 635   DUP,
 636   PUSHB_1,
 637     3,
 638   CINDEX, /* s: start end end start */
 639   LT, /* start > end */
 640   IF,
 641     /* we have a wrap-around segment with two more arguments */
 642     /* to give the last and first point of the contour, respectively; */
 643     /* our job is to store a segment `start'-`last', */
 644     /* and to get extrema for the two segments */
 645     /* `start'-`last' and `first'-`end' */
 646
 647     /* s: first last start end */
 648     PUSHB_1,
 649       sal_i,
 650     RS,
 651     PUSHB_1,
 652       4,
 653     CINDEX,
 654     WS, /* sal[sal_i] = last */
 655
 656     ROLL,
 657     ROLL, /* s: first end last start */
 658     DUP,
 659     ROLL,
 660     SWAP, /* s: first end start last start */
 661     SUB, /* s: first end start loop_count */
 662
 663     PUSHB_1,
 664       bci_get_point_extrema,
 665     LOOPCALL,
 666     /* clean up stack */
 667     POP,
 668
 669     SWAP, /* s: end first */
 670     PUSHB_1,
 671       1,
 672     SUB,
 673     DUP,
 674     ROLL, /* s: (first - 1) (first - 1) end */
 675     SWAP,
 676     SUB, /* s: (first - 1) loop_count */
 677
 678     PUSHB_1,
 679       bci_get_point_extrema,
 680     LOOPCALL,
 681     /* clean up stack */
 682     POP,
 683
 684   ELSE, /* s: start end */
 685     PUSHB_1,
 686       sal_i,
 687     RS,
 688     PUSHB_1,
 689       2,
 690     CINDEX,
 691     WS, /* sal[sal_i] = end */
 692
 693     PUSHB_1,
 694       2,
 695     CINDEX,
 696     SUB, /* s: start loop_count */
 697
 698     PUSHB_1,
 699       bci_get_point_extrema,
 700     LOOPCALL,
 701     /* clean up stack */
 702     POP,
 703   EIF,
 704
 705   /* the twilight point representing a segment */
 706   /* is in the middle between the minimum and maximum */
 707   PUSHB_1,
 708     sal_point_min,
 709   RS,
 710   GC_orig,
 711   PUSHB_1,
 712     sal_point_max,
 713   RS,
 714   GC_orig,
 715   ADD,
 716   PUSHB_1,
 717     2*64,
 718   DIV, /* s: middle_pos */
 719
 720   /* now scale it */
 721   PUSHB_1,
 722     cvtl_scale,
 723   RCVT,
 724   MUL, /* middle_pos * scale * 2^10 */
 725   PUSHB_1,
 726     cvtl_0x10000,
 727   RCVT,
 728   DIV, /* middle_pos = middle_pos * scale */
 729
 730   /* write it to temporary CVT location */
 731   PUSHB_2,
 732     cvtl_temp,
 733     0,
 734   SZP0, /* set zp0 to twilight zone 0 */
 735   SWAP,
 736   WCVTP,
 737
 738   /* create twilight point with index `sal_j' */
 739   PUSHB_1,
 740     sal_j,
 741   RS,
 742   PUSHB_1,
 743     cvtl_temp,
 744   MIAP_noround,
 745
 746   PUSHB_3,
 747     sal_j,
 748     1,
 749     sal_j,
 750   RS,
 751   ADD, /* twilight_point = twilight_point + 1 */
 752   WS,
 753
 754   ENDF,
 755
 756 };
 757
 758
 759 /*
 760  * bci_create_segments
 761  *
 762  *   Set up segments by defining point ranges which defines them
 763  *   and computing twilight points to represent them.
 764  *
 765  * in: num_segments (N)
 766  *     segment_start_0
 767  *     segment_end_0
 768  *       [contour_last 0 (if wrap-around segment)]
 769  *       [contour_first 0 (if wrap-around segment)]
 770  *     segment_start_1
 771  *     segment_end_1
 772  *       [contour_last 0 (if wrap-around segment)]
 773  *       [contour_first 0 (if wrap-around segment)]
 774  *     ...
 775  *     segment_start_(N-1)
 776  *     segment_end_(N-1)
 777  *       [contour_last (N-1) (if wrap-around segment)]
 778  *       [contour_first (N-1) (if wrap-around segment)]
 779  *
 780  * uses: bci_create_segment
 781  *
 782  * sal: sal_i (start of current segment)
 783  *      sal_j (current twilight point)
 784  */
 785
 786 unsigned char FPGM(bci_create_segments) [] = {
 787
 788   PUSHB_1,
 789     bci_create_segments,
 790   FDEF,
 791
 792   /* all our measurements are taken along the y axis */
 793   SVTCA_y,
 794
 795   DUP,
 796   ADD,
 797   PUSHB_1,
 798     1,
 799   SUB, /* delta = (2*num_segments - 1) */
 800
 801   PUSHB_4,
 802     sal_segment_offset,
 803     sal_segment_offset,
 804
 805     sal_j,
 806     0,
 807   WS, /* sal_j = 0 (point offset) */
 808
 809   ROLL,
 810   ADD, /* s: ... sal_segment_offset (sal_segment_offset + delta) */
 811
 812   /* `bci_create_segment_point' also increases the loop counter by 1; */
 813   /* this effectively means we have a loop step of 2 */
 814   PUSHB_2,
 815     bci_create_segment,
 816     bci_loop,
 817   CALL,
 818
 819   ENDF,
 820
 821 };
 822
 823
 824 /*
 825  * bci_align_segment
 826  *
 827  *   Align all points in a segment to the twilight point in rp0.
 828  *   zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
 829  *
 830  * in: segment_index
 831  */
 832
 833 unsigned char FPGM(bci_align_segment) [] = {
 834
 835   PUSHB_1,
 836     bci_align_segment,
 837   FDEF,
 838
 839   /* we need the values of `sal_segment_offset + 2*segment_index' */
 840   /* and `sal_segment_offset + 2*segment_index + 1' */
 841   DUP,
 842   ADD,
 843   PUSHB_1,
 844     sal_segment_offset,
 845   ADD,
 846   DUP,
 847   RS,
 848   SWAP,
 849   PUSHB_1,
 850     1,
 851   ADD,
 852   RS, /* s: first last */
 853
 854 /* start_loop: */
 855   PUSHB_1,
 856     2,
 857   CINDEX, /* s: first last first */
 858   PUSHB_1,
 859     2,
 860   CINDEX, /* s: first last first last */
 861   LTEQ, /* first <= end */
 862   IF, /* s: first last */
 863     SWAP,
 864     DUP, /* s: last first first */
 865     ALIGNRP, /* align point with index `first' with rp0 */
 866
 867     PUSHB_1,
 868       1,
 869     ADD, /* first = first + 1 */
 870     SWAP, /* s: first last */
 871
 872     PUSHB_1,
 873       18,
 874     NEG,
 875     JMPR, /* goto start_loop */
 876
 877   ELSE,
 878     POP,
 879     POP,
 880   EIF,
 881
 882   ENDF,
 883
 884 };
 885
 886
 887 /*
 888  * bci_align_segments
 889  *
 890  *   Align segments to the twilight point in rp0.
 891  *   zp0 and zp1 must be set to 0 (twilight) and 1 (normal), respectively.
 892  *
 893  * in: first_segment
 894  *     loop_counter (N)
 895  *       segment_1
 896  *       segment_2
 897  *       ...
 898  *       segment_N
 899  *
 900  * uses: handle_segment
 901  *
 902  */
 903
 904 unsigned char FPGM(bci_align_segments) [] = {
 905
 906   PUSHB_1,
 907     bci_align_segments,
 908   FDEF,
 909
 910   PUSHB_1,
 911     bci_align_segment,
 912   CALL,
 913
 914   PUSHB_1,
 915     bci_align_segment,
 916   LOOPCALL,
 917
 918   ENDF,
 919
 920 };
 921
 922
 923 /*
 924  * bci_scale_contour
 925  *
 926  *   Scale a contour using two points giving the maximum and minimum
 927  *   coordinates.
 928  *
 929  *   It expects that no point on the contour is touched.
 930  *
 931  * in: min_point
 932  *     max_point
 933  *
 934  * CVT: cvtl_scale
 935  *      cvtl_0x10000
 936  */
 937
 938 unsigned char FPGM(bci_scale_contour) [] = {
 939
 940   PUSHB_1,
 941     bci_scale_contour,
 942   FDEF,
 943
 944   DUP,
 945   DUP,
 946   GC_orig,
 947   DUP,
 948   PUSHB_1,
 949     cvtl_scale,
 950   RCVT,
 951   MUL, /* min_pos * scale * 2^10 */
 952   PUSHB_1,
 953     cvtl_0x10000,
 954   RCVT,
 955   DIV, /* min_pos_new = min_pos * scale */
 956   SWAP,
 957   SUB,
 958   SHPIX,
 959
 960   /* don't scale a single-point contour twice */
 961   SWAP,
 962   DUP,
 963   ROLL,
 964   NEQ,
 965   IF,
 966     DUP,
 967     GC_orig,
 968     DUP,
 969     PUSHB_1,
 970       cvtl_scale,
 971     RCVT,
 972     MUL, /* max_pos * scale * 2^10 */
 973     PUSHB_1,
 974       cvtl_0x10000,
 975     RCVT,
 976     DIV, /* max_pos_new = max_pos * scale */
 977     SWAP,
 978     SUB,
 979     SHPIX,
 980
 981   ELSE,
 982     POP,
 983   EIF,
 984
 985   ENDF,
 986
 987 };
 988
 989
 990 /*
 991  * bci_scale_glyph
 992  *
 993  *   Scale a glyph using a list of points (two points per contour, giving
 994  *   the maximum and mininum coordinates).
 995  *
 996  *   It expects that no point in the glyph is touched.
 997  *
 998  * in: num_contours (N)
 999  *       min_point_1
1000  *       max_point_1
1001  *       min_point_2
1002  *       max_point_2
1003  *       ...
1004  *       min_point_N
1005  *       max_point_N
1006  *
1007  * uses: bci_scale_contour
1008  */
1009
1010 unsigned char FPGM(bci_scale_glyph) [] = {
1011
1012   PUSHB_1,
1013     bci_scale_glyph,
1014   FDEF,
1015
1016   SVTCA_y,
1017
1018   PUSHB_1,
1019     1,
1020   SZPS, /* set zp0, zp1, and zp2 to normal zone 1 */
1021
1022   PUSHB_1,
1023     bci_scale_contour,
1024   LOOPCALL,
1025
1026   PUSHB_1,
1027     1,
1028   SZP2, /* set zp2 to normal zone 1 */
1029   IUP_y,
1030
1031   ENDF,
1032
1033 };
1034
1035
1036 /*
1037  * bci_shift_contour
1038  *
1039  *   Shift a contour by a given amount.
1040  *
1041  *   It expects that rp1 (pointed to by zp0) is set up properly; zp2 must
1042  *   point to the normal zone 1.
1043  *
1044  * in:  contour
1045  * out: contour + 1
1046  */
1047
1048 unsigned char FPGM(bci_shift_contour) [] = {
1049
1050   PUSHB_1,
1051     bci_shift_contour,
1052   FDEF,
1053
1054   DUP,
1055   SHC_rp1, /* shift `contour' by (rp1_pos - rp1_orig_pos) */
1056
1057   PUSHB_1,
1058     1,
1059   ADD,
1060
1061   ENDF,
1062
1063 };
1064
1065
1066 /*
1067  * bci_shift_subglyph
1068  *
1069  *   Shift a subglyph.  To be more specific, it corrects the already applied
1070  *   subglyph offset (if any) from the `glyf' table which needs to be scaled
1071  *   also.
1072  *
1073  *   If this function is called, a point `x' in the subglyph has been scaled
1074  *   by `cvtl_scale' already (during the hinting of the subglyph itself), and
1075  *   `offset' has been applied also:
1076  *
1077  *     x  ->  x * scale + offset         (1)
1078  *
1079  *   However, the offset should be applied first, then the scaling:
1080  *
1081  *     x  ->  (x + offset) * scale       (2)
1082  *
1083  *   Our job is now to transform (1) to (2); a simple calculation shows that
1084  *   we have to shift all points of the subglyph by
1085  *
1086  *     offset * scale - offset = offset * (scale - 1)
1087  *
1088  * in: offset (in FUnits)
1089  *     num_contours
1090  *     first_contour
1091  *
1092  * CVT: cvtl_funits_to_pixels
1093  *      cvtl_0x10000
1094  *      cvtl_scale
1095  */
1096
1097 unsigned char FPGM(bci_shift_subglyph) [] = {
1098
1099   PUSHB_1,
1100     bci_shift_subglyph,
1101   FDEF,
1102
1103   SVTCA_y,
1104
1105   PUSHB_1,
1106     cvtl_funits_to_pixels,
1107   RCVT, /* scaling factor FUnits -> pixels */
1108   MUL,
1109   PUSHB_1,
1110     cvtl_0x10000,
1111   RCVT,
1112   DIV,
1113
1114   /* the autohinter always rounds offsets */
1115   PUSHB_1,
1116     bci_round,
1117   CALL, /* offset = round(offset) */
1118
1119   PUSHB_1,
1120     cvtl_scale,
1121   RCVT,
1122   PUSHB_1,
1123     cvtl_0x10000,
1124   RCVT,
1125   SUB, /* scale - 1 (in 16.16 format) */
1126   MUL,
1127   PUSHB_1,
1128     cvtl_0x10000,
1129   RCVT,
1130   DIV, /* delta = offset * (scale - 1) */
1131
1132   /* and round again */
1133   PUSHB_1,
1134     bci_round,
1135   CALL, /* offset = round(offset) */
1136
1137   PUSHB_1,
1138     0,
1139   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1140
1141   /* we create twilight point 0 as a reference point, */
1142   /* setting the original position to zero (using `cvtl_temp') */
1143   PUSHB_5,
1144     0,
1145     0,
1146     cvtl_temp,
1147     cvtl_temp,
1148     0,
1149   WCVTP,
1150   MIAP_noround, /* rp0 and rp1 now point to twilight point 0 */
1151
1152   SWAP, /* s: first_contour num_contours 0 delta */
1153   SHPIX, /* rp1_pos - rp1_orig_pos = delta */
1154
1155   PUSHB_2,
1156     bci_shift_contour,
1157     1,
1158   SZP2, /* set zp2 to normal zone 1 */
1159   LOOPCALL,
1160
1161   ENDF,
1162
1163 };
1164
1165
1166 /*
1167  * bci_ip_outer_align_point
1168  *
1169  *   Auxiliary function for `bci_action_ip_before' and
1170  *   `bci_action_ip_after'.
1171  *
1172  *   It expects rp0 to contain the edge for alignment, zp0 set to twilight
1173  *   zone, and both zp1 and zp2 set to normal zone.
1174  *
1175  * in: point
1176  *
1177  * sal: sal_i (edge_orig_pos)
1178  *
1179  * CVT: cvtl_scale
1180  *      cvtl_0x10000
1181  */
1182
1183 unsigned char FPGM(bci_ip_outer_align_point) [] = {
1184
1185   PUSHB_1,
1186     bci_ip_outer_align_point,
1187   FDEF,
1188
1189   DUP,
1190   ALIGNRP, /* align `point' with `edge' */
1191   DUP,
1192   GC_orig,
1193   /* now scale it */
1194   PUSHB_1,
1195     cvtl_scale,
1196   RCVT,
1197   MUL, /* point_orig_pos * scale * 2^10 */
1198   PUSHB_1,
1199     cvtl_0x10000,
1200   RCVT,
1201   DIV, /* point_orig_pos = point_orig_pos * scale */
1202
1203   PUSHB_1,
1204     sal_i,
1205   RS,
1206   SUB, /* s: point (point_orig_pos - edge_orig_pos) */
1207   SHPIX,
1208
1209   ENDF,
1210
1211 };
1212
1213
1214 /*
1215  * bci_ip_on_align_points
1216  *
1217  *   Auxiliary function for `bci_action_ip_on'.
1218  *
1219  * in: edge (in twilight zone)
1220  *     loop_counter (N)
1221  *       point_1
1222  *       point_2
1223  *       ...
1224  *       point_N
1225  */
1226
1227 unsigned char FPGM(bci_ip_on_align_points) [] = {
1228
1229   PUSHB_1,
1230     bci_ip_on_align_points,
1231   FDEF,
1232
1233   MDAP_noround, /* set rp0 and rp1 to `edge' */
1234
1235   SLOOP,
1236   ALIGNRP,
1237
1238   ENDF,
1239
1240 };
1241
1242
1243 /*
1244  * bci_ip_between_align_point
1245  *
1246  *   Auxiliary function for `bci_ip_between_align_points'.
1247  *
1248  *   It expects rp0 to contain the edge for alignment, zp0 set to twilight
1249  *   zone, and both zp1 and zp2 set to normal zone.
1250  *
1251  * in: point
1252  *
1253  * sal: sal_i (edge_orig_pos)
1254  *      sal_j (stretch_factor)
1255  *
1256  * CVT: cvtl_scale
1257  *      cvtl_0x10000
1258  */
1259
1260 unsigned char FPGM(bci_ip_between_align_point) [] = {
1261
1262   PUSHB_1,
1263     bci_ip_between_align_point,
1264   FDEF,
1265
1266   DUP,
1267   ALIGNRP, /* align `point' with `edge' */
1268   DUP,
1269   GC_orig,
1270   /* now scale it */
1271   PUSHB_1,
1272     cvtl_scale,
1273   RCVT,
1274   MUL, /* point_orig_pos * scale * 2^10 */
1275   PUSHB_1,
1276     cvtl_0x10000,
1277   RCVT,
1278   DIV, /* point_orig_pos = point_orig_pos * scale */
1279
1280   PUSHB_1,
1281     sal_i,
1282   RS,
1283   SUB, /* s: point (point_orig_pos - edge_orig_pos) */
1284   PUSHB_1,
1285     sal_j,
1286   RS,
1287   MUL, /* s: point delta */
1288   SHPIX,
1289
1290   ENDF,
1291
1292 };
1293
1294
1295 /*
1296  * bci_ip_between_align_points
1297  *
1298  *   Auxiliary function for `bci_action_ip_between'.
1299  *
1300  * in: after_edge (in twilight zone)
1301  *     before_edge (in twilight zone)
1302  *     loop_counter (N)
1303  *       point_1
1304  *       point_2
1305  *       ...
1306  *       point_N
1307  *
1308  * sal: sal_i (before_orig_pos)
1309  *      sal_j (stretch_factor)
1310  *
1311  * uses: bci_ip_between_align_point
1312  */
1313
1314 unsigned char FPGM(bci_ip_between_align_points) [] = {
1315
1316   PUSHB_1,
1317     bci_ip_between_align_points,
1318   FDEF,
1319
1320   PUSHB_2,
1321     2,
1322     0,
1323   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1324   CINDEX,
1325   DUP, /* s: ... before after before before */
1326   MDAP_noround, /* set rp0 and rp1 to `before' */
1327   DUP,
1328   GC_orig, /* s: ... before after before before_orig_pos */
1329   PUSHB_1,
1330     sal_i,
1331   SWAP,
1332   WS, /* sal_i = before_orig_pos */
1333   PUSHB_1,
1334     2,
1335   CINDEX, /* s: ... before after before after */
1336   MD_cur, /* b = after_pos - before_pos */
1337   ROLL,
1338   ROLL,
1339   MD_orig_ZP2_0, /* a = after_orig_pos - before_orig_pos */
1340   DIV, /* s: a/b */
1341   PUSHB_1,
1342     sal_j,
1343   SWAP,
1344   WS, /* sal_j = stretch_factor */
1345
1346   PUSHB_3,
1347     bci_ip_between_align_point,
1348     1,
1349     1,
1350   SZP2, /* set zp2 to normal zone 1 */
1351   SZP1, /* set zp1 to normal zone 1 */
1352   LOOPCALL,
1353
1354   ENDF,
1355
1356 };
1357
1358
1359 /*
1360  * bci_action_ip_before
1361  *
1362  *   Handle `ip_before' data to align points located before the first edge.
1363  *
1364  * in: first_edge (in twilight zone)
1365  *     loop_counter (N)
1366  *       point_1
1367  *       point_2
1368  *       ...
1369  *       point_N
1370  *
1371  * sal: sal_i (first_edge_orig_pos)
1372  *
1373  * uses: bci_ip_outer_align_point
1374  */
1375
1376 unsigned char FPGM(bci_action_ip_before) [] = {
1377
1378   PUSHB_1,
1379     bci_action_ip_before,
1380   FDEF,
1381
1382   PUSHB_1,
1383     0,
1384   SZP2, /* set zp2 to twilight zone 0 */
1385
1386   DUP,
1387   GC_orig,
1388   PUSHB_1,
1389     sal_i,
1390   SWAP,
1391   WS, /* sal_i = first_edge_orig_pos */
1392
1393   PUSHB_3,
1394     0,
1395     1,
1396     1,
1397   SZP2, /* set zp2 to normal zone 1 */
1398   SZP1, /* set zp1 to normal zone 1 */
1399   SZP0, /* set zp0 to twilight zone 0 */
1400
1401   MDAP_noround, /* set rp0 and rp1 to `first_edge' */
1402
1403   PUSHB_1,
1404     bci_ip_outer_align_point,
1405   LOOPCALL,
1406
1407   ENDF,
1408
1409 };
1410
1411
1412 /*
1413  * bci_action_ip_after
1414  *
1415  *   Handle `ip_after' data to align points located after the last edge.
1416  *
1417  * in: last_edge (in twilight zone)
1418  *     loop_counter (N)
1419  *       point_1
1420  *       point_2
1421  *       ...
1422  *       point_N
1423  *
1424  * sal: sal_i (last_edge_orig_pos)
1425  *
1426  * uses: bci_ip_outer_align_point
1427  */
1428
1429 unsigned char FPGM(bci_action_ip_after) [] = {
1430
1431   PUSHB_1,
1432     bci_action_ip_after,
1433   FDEF,
1434
1435   PUSHB_1,
1436     0,
1437   SZP2, /* set zp2 to twilight zone 0 */
1438
1439   DUP,
1440   GC_orig,
1441   PUSHB_1,
1442     sal_i,
1443   SWAP,
1444   WS, /* sal_i = last_edge_orig_pos */
1445
1446   PUSHB_3,
1447     0,
1448     1,
1449     1,
1450   SZP2, /* set zp2 to normal zone 1 */
1451   SZP1, /* set zp1 to normal zone 1 */
1452   SZP0, /* set zp0 to twilight zone 0 */
1453
1454   MDAP_noround, /* set rp0 and rp1 to `last_edge' */
1455
1456   PUSHB_1,
1457     bci_ip_outer_align_point,
1458   LOOPCALL,
1459
1460   ENDF,
1461
1462 };
1463
1464
1465 /*
1466  * bci_action_ip_on
1467  *
1468  *   Handle `ip_on' data to align points located on an edge coordinate (but
1469  *   not part of an edge).
1470  *
1471  * in: loop_counter (M)
1472  *       edge_1 (in twilight zone)
1473  *       loop_counter (N_1)
1474  *         point_1
1475  *         point_2
1476  *         ...
1477  *         point_N_1
1478  *       edge_2 (in twilight zone)
1479  *       loop_counter (N_2)
1480  *         point_1
1481  *         point_2
1482  *         ...
1483  *         point_N_2
1484  *       ...
1485  *       edge_M (in twilight zone)
1486  *       loop_counter (N_M)
1487  *         point_1
1488  *         point_2
1489  *         ...
1490  *         point_N_M
1491  *
1492  * uses: bci_ip_on_align_points
1493  */
1494
1495 unsigned char FPGM(bci_action_ip_on) [] = {
1496
1497   PUSHB_1,
1498     bci_action_ip_on,
1499   FDEF,
1500
1501   PUSHB_2,
1502     0,
1503     1,
1504   SZP1, /* set zp1 to normal zone 1 */
1505   SZP0, /* set zp0 to twilight zone 0 */
1506
1507   PUSHB_1,
1508     bci_ip_on_align_points,
1509   LOOPCALL,
1510
1511   ENDF,
1512
1513 };
1514
1515
1516 /*
1517  * bci_action_ip_between
1518  *
1519  *   Handle `ip_between' data to align points located between two edges.
1520  *
1521  * in: loop_counter (M)
1522  *       before_edge_1 (in twilight zone)
1523  *       after_edge_1 (in twilight zone)
1524  *       loop_counter (N_1)
1525  *         point_1
1526  *         point_2
1527  *         ...
1528  *         point_N_1
1529  *       before_edge_2 (in twilight zone)
1530  *       after_edge_2 (in twilight zone)
1531  *       loop_counter (N_2)
1532  *         point_1
1533  *         point_2
1534  *         ...
1535  *         point_N_2
1536  *       ...
1537  *       before_edge_M (in twilight zone)
1538  *       after_edge_M (in twilight zone)
1539  *       loop_counter (N_M)
1540  *         point_1
1541  *         point_2
1542  *         ...
1543  *         point_N_M
1544  *
1545  * uses: bci_ip_between_align_points
1546  */
1547
1548 unsigned char FPGM(bci_action_ip_between) [] = {
1549
1550   PUSHB_1,
1551     bci_action_ip_between,
1552   FDEF,
1553
1554   PUSHB_1,
1555     bci_ip_between_align_points,
1556   LOOPCALL,
1557
1558   ENDF,
1559
1560 };
1561
1562
1563 /*
1564  * bci_action_adjust_common
1565  *
1566  *   Common code for bci_action_adjust routines.
1567  */
1568
1569 unsigned char FPGM(bci_action_adjust_common) [] = {
1570
1571   PUSHB_1,
1572     bci_action_adjust_common,
1573   FDEF,
1574
1575   PUSHB_1,
1576     0,
1577   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1578
1579   PUSHB_1,
1580     4,
1581   CINDEX, /* s: [...] edge2 edge is_round is_serif edge2 */
1582   PUSHB_1,
1583     4,
1584   CINDEX, /* s: [...] edge2 edge is_round is_serif edge2 edge */
1585   MD_orig_ZP2_0, /* s: [...] edge2 edge is_round is_serif org_len */
1586
1587   PUSHB_1,
1588     bci_compute_stem_width,
1589   CALL,
1590   NEG, /* s: [...] edge2 edge -cur_len */
1591
1592   ROLL, /* s: [...] edge -cur_len edge2 */
1593   MDAP_noround, /* set rp0 and rp1 to `edge2' */
1594   SWAP,
1595   DUP,
1596   DUP, /* s: [...] -cur_len edge edge edge */
1597   ALIGNRP, /* align `edge' with `edge2' */
1598   ROLL,
1599   SHPIX, /* shift `edge' by -cur_len */
1600
1601   ENDF,
1602
1603 };
1604
1605
1606 /*
1607  * bci_action_adjust_bound
1608  *
1609  *   Handle the ADJUST_BOUND action to align an edge of a stem if the other
1610  *   edge of the stem has already been moved, then moving it again if
1611  *   necessary to stay bound.
1612  *
1613  * in: edge2_is_serif
1614  *     edge_is_round
1615  *     edge_point (in twilight zone)
1616  *     edge2_point (in twilight zone)
1617  *     edge[-1] (in twilight zone)
1618  *     ... stuff for bci_align_segments (edge) ...
1619  *
1620  * uses: bci_action_adjust_common
1621  */
1622
1623 unsigned char FPGM(bci_action_adjust_bound) [] = {
1624
1625   PUSHB_1,
1626     bci_action_adjust_bound,
1627   FDEF,
1628
1629   PUSHB_1,
1630     bci_action_adjust_common,
1631   CALL,
1632
1633   SWAP, /* s: edge edge[-1] */
1634   DUP,
1635   MDAP_noround, /* set rp0 and rp1 to `edge[-1]' */
1636   GC_cur,
1637   PUSHB_1,
1638     2,
1639   CINDEX,
1640   GC_cur, /* s: edge edge[-1]_pos edge_pos */
1641   GT, /* edge_pos < edge[-1]_pos */
1642   IF,
1643     DUP,
1644     ALIGNRP, /* align `edge' to `edge[-1]' */
1645   EIF,
1646
1647   MDAP_noround, /* set rp0 and rp1 to `edge' */
1648
1649   PUSHB_2,
1650     bci_align_segments,
1651     1,
1652   SZP1, /* set zp1 to normal zone 1 */
1653   CALL,
1654
1655   ENDF,
1656
1657 };
1658
1659
1660 /*
1661  * bci_action_adjust
1662  *
1663  *   Handle the ADJUST action to align an edge of a stem if the other edge
1664  *   of the stem has already been moved.
1665  *
1666  * in: edge2_is_serif
1667  *     edge_is_round
1668  *     edge_point (in twilight zone)
1669  *     edge2_point (in twilight zone)
1670  *     ... stuff for bci_align_segments (edge) ...
1671  *
1672  * uses: bci_action_adjust_common
1673  */
1674
1675 unsigned char FPGM(bci_action_adjust) [] = {
1676
1677   PUSHB_1,
1678     bci_action_adjust,
1679   FDEF,
1680
1681   PUSHB_1,
1682     bci_action_adjust_common,
1683   CALL,
1684
1685   MDAP_noround, /* set rp0 and rp1 to `edge' */
1686
1687   PUSHB_2,
1688     bci_align_segments,
1689     1,
1690   SZP1, /* set zp1 to normal zone 1 */
1691   CALL,
1692
1693   ENDF,
1694
1695 };
1696
1697
1698 /*
1699  * bci_action_stem_common
1700  *
1701  *   Common code for bci_action_stem routines.
1702  */
1703
1704 #undef sal_u_off
1705 #define sal_u_off sal_temp1
1706 #undef sal_d_off
1707 #define sal_d_off sal_temp2
1708 #undef sal_org_len
1709 #define sal_org_len sal_temp3
1710 #undef sal_edge2
1711 #define sal_edge2 sal_temp3
1712
1713 unsigned char FPGM(bci_action_stem_common) [] = {
1714
1715   PUSHB_1,
1716     bci_action_stem_common,
1717   FDEF,
1718
1719   PUSHB_1,
1720     0,
1721   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
1722
1723   PUSHB_1,
1724     4,
1725   CINDEX,
1726   PUSHB_1,
1727     4,
1728   CINDEX,
1729   DUP, /* s: [...] edge2 edge is_round is_serif edge2 edge edge */
1730   MDAP_noround, /* set rp0 and rp1 to `edge_point' (for ALIGNRP below) */
1731
1732   MD_orig_ZP2_0, /* s: [...] edge2 edge is_round is_serif org_len */
1733   DUP,
1734   PUSHB_1,
1735     sal_org_len,
1736   SWAP,
1737   WS,
1738
1739   PUSHB_1,
1740     bci_compute_stem_width,
1741   CALL, /* s: [...] edge2 edge cur_len */
1742
1743   DUP,
1744   PUSHB_1,
1745     96,
1746   LT, /* cur_len < 96 */
1747   IF,
1748     DUP,
1749     PUSHB_1,
1750       64,
1751     LTEQ, /* cur_len <= 64 */
1752     IF,
1753       PUSHB_4,
1754         sal_u_off,
1755         32,
1756         sal_d_off,
1757         32,
1758
1759     ELSE,
1760       PUSHB_4,
1761         sal_u_off,
1762         38,
1763         sal_d_off,
1764         26,
1765     EIF,
1766     WS,
1767     WS,
1768
1769     SWAP, /* s: [...] edge2 cur_len edge */
1770     DUP,
1771     PUSHB_1,
1772       sal_anchor,
1773     RS,
1774     DUP, /* s: [...] edge2 cur_len edge edge anchor anchor */
1775     ROLL,
1776     SWAP,
1777     MD_orig_ZP2_0,
1778     SWAP,
1779     GC_cur,
1780     ADD, /* s: [...] edge2 cur_len edge org_pos */
1781     PUSHB_1,
1782       sal_org_len,
1783     RS,
1784     PUSHB_1,
1785       2*64,
1786     DIV,
1787     ADD, /* s: [...] edge2 cur_len edge org_center */
1788
1789     DUP,
1790     PUSHB_1,
1791       bci_round,
1792     CALL, /* s: [...] edge2 cur_len edge org_center cur_pos1 */
1793
1794     DUP,
1795     ROLL,
1796     ROLL,
1797     SUB, /* s: ... cur_len edge cur_pos1 (org_center - cur_pos1) */
1798
1799     DUP,
1800     PUSHB_1,
1801       sal_u_off,
1802     RS,
1803     ADD,
1804     ABS, /* s: ... cur_len edge cur_pos1 (org_center - cur_pos1) delta1 */
1805
1806     SWAP,
1807     PUSHB_1,
1808       sal_d_off,
1809     RS,
1810     SUB,
1811     ABS, /* s: [...] edge2 cur_len edge cur_pos1 delta1 delta2 */
1812
1813     LT, /* delta1 < delta2 */
1814     IF,
1815       PUSHB_1,
1816         sal_u_off,
1817       RS,
1818       SUB, /* cur_pos1 = cur_pos1 - u_off */
1819
1820     ELSE,
1821       PUSHB_1,
1822         sal_d_off,
1823       RS,
1824       ADD, /* cur_pos1 = cur_pos1 + d_off */
1825     EIF, /* s: [...] edge2 cur_len edge cur_pos1 */
1826
1827     PUSHB_1,
1828       3,
1829     CINDEX,
1830     PUSHB_1,
1831       2*64,
1832     DIV,
1833     SUB, /* arg = cur_pos1 - cur_len/2 */
1834
1835     SWAP, /* s: [...] edge2 cur_len arg edge */
1836     DUP,
1837     DUP,
1838     PUSHB_1,
1839       4,
1840     MINDEX,
1841     SWAP, /* s: [...] edge2 cur_len edge edge arg edge */
1842     GC_cur,
1843     SUB,
1844     SHPIX, /* edge = cur_pos1 - cur_len/2 */
1845
1846   ELSE,
1847     SWAP, /* s: [...] edge2 cur_len edge */
1848     PUSHB_1,
1849       sal_anchor,
1850     RS,
1851     GC_cur, /* s: [...] edge2 cur_len edge anchor_pos */
1852     PUSHB_1,
1853       2,
1854     CINDEX,
1855     PUSHB_1,
1856       sal_anchor,
1857     RS,
1858     MD_orig_ZP2_0,
1859     ADD, /* s: [...] edge2 cur_len edge org_pos */
1860
1861     DUP,
1862     PUSHB_1,
1863       sal_org_len,
1864     RS,
1865     PUSHB_1,
1866       2*64,
1867     DIV,
1868     ADD, /* s: [...] edge2 cur_len edge org_pos org_center */
1869
1870     SWAP,
1871     DUP,
1872     PUSHB_1,
1873       bci_round,
1874     CALL, /* cur_pos1 = ROUND(org_pos) */
1875     SWAP,
1876     PUSHB_1,
1877       sal_org_len,
1878     RS,
1879     ADD,
1880     PUSHB_1,
1881       bci_round,
1882     CALL,
1883     PUSHB_1,
1884       5,
1885     CINDEX,
1886     SUB, /* s: [...] edge2 cur_len edge org_center cur_pos1 cur_pos2 */
1887
1888     PUSHB_1,
1889       5,
1890     CINDEX,
1891     PUSHB_1,
1892       2*64,
1893     DIV,
1894     PUSHB_1,
1895       4,
1896     MINDEX,
1897     SUB, /* s: ... cur_len edge cur_pos1 cur_pos2 (cur_len/2 - org_center) */
1898
1899     DUP,
1900     PUSHB_1,
1901       4,
1902     CINDEX,
1903     ADD,
1904     ABS, /* delta1 = ABS(cur_pos1 + cur_len / 2 - org_center) */
1905     SWAP,
1906     PUSHB_1,
1907       3,
1908     CINDEX,
1909     ADD,
1910     ABS, /* s: ... edge2 cur_len edge cur_pos1 cur_pos2 delta1 delta2 */
1911     LT, /* delta1 < delta2 */
1912     IF,
1913       POP, /* arg = cur_pos1 */
1914
1915     ELSE,
1916       SWAP,
1917       POP, /* arg = cur_pos2 */
1918     EIF, /* s: [...] edge2 cur_len edge arg */
1919     SWAP,
1920     DUP,
1921     DUP,
1922     PUSHB_1,
1923       4,
1924     MINDEX,
1925     SWAP, /* s: [...] edge2 cur_len edge edge arg edge */
1926     GC_cur,
1927     SUB,
1928     SHPIX, /* edge = arg */
1929   EIF, /* s: [...] edge2 cur_len edge */
1930
1931   ENDF,
1932
1933 };
1934
1935
1936 /*
1937  * bci_action_stem_bound
1938  *
1939  *   Handle the STEM action to align two edges of a stem, then moving one
1940  *   edge again if necessary to stay bound.
1941  *
1942  *   The code after computing `cur_len' to shift `edge' and `edge2'
1943  *   is equivalent to the snippet below (part of `ta_latin_hint_edges'):
1944  *
1945  *      if cur_len < 96:
1946  *        if cur_len < = 64:
1947  *          u_off = 32
1948  *          d_off = 32
1949  *        else:
1950  *          u_off = 38
1951  *          d_off = 26
1952  *
1953  *        org_pos = anchor + (edge_orig - anchor_orig);
1954  *        org_center = org_pos + org_len / 2;
1955  *
1956  *        cur_pos1 = ROUND(org_center)
1957  *        delta1 = ABS(org_center - (cur_pos1 - u_off))
1958  *        delta2 = ABS(org_center - (cur_pos1 + d_off))
1959  *        if (delta1 < delta2):
1960  *          cur_pos1 = cur_pos1 - u_off
1961  *        else:
1962  *          cur_pos1 = cur_pos1 + d_off
1963  *
1964  *        edge = cur_pos1 - cur_len / 2
1965  *
1966  *      else:
1967  *        org_pos = anchor + (edge_orig - anchor_orig)
1968  *        org_center = org_pos + org_len / 2;
1969  *
1970  *        cur_pos1 = ROUND(org_pos)
1971  *        delta1 = ABS(cur_pos1 + cur_len / 2 - org_center)
1972  *        cur_pos2 = ROUND(org_pos + org_len) - cur_len
1973  *        delta2 = ABS(cur_pos2 + cur_len / 2 - org_center)
1974  *
1975  *        if (delta1 < delta2):
1976  *          edge = cur_pos1
1977  *        else:
1978  *          edge = cur_pos2
1979  *
1980  *      edge2 = edge + cur_len
1981  *
1982  * in: edge2_is_serif
1983  *     edge_is_round
1984  *     edge_point (in twilight zone)
1985  *     edge2_point (in twilight zone)
1986  *     edge[-1] (in twilight zone)
1987  *     ... stuff for bci_align_segments (edge) ...
1988  *     ... stuff for bci_align_segments (edge2)...
1989  *
1990  * sal: sal_anchor
1991  *      sal_temp1
1992  *      sal_temp2
1993  *      sal_temp3
1994  *
1995  * uses: bci_action_stem_common
1996  */
1997
1998 unsigned char FPGM(bci_action_stem_bound) [] = {
1999
2000   PUSHB_1,
2001     bci_action_stem_bound,
2002   FDEF,
2003
2004   PUSHB_1,
2005     bci_action_stem_common,
2006   CALL,
2007
2008   ROLL, /* s: edge[-1] cur_len edge edge2 */
2009   DUP,
2010   DUP,
2011   ALIGNRP, /* align `edge2' with rp0 (still `edge') */
2012   PUSHB_1,
2013     sal_edge2,
2014   SWAP,
2015   WS, /* s: edge[-1] cur_len edge edge2 */
2016   ROLL,
2017   SHPIX, /* edge2 = edge + cur_len */
2018
2019   SWAP, /* s: edge edge[-1] */
2020   DUP,
2021   MDAP_noround, /* set rp0 and rp1 to `edge[-1]' */
2022   GC_cur,
2023   PUSHB_1,
2024     2,
2025   CINDEX,
2026   GC_cur, /* s: edge edge[-1]_pos edge_pos */
2027   GT, /* edge_pos < edge[-1]_pos */
2028   IF,
2029     DUP,
2030     ALIGNRP, /* align `edge' to `edge[-1]' */
2031   EIF,
2032
2033   MDAP_noround, /* set rp0 and rp1 to `edge' */
2034
2035   PUSHB_2,
2036     bci_align_segments,
2037     1,
2038   SZP1, /* set zp1 to normal zone 1 */
2039   CALL,
2040
2041   PUSHB_1,
2042     sal_edge2,
2043   RS,
2044   MDAP_noround, /* set rp0 and rp1 to `edge2' */
2045
2046   PUSHB_1,
2047     bci_align_segments,
2048   CALL,
2049
2050   ENDF,
2051
2052 };
2053
2054
2055 /*
2056  * bci_action_stem
2057  *
2058  *   Handle the STEM action to align two edges of a stem.
2059  *
2060  *   See `bci_action_stem_bound' for more details.
2061  *
2062  * in: edge2_is_serif
2063  *     edge_is_round
2064  *     edge_point (in twilight zone)
2065  *     edge2_point (in twilight zone)
2066  *     ... stuff for bci_align_segments (edge) ...
2067  *     ... stuff for bci_align_segments (edge2)...
2068  *
2069  * sal: sal_anchor
2070  *      sal_temp1
2071  *      sal_temp2
2072  *      sal_temp3
2073  *
2074  * uses: bci_action_stem_common
2075  */
2076
2077 unsigned char FPGM(bci_action_stem) [] = {
2078
2079   PUSHB_1,
2080     bci_action_stem,
2081   FDEF,
2082
2083   PUSHB_1,
2084     bci_action_stem_common,
2085   CALL,
2086
2087   POP,
2088   SWAP, /* s: cur_len edge2 */
2089   DUP,
2090   DUP,
2091   ALIGNRP, /* align `edge2' with rp0 (still `edge') */
2092   PUSHB_1,
2093     sal_edge2,
2094   SWAP,
2095   WS, /* s: cur_len edge2 */
2096   SWAP,
2097   SHPIX, /* edge2 = edge + cur_len */
2098
2099   PUSHB_2,
2100     bci_align_segments,
2101     1,
2102   SZP1, /* set zp1 to normal zone 1 */
2103   CALL,
2104
2105   PUSHB_1,
2106     sal_edge2,
2107   RS,
2108   MDAP_noround, /* set rp0 and rp1 to `edge2' */
2109
2110   PUSHB_1,
2111     bci_align_segments,
2112   CALL,
2113   ENDF,
2114
2115 };
2116
2117
2118 /*
2119  * bci_action_link
2120  *
2121  *   Handle the LINK action to link an edge to another one.
2122  *
2123  * in: stem_is_serif
2124  *     base_is_round
2125  *     base_point (in twilight zone)
2126  *     stem_point (in twilight zone)
2127  *     ... stuff for bci_align_segments (base) ...
2128  */
2129
2130 unsigned char FPGM(bci_action_link) [] = {
2131
2132   PUSHB_1,
2133     bci_action_link,
2134   FDEF,
2135
2136   PUSHB_1,
2137     0,
2138   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2139
2140   PUSHB_1,
2141     4,
2142   CINDEX,
2143   PUSHB_1,
2144     4,
2145   MINDEX,
2146   DUP, /* s: stem is_round is_serif stem base base */
2147   MDAP_noround, /* set rp0 and rp1 to `base_point' (for ALIGNRP below) */
2148
2149   MD_orig_ZP2_0, /* s: stem is_round is_serif dist_orig */
2150
2151   PUSHB_1,
2152     bci_compute_stem_width,
2153   CALL, /* s: stem new_dist */
2154
2155   SWAP,
2156   DUP,
2157   ALIGNRP, /* align `stem_point' with `base_point' */
2158   DUP,
2159   MDAP_noround, /* set rp0 and rp1 to `stem_point' */
2160   SWAP,
2161   SHPIX, /* stem_point = base_point + new_dist */
2162
2163   PUSHB_2,
2164     bci_align_segments,
2165     1,
2166   SZP1, /* set zp1 to normal zone 1 */
2167   CALL,
2168
2169   ENDF,
2170
2171 };
2172
2173
2174 /*
2175  * bci_action_anchor
2176  *
2177  *   Handle the ANCHOR action to align two edges
2178  *   and to set the edge anchor.
2179  *
2180  *   The code after computing `cur_len' to shift `edge' and `edge2'
2181  *   is equivalent to the snippet below (part of `ta_latin_hint_edges'):
2182  *
2183  *      if cur_len < 96:
2184  *        if cur_len < = 64:
2185  *          u_off = 32
2186  *          d_off = 32
2187  *        else:
2188  *          u_off = 38
2189  *          d_off = 26
2190  *
2191  *        org_center = edge_orig + org_len / 2
2192  *        cur_pos1 = ROUND(org_center)
2193  *
2194  *        error1 = ABS(org_center - (cur_pos1 - u_off))
2195  *        error2 = ABS(org_center - (cur_pos1 + d_off))
2196  *        if (error1 < error2):
2197  *          cur_pos1 = cur_pos1 - u_off
2198  *        else:
2199  *          cur_pos1 = cur_pos1 + d_off
2200  *
2201  *        edge = cur_pos1 - cur_len / 2
2202  *        edge2 = edge + cur_len
2203  *
2204  *      else:
2205  *        edge = ROUND(edge_orig)
2206  *
2207  * in: edge2_is_serif
2208  *     edge_is_round
2209  *     edge_point (in twilight zone)
2210  *     edge2_point (in twilight zone)
2211  *     ... stuff for bci_align_segments (edge) ...
2212  *
2213  * sal: sal_anchor
2214  *      sal_temp1
2215  *      sal_temp2
2216  *      sal_temp3
2217  */
2218
2219 #undef sal_u_off
2220 #define sal_u_off sal_temp1
2221 #undef sal_d_off
2222 #define sal_d_off sal_temp2
2223 #undef sal_org_len
2224 #define sal_org_len sal_temp3
2225
2226 unsigned char FPGM(bci_action_anchor) [] = {
2227
2228   PUSHB_1,
2229     bci_action_anchor,
2230   FDEF,
2231
2232   /* store anchor point number in `sal_anchor' */
2233   PUSHB_2,
2234     sal_anchor,
2235     4,
2236   CINDEX,
2237   WS, /* sal_anchor = edge_point */
2238
2239   PUSHB_1,
2240     0,
2241   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2242
2243   PUSHB_1,
2244     4,
2245   CINDEX,
2246   PUSHB_1,
2247     4,
2248   CINDEX,
2249   DUP, /* s: edge2 edge is_round is_serif edge2 edge edge */
2250   MDAP_noround, /* set rp0 and rp1 to `edge_point' (for ALIGNRP below) */
2251
2252   MD_orig_ZP2_0, /* s: edge2 edge is_round is_serif org_len */
2253   DUP,
2254   PUSHB_1,
2255     sal_org_len,
2256   SWAP,
2257   WS,
2258
2259   PUSHB_1,
2260     bci_compute_stem_width,
2261   CALL, /* s: edge2 edge cur_len */
2262
2263   DUP,
2264   PUSHB_1,
2265     96,
2266   LT, /* cur_len < 96 */
2267   IF,
2268     DUP,
2269     PUSHB_1,
2270       64,
2271     LTEQ, /* cur_len <= 64 */
2272     IF,
2273       PUSHB_4,
2274         sal_u_off,
2275         32,
2276         sal_d_off,
2277         32,
2278
2279     ELSE,
2280       PUSHB_4,
2281         sal_u_off,
2282         38,
2283         sal_d_off,
2284         26,
2285     EIF,
2286     WS,
2287     WS,
2288
2289     SWAP, /* s: edge2 cur_len edge */
2290     DUP, /* s: edge2 cur_len edge edge */
2291
2292     GC_orig,
2293     PUSHB_1,
2294       sal_org_len,
2295     RS,
2296     PUSHB_1,
2297       2*64,
2298     DIV,
2299     ADD, /* s: edge2 cur_len edge org_center */
2300
2301     DUP,
2302     PUSHB_1,
2303       bci_round,
2304     CALL, /* s: edge2 cur_len edge org_center cur_pos1 */
2305
2306     DUP,
2307     ROLL,
2308     ROLL,
2309     SUB, /* s: edge2 cur_len edge cur_pos1 (org_center - cur_pos1) */
2310
2311     DUP,
2312     PUSHB_1,
2313       sal_u_off,
2314     RS,
2315     ADD,
2316     ABS, /* s: edge2 cur_len edge cur_pos1 (org_center - cur_pos1) error1 */
2317
2318     SWAP,
2319     PUSHB_1,
2320       sal_d_off,
2321     RS,
2322     SUB,
2323     ABS, /* s: edge2 cur_len edge cur_pos1 error1 error2 */
2324
2325     LT, /* error1 < error2 */
2326     IF,
2327       PUSHB_1,
2328         sal_u_off,
2329       RS,
2330       SUB, /* cur_pos1 = cur_pos1 - u_off */
2331
2332     ELSE,
2333       PUSHB_1,
2334         sal_d_off,
2335       RS,
2336       ADD, /* cur_pos1 = cur_pos1 + d_off */
2337     EIF, /* s: edge2 cur_len edge cur_pos1 */
2338
2339     PUSHB_1,
2340       3,
2341     CINDEX,
2342     PUSHB_1,
2343       2*64,
2344     DIV,
2345     SUB, /* s: edge2 cur_len edge (cur_pos1 - cur_len/2) */
2346
2347     PUSHB_1,
2348       2,
2349     CINDEX, /* s: edge2 cur_len edge (cur_pos1 - cur_len/2) edge */
2350     GC_cur,
2351     SUB,
2352     SHPIX, /* edge = cur_pos1 - cur_len/2 */
2353
2354     SWAP, /* s: cur_len edge2 */
2355     DUP,
2356     ALIGNRP, /* align `edge2' with rp0 (still `edge') */
2357     SWAP,
2358     SHPIX, /* edge2 = edge1 + cur_len */
2359
2360   ELSE,
2361     POP, /* s: edge2 edge */
2362     DUP,
2363     DUP,
2364     GC_cur,
2365     SWAP,
2366     GC_orig,
2367     PUSHB_1,
2368       bci_round,
2369     CALL, /* s: edge2 edge edge_pos round(edge_orig_pos) */
2370     SWAP,
2371     SUB,
2372     SHPIX, /* edge = round(edge_orig) */
2373
2374     /* clean up stack */
2375     POP,
2376   EIF,
2377
2378   PUSHB_2,
2379     bci_align_segments,
2380     1,
2381   SZP1, /* set zp1 to normal zone 1 */
2382   CALL,
2383
2384   ENDF,
2385
2386 };
2387
2388
2389 /*
2390  * bci_action_blue_anchor
2391  *
2392  *   Handle the BLUE_ANCHOR action to align an edge with a blue zone
2393  *   and to set the edge anchor.
2394  *
2395  * in: anchor_point (in twilight zone)
2396  *     blue_cvt_idx
2397  *     edge_point (in twilight zone)
2398  *     ... stuff for bci_align_segments (edge) ...
2399  *
2400  * sal: sal_anchor
2401  *
2402  * uses: bci_action_blue
2403  */
2404
2405 unsigned char FPGM(bci_action_blue_anchor) [] = {
2406
2407   PUSHB_1,
2408     bci_action_blue_anchor,
2409   FDEF,
2410
2411   /* store anchor point number in `sal_anchor' */
2412   PUSHB_1,
2413     sal_anchor,
2414   SWAP,
2415   WS,
2416
2417   PUSHB_1,
2418     bci_action_blue,
2419   CALL,
2420
2421   ENDF,
2422
2423 };
2424
2425
2426 /*
2427  * bci_action_blue
2428  *
2429  *   Handle the BLUE action to align an edge with a blue zone.
2430  *
2431  * in: blue_cvt_idx
2432  *     edge_point (in twilight zone)
2433  *     ... stuff for bci_align_segments (edge) ...
2434  */
2435
2436 unsigned char FPGM(bci_action_blue) [] = {
2437
2438   PUSHB_1,
2439     bci_action_blue,
2440   FDEF,
2441
2442   PUSHB_1,
2443     0,
2444   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2445
2446   /* move `edge_point' to `blue_cvt_idx' position; */
2447   /* note that we can't use MIAP since this would modify */
2448   /* the twilight point's original coordinates also */
2449   RCVT,
2450   SWAP,
2451   DUP,
2452   MDAP_noround, /* set rp0 and rp1 to `edge' */
2453   DUP,
2454   GC_cur, /* s: new_pos edge edge_pos */
2455   ROLL,
2456   SWAP,
2457   SUB, /* s: edge (new_pos - edge_pos) */
2458   SHPIX,
2459
2460   PUSHB_2,
2461     bci_align_segments,
2462     1,
2463   SZP1, /* set zp1 to normal zone 1 */
2464   CALL,
2465
2466   ENDF,
2467
2468 };
2469
2470
2471 /*
2472  * bci_action_serif_common
2473  *
2474  *   Common code for bci_action_serif routines.
2475  */
2476
2477 unsigned char FPGM(bci_action_serif_common) [] = {
2478
2479   PUSHB_1,
2480     bci_action_serif_common,
2481   FDEF,
2482
2483   PUSHB_1,
2484     0,
2485   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2486
2487   DUP,
2488   DUP,
2489   DUP,
2490   PUSHB_1,
2491     5,
2492   MINDEX, /* s: [...] serif serif serif serif base */
2493   DUP,
2494   MDAP_noround, /* set rp0 and rp1 to `base_point' */
2495   MD_orig_ZP2_0,
2496   SWAP,
2497   ALIGNRP, /* align `serif_point' with `base_point' */
2498   SHPIX, /* serif = base + (serif_orig_pos - base_orig_pos) */
2499
2500   ENDF,
2501
2502 };
2503
2504
2505 /*
2506  * bci_lower_bound
2507  *
2508  *   Move an edge if necessary to stay within a lower bound.
2509  *
2510  * in: edge
2511  *     bound
2512  */
2513
2514 unsigned char FPGM(bci_lower_bound) [] = {
2515
2516   PUSHB_1,
2517     bci_lower_bound,
2518   FDEF,
2519
2520   SWAP, /* s: edge bound */
2521   DUP,
2522   MDAP_noround, /* set rp0 and rp1 to `bound' */
2523   GC_cur,
2524   PUSHB_1,
2525     2,
2526   CINDEX,
2527   GC_cur, /* s: edge bound_pos edge_pos */
2528   GT, /* edge_pos < bound_pos */
2529   IF,
2530     DUP,
2531     ALIGNRP, /* align `edge' to `bound' */
2532   EIF,
2533
2534   MDAP_noround, /* set rp0 and rp1 to `edge_point' */
2535
2536   PUSHB_2,
2537     bci_align_segments,
2538     1,
2539   SZP1, /* set zp1 to normal zone 1 */
2540   CALL,
2541
2542   ENDF,
2543
2544 };
2545
2546
2547 /*
2548  * bci_upper_bound
2549  *
2550  *   Move an edge if necessary to stay within an upper bound.
2551  *
2552  * in: edge
2553  *     bound
2554  */
2555
2556 unsigned char FPGM(bci_upper_bound) [] = {
2557
2558   PUSHB_1,
2559     bci_upper_bound,
2560   FDEF,
2561
2562   SWAP, /* s: edge bound */
2563   DUP,
2564   MDAP_noround, /* set rp0 and rp1 to `bound' */
2565   GC_cur,
2566   PUSHB_1,
2567     2,
2568   CINDEX,
2569   GC_cur, /* s: edge bound_pos edge_pos */
2570   LT, /* edge_pos > bound_pos */
2571   IF,
2572     DUP,
2573     ALIGNRP, /* align `edge' to `bound' */
2574   EIF,
2575
2576   MDAP_noround, /* set rp0 and rp1 to `edge_point' */
2577
2578   PUSHB_2,
2579     bci_align_segments,
2580     1,
2581   SZP1, /* set zp1 to normal zone 1 */
2582   CALL,
2583
2584   ENDF,
2585
2586 };
2587
2588
2589 /*
2590  * bci_lower_upper_bound
2591  *
2592  *   Move an edge if necessary to stay within a lower and lower bound.
2593  *
2594  * in: edge
2595  *     lower
2596  *     upper
2597  */
2598
2599 unsigned char FPGM(bci_lower_upper_bound) [] = {
2600
2601   PUSHB_1,
2602     bci_lower_upper_bound,
2603   FDEF,
2604
2605   SWAP, /* s: upper serif lower */
2606   DUP,
2607   MDAP_noround, /* set rp0 and rp1 to `lower' */
2608   GC_cur,
2609   PUSHB_1,
2610     2,
2611   CINDEX,
2612   GC_cur, /* s: upper serif lower_pos serif_pos */
2613   GT, /* serif_pos < lower_pos */
2614   IF,
2615     DUP,
2616     ALIGNRP, /* align `serif' to `lower' */
2617   EIF,
2618
2619   SWAP, /* s: serif upper */
2620   DUP,
2621   MDAP_noround, /* set rp0 and rp1 to `upper' */
2622   GC_cur,
2623   PUSHB_1,
2624     2,
2625   CINDEX,
2626   GC_cur, /* s: serif upper_pos serif_pos */
2627   LT, /* serif_pos > upper_pos */
2628   IF,
2629     DUP,
2630     ALIGNRP, /* align `serif' to `upper' */
2631   EIF,
2632
2633   MDAP_noround, /* set rp0 and rp1 to `serif_point' */
2634
2635   PUSHB_2,
2636     bci_align_segments,
2637     1,
2638   SZP1, /* set zp1 to normal zone 1 */
2639   CALL,
2640
2641   ENDF,
2642
2643 };
2644
2645
2646 /*
2647  * bci_action_serif
2648  *
2649  *   Handle the SERIF action to align a serif with its base.
2650  *
2651  * in: serif_point (in twilight zone)
2652  *     base_point (in twilight zone)
2653  *     ... stuff for bci_align_segments (serif) ...
2654  *
2655  * uses: bci_action_serif_common
2656  */
2657
2658 unsigned char FPGM(bci_action_serif) [] = {
2659
2660   PUSHB_1,
2661     bci_action_serif,
2662   FDEF,
2663
2664   PUSHB_1,
2665     bci_action_serif_common,
2666   CALL,
2667
2668   MDAP_noround, /* set rp0 and rp1 to `serif_point' */
2669
2670   PUSHB_2,
2671     bci_align_segments,
2672     1,
2673   SZP1, /* set zp1 to normal zone 1 */
2674   CALL,
2675
2676   ENDF,
2677
2678 };
2679
2680
2681 /*
2682  * bci_action_serif_lower_bound
2683  *
2684  *   Handle the SERIF action to align a serif with its base, then moving it
2685  *   again if necessary to stay within a lower bound.
2686  *
2687  * in: serif_point (in twilight zone)
2688  *     base_point (in twilight zone)
2689  *     edge[-1] (in twilight zone)
2690  *     ... stuff for bci_align_segments (serif) ...
2691  *
2692  * uses: bci_action_serif_common
2693  *       bci_lower_bound
2694  */
2695
2696 unsigned char FPGM(bci_action_serif_lower_bound) [] = {
2697
2698   PUSHB_1,
2699     bci_action_serif_lower_bound,
2700   FDEF,
2701
2702   PUSHB_1,
2703     bci_action_serif_common,
2704   CALL,
2705
2706   PUSHB_1,
2707     bci_lower_bound,
2708   CALL,
2709
2710   ENDF,
2711
2712 };
2713
2714
2715 /*
2716  * bci_action_serif_upper_bound
2717  *
2718  *   Handle the SERIF action to align a serif with its base, then moving it
2719  *   again if necessary to stay within an upper bound.
2720  *
2721  * in: serif_point (in twilight zone)
2722  *     base_point (in twilight zone)
2723  *     edge[1] (in twilight zone)
2724  *     ... stuff for bci_align_segments (serif) ...
2725  *
2726  * uses: bci_action_serif_common
2727  *       bci_upper_bound
2728  */
2729
2730 unsigned char FPGM(bci_action_serif_upper_bound) [] = {
2731
2732   PUSHB_1,
2733     bci_action_serif_upper_bound,
2734   FDEF,
2735
2736   PUSHB_1,
2737     bci_action_serif_common,
2738   CALL,
2739
2740   PUSHB_1,
2741     bci_upper_bound,
2742   CALL,
2743
2744   ENDF,
2745
2746 };
2747
2748
2749 /*
2750  * bci_action_serif_lower_upper_bound
2751  *
2752  *   Handle the SERIF action to align a serif with its base, then moving it
2753  *   again if necessary to stay within a lower and upper bound.
2754  *
2755  * in: serif_point (in twilight zone)
2756  *     base_point (in twilight zone)
2757  *     edge[-1] (in twilight zone)
2758  *     edge[1] (in twilight zone)
2759  *     ... stuff for bci_align_segments (serif) ...
2760  *
2761  * uses: bci_action_serif_common
2762  *       bci_lower_upper_bound
2763  */
2764
2765 unsigned char FPGM(bci_action_serif_lower_upper_bound) [] = {
2766
2767   PUSHB_1,
2768     bci_action_serif_lower_upper_bound,
2769   FDEF,
2770
2771   PUSHB_1,
2772     0,
2773   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2774
2775   PUSHB_1,
2776     bci_action_serif_common,
2777   CALL,
2778
2779   PUSHB_1,
2780     bci_lower_upper_bound,
2781   CALL,
2782
2783   ENDF,
2784
2785 };
2786
2787
2788 /*
2789  * bci_action_serif_anchor_common
2790  *
2791  *   Common code for bci_action_serif_anchor routines.
2792  */
2793
2794 unsigned char FPGM(bci_action_serif_anchor_common) [] = {
2795
2796   PUSHB_1,
2797     bci_action_serif_anchor_common,
2798   FDEF,
2799
2800   PUSHB_1,
2801     0,
2802   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2803
2804   DUP,
2805   PUSHB_1,
2806     sal_anchor,
2807   SWAP,
2808   WS, /* sal_anchor = edge_point */
2809
2810   DUP,
2811   DUP,
2812   DUP,
2813   GC_cur,
2814   SWAP,
2815   GC_orig,
2816   PUSHB_1,
2817     bci_round,
2818   CALL, /* s: [...] edge edge edge_pos round(edge_orig_pos) */
2819   SWAP,
2820   SUB,
2821   SHPIX, /* edge = round(edge_orig) */
2822
2823   ENDF,
2824
2825 };
2826
2827
2828 /*
2829  * bci_action_serif_anchor
2830  *
2831  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
2832  *   anchor.
2833  *
2834  * in: edge_point (in twilight zone)
2835  *     ... stuff for bci_align_segments (edge) ...
2836  *
2837  * uses: bci_action_serif_anchor_common
2838  */
2839
2840 unsigned char FPGM(bci_action_serif_anchor) [] = {
2841
2842   PUSHB_1,
2843     bci_action_serif_anchor,
2844   FDEF,
2845
2846   PUSHB_1,
2847     bci_action_serif_anchor_common,
2848   CALL,
2849
2850   MDAP_noround, /* set rp0 and rp1 to `edge' */
2851
2852   PUSHB_2,
2853     bci_align_segments,
2854     1,
2855   SZP1, /* set zp1 to normal zone 1 */
2856   CALL,
2857
2858   ENDF,
2859
2860 };
2861
2862
2863 /*
2864  * bci_action_serif_anchor_lower_bound
2865  *
2866  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
2867  *   anchor, then moving it again if necessary to stay within a lower
2868  *   bound.
2869  *
2870  * in: edge_point (in twilight zone)
2871  *     edge[-1] (in twilight zone)
2872  *     ... stuff for bci_align_segments (edge) ...
2873  *
2874  * uses: bci_action_serif_anchor_common
2875  *       bci_lower_bound
2876  */
2877
2878 unsigned char FPGM(bci_action_serif_anchor_lower_bound) [] = {
2879
2880   PUSHB_1,
2881     bci_action_serif_anchor_lower_bound,
2882   FDEF,
2883
2884   PUSHB_1,
2885     bci_action_serif_anchor_common,
2886   CALL,
2887
2888   PUSHB_1,
2889     bci_lower_bound,
2890   CALL,
2891
2892   ENDF,
2893
2894 };
2895
2896
2897 /*
2898  * bci_action_serif_anchor_upper_bound
2899  *
2900  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
2901  *   anchor, then moving it again if necessary to stay within an upper
2902  *   bound.
2903  *
2904  * in: edge_point (in twilight zone)
2905  *     edge[1] (in twilight zone)
2906  *     ... stuff for bci_align_segments (edge) ...
2907  *
2908  * uses: bci_action_serif_anchor_common
2909  *       bci_upper_bound
2910  */
2911
2912 unsigned char FPGM(bci_action_serif_anchor_upper_bound) [] = {
2913
2914   PUSHB_1,
2915     bci_action_serif_anchor_upper_bound,
2916   FDEF,
2917
2918   PUSHB_1,
2919     bci_action_serif_anchor_common,
2920   CALL,
2921
2922   PUSHB_1,
2923     bci_upper_bound,
2924   CALL,
2925
2926   ENDF,
2927
2928 };
2929
2930
2931 /*
2932  * bci_action_serif_anchor_lower_upper_bound
2933  *
2934  *   Handle the SERIF_ANCHOR action to align a serif and to set the edge
2935  *   anchor, then moving it again if necessary to stay within a lower and
2936  *   upper bound.
2937  *
2938  * in: edge_point (in twilight zone)
2939  *     edge[-1] (in twilight zone)
2940  *     edge[1] (in twilight zone)
2941  *     ... stuff for bci_align_segments (edge) ...
2942  *
2943  * uses: bci_action_serif_anchor_common
2944  *       bci_lower_upper_bound
2945  */
2946
2947 unsigned char FPGM(bci_action_serif_anchor_lower_upper_bound) [] = {
2948
2949   PUSHB_1,
2950     bci_action_serif_anchor_lower_upper_bound,
2951   FDEF,
2952
2953   PUSHB_1,
2954     bci_action_serif_anchor_common,
2955   CALL,
2956
2957   PUSHB_1,
2958     bci_lower_upper_bound,
2959   CALL,
2960
2961   ENDF,
2962
2963 };
2964
2965
2966 /*
2967  * bci_action_serif_link1_common
2968  *
2969  *   Common code for bci_action_serif_link1 routines.
2970  */
2971
2972 unsigned char FPGM(bci_action_serif_link1_common) [] = {
2973
2974   PUSHB_1,
2975     bci_action_serif_link1_common,
2976   FDEF,
2977
2978   PUSHB_1,
2979     0,
2980   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
2981
2982   PUSHB_1,
2983     3,
2984   CINDEX, /* s: [...] after edge before after */
2985   PUSHB_1,
2986     2,
2987   CINDEX, /* s: [...] after edge before after before */
2988   MD_orig_ZP2_0,
2989   PUSHB_1,
2990     0,
2991   EQ, /* after_orig_pos == before_orig_pos */
2992   IF, /* s: [...] after edge before */
2993     MDAP_noround, /* set rp0 and rp1 to `before' */
2994     DUP,
2995     ALIGNRP, /* align `edge' with `before' */
2996     SWAP,
2997     POP,
2998
2999   ELSE,
3000     PUSHB_1,
3001       2,
3002     CINDEX, /* s: [...] after edge before edge */
3003     PUSHB_1,
3004       2,
3005     CINDEX, /* s: [...] after edge before edge before */
3006     MD_orig_ZP2_0, /* a = edge_orig_pos - before_orig_pos */
3007     PUSHW_1,
3008       0x10, /* 64*64 */
3009       0x00,
3010     MUL,
3011
3012     PUSHB_1,
3013       4,
3014     CINDEX, /* s: [...] after edge before a*64 after */
3015     PUSHB_1,
3016       3,
3017     CINDEX, /* s: [...] after edge before a*64 after before */
3018     MD_cur, /* b = after_pos - before_pos */
3019     MUL, /* s: [...] after edge before a*b */
3020
3021     PUSHB_1,
3022       4,
3023     CINDEX, /* s: [...] after edge before a*b after */
3024     PUSHB_1,
3025       3,
3026     CINDEX, /* s: [...] after edge before a*b after before */
3027     MD_orig_ZP2_0, /* c = after_orig_pos - before_orig_pos */
3028     PUSHW_1,
3029       0x10, /* 64*64 */
3030       0x00,
3031     MUL,
3032
3033     DIV, /* s: [...] after edge before a*b/c */
3034
3035     SWAP,
3036     MDAP_noround, /* set rp0 and rp1 to `before' */
3037     SWAP, /* s: [...] after a*b/c edge */
3038     DUP,
3039     DUP,
3040     ALIGNRP, /* align `edge' with `before' */
3041     ROLL,
3042     SHPIX, /* shift `edge' by `a*b/c' */
3043
3044     SWAP, /* s: [...] edge after */
3045     POP,
3046   EIF,
3047
3048   ENDF,
3049
3050 };
3051
3052
3053 /*
3054  * bci_action_serif_link1
3055  *
3056  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
3057  *   before and after.
3058  *
3059  * in: before_point (in twilight zone)
3060  *     edge_point (in twilight zone)
3061  *     after_point (in twilight zone)
3062  *     ... stuff for bci_align_segments (edge) ...
3063  *
3064  * uses: bci_action_serif_link1_common
3065  */
3066
3067 unsigned char FPGM(bci_action_serif_link1) [] = {
3068
3069   PUSHB_1,
3070     bci_action_serif_link1,
3071   FDEF,
3072
3073   PUSHB_1,
3074     bci_action_serif_link1_common,
3075   CALL,
3076
3077   MDAP_noround, /* set rp0 and rp1 to `edge' */
3078
3079   PUSHB_2,
3080     bci_align_segments,
3081     1,
3082   SZP1, /* set zp1 to normal zone 1 */
3083   CALL,
3084
3085   ENDF,
3086
3087 };
3088
3089
3090 /*
3091  * bci_action_serif_link1_lower_bound
3092  *
3093  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
3094  *   before and after.  Additionally, move the serif again if necessary to
3095  *   stay within a lower bound.
3096  *
3097  * in: before_point (in twilight zone)
3098  *     edge_point (in twilight zone)
3099  *     after_point (in twilight zone)
3100  *     edge[-1] (in twilight zone)
3101  *     ... stuff for bci_align_segments (edge) ...
3102  *
3103  * uses: bci_action_serif_link1_common
3104  *       bci_lower_bound
3105  */
3106
3107 unsigned char FPGM(bci_action_serif_link1_lower_bound) [] = {
3108
3109   PUSHB_1,
3110     bci_action_serif_link1_lower_bound,
3111   FDEF,
3112
3113   PUSHB_1,
3114     bci_action_serif_link1_common,
3115   CALL,
3116
3117   PUSHB_1,
3118     bci_lower_bound,
3119   CALL,
3120
3121   ENDF,
3122
3123 };
3124
3125
3126 /*
3127  * bci_action_serif_link1_upper_bound
3128  *
3129  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
3130  *   before and after.  Additionally, move the serif again if necessary to
3131  *   stay within an upper bound.
3132  *
3133  * in: before_point (in twilight zone)
3134  *     edge_point (in twilight zone)
3135  *     after_point (in twilight zone)
3136  *     edge[1] (in twilight zone)
3137  *     ... stuff for bci_align_segments (edge) ...
3138  *
3139  * uses: bci_action_serif_link1_common
3140  *       bci_upper_bound
3141  */
3142
3143 unsigned char FPGM(bci_action_serif_link1_upper_bound) [] = {
3144
3145   PUSHB_1,
3146     bci_action_serif_link1_upper_bound,
3147   FDEF,
3148
3149   PUSHB_1,
3150     bci_action_serif_link1_common,
3151   CALL,
3152
3153   PUSHB_1,
3154     bci_upper_bound,
3155   CALL,
3156
3157   ENDF,
3158
3159 };
3160
3161
3162 /*
3163  * bci_action_serif_link1_lower_upper_bound
3164  *
3165  *   Handle the SERIF_LINK1 action to align a serif, depending on edges
3166  *   before and after.  Additionally, move the serif again if necessary to
3167  *   stay within a lower and upper bound.
3168  *
3169  * in: before_point (in twilight zone)
3170  *     edge_point (in twilight zone)
3171  *     after_point (in twilight zone)
3172  *     edge[-1] (in twilight zone)
3173  *     edge[1] (in twilight zone)
3174  *     ... stuff for bci_align_segments (edge) ...
3175  *
3176  * uses: bci_action_serif_link1_common
3177  *       bci_lower_upper_bound
3178  */
3179
3180 unsigned char FPGM(bci_action_serif_link1_lower_upper_bound) [] = {
3181
3182   PUSHB_1,
3183     bci_action_serif_link1_lower_upper_bound,
3184   FDEF,
3185
3186   PUSHB_1,
3187     bci_action_serif_link1_common,
3188   CALL,
3189
3190   PUSHB_1,
3191     bci_lower_upper_bound,
3192   CALL,
3193
3194   ENDF,
3195
3196 };
3197
3198
3199 /*
3200  * bci_action_serif_link2_common
3201  *
3202  *   Common code for bci_action_serif_link2 routines.
3203  */
3204
3205 unsigned char FPGM(bci_action_serif_link2_common) [] = {
3206
3207   PUSHB_1,
3208     bci_action_serif_link2_common,
3209   FDEF,
3210
3211   PUSHB_1,
3212     0,
3213   SZPS, /* set zp0, zp1, and zp2 to twilight zone 0 */
3214
3215   DUP, /* s: [...] edge edge */
3216   PUSHB_1,
3217     sal_anchor,
3218   RS,
3219   DUP, /* s: [...] edge edge anchor anchor */
3220   MDAP_noround, /* set rp0 and rp1 to `sal_anchor' */
3221
3222   MD_orig_ZP2_0,
3223   DUP,
3224   ADD,
3225   PUSHB_1,
3226     32,
3227   ADD,
3228   FLOOR,
3229   PUSHB_1,
3230     2*64,
3231   DIV, /* delta = (edge_orig_pos - anchor_orig_pos + 16) & ~31 */
3232
3233   SWAP,
3234   DUP,
3235   DUP,
3236   ALIGNRP, /* align `edge' with `sal_anchor' */
3237   ROLL,
3238   SHPIX, /* shift `edge' by `delta' */
3239
3240   ENDF,
3241
3242 };
3243
3244
3245 /*
3246  * bci_action_serif_link2
3247  *
3248  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3249  *
3250  * in: edge_point (in twilight zone)
3251  *     ... stuff for bci_align_segments (edge) ...
3252  *
3253  * uses: bci_action_serif_link2_common
3254  */
3255
3256 unsigned char FPGM(bci_action_serif_link2) [] = {
3257
3258   PUSHB_1,
3259     bci_action_serif_link2,
3260   FDEF,
3261
3262   PUSHB_1,
3263     bci_action_serif_link2_common,
3264   CALL,
3265
3266   MDAP_noround, /* set rp0 and rp1 to `edge' */
3267
3268   PUSHB_2,
3269     bci_align_segments,
3270     1,
3271   SZP1, /* set zp1 to normal zone 1 */
3272   CALL,
3273
3274   ENDF,
3275
3276 };
3277
3278
3279 /*
3280  * bci_action_serif_link2_lower_bound
3281  *
3282  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3283  *   Additionally, move the serif again if necessary to stay within a lower
3284  *   bound.
3285  *
3286  * in: edge_point (in twilight zone)
3287  *     edge[-1] (in twilight zone)
3288  *     ... stuff for bci_align_segments (edge) ...
3289  *
3290  * uses: bci_action_serif_link2_common
3291  *       bci_lower_bound
3292  */
3293
3294 unsigned char FPGM(bci_action_serif_link2_lower_bound) [] = {
3295
3296   PUSHB_1,
3297     bci_action_serif_link2_lower_bound,
3298   FDEF,
3299
3300   PUSHB_1,
3301     bci_action_serif_link2_common,
3302   CALL,
3303
3304   PUSHB_1,
3305     bci_lower_bound,
3306   CALL,
3307
3308   ENDF,
3309
3310 };
3311
3312
3313 /*
3314  * bci_action_serif_link2_upper_bound
3315  *
3316  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3317  *   Additionally, move the serif again if necessary to stay within an upper
3318  *   bound.
3319  *
3320  * in: edge_point (in twilight zone)
3321  *     edge[1] (in twilight zone)
3322  *     ... stuff for bci_align_segments (edge) ...
3323  *
3324  * uses: bci_action_serif_link2_common
3325  *       bci_upper_bound
3326  */
3327
3328 unsigned char FPGM(bci_action_serif_link2_upper_bound) [] = {
3329
3330   PUSHB_1,
3331     bci_action_serif_link2_upper_bound,
3332   FDEF,
3333
3334   PUSHB_1,
3335     bci_action_serif_link2_common,
3336   CALL,
3337
3338   PUSHB_1,
3339     bci_upper_bound,
3340   CALL,
3341
3342   ENDF,
3343
3344 };
3345
3346
3347 /*
3348  * bci_action_serif_link2_lower_upper_bound
3349  *
3350  *   Handle the SERIF_LINK2 action to align a serif relative to the anchor.
3351  *   Additionally, move the serif again if necessary to stay within a lower
3352  *   and upper bound.
3353  *
3354  * in: edge_point (in twilight zone)
3355  *     edge[-1] (in twilight zone)
3356  *     edge[1] (in twilight zone)
3357  *     ... stuff for bci_align_segments (edge) ...
3358  *
3359  * uses: bci_action_serif_link2_common
3360  *       bci_lower_upper_bound
3361  */
3362
3363 unsigned char FPGM(bci_action_serif_link2_lower_upper_bound) [] = {
3364
3365   PUSHB_1,
3366     bci_action_serif_link2_lower_upper_bound,
3367   FDEF,
3368
3369   PUSHB_1,
3370     bci_action_serif_link2_common,
3371   CALL,
3372
3373   PUSHB_1,
3374     bci_lower_upper_bound,
3375   CALL,
3376
3377   ENDF,
3378
3379 };
3380
3381
3382 /*
3383  * bci_handle_action
3384  *
3385  *   Execute function.
3386  *
3387  * in: function_index
3388  */
3389
3390 unsigned char FPGM(bci_handle_action) [] = {
3391
3392   PUSHB_1,
3393     bci_handle_action,
3394   FDEF,
3395
3396   CALL,
3397
3398   ENDF,
3399
3400 };
3401
3402
3403 /*
3404  * bci_hint_glyph
3405  *
3406  *   This is the top-level glyph hinting function
3407  *   which parses the arguments on the stack and calls subroutines.
3408  *
3409  * in: num_actions (M)
3410  *       action_0_func_idx
3411  *         ... data ...
3412  *       action_1_func_idx
3413  *         ... data ...
3414  *       ...
3415  *       action_M_func_idx
3416  *         ... data ...
3417  *
3418  * uses: bci_handle_action
3419  *
3420  *       bci_action_ip_before
3421  *       bci_action_ip_after
3422  *       bci_action_ip_on
3423  *       bci_action_ip_between
3424  *
3425  *       bci_action_adjust_bound
3426  *       bci_action_stem_bound
3427  *
3428  *       bci_action_link
3429  *       bci_action_anchor
3430  *       bci_action_blue_anchor
3431  *       bci_action_adjust
3432  *       bci_action_stem
3433  *       bci_action_blue
3434  *
3435  *       bci_action_serif
3436  *       bci_action_serif_lower_bound
3437  *       bci_action_serif_upper_bound
3438  *       bci_action_serif_lower_upper_bound
3439  *
3440  *       bci_action_serif_anchor
3441  *       bci_action_serif_anchor_lower_bound
3442  *       bci_action_serif_anchor_upper_bound
3443  *       bci_action_serif_anchor_lower_upper_bound
3444  *
3445  *       bci_action_serif_link1
3446  *       bci_action_serif_link1_lower_bound
3447  *       bci_action_serif_link1_upper_bound
3448  *       bci_action_serif_link1_lower_upper_bound
3449  *
3450  *       bci_action_serif_link2
3451  *       bci_action_serif_link2_lower_bound
3452  *       bci_action_serif_link2_upper_bound
3453  *       bci_action_serif_link2_lower_upper_bound
3454  */
3455
3456 unsigned char FPGM(bci_hint_glyph) [] = {
3457
3458   PUSHB_1,
3459     bci_hint_glyph,
3460   FDEF,
3461
3462   PUSHB_1,
3463     bci_handle_action,
3464   LOOPCALL,
3465
3466   PUSHB_1,
3467     1,
3468   SZP2, /* set zp2 to normal zone 1 */
3469   IUP_y,
3470
3471   ENDF,
3472
3473 };
3474
3475
3476 #define COPY_FPGM(func_name) \
3477           memcpy(buf_p, fpgm_ ## func_name, \
3478                  sizeof (fpgm_ ## func_name)); \
3479           buf_p += sizeof (fpgm_ ## func_name) \
3480
3481 static FT_Error
3482 TA_table_build_fpgm(FT_Byte** fpgm,
3483                     FT_ULong* fpgm_len,
3484                     FONT* font)
3485 {
3486   FT_UInt buf_len;
3487   FT_UInt len;
3488   FT_Byte* buf;
3489   FT_Byte* buf_p;
3490
3491
3492   buf_len = sizeof (FPGM(bci_round))
3493             + sizeof (FPGM(bci_compute_stem_width_a))
3494             + 1
3495             + sizeof (FPGM(bci_compute_stem_width_b))
3496             + 1
3497             + sizeof (FPGM(bci_compute_stem_width_c))
3498             + sizeof (FPGM(bci_loop))
3499             + sizeof (FPGM(bci_cvt_rescale))
3500             + sizeof (FPGM(bci_blue_round_a))
3501             + 1
3502             + sizeof (FPGM(bci_blue_round_b))
3503             + sizeof (FPGM(bci_get_point_extrema))
3504
3505             + sizeof (FPGM(bci_create_segment))
3506             + sizeof (FPGM(bci_create_segments))
3507             + sizeof (FPGM(bci_align_segment))
3508             + sizeof (FPGM(bci_align_segments))
3509
3510             + sizeof (FPGM(bci_scale_contour))
3511             + sizeof (FPGM(bci_scale_glyph))
3512             + sizeof (FPGM(bci_shift_contour))
3513             + sizeof (FPGM(bci_shift_subglyph))
3514
3515             + sizeof (FPGM(bci_ip_outer_align_point))
3516             + sizeof (FPGM(bci_ip_on_align_points))
3517             + sizeof (FPGM(bci_ip_between_align_point))
3518             + sizeof (FPGM(bci_ip_between_align_points))
3519
3520             + sizeof (FPGM(bci_action_adjust_common))
3521             + sizeof (FPGM(bci_action_stem_common))
3522             + sizeof (FPGM(bci_action_serif_common))
3523             + sizeof (FPGM(bci_action_serif_anchor_common))
3524             + sizeof (FPGM(bci_action_serif_link1_common))
3525             + sizeof (FPGM(bci_action_serif_link2_common))
3526
3527             + sizeof (FPGM(bci_lower_bound))
3528             + sizeof (FPGM(bci_upper_bound))
3529             + sizeof (FPGM(bci_lower_upper_bound))
3530
3531             + sizeof (FPGM(bci_action_ip_before))
3532             + sizeof (FPGM(bci_action_ip_after))
3533             + sizeof (FPGM(bci_action_ip_on))
3534             + sizeof (FPGM(bci_action_ip_between))
3535
3536             + sizeof (FPGM(bci_action_adjust_bound))
3537             + sizeof (FPGM(bci_action_stem_bound))
3538             + sizeof (FPGM(bci_action_link))
3539             + sizeof (FPGM(bci_action_anchor))
3540             + sizeof (FPGM(bci_action_blue_anchor))
3541             + sizeof (FPGM(bci_action_adjust))
3542             + sizeof (FPGM(bci_action_stem))
3543             + sizeof (FPGM(bci_action_blue))
3544             + sizeof (FPGM(bci_action_serif))
3545             + sizeof (FPGM(bci_action_serif_lower_bound))
3546             + sizeof (FPGM(bci_action_serif_upper_bound))
3547             + sizeof (FPGM(bci_action_serif_lower_upper_bound))
3548             + sizeof (FPGM(bci_action_serif_anchor))
3549             + sizeof (FPGM(bci_action_serif_anchor_lower_bound))
3550             + sizeof (FPGM(bci_action_serif_anchor_upper_bound))
3551             + sizeof (FPGM(bci_action_serif_anchor_lower_upper_bound))
3552             + sizeof (FPGM(bci_action_serif_link1))
3553             + sizeof (FPGM(bci_action_serif_link1_lower_bound))
3554             + sizeof (FPGM(bci_action_serif_link1_upper_bound))
3555             + sizeof (FPGM(bci_action_serif_link1_lower_upper_bound))
3556             + sizeof (FPGM(bci_action_serif_link2))
3557             + sizeof (FPGM(bci_action_serif_link2_lower_bound))
3558             + sizeof (FPGM(bci_action_serif_link2_upper_bound))
3559             + sizeof (FPGM(bci_action_serif_link2_lower_upper_bound))
3560
3561             + sizeof (FPGM(bci_handle_action))
3562             + sizeof (FPGM(bci_hint_glyph));
3563   /* buffer length must be a multiple of four */
3564   len = (buf_len + 3) & ~3;
3565   buf = (FT_Byte*)malloc(len);
3566   if (!buf)
3567     return FT_Err_Out_Of_Memory;
3568
3569   /* pad end of buffer with zeros */
3570   buf[len - 1] = 0x00;
3571   buf[len - 2] = 0x00;
3572   buf[len - 3] = 0x00;
3573
3574   /* copy font program into buffer and fill in the missing variables */
3575   buf_p = buf;
3576
3577   COPY_FPGM(bci_round);
3578   COPY_FPGM(bci_compute_stem_width_a);
3579   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
3580   COPY_FPGM(bci_compute_stem_width_b);
3581   *(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
3582   COPY_FPGM(bci_compute_stem_width_c);
3583   COPY_FPGM(bci_loop);
3584   COPY_FPGM(bci_cvt_rescale);
3585   COPY_FPGM(bci_blue_round_a);
3586   *(buf_p++) = (unsigned char)CVT_BLUES_SIZE(font);
3587   COPY_FPGM(bci_blue_round_b);
3588   COPY_FPGM(bci_get_point_extrema);
3589
3590   COPY_FPGM(bci_create_segment);
3591   COPY_FPGM(bci_create_segments);
3592   COPY_FPGM(bci_align_segment);
3593   COPY_FPGM(bci_align_segments);
3594
3595   COPY_FPGM(bci_scale_contour);
3596   COPY_FPGM(bci_scale_glyph);
3597   COPY_FPGM(bci_shift_contour);
3598   COPY_FPGM(bci_shift_subglyph);
3599
3600   COPY_FPGM(bci_ip_outer_align_point);
3601   COPY_FPGM(bci_ip_on_align_points);
3602   COPY_FPGM(bci_ip_between_align_point);
3603   COPY_FPGM(bci_ip_between_align_points);
3604
3605   COPY_FPGM(bci_action_adjust_common);
3606   COPY_FPGM(bci_action_stem_common);
3607   COPY_FPGM(bci_action_serif_common);
3608   COPY_FPGM(bci_action_serif_anchor_common);
3609   COPY_FPGM(bci_action_serif_link1_common);
3610   COPY_FPGM(bci_action_serif_link2_common);
3611
3612   COPY_FPGM(bci_lower_bound);
3613   COPY_FPGM(bci_upper_bound);
3614   COPY_FPGM(bci_lower_upper_bound);
3615
3616   COPY_FPGM(bci_action_ip_before);
3617   COPY_FPGM(bci_action_ip_after);
3618   COPY_FPGM(bci_action_ip_on);
3619   COPY_FPGM(bci_action_ip_between);
3620
3621   COPY_FPGM(bci_action_adjust_bound);
3622   COPY_FPGM(bci_action_stem_bound);
3623   COPY_FPGM(bci_action_link);
3624   COPY_FPGM(bci_action_anchor);
3625   COPY_FPGM(bci_action_blue_anchor);
3626   COPY_FPGM(bci_action_adjust);
3627   COPY_FPGM(bci_action_stem);
3628   COPY_FPGM(bci_action_blue);
3629   COPY_FPGM(bci_action_serif);
3630   COPY_FPGM(bci_action_serif_lower_bound);
3631   COPY_FPGM(bci_action_serif_upper_bound);
3632   COPY_FPGM(bci_action_serif_lower_upper_bound);
3633   COPY_FPGM(bci_action_serif_anchor);
3634   COPY_FPGM(bci_action_serif_anchor_lower_bound);
3635   COPY_FPGM(bci_action_serif_anchor_upper_bound);
3636   COPY_FPGM(bci_action_serif_anchor_lower_upper_bound);
3637   COPY_FPGM(bci_action_serif_link1);
3638   COPY_FPGM(bci_action_serif_link1_lower_bound);
3639   COPY_FPGM(bci_action_serif_link1_upper_bound);
3640   COPY_FPGM(bci_action_serif_link1_lower_upper_bound);
3641   COPY_FPGM(bci_action_serif_link2);
3642   COPY_FPGM(bci_action_serif_link2_lower_bound);
3643   COPY_FPGM(bci_action_serif_link2_upper_bound);
3644   COPY_FPGM(bci_action_serif_link2_lower_upper_bound);
3645
3646   COPY_FPGM(bci_handle_action);
3647   COPY_FPGM(bci_hint_glyph);
3648
3649   *fpgm = buf;
3650   *fpgm_len = buf_len;
3651
3652   return FT_Err_Ok;
3653 }
3654
3655
3656 FT_Error
3657 TA_sfnt_build_fpgm_table(SFNT* sfnt,
3658                          FONT* font)
3659 {
3660   FT_Error error;
3661
3662   FT_Byte* fpgm_buf;
3663   FT_ULong fpgm_len;
3664
3665
3666   error = TA_sfnt_add_table_info(sfnt);
3667   if (error)
3668     return error;
3669
3670   error = TA_table_build_fpgm(&fpgm_buf, &fpgm_len, font);
3671   if (error)
3672     return error;
3673
3674   if (fpgm_len > sfnt->max_instructions)
3675     sfnt->max_instructions = fpgm_len;
3676
3677   /* in case of success, `fpgm_buf' gets linked */
3678   /* and is eventually freed in `TA_font_unload' */
3679   error = TA_font_add_table(font,
3680                             &sfnt->table_infos[sfnt->num_table_infos - 1],
3681                             TTAG_fpgm, fpgm_len, fpgm_buf);
3682   if (error)
3683   {
3684     free(fpgm_buf);
3685     return error;
3686   }
3687
3688   return FT_Err_Ok;
3689 }
3690
3691 /* end of tafpgm.c */