|
|
/***
**** Module: ttprog**** Description:** This is a module of the T1 to TT font converter. This is a** sub-module of Hint module. This modules deals with the ** the font program fo the font.**** Author: Michael Jansson**** Created: 8/24/93*****/
/**** INCLUDES *//* General types and definitions. */#include <limits.h>
/* Special types and definitions. */#include "titott.h"
#include "types.h"
#include "safemem.h"
#include "metrics.h"
#include "t1msg.h"
/* Module dependent types and prototypes. *//*#include "hints.h"*/#include "ttprog.h"
/***** MACROS *//*-none-*/
/***** CONSTANTS */#define MAXIP 100
#define CURVEPHASE 6
#define MAXTHINPNTS 512
#define UNDEF -1
#define SMALL_LOWER 21L
#define SMALL_UPPER 50L
#define LARGE_LOWER 21L
#define LARGE_UPPER 21L
#define BUFSIZE 20
#define TTFUN_SET_ZONE 1
#define TTFUN_COPY_ZONE 2
#define TTFUN_STEM_SNAP_WIDTH 3
#define TTFUN_STEM_STD_WIDTH 4
#define TTFUN_SHIFT_BLUE_ZONE 5
#define TTFUN_ALIGN_BLUE_ZONE 6
#define TTFUN_COPY_FAMILY 7
#define TTFUN_WRITE_STEM 8
#define TTFUN_VERTICAL 9
#define TTFUN_HORIZONTAL 10
#define TTFUN_VCENTER 11
#define TTFUN_HCENTER 12
#define TTFUN_RELATIVE1V 13
#define TTFUN_RELATIVE2V 14
#define TTFUN_RELATIVE1H 15
#define TTFUN_RELATIVE2H 16
#define TTFUN_SIDE1 17
#define TTFUN_SIDE2 18
#define TTFUN_FLEX 19
#define TTFUN_SCALE3 20
#define TTFUN_SHIFT1 21
#define TTFUN_SHIFT2 22
#define TTFUN_IP1 23
#define TTFUN_IP2 24
#define TTFUN_IPN 25
#define TTFUN_SHP1 26
#define TTFUN_SHP2 27
#define TTFUN_SHPN 28
#define TTFUN_RANGE 29
#define TTFUN_OBLIQUE 30
#define TTFUN_NUM 31 /* 1..30 */
#define FDEF(name) op_pushb1, name, op_fdef,
#define ENDF op_endf,
#define CALL(name) op_pushb1, name, op_call
#define WCVT(name) op_pushb1, name, op_swap, op_wcvtf
#define PUSH1(v) op_pushb1, (v)
#define PUSH2(v1, v2) op_pushb1+1, (v1), (v2)
#define PUSH3(v1, v2, v3) op_pushb1+2, (v1), (v2), (v3)
#define PUSH4(v1, v2, v3, v4) op_pushb1+3, (v1), (v2), (v3), (v4)
#define PUSH5(v1,v2,v3,v4,v5) op_pushb1+4, (v1), (v2), (v3), (v4), (v5)
static const UBYTE FontProg[] = {
/******* SET ZONE FUNCTION
* * Args: flat_pos * */FDEF(TTFUN_SET_ZONE) PUSH1(TMPPNT), op_swap, op_miap, PUSH1(TMPPNT), op_mdap | SUBOP_R,ENDF
/******* COPY ZONE FUNCTION
* * Args: from_cvt, to_cvt * */FDEF(TTFUN_COPY_ZONE) op_rcvt, op_round, op_wcvtp,ENDF
/******* STEM SNAP WIDTH FUNCTION
* * Args: std_ci, std_cvt, snap_ci, snap_cvt, width, storage * */FDEF(TTFUN_STEM_SNAP_WIDTH) op_mppem, op_gteq, op_if,
/* Use std */ op_rcvt, op_round, PUSH1(ONEPIXEL/2), op_max, op_swap, op_pop, op_swap, op_pop, op_swap, op_pop, CALL(TTFUN_WRITE_STEM), op_else, op_pop, op_mppem, op_gteq, op_if, /* Use snap */ op_rcvt, op_round, PUSH1(ONEPIXEL/2), op_max, op_swap, op_pop, CALL(TTFUN_WRITE_STEM), /* Use real width. */ op_else, op_pop, WCVT(TMPCVT), PUSH1(TMPCVT), op_rcvt, op_round, PUSH1(ONEPIXEL/2), op_max, CALL(TTFUN_WRITE_STEM), op_eif, op_eif,ENDF
/******* STEM STD WIDTH FUNCTION
* * Args: std_ci, std_cvt, width, storage * */FDEF(TTFUN_STEM_STD_WIDTH) op_mppem, op_gteq, op_if, /* Use std */ op_rcvt, op_round, PUSH1(ONEPIXEL/2), op_max, op_swap, op_pop, CALL(TTFUN_WRITE_STEM), /* Use real width. */ op_else, op_pop, WCVT(TMPCVT), PUSH1(TMPCVT), op_rcvt, op_round, PUSH1(ONEPIXEL/2), op_max, CALL(TTFUN_WRITE_STEM), op_eif, ENDF
/******* SHIFT BLUE ZONE FUNCTION
* * Args: cvt * */FDEF(TTFUN_SHIFT_BLUE_ZONE) PUSH5(TMPPNT1, TMPPNT1, TMPPNT, TMPPNT1, 5), op_cindex, op_miap, op_srp0, op_mdrp | SUBOP_mMRGR, op_gc, op_wcvtp,ENDF
/******* ALIGN BLUE ZONE FUNCTION
* * Args: cvt * */FDEF(TTFUN_ALIGN_BLUE_ZONE) PUSH5(TMPPNT1, TMPPNT1, TMPPNT, TMPPNT1, 5), op_cindex, op_miap, op_srp0, op_mdrp | SUBOP_ROUND, op_gc, op_wcvtp,ENDF
/******* COPY FAMILY FUNCTION
* * Args: base_cvt * */FDEF(TTFUN_COPY_FAMILY) op_dup, PUSH1(1), op_add, op_rcvt, op_wcvtp,ENDF
/******* WRITE STEM FUNCTION
* * Args: width, storage * */FDEF(TTFUN_WRITE_STEM) op_dup, /* -| width, width, storage */ op_dup, /* -| width, width, width, storage */ op_add, /* -| 2*width, width, storage, */ op_odd, /* -| odd/even, width, storage */ PUSH2(1, 4), /* -| 4, 1, odd/even, width, storage */ op_cindex, /* -| storage, 1, odd/even, width, storage */ op_add, op_swap, /* -| odd/even, storage+1, width, storage */ op_ws, op_ws,ENDF
/******* VERTICAL FUNCTION
* * Args: -*none*- * */FDEF(TTFUN_VERTICAL) op_svcta | SUBOP_X, PUSH1(TWILIGHT), op_szps,ENDF
/******* HORIZONTAL FUNCTION
* * Args: -*none*- * */FDEF(TTFUN_HORIZONTAL) PUSH1(TWILIGHT), op_svcta, op_szps,ENDF
/******* CENTER VSTEM FUNCTION
* * Args: p1, p2, p3, p4, c, tz1, width * */FDEF(TTFUN_VCENTER)
/* Set rounding state for the center. */ PUSH2(1, 8), op_cindex, op_add, op_rs, op_if, op_rthg, op_else, op_rtg, op_eif,
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 6), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 6), op_cindex, op_add, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 2, 5), op_cindex, op_add, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 3, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round center. */ WCVT(TMPCVT), /* c */ PUSH2(TMPPNT, TMPCVT), op_miap| SUBOP_R, op_rtg,
/* Align all points to the center. */ op_dup, op_dup, PUSH1(1), op_add, op_alignrp, op_alignrp, /* tz1, tz1+1 */
/* Compute the width. */ op_swap, op_rs, PUSH1(CURVEPHASE), op_sub, op_swap,
/* -| tz1, width */ op_dup, op_dup, op_dup, op_srp0, PUSH1(4), op_cindex, op_neg, /* -| (-width/2), tz1, tz1, tz1, width */ op_shpix, PUSH1(2), op_add, op_alignrp, /* -| tz1+2, tz1, width */
/* Do the other side. */ /* -| tz1, width */ PUSH1(1), op_add, op_dup, op_dup, /* -| tz1+1, tz1+1, tz1+1, width */ op_srp0, op_roll, /* -| width, tz1+1, tz1+1 */ op_shpix, PUSH1(2), op_add, op_alignrp, /* -| tz1+3 */
/* Done. */ENDF
/******* CENTER HSTEM FUNCTION
* * Args: p1, p2, c, tz1, width * */FDEF(TTFUN_HCENTER)
/* Set,rounding state for the center. */ PUSH2(1, 6), op_cindex, op_add, op_rs, op_if, op_rthg, op_else, op_rtg, op_eif,
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 4), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round center. */ WCVT(TMPCVT), /* c */ PUSH2(TMPPNT, TMPCVT), op_miap| SUBOP_R, op_rtg,
/* Align all points to the center. */ op_dup, op_dup, PUSH1(1), op_add, op_alignrp, op_alignrp, /* tz1, tz1+1 */
/* Compute the width. */ op_swap, op_rs, PUSH1(CURVEPHASE), op_sub, op_swap,
/* -| tz1, width */ op_dup, PUSH1(3), op_cindex, op_neg, /* -| -width, tz1, tz1, width */ op_shpix,
/* Do the other side. */ /* -| tz1, width */ PUSH1(1), op_add, op_swap, /* -| width, tz1+1 */ op_shpix,
/* Done. */ENDF
/******* RELATIVE1V STEM FUNCTION
* * Args: p1, p2, p3, p4, ref, tz1, width * */FDEF(TTFUN_RELATIVE1V)
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 6), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 6), op_cindex, op_add, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 2, 5), op_cindex, op_add, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 3, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round side. */ op_srp0, op_dup, op_mdrp | SUBOP_MmRGR,
/* Align points on the left side. */ op_dup, PUSH1(1), op_add, op_dup, op_dup, op_dup, PUSH1(1), op_add, /* -| tz1+2, tz1+1, tz1+1, tz+1, tz, width */ op_alignrp, op_alignrp,
/* Align right side */ op_srp0, /* -| tz1+1, tz1, width */ op_roll, op_rs, op_dup, op_add, /* -| width*2, tz1+1, tz1 */ op_shpix, PUSH1(3), op_add, op_alignrp, /* -| tz1+3 */
ENDF
/******* RELATIVE2V STEM FUNCTION
* * Args: p1, p2, p3, p4, ref, tz1, width * */FDEF(TTFUN_RELATIVE2V)
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 6), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 6), op_cindex, op_add, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 2, 5), op_cindex, op_add, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 3, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round side. */ op_srp0, op_dup, PUSH1(1), op_add, op_mdrp | SUBOP_MmRGR,
/* Align points on the left side. */ op_dup, op_dup, op_dup, op_dup, PUSH1(3), op_add, /* -| tz1+3, tz1, tz1, tz1, tz1, width */ op_alignrp, op_alignrp,
/* Align left side */ op_srp0, /* -| tz1, tz1, width */ op_roll, op_rs, op_dup, op_add, op_neg, op_shpix, /* -| -2*width, tz1, tz1 */ PUSH1(2), op_add, op_alignrp, /* -| tz1+2 */
ENDF
/******* RELATIVE1H STEM FUNCTION
* * Args: p1, p2, ref, tz1, width * */FDEF(TTFUN_RELATIVE1H)
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 4), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round side. */ op_srp0, op_dup, op_mdrp | SUBOP_MmRGR,
/* Align all point to the lower side. */ PUSH1(1), op_add, op_dup, op_alignrp,
/* Align right side */ op_swap, op_rs, op_dup, op_add, op_shpix,
ENDF
/******* RELATIVE2H STEM FUNCTION
* * Args: p1, p2, ref, tz1, width * */FDEF(TTFUN_RELATIVE2H)
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 4), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round side. */ op_srp0, op_dup, PUSH1(1), op_add, op_mdrp | SUBOP_MmRGR,
/* Align all points to the center. */ op_dup, op_alignrp,
/* Align left side */ op_swap, op_rs, op_dup, op_add, op_neg, op_shpix,
ENDF
/******* SIDE1 STEM FUNCTION
* * Args: p1, p2, zone, tz1, width * */FDEF(TTFUN_SIDE1)
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 4), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round side. */ PUSH2(TMPPNT, TMPPNT), op_srp0, op_swap, op_miap | SUBOP_R,
/* Align all points to the side. */ op_dup, PUSH1(1), op_add, op_dup, op_roll, op_alignrp, op_alignrp,
/* Align first side */ op_swap, op_rs, op_dup, op_add, PUSH1(CURVEPHASE), op_sub, op_shpix,
ENDF
/******* SIDE2 STEM FUNCTION
* * Args: p1, p2, zone, tz1, width * */FDEF(TTFUN_SIDE2)
/* Create the stem in the twilight zone. */ WCVT(TMPCVT), PUSH2(TMPCVT, 4), op_cindex, op_swap, op_miap,
WCVT(TMPCVT), PUSH3(TMPCVT, 1, 4), op_cindex, op_add, op_swap, op_miap,
/* Move/round side. */ PUSH2(TMPPNT, TMPPNT), op_srp0, op_swap, op_miap | SUBOP_R,
/* Align all points to the side. */ op_dup, op_dup, PUSH1(1), op_add, op_alignrp, op_alignrp,
/* Align second side */ op_swap, op_rs, op_dup, op_add, PUSH1(CURVEPHASE), op_sub, op_neg, op_shpix,
ENDF
/******* FLEX FUNCTION
* * Args on the stack: pnt_start, pnt_mid, ref_pos, pnt_mid, * pnt_start, pnt_mid, cnt, p1, p2, .... * */FDEF(TTFUN_FLEX) op_srp0, op_alignrp, op_wcvtf, op_rcvt, op_shpix, op_srp1, op_srp2, op_sloop, op_ip,ENDF
/******* SCALE3 FUNCTION
* * Args: cnt, p1, p2, ... * */FDEF(TTFUN_SCALE3) PUSH4(GLYPHZONE, TMPPNT1, TMPPNT, TMPPNT1), op_pushw1, HIBYTE(-31), LOBYTE(-31), PUSH3(TMPPNT, 0, TMPPNT1), op_pushw1, HIBYTE(1000), LOBYTE(1000), op_scfs, op_scfs, op_shpix, op_srp1, op_srp2, op_szp2, op_sloop, op_ip,ENDF
/******* SHIFT1 FUNCTION
* * Args: cnt reduction p1 p2 ... * */FDEF(TTFUN_SHIFT1) op_sloop, op_rs, op_neg, op_shpix,ENDF
/******* SHIFT2 FUNCTION
* * Args: cnt reduction p1 p2 ... * */FDEF(TTFUN_SHIFT2) op_sloop, op_rs, op_shpix,ENDF
/******* IP1 FUNCTION
* * Args: rp1, rp2, p1 * */FDEF(TTFUN_IP1) op_srp1, op_srp2, op_ip,ENDF
/******* IP2 FUNCTION
* * Args: rp1, rp2, p1, p2 * */FDEF(TTFUN_IP2) op_srp1, op_srp2, op_ip, op_ip,ENDF
/******* IPN FUNCTION
* * Args: rp1, rp2, cnt, p1, p2 * */FDEF(TTFUN_IPN) op_srp1, op_srp2, op_sloop, op_ip,ENDF
/******* SHP1 FUNCTION
* * Args: rp, p * */FDEF(TTFUN_SHP1) op_srp1, op_shp,ENDF
/******* SHP2 FUNCTION
* * Args: rp, p1, p2 * */FDEF(TTFUN_SHP2) op_srp1, op_shp, op_shp,ENDF
/******* SHPN FUNCTION
* * Args: rp, cnt, p1, p2 * */FDEF(TTFUN_SHPN) op_srp1, op_sloop, op_shp,ENDF
/******* RANGE FUNCTION
* * Args: p * */FDEF(TTFUN_RANGE) op_dup, PUSH1(1), op_add,ENDF
/******* RANGE FUNCTION
* * Args: pos_x, pos_y, * */FDEF(TTFUN_OBLIQUE) op_svcta | SUBOP_Y, PUSH1(TMPPNT1), op_swap, op_scfs, PUSH2(TMPPNT, 0), op_scfs, op_svcta | SUBOP_X, PUSH1(TMPPNT1), op_swap, op_scfs, PUSH2(TMPPNT, 0), op_scfs, PUSH2(TMPPNT, TMPPNT1), op_spvtl,ENDF
};
/***** LOCAL TYPES */
/***** STATIC FUNCTIONS */
/***
** Function: GetVStemWidth**** Description:** This function allocates a storage entry for the ** width of a vertical stem;***/static short GetVStemWidth(WeightControl *weight, const funit width){ StemWidth *newwidths = NULL; short entry = 0; USHORT j;
if (weight->cnt_vw >= weight->max_vw) { newwidths = Realloc(weight->vwidths, sizeof(StemWidth)*(weight->max_vw+BUFSIZE)); if (newwidths == NULL) { entry = NOMEM; } else { weight->vwidths = newwidths; weight->max_vw += BUFSIZE; } }
if (entry != NOMEM) { for (j=0; j<weight->cnt_vw; j++) { if (weight->vwidths[j].width==width) { entry = (short)weight->vwidths[j].storage; break; } }
if (j==weight->cnt_vw) { weight->vwidths[weight->cnt_vw].storage = weight->storage; weight->vwidths[weight->cnt_vw].width = width; entry = (short)weight->storage; weight->storage += 2; weight->cnt_vw++; } }
return entry;}
/***
** Function: GetHStemWidth**** Description:** This function allocates a storage entry for the ** width of a vertical stem;***/static short GetHStemWidth(WeightControl *weight, const funit width){ StemWidth *newwidths = NULL; short entry = 0; USHORT j;
if (weight->cnt_hw >= weight->max_hw) { newwidths = Realloc(weight->hwidths, sizeof(StemWidth)*(weight->max_hw+BUFSIZE)); if (newwidths == NULL) { entry = NOMEM; } else { weight->hwidths = newwidths; weight->max_hw += BUFSIZE; } }
if (entry != NOMEM) { for (j=0; j<weight->cnt_hw; j++) { if (weight->hwidths[j].width==width) { entry = (short)weight->hwidths[j].storage; break; } }
if (j==weight->cnt_hw) { weight->hwidths[weight->cnt_hw].storage = weight->storage; weight->hwidths[weight->cnt_hw].width = width; entry = (short)weight->storage; weight->storage += 2; weight->cnt_hw++; } }
return entry;}
/***** GLOBAL FUNCTIONS */
/***
** Function: SetZone**** Description:** This function initiate an alignment zone** by creating an appropriate point in the** twilight zone.***/USHORT SetZone(UBYTE *prep, USHORT tp, const short cvt){ /* Set up the zone. */ if (cvt>255) { prep[tp++] = op_pushw1; prep[tp++] = HIBYTE(cvt); prep[tp++] = LOBYTE(cvt); prep[tp++] = op_pushb1; prep[tp++] = TTFUN_SET_ZONE; } else { prep[tp++] = op_pushb1 + 1; prep[tp++] = (UBYTE)cvt; prep[tp++] = TTFUN_SET_ZONE; } prep[tp++] = op_call;
return tp;}
/***
** Function: CopyZone**** Description:** This function copies a cvt entry, representing an** alignment zone, to the cvt used for a particular hstem.***/USHORT CopyZone(UBYTE *prep, short tp, short *args, const short ta){ args[0] = TTFUN_COPY_ZONE; args[1] = (short)((ta-2)/2); AssembleArgs(args, ta, prep, &tp); prep[tp++] = op_loopcall;
return (USHORT)tp;}
/***
** Function: CopyFamilyBlue**** Description:** This function copies a cvt entry, representing a** family blue zone, to the cvt used for a particular hstem.***/USHORT CopyFamilyBlue(UBYTE *prep, short tp, short *args, const short ta){ args[0] = TTFUN_COPY_FAMILY; args[1] = (short)(ta-2); AssembleArgs(args, ta, prep, &tp); prep[tp++] = op_loopcall;
return (USHORT)tp;}
/***
** Function: AlignFlat**** Description:** This function creates a cvt entry for** a particular hstem.***/USHORT AlignFlat(UBYTE *prep, short tp, short *args, const short ta){ args[0] = TTFUN_ALIGN_BLUE_ZONE; args[1] = (short)(ta-2); AssembleArgs(args, ta, prep, &tp); prep[tp++] = op_loopcall;
return (USHORT)tp;}
/***
** Function: AlignOvershoot**** Description:** This function creates a cvt entry for** a particular hstem.***/USHORT AlignOvershoot(UBYTE *prep, short tp, short *args, const short ta){ args[0] = TTFUN_SHIFT_BLUE_ZONE; args[1] = (short)(ta-2); AssembleArgs(args, ta, prep, &tp); prep[tp++] = op_loopcall;
return (USHORT)tp;}
/***
** Function: GetTopPos**** Description:** This function allocates a cvt entry for the ** top side of a horizontal stem;***/short GetTopPos(const Blues *blues, AlignmentControl *align, const funit pos){ short entry = UNDEF; const funit *bluevals; short fuzz; USHORT i, j;
bluevals = &(blues->bluevalues[0]); fuzz = blues->blueFuzz;
/* Check if it is within a zone. */ for (i=0; i<blues->blue_cnt; i+=2) { if (((bluevals[i]-fuzz)<=pos) && ((bluevals[i+1]+fuzz)>=pos)) break; }
/* Record the position? */ if (i!=blues->blue_cnt) { i /= 2;
/* Is the position already mapped to a cvt entry? */ for (j=0; j<align->top[i].cnt; j++) { if (align->top[i].pos[j].y==pos) { entry = (short)align->top[i].pos[j].cvt; break; } }
if (j==align->top[i].cnt) {
/* Allocate the BlueZone cvt's */ if (align->top[i].cnt==0) { align->top[i].blue_cvt = align->cvt; align->cvt +=2; }
align->top[i].pos[align->top[i].cnt].cvt = align->cvt; align->top[i].pos[align->top[i].cnt].y = pos; entry = (short)align->cvt; align->cvt+=2; align->top[i].cnt++; } }
return entry;}
/***
** Function: GetBottomPos**** Description:** This function allocates a cvt entry for the ** top side of a horizontal stem;***/short GetBottomPos(const Blues *blues, AlignmentControl *align, const funit pos){ short entry = UNDEF; const funit *bluevals; short fuzz; USHORT i, j;
bluevals = &(blues->otherblues[0]); fuzz = blues->blueFuzz;
/* Check if it is within a zone. */ for (i=0; i<blues->oblue_cnt; i+=2) { if (((bluevals[i]-fuzz)<=pos) && ((bluevals[i+1]+fuzz)>=pos)) break; }
/* Record the position? */ if (i!=blues->oblue_cnt) { i /= 2;
/* Is the position already mapped to a cvt entry? */ for (j=0; j<align->bottom[i].cnt; j++) { if (align->bottom[i].pos[j].y==pos) { entry = (short)align->bottom[i].pos[j].cvt; break; } }
if (j==align->bottom[i].cnt) {
/* Allocate the BlueZone and FamilyBlue cvt's */ if (align->bottom[i].cnt==0) { align->bottom[i].blue_cvt = align->cvt++; }
align->bottom[i].pos[align->bottom[i].cnt].cvt = align->cvt; align->bottom[i].pos[align->bottom[i].cnt].y = pos; entry = (short)align->cvt; align->cvt+=2; align->bottom[i].cnt++; } }
return entry;}
/***
** Function: CutInSize**** Description:** This function computes the cut in size** of a stem, given a master width and the** width of the stem. This is done with the** StdVW==2.0 pixel treshold and the thinn** and wide cut in values.***/USHORT CutInSize(const funit width, const funit master, const USHORT tresh, const funit upem){ USHORT cis, ci1, ci2;
/*lint -e776 */ if (width > master) { ci1 = (USHORT)((long)upem * SMALL_UPPER / ONEPIXEL / (long)(width - master)); ci2 = (USHORT)((long)upem * LARGE_UPPER / ONEPIXEL / (long)(width - master)); } else if (width < master) { ci1 = (USHORT)((long)upem * SMALL_LOWER / ONEPIXEL / (long)(master - width)); ci2 = (USHORT)((long)upem * LARGE_LOWER / ONEPIXEL / (long)(master - width)); } else { ci1 = INFINITY; ci2 = INFINITY; } /*lint +e776 */
if (ci1 < tresh) { cis = ci1; } else if (ci2 < tresh) { cis = tresh; } else { cis = ci2; }
return cis;}
/***
** Function: SnapStemArgs**** Description:** ***/USHORT SnapStemArgs(short *args, USHORT ta, const funit width, const USHORT std_cvt, const USHORT snap_cvt, const USHORT std_ci, const USHORT snap_ci, const USHORT storage){ args[ta++] = (short)std_ci; args[ta++] = (short)std_cvt; args[ta++] = (short)snap_ci; args[ta++] = (short)snap_cvt; args[ta++] = (short)(width/2); args[ta++] = (short)storage;
return ta;}
/***
** Function: StdStemArgs**** Description:** ***/USHORT StdStemArgs(short *args, USHORT ta, const funit width, const USHORT std_cvt, const USHORT std_ci, const USHORT storage){ args[ta++] = (short)std_ci; args[ta++] = (short)std_cvt; args[ta++] = (short)(width/2); args[ta++] = (short)storage;
return ta;}
/***
** Function: CreateStdStems**** Description:** ***/USHORT CreateStdStems(UBYTE *prep, USHORT tp, const short cnt){ if (cnt>255) { prep[tp++] = op_pushw1; prep[tp++] = HIBYTE(cnt); prep[tp++] = LOBYTE(cnt); prep[tp++] = op_pushb1; prep[tp++] = TTFUN_STEM_STD_WIDTH; } else { prep[tp++] = op_pushb1 + 1; prep[tp++] = (UBYTE)cnt; prep[tp++] = TTFUN_STEM_STD_WIDTH; }
prep[tp++] = op_loopcall;
return tp;}
/***
** Function: CreateSnapStems**** Description:** ***/USHORT CreateSnapStems(UBYTE *prep, USHORT tp, const short cnt){ if (cnt>255) { prep[tp++] = op_pushw1; prep[tp++] = HIBYTE(cnt); prep[tp++] = LOBYTE(cnt); prep[tp++] = op_pushb1; prep[tp++] = TTFUN_STEM_SNAP_WIDTH; } else { prep[tp++] = op_pushb1 + 1; prep[tp++] = (UBYTE)cnt; prep[tp++] = TTFUN_STEM_SNAP_WIDTH; }
prep[tp++] = op_loopcall;
return tp;}
/***
** Function: tt_GetFontProg**** Description:** This function returns the static font** font program.***/const UBYTE *tt_GetFontProg(void){ return FontProg;}
/***
** Function: tt_GetFontProgSize**** Description:** This function returns the size of the** static font program.***/USHORT tt_GetFontProgSize(void){ return (USHORT)sizeof(FontProg);}
/***
** Function: tt_GetNumFuns**** Description:** This function returns the number of functions** defined in the static font program.***/USHORT tt_GetNumFuns(void){ return (USHORT)TTFUN_NUM;}
/***
** Function: EmitFlex**** Description:** Convert a T1 flex hint into a TrueType IP[] ** intruction sequence that will reduce a flex** that is flatter than a given height.***/errcode EmitFlex(short *args, short *pcd, const funit height, const short start, const short mid, const short last){ errcode status = SUCCESS; int i;
/* Enough space for the instructions? */ args[(*pcd)++] = TTFUN_FLEX; args[(*pcd)++] = start; args[(*pcd)++] = mid; args[(*pcd)++] = (short)height; args[(*pcd)++] = TMPCVT; args[(*pcd)++] = TMPCVT; args[(*pcd)++] = mid; args[(*pcd)++] = start; args[(*pcd)++] = mid;
/* Push the flex points onto the stack. */ args[(*pcd)++] = (short)(last-start-2); for (i=start+(short)1; i<last; i++) if (i!=mid) args[(*pcd)++] = (short)i;
return status;}
/***
** Function: ReduceDiagonals**** Description:** This function generates the TT instructions** that will shrink the outline, in order to** control the width of diagonals. This implementation** can probably be improved.***/short ReduceDiagonals(const Outline *paths, UBYTE *pgm, short *pc, short *args, short *pcd){ short cw[MAXTHINPNTS]; short ccw[MAXTHINPNTS]; short targ[MAXTHINPNTS]; const Outline *path; Point *pts; short i,j; short cwi = 0, ccwi = 0; short prev; short n,m; short prev_cw, prev_ccw; short ta;
/* Collect points on left and right side that are diagonals. */ i = 0; for (path = paths; path && ccwi<MAXTHINPNTS && cwi<MAXTHINPNTS; path=path->next) {
pts = &path->pts[0]; prev_cw = FALSE; prev_ccw = FALSE;
/* Are the first and last point coinciding? */ if (pts[path->count-1].x!=pts[0].x || pts[path->count-1].y!=pts[0].y) prev = (short)(path->count-(short)1); else prev = (short)(path->count-(short)2);
/* Special case the first point. */ if (!OnCurve(path->onoff, prev) || (pts[0].x != pts[prev].x && ABS(pts[0].x - pts[prev].x) < ABS(pts[0].y - pts[prev].y)*8)) { if (pts[0].y>pts[prev].y+20) { if (pts[prev].y<=pts[prev-1].y) cw[cwi++] = (short)(i+(short)path->count-1); cw[cwi++] = i; prev_cw = TRUE; prev_ccw = FALSE; } else if (pts[0].y<pts[prev].y-20) { if (pts[prev].y>=pts[prev-1].y) ccw[ccwi++] = (short)(i+(short)path->count-1); ccw[ccwi++] = i; prev_cw = FALSE; prev_ccw = TRUE; } }
for (j=1; j<(short)path->count && ccwi<MAXTHINPNTS && cwi<MAXTHINPNTS; j++) { i++; if (!OnCurve(path->onoff, j-1) || (pts[j].x != pts[j-1].x && ABS(pts[j].x - pts[j-1].x) < ABS(pts[j].y - pts[j-1].y)*8)) { if (pts[j].y>pts[j-1].y+20) { if (!prev_cw) cw[cwi++] = (short)(i-1); cw[cwi++] = i; prev_cw = TRUE; prev_ccw = FALSE; } else if (pts[j].y<pts[j-1].y-20) { if (!prev_ccw) ccw[ccwi++] = (short)(i-1); ccw[ccwi++] = i; prev_cw = FALSE; prev_ccw = TRUE; } else { prev_cw = FALSE; prev_ccw = FALSE; } } else { prev_cw = FALSE; prev_ccw = FALSE; } } i++; }
/* Did we get all points? */ if (ccwi>=MAXTHINPNTS || cwi>=MAXTHINPNTS) { LogError(MSG_WARNING, MSG_DIAG, NULL); }
/* Any points to shift? */ if (cwi || ccwi) { args[(*pcd)++] = STORAGE_DIAG; pgm[(*pc)++] = op_rs; pgm[(*pc)++] = op_if; pgm[(*pc)++] = op_svcta + SUBOP_X;
/* Switch over to GLYPHZONE */ pgm[(*pc)++] = op_szp2; args[(*pcd)++] = 1;
ta = 3;
/* Disable "cw[m] may not have been initialized".*/ /*lint -e644 */ for (n=0; n<cwi; n=m) { for (m=(short)(n+1); m<cwi && cw[m]==cw[m-1]+1; m++); /*lint +e644 */ if (m-n<=4) { for (i=n; i<m; i++) targ[ta++] = cw[i]; } else { targ[0] = TTFUN_RANGE; targ[1] = (short)(m-n-1); targ[2] = cw[n]; AssembleArgs(targ, ta, pgm, pc); pgm[(*pc)++] = op_loopcall; ta = 3; } } targ[0] = TTFUN_SHIFT1; targ[1] = cwi; targ[2] = STORAGE_DIAG; AssembleArgs(targ, ta, pgm, pc); pgm[(*pc)++] = op_call;
/************ Shift back the left side of the glyph. */
ta = 3;
/* Disable "ccw[m] may not have been initialized".*/ /*lint -e644 */ for (n=0; n<ccwi; n=m) { for (m=(short)(n+1); m<ccwi && ccw[m]==ccw[m-1]+1; m++); /*lint +e644 */ if (m-n<=4) { for (i=n; i<m; i++) targ[ta++] = ccw[i]; } else { targ[0] = TTFUN_RANGE; targ[1] = (short)(m-n-1); targ[2] = ccw[n]; AssembleArgs(targ, ta, pgm, pc); pgm[(*pc)++] = op_loopcall; ta = 3; } } targ[0] = TTFUN_SHIFT2; targ[1] = ccwi; targ[2] = STORAGE_DIAG; AssembleArgs(targ, ta, pgm, pc); pgm[(*pc)++] = op_call;
#ifdef SYMETRICAL_REDUCTION
/* The amount that the outline is shrunk is computed once at
each size, in the pre-program. The outline is shrunk symetrically by the amount: 1/16 + (12 Funits)*size/UPEm.
This approach yields more symmetrical results than shrinking the outline horizontally alone (see separate papers on the topic). */
/* Same thing for the height... */ i = 0; cwi = 0; ccwi = 0; for (path = paths; path && ccwi<MAXTHINPNTS && cwi<MAXTHINPNTS; path=path->next) {
pts = &path->pts[0];
/* Are the first and last point coinciding? */ if (pts[path->count-1].y!=pts[0].y || pts[path->count-1].x!=pts[0].x) prev = path->count-1; else prev = path->count-2;
if (!OnCurve(path->onoff, prev) || (pts[0].y != pts[prev].y && ABS(pts[0].y - pts[prev].y) < ABS(pts[0].x - pts[prev].x)*8)) { if (pts[0].x>pts[prev].x+20) { if (pts[prev].x<=pts[prev-1].x) cw[cwi++] = i+path->count-1; cw[cwi++] = i; } else if (pts[0].x<pts[prev].x-20) { if (pts[prev].x>=pts[prev-1].x) ccw[ccwi++] = i+path->count-1; ccw[ccwi++] = i; } }
for (j=1; j<path->count && ccwi<MAXTHINPNTS && cwi<MAXTHINPNTS; j++) { i++; if (!OnCurve(path->onoff, j-1) || (pts[j].y != pts[j-1].y && ABS(pts[j].y - pts[j-1].y) < ABS(pts[j].x - pts[j-1].x)*8)) { if (pts[j].x>pts[j-1].x+20) { if (!cwi || cw[cwi-1]!=i-1) cw[cwi++] = i-1; cw[cwi++] = i; } else if (pts[j].x<pts[j-1].x-20) { if (!ccwi || ccw[ccwi-1]!=i-1) ccw[ccwi++] = i-1; ccw[ccwi++] = i; } } } i++; }
if (ccwi>=MAXTHINPNTS || cwi>=MAXTHINPNTS) { LogError(MSG_WARNING, MSG_DIAG, NULL); }
/* Any points to shift? */ if (cwi || ccwi) { pgm[(*pc)++] = op_svcta + SUBOP_Y;
for (n=0; n<cwi; n=m) { for (m=n+1; m<cwi && cw[m]==cw[m-1]+1; m++); pgm[(*pc)++] = op_pushb1 + 2; pgm[(*pc)++] = cw[n]; pgm[(*pc)++] = (UBYTE)(m-n-1); pgm[(*pc)++] = TTFUN_RANGE; pgm[(*pc)++] = op_loopcall; } pgm[(*pc)++] = op_pushb1+2; pgm[(*pc)++] = STORAGE_DIAG; pgm[(*pc)++] = cwi; pgm[(*pc)++] = TTFUN_SHIFT2; pgm[(*pc)++] = op_call;
/************ Shift back the left side of the glyph. */
for (n=0; n<ccwi; n=m) { for (m=n+1; m<ccwi && ccw[m]==ccw[m-1]+1; m++); pgm[(*pc)++] = op_pushb1 + 2; pgm[(*pc)++] = (UBYTE)ccw[n]; pgm[(*pc)++] = (UBYTE)(m-n-1); pgm[(*pc)++] = TTFUN_RANGE; pgm[(*pc)++] = op_loopcall; } pgm[(*pc)++] = op_pushb1+2; pgm[(*pc)++] = STORAGE_DIAG; pgm[(*pc)++] = (UBYTE)ccwi; pgm[(*pc)++] = TTFUN_SHIFT1; pgm[(*pc)++] = op_call; }#endif
pgm[(*pc)++] = op_eif; }
/* Args + num of args + function number. */ return (short)(MAX(cwi, ccwi)+2); }
/***
** Function: ScaleDown3**** Description:** This function generates the TT instructions** that will scale down points 3%.***/void ScaleDown3(const Extremas *extr, const short xcnt, UBYTE *pgm, short *pc, short *args, short *pcd){ short i,j,offset, opc, opcd;
/* Remember the state of the stacks. */ opc = (*pc); opcd = (*pcd);
args[(*pcd)++] = TTFUN_SCALE3;
offset = (*pcd)++; args[offset] = 0; for (i=0; i<xcnt; i++) { if ((extr[i].rp1==UNDEF || extr[i].rp2==UNDEF)) { for (j=0; j<extr[i].n; j++) { args[(*pcd)++] = extr[i].pts[j]; } args[offset] = (short)(args[offset] + extr[i].n); } } if (args[offset]>0) { pgm[(*pc)++] = op_call; } else { /* Back track. */ (*pc) = opc; (*pcd) = opcd; }}
/***
** Function: EmitIP**** Description:** This function generates the TT instructions** that will interpolate points that are either** within or between stem sides.***/void EmitIP(const Extremas *extr, const short xcnt, UBYTE *pgm, short *pc, short *args, short *pcd, const short scale3offset){ short i,j,num; short ones[MAXIP], twoes[MAXIP], nths[MAXIP]; short cnt1, cnt2, cntn;
/*lint -e530 -e644 */ /* Shift extrems. */ cnt1 = 0; cnt2 = 0; cntn = 0; num = 0; for (i=0; i<xcnt; i++) { short rp;
/* Skip interpolations. */ if (extr[i].rp1!=UNDEF && extr[i].rp2!=UNDEF) continue;
/* Set the reference points. */ if (extr[i].rp1!=UNDEF) { rp = (short)(extr[i].rp1+scale3offset); } else { rp = (short)(extr[i].rp2+scale3offset); }
if (extr[i].n==1) { if ((cnt1+2)>=MAXIP) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_SHP1; args[(*pcd)++] = (short)(cnt1/2); for (j=0; j<cnt1; j++) args[(*pcd)++] = (short)ones[j]; cnt1 = 0; } ones[cnt1++] = rp; ones[cnt1++] = extr[i].pts[0]; } else if (extr[i].n==2) { if ((cnt2+3)>=MAXIP) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_SHP2; args[(*pcd)++] = (short)(cnt2/3); for (j=0; j<cnt2; j++) args[(*pcd)++] = (short)twoes[j]; cnt2 = 0; } twoes[cnt2++] = rp; twoes[cnt2++] = extr[i].pts[0]; twoes[cnt2++] = extr[i].pts[1]; } else { if ((cntn+2+extr[i].n)>=MAXIP) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_SHPN; args[(*pcd)++] = num; for (j=0; j<cntn; j++) args[(*pcd)++] = (short)nths[j]; cntn = 0; num = 0; } nths[cntn++] = rp; nths[cntn++] = extr[i].n; for (j=0; j<extr[i].n; j++) { nths[cntn++] = extr[i].pts[j]; } num++; } }
if (cnt1) { if (cnt1>2) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_SHP1; args[(*pcd)++] = (short)(cnt1/2); } else { pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_SHP1; } for (i=0; i<cnt1; i++) args[(*pcd)++] = ones[i]; } if (cnt2) { if (cnt2>3) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_SHP2; args[(*pcd)++] = (short)(cnt2/3); } else { pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_SHP2; } for (i=0; i<cnt2; i++) args[(*pcd)++] = twoes[i]; } if (cntn) { if (num>1) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_SHPN; args[(*pcd)++] = num; } else { pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_SHPN; } for (i=0; i<cntn; i++) args[(*pcd)++] = (short)nths[i]; }
/* Interpolate the extrems. */ cnt1 = 0; cnt2 = 0; cntn = 0; num = 0; for (i=0; i<xcnt; i++) {
/* Skip interpolations. */ if (extr[i].rp1==UNDEF || extr[i].rp2==UNDEF) continue;
if (extr[i].n==1) { if ((cnt1+3)>=MAXIP) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_IP1; args[(*pcd)++] = (short)(cnt1/2); for (j=0; j<cnt1; j++) args[(*pcd)++] = (short)ones[j]; cnt1 = 0; } ones[cnt1++] = extr[i].rp1; ones[cnt1++] = extr[i].rp2; ones[cnt1++] = extr[i].pts[0]; } else if (extr[i].n==2) { if ((cnt2+4)>=MAXIP) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_IP2; args[(*pcd)++] = (short)(cnt2/3); for (j=0; j<cnt2; j++) args[(*pcd)++] = (short)twoes[j]; cnt2 = 0; } twoes[cnt2++] = extr[i].rp1; twoes[cnt2++] = extr[i].rp2; twoes[cnt2++] = extr[i].pts[0]; twoes[cnt2++] = extr[i].pts[1]; } else { if ((cntn+3+extr[i].n)>=MAXIP) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_IPN; args[(*pcd)++] = num; for (j=0; j<cntn; j++) args[(*pcd)++] = (short)nths[j]; cntn = 0; num = 0; } nths[cntn++] = extr[i].rp1; nths[cntn++] = extr[i].rp2; nths[cntn++] = extr[i].n; for (j=0; j<extr[i].n; j++) { nths[cntn++] = extr[i].pts[j]; } num++; } }
if (cnt1) { if (cnt1>3) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_IP1; args[(*pcd)++] = (short)(cnt1/3); } else { pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_IP1; } for (i=0; i<cnt1; i++) args[(*pcd)++] = (short)ones[i]; } if (cnt2) { if (cnt2>4) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_IP2; args[(*pcd)++] = (short)(cnt2/4); } else { pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_IP2; } for (i=0; i<cnt2; i++) args[(*pcd)++] = (short)twoes[i]; } if (cntn) { if (num>1) { pgm[(*pc)++] = op_loopcall; args[(*pcd)++] = TTFUN_IPN; args[(*pcd)++] = num; } else { pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_IPN; } for (i=0; i<cntn; i++) args[(*pcd)++] = (short)nths[i]; } /*lint +e530 +e644 */}
/***
** Function: EmitVerticalStem**** Description:** This function generates the code that** will initiate the graphics state of the** TrueType interpreter for the grid fitting** of vertical stems.***/void EmitVerticalStems(UBYTE *pgm, short *pc, short *args, short *pcd){ pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_VERTICAL;}
/***
** Function: EmitHorizontalStem**** Description:** This function generates the code that** will initiate the graphics state of the** TrueType interpreter for the grid fitting** of vertical stems.***/void EmitHorizontalStems(UBYTE *pgm, short *pc, short *args, short *pcd){ pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_HORIZONTAL;}
/***
** Function: EmitVStem**** Description:** This function generates the code that** will create and grid fit points in the** twilight zone, corresponding to a vstem.***/errcode EmitVStem(UBYTE *pgm, short *pc, short *args, short *pcd, struct T1Metrics *t1m, const funit width, const funit real_side1, const funit real_side2, const funit side1, const funit side2, const short rp, const enum aligntype align, const short ref){ errcode status = SUCCESS; short w_storage;
if ((w_storage = GetVStemWidth(GetWeight(t1m), width))==NOMEM) { SetError(status = NOMEM); } else {
pgm[(*pc)++] = op_call; switch (align) { case at_centered: args[(*pcd)++] = TTFUN_VCENTER; args[(*pcd)++] = (short)real_side1; args[(*pcd)++] = (short)real_side2; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = (short)((side1+side2)/2); args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_relative1: args[(*pcd)++] = TTFUN_RELATIVE1V; args[(*pcd)++] = (short)real_side1; args[(*pcd)++] = (short)real_side2; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = ref; args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_relative2: args[(*pcd)++] = TTFUN_RELATIVE2V; args[(*pcd)++] = (short)real_side1; args[(*pcd)++] = (short)real_side2; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = ref; args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_side1: case at_side2: LogError(MSG_WARNING, MSG_ALIGN, NULL); break; } }
return status;}
/***
** Function: EmitHStem**** Description:** This function generates the code that** will create and grid fit points in the** twilight zone, corresponding to a hstem.***/errcode EmitHStem(UBYTE *pgm, short *pc, short *args, short *pcd, struct T1Metrics *t1m, const funit width, const funit side1, const funit side2, const short rp, const enum aligntype align, const short ref){ errcode status = SUCCESS; short w_storage;
if ((w_storage = GetHStemWidth(GetWeight(t1m), width))==NOMEM) { SetError(status = NOMEM); } else {
pgm[(*pc)++] = op_call; switch (align) {
case at_side1: args[(*pcd)++] = TTFUN_SIDE1; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = ref; args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_side2: args[(*pcd)++] = TTFUN_SIDE2; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = ref; args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_relative1: args[(*pcd)++] = TTFUN_RELATIVE1H; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = ref; args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_relative2: args[(*pcd)++] = TTFUN_RELATIVE2H; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = ref; args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break;
case at_centered: default: args[(*pcd)++] = TTFUN_HCENTER; args[(*pcd)++] = (short)side1; args[(*pcd)++] = (short)side2; args[(*pcd)++] = (short)((side1+side2)/2); args[(*pcd)++] = rp; args[(*pcd)++] = w_storage; break; } }
return status;}
/***
** Function: FamilyCutIn**** Description:** This function generates a branch in the** pre-program. ***/USHORT FamilyCutIn(UBYTE *prep, USHORT tp, const short cis){ prep[tp++] = op_mppem; if (cis<256) { prep[tp++] = op_pushb1; prep[tp++] = (UBYTE)cis; } else { prep[tp++] = op_pushw1; prep[tp++] = HIBYTE(cis); prep[tp++] = LOBYTE(cis); } prep[tp++] = op_lt; prep[tp++] = op_if;
return tp;}
/***
** Function: SetProjection**** Description:** This function generates the TrueType code that** changes the projection vector in oblique typefaces.***/void SetProjection(UBYTE *pgm, short *pc, short *args, short *pcd, const funit x, const funit y){ pgm[(*pc)++] = op_call; args[(*pcd)++] = TTFUN_OBLIQUE; args[(*pcd)++] = (short)y; args[(*pcd)++] = (short)x;}
/***
** Function: AssembleArgs**** Description:** This function takes a sequence of arguments and** assembles them into a sequence of PUSHB1[], PUSHW1[],** NPUSHB[] and NPUSHW[] instructions.***/void AssembleArgs(short *args, const short pcd, UBYTE *is, short *cnt){ short bytes; short i,j;
if ((args[pcd-1] <= UCHAR_MAX && args[pcd-1]>=0)) { bytes = 1; } else { bytes = 0; }
for (i=0, j=0; j<pcd; i++) {
/* Pack a sequence of bytes? */ if (bytes) { if ((i-j)>=255 || i==pcd || (args[pcd-i-1]>UCHAR_MAX || args[pcd-i-1]<0)) { bytes = 0; if ((i-j)<=8) { is[(*cnt)++] = (UBYTE)(op_pushb1 + (i-j) - 1); } else { is[(*cnt)++] = op_npushb; is[(*cnt)++] = (UBYTE)(i-j); } while (j<i) is[(*cnt)++] = (UBYTE)args[pcd-1-j++]; }
/* Pack a sequence of words? */ } else { if ((i-j)>=255 || i==pcd || (args[pcd-i-1]<=UCHAR_MAX && args[pcd-i-1]>=0)) { bytes = 1; if ((i-j)<=8) { is[(*cnt)++] = (UBYTE)(op_pushw1 + (i-j) - 1); } else { is[(*cnt)++] = op_npushw; is[(*cnt)++] = (UBYTE)(i-j); } while (j<i) { is[(*cnt)++] = HIBYTE(args[pcd-j-1]); is[(*cnt)++] = LOBYTE(args[pcd-j-1]); j++; } } } }}
|
