src/tabytecode.c

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