/* * Handle the case of a large value or a value with a fraction part. * See gxmatrix.h for more details. */ fixed fixed_coeff_mult(fixed value, long coeff, const fixed_coeff *pfc, int maxb) { int shift = pfc->shift; /* * Test if the value is too large for simple long math. */ if ((value + (fixed_1 << (maxb - 1))) & (-fixed_1 << maxb)) { /* The second argument of fixed_mult_quo must be non-negative. */ return (coeff < 0 ? -fixed_mult_quo(value, -coeff, fixed_1 << shift) : fixed_mult_quo(value, coeff, fixed_1 << shift)); } else { /* * The construction above guarantees that the multiplications * won't overflow the capacity of an int. */ return (fixed) arith_rshift(fixed2int_var(value) * coeff + fixed2int(fixed_fraction(value) * coeff) + pfc->round, shift); } }
/* Note that the arguments are fixeds, not ints! */ int gz_fill_trapezoid_fixed(fixed fx0, fixed fw0, fixed fy0, fixed fx1, fixed fw1, fixed fh, int swap_axes, gx_device_color *pdevc, gs_state *pgs) { /* For the moment, we just convert everything to ints. */ /* Later we will do the right thing with fractional pixels. */ int x0 = fixed2int(fx0); fixed fx0r = fx0 + fw0; int w0 = fixed2int_ceiling(fx0r) - x0; int y0 = fixed2int(fy0); int x1 = fixed2int(fx1); fixed fx1r = fx1 + fw1; int w1 = fixed2int_ceiling(fx1r) - x1; fixed fy1 = fy0 + fh; int y1 = fixed2int_ceiling(fy1); int h = y1 - y0; if ( w0 == 0 && w1 == 0 || h <= 0 ) return 0; if ( !swap_axes && color_is_pure(pdevc) ) { gx_device *dev = pgs->device->info; if ( (*dev->procs->fill_trapezoid)(dev, x0, y0, w0, x1, y1, w1, pdevc->color1) >= 0 ) return 0; } { int xl, fxl; int dxl, dxl1, dxlf = x1 - x0; int xr, fxr; int dxr, dxr1, dxrf = x1 + w1 - (x0 + w0); int y = y0; int rxl, rxr, ry; /* Compute integer and fractional deltas */ #define reduce_delta(df, d, d1, pos)\ if ( df >= 0 )\ { if ( df >= h )\ d1 = (d = df / h) + 1, df -= d * h;\ else /* save the divides */\ { pos();\ d = 0, d1 = 1;\ }\ }\ else /* df < 0 */\ { if ( df <= -h )\ d1 = (d = df / h) - 1, df = d * h - df;\ else /* save the divides */\ d = 0, d1 = -1, df = -df;\ } #define fill_trap_rect(x,y,w,h)\ if ( swap_axes ) gz_fill_rectangle(y, x, h, w, pdevc, pgs);\ else gz_fill_rectangle(x, y, w, h, pdevc, pgs) #define pos_for_xl() /* nothing */ reduce_delta(dxlf, dxl, dxl1, pos_for_xl); #define pos_for_xr()\ if ( dxl == 0 && dxlf == 0 && dxrf == 0 ) /* detect rectangle */\ { fill_trap_rect(x0, y0, w0, h);\ return 0;\ } reduce_delta(dxrf, dxr, dxr1, pos_for_xr); xl = x0, fxl = arith_rshift(dxlf, 1); xr = x0 + w0, fxr = arith_rshift(dxrf, 1); rxl = xl, rxr = xr, ry = y; /* Do the fill */ do { if ( xl != rxl || xr != rxr ) /* detect rectangles */ { fill_trap_rect(rxl, ry, rxr - rxl, y - ry); rxl = xl, rxr = xr, ry = y; } if ( (fxl += dxlf) >= h ) fxl -= h, xl += dxl1; else xl += dxl; if ( (fxr += dxrf) >= h ) fxr -= h, xr += dxr1; else xr += dxr; } while ( ++y < y1 ); if ( y != ry ) { fill_trap_rect(rxl, ry, rxr - rxl, y - ry); } #undef fill_trap_rect } return 0; }
/* * Define an implementation that uses trilinear interpolation. */ static void interpolate_accum(const fixed * pi, const gx_color_lookup_table * pclt, frac * pv, fixed factor) { const int *pdim = pclt->dims; int m = pclt->m; if (pclt->n > 3) { /* Do two 3-D interpolations, interpolating between them. */ gx_color_lookup_table clt3; int ix = fixed2int_var(pi[0]); fixed fx = fixed_fraction(pi[0]); clt3.n = 3; clt3.dims[0] = pdim[1]; /* needed only for range checking */ clt3.dims[1] = pdim[2]; clt3.dims[2] = pdim[3]; clt3.m = m; clt3.table = pclt->table + ix * pdim[1]; interpolate_accum(pi + 1, &clt3, pv, fixed_1); if (ix == pdim[0] - 1) return; clt3.table += pdim[1]; interpolate_accum(pi + 1, &clt3, pv, fx); } else { int ic = fixed2int_var(pi[2]); fixed fc = fixed_fraction(pi[2]); uint dc1 = (ic == pdim[2] - 1 ? 0 : m); int ib = fixed2int_var(pi[1]); fixed fb = fixed_fraction(pi[1]); uint db1 = (ib == pdim[1] - 1 ? 0 : pdim[2] * m); uint dbc = (ib * pdim[2] + ic) * m; uint dbc1 = db1 + dc1; int ia = fixed2int_var(pi[0]); fixed fa = fixed_fraction(pi[0]); const byte *pa0 = pclt->table[ia].data + dbc; const byte *pa1 = (ia == pdim[0] - 1 ? pa0 : pclt->table[ia + 1].data + dbc); int j; /* The values to be interpolated are */ /* pa{0,1}[{0,db1,dc1,dbc1}]. */ for (j = 0; j < m; ++j, ++pa0, ++pa1) { frac v000 = byte2frac(pa0[0]); frac v001 = byte2frac(pa0[dc1]); frac v010 = byte2frac(pa0[db1]); frac v011 = byte2frac(pa0[dbc1]); frac v100 = byte2frac(pa1[0]); frac v101 = byte2frac(pa1[dc1]); frac v110 = byte2frac(pa1[db1]); frac v111 = byte2frac(pa1[dbc1]); frac rv; frac v00 = v000 + (frac) arith_rshift((long)fc * (v001 - v000), _fixed_shift); frac v01 = v010 + (frac) arith_rshift((long)fc * (v011 - v010), _fixed_shift); frac v10 = v100 + (frac) arith_rshift((long)fc * (v101 - v100), _fixed_shift); frac v11 = v110 + (frac) arith_rshift((long)fc * (v111 - v110), _fixed_shift); frac v0 = v00 + (frac) arith_rshift((long)fb * (v01 - v00), _fixed_shift); frac v1 = v10 + (frac) arith_rshift((long)fb * (v11 - v10), _fixed_shift); rv = v0 + (frac) arith_rshift((long)fa * (v1 - v0), _fixed_shift); if (factor == fixed_1) pv[j] = rv; else pv[j] += (frac) arith_rshift((long)factor * (rv - pv[j]), _fixed_shift); } } }
/* * Continue interpreting a Type 2 charstring. If str != 0, it is taken as * the byte string to interpret. Return 0 on successful completion, <0 on * error, or >0 when client intervention is required (or allowed). The int* * argument is only for compatibility with the Type 1 charstring interpreter. */ int gs_type2_interpret(gs_type1_state * pcis, const gs_glyph_data_t *pgd, int *ignore_pindex) { gs_font_type1 *pfont = pcis->pfont; gs_type1_data *pdata = &pfont->data; t1_hinter *h = &pcis->h; bool encrypted = pdata->lenIV >= 0; fixed cstack[ostack_size]; cs_ptr csp; #define clear CLEAR_CSTACK(cstack, csp) ip_state_t *ipsp = &pcis->ipstack[pcis->ips_count - 1]; register const byte *cip; register crypt_state state; register int c; cs_ptr ap; bool vertical; int code = 0; /****** FAKE THE REGISTRY ******/ struct { float *values; uint size; } Registry[1]; Registry[0].values = pcis->pfont->data.WeightVector.values; switch (pcis->init_done) { case -1: t1_hinter__init(h, pcis->path); break; case 0: gs_type1_finish_init(pcis); /* sets origin */ code = t1_hinter__set_mapping(h, &pcis->pis->ctm, &pfont->FontMatrix, &pfont->base->FontMatrix, pcis->scale.x.log2_unit, pcis->scale.x.log2_unit, pcis->scale.x.log2_unit - pcis->log2_subpixels.x, pcis->scale.y.log2_unit - pcis->log2_subpixels.y, pcis->origin.x, pcis->origin.y, gs_currentaligntopixels(pfont->dir)); if (code < 0) return code; code = t1_hinter__set_font_data(h, 2, pdata, pcis->no_grid_fitting, pcis->pfont->is_resource); if (code < 0) return code; break; default /*case 1 */ : break; } INIT_CSTACK(cstack, csp, pcis); if (pgd == 0) goto cont; ipsp->cs_data = *pgd; cip = pgd->bits.data; if (cip == 0) return (gs_note_error(gs_error_invalidfont)); call:state = crypt_charstring_seed; if (encrypted) { int skip = pdata->lenIV; /* Skip initial random bytes */ for (; skip > 0; ++cip, --skip) decrypt_skip_next(*cip, state); } goto top; cont:if (ipsp < pcis->ipstack || ipsp->ip == 0) return (gs_note_error(gs_error_invalidfont)); cip = ipsp->ip; state = ipsp->dstate; top:for (;;) { uint c0 = *cip++; charstring_next(c0, state, c, encrypted); if (c >= c_num1) { /* This is a number, decode it and push it on the stack. */ if (c < c_pos2_0) { /* 1-byte number */ decode_push_num1(csp, cstack, c); } else if (c < cx_num4) { /* 2-byte number */ decode_push_num2(csp, cstack, c, cip, state, encrypted); } else if (c == cx_num4) { /* 4-byte number */ long lw; decode_num4(lw, cip, state, encrypted); /* 32-bit numbers are 16:16. */ CS_CHECK_PUSH(csp, cstack); *++csp = arith_rshift(lw, 16 - _fixed_shift); } else /* not possible */ return_error(gs_error_invalidfont); pushed:if_debug3('1', "[1]%d: (%d) %f\n", (int)(csp - cstack), c, fixed2float(*csp)); continue; } #ifdef DEBUG if (gs_debug['1']) { static const char *const c2names[] = {char2_command_names}; if (c2names[c] == 0) dlprintf2("[1]0x%lx: %02x??\n", (ulong) (cip - 1), c); else dlprintf3("[1]0x%lx: %02x %s\n", (ulong) (cip - 1), c, c2names[c]); } #endif switch ((char_command) c) { #define cnext clear; goto top /* Commands with identical functions in Type 1 and Type 2, */ /* except for 'escape'. */ case c_undef0: case c_undef2: case c_undef17: return_error(gs_error_invalidfont); case c_callsubr: c = fixed2int_var(*csp) + pdata->subroutineNumberBias; code = pdata->procs.subr_data (pfont, c, false, &ipsp[1].cs_data); subr:if (code < 0) { /* Calling a Subr with an out-of-range index is clearly a error: * the Adobe documentation says the results of doing this are * undefined. However, we have seen a PDF file produced by Adobe * PDF Library 4.16 that included a Type 2 font that called an * out-of-range Subr, and Acrobat Reader did not signal an error. * Therefore, we ignore such calls. */ cip++; goto top; } --csp; ipsp->ip = cip, ipsp->dstate = state; ++ipsp; cip = ipsp->cs_data.bits.data; goto call; case c_return: gs_glyph_data_free(&ipsp->cs_data, "gs_type2_interpret"); --ipsp; goto cont; case c_undoc15: /* See gstype1.h for information on this opcode. */ cnext; /* Commands with similar but not identical functions */ /* in Type 1 and Type 2 charstrings. */ case cx_hstem: goto hstem; case cx_vstem: goto vstem; case cx_vmoveto: check_first_operator(csp > cstack); code = t1_hinter__rmoveto(h, 0, *csp); move: cc: if (code < 0) return code; goto pp; case cx_rlineto: for (ap = cstack; ap + 1 <= csp; ap += 2) { code = t1_hinter__rlineto(h, ap[0], ap[1]); if (code < 0) return code; } pp: cnext; case cx_hlineto: vertical = false; goto hvl; case cx_vlineto: vertical = true; hvl:for (ap = cstack; ap <= csp; vertical = !vertical, ++ap) { if (vertical) { code = t1_hinter__rlineto(h, 0, ap[0]); } else { code = t1_hinter__rlineto(h, ap[0], 0); } if (code < 0) return code; } goto pp; case cx_rrcurveto: for (ap = cstack; ap + 5 <= csp; ap += 6) { code = t1_hinter__rcurveto(h, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5]); if (code < 0) return code; } goto pp; case cx_endchar: /* * It is a feature of Type 2 CharStrings that if endchar is * invoked with 4 or 5 operands, it is equivalent to the * Type 1 seac operator. In this case, the asb operand of * seac is missing: we assume it is the same as the * l.s.b. of the accented character. This feature was * undocumented until the 16 March 2000 version of the Type * 2 Charstring Format specification, but, thankfully, is * described in that revision. */ if (csp >= cstack + 3) { check_first_operator(csp > cstack + 3); code = gs_type1_seac(pcis, cstack, 0, ipsp); if (code < 0) return code; clear; cip = ipsp->cs_data.bits.data; goto call; } /* * This might be the only operator in the charstring. * In this case, there might be a width on the stack. */ check_first_operator(csp >= cstack); if (pcis->seac_accent < 0) { code = t1_hinter__endglyph(h); if (code < 0) return code; code = gx_setcurrentpoint_from_path(pcis->pis, pcis->path); if (code < 0) return code; } else { t1_hinter__setcurrentpoint(h, pcis->save_adxy.x + pcis->origin_offset.x, pcis->save_adxy.y + pcis->origin_offset.y); code = t1_hinter__end_subglyph(h); if (code < 0) return code; } code = gs_type1_endchar(pcis); if (code == 1) { /* * Reset the total hint count so that hintmask will * parse its following data correctly. * (gs_type1_endchar already reset the actual hint * tables.) */ pcis->num_hints = 0; /* do accent of seac */ ipsp = &pcis->ipstack[pcis->ips_count - 1]; cip = ipsp->cs_data.bits.data; goto call; } return code; case cx_rmoveto: /* See vmoveto above re closing the subpath. */ check_first_operator(!((csp - cstack) & 1)); if (csp > cstack + 1) { /* Some Type 2 charstrings omit the vstemhm operator before rmoveto, even though this is only allowed before hintmask and cntrmask. Thanks to Felix Pahl. */ type2_vstem(pcis, csp - 2, cstack); cstack [0] = csp [-1]; cstack [1] = csp [ 0]; csp = cstack + 1; } code = t1_hinter__rmoveto(h, csp[-1], *csp); goto move; case cx_hmoveto: /* See vmoveto above re closing the subpath. */ check_first_operator(csp > cstack); code = t1_hinter__rmoveto(h, *csp, 0); goto move; case cx_vhcurveto: vertical = true; goto hvc; case cx_hvcurveto: vertical = false; hvc:for (ap = cstack; ap + 3 <= csp; vertical = !vertical, ap += 4) { gs_fixed_point pt[2] = {{0, 0}, {0, 0}}; if (vertical) { pt[0].y = ap[0]; pt[1].x = ap[3]; if (ap + 4 == csp) pt[1].y = ap[4]; } else { pt[0].x = ap[0]; if (ap + 4 == csp) pt[1].x = ap[4]; pt[1].y = ap[3]; } code = t1_hinter__rcurveto(h, pt[0].x, pt[0].y, ap[1], ap[2], pt[1].x, pt[1].y); if (code < 0) return code; } goto pp; /*********************** * New Type 2 commands * ***********************/ case c2_blend: { int n = fixed2int_var(*csp); int num_values = csp - cstack; gs_font_type1 *pfont = pcis->pfont; int k = pfont->data.WeightVector.count; int i, j; cs_ptr base, deltas; base = csp - 1 - num_values; deltas = base + n - 1; for (j = 0; j < n; j++, base++, deltas += k - 1) for (i = 1; i < k; i++) *base += (fixed)(deltas[i] * pfont->data.WeightVector.values[i]); } cnext; case c2_hstemhm: hstem:check_first_operator(!((csp - cstack) & 1)); { fixed x = 0; for (ap = cstack; ap + 1 <= csp; x += ap[1], ap += 2) { code = t1_hinter__hstem(h, x += ap[0], ap[1]); if (code < 0) return code; } } pcis->num_hints += (csp + 1 - cstack) >> 1; cnext; case c2_hintmask: /* * A hintmask at the beginning of the CharString is * equivalent to vstemhm + hintmask. For simplicity, we use * this interpretation everywhere. */ case c2_cntrmask: check_first_operator(!((csp - cstack) & 1)); type2_vstem(pcis, csp, cstack); /* * We should clear the stack here only if this is the * initial mask operator that includes the implicit * vstemhm, but currently this is too much trouble to * detect. */ clear; { byte mask[max_total_stem_hints / 8]; int i; for (i = 0; i < pcis->num_hints; ++cip, i += 8) { charstring_next(*cip, state, mask[i >> 3], encrypted); if_debug1('1', " 0x%02x", mask[i >> 3]); } if_debug0('1', "\n"); ipsp->ip = cip; ipsp->dstate = state; if (c == c2_cntrmask) { /****** NYI ******/ } else { /* hintmask or equivalent */ if_debug0('1', "[1]hstem hints:\n"); if_debug0('1', "[1]vstem hints:\n"); code = t1_hinter__hint_mask(h, mask); if (code < 0) return code; } } break; case c2_vstemhm: vstem:check_first_operator(!((csp - cstack) & 1)); type2_vstem(pcis, csp, cstack); cnext; case c2_rcurveline: for (ap = cstack; ap + 5 <= csp; ap += 6) { code = t1_hinter__rcurveto(h, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5]); if (code < 0) return code; } code = t1_hinter__rlineto(h, ap[0], ap[1]); goto cc; case c2_rlinecurve: for (ap = cstack; ap + 7 <= csp; ap += 2) { code = t1_hinter__rlineto(h, ap[0], ap[1]); if (code < 0) return code; } code = t1_hinter__rcurveto(h, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5]); goto cc; case c2_vvcurveto: ap = cstack; { int n = csp + 1 - cstack; fixed dxa = (n & 1 ? *ap++ : 0); for (; ap + 3 <= csp; ap += 4) { code = t1_hinter__rcurveto(h, dxa, ap[0], ap[1], ap[2], fixed_0, ap[3]); if (code < 0) return code; dxa = 0; } } goto pp; case c2_hhcurveto: ap = cstack; { int n = csp + 1 - cstack; fixed dya = (n & 1 ? *ap++ : 0); for (; ap + 3 <= csp; ap += 4) { code = t1_hinter__rcurveto(h, ap[0], dya, ap[1], ap[2], ap[3], fixed_0); if (code < 0) return code; dya = 0; } } goto pp; case c2_shortint: { int c1, c2; charstring_next(*cip, state, c1, encrypted); ++cip; charstring_next(*cip, state, c2, encrypted); ++cip; CS_CHECK_PUSH(csp, cstack); *++csp = int2fixed((((c1 ^ 0x80) - 0x80) << 8) + c2); } goto pushed; case c2_callgsubr: c = fixed2int_var(*csp) + pdata->gsubrNumberBias; code = pdata->procs.subr_data (pfont, c, true, &ipsp[1].cs_data); goto subr; case cx_escape: charstring_next(*cip, state, c, encrypted); ++cip; #ifdef DEBUG if (gs_debug['1'] && c < char2_extended_command_count) { static const char *const ce2names[] = {char2_extended_command_names}; if (ce2names[c] == 0) dlprintf2("[1]0x%lx: %02x??\n", (ulong) (cip - 1), c); else dlprintf3("[1]0x%lx: %02x %s\n", (ulong) (cip - 1), c, ce2names[c]); } #endif switch ((char2_extended_command) c) { case ce2_and: csp[-1] = ((csp[-1] != 0) & (*csp != 0) ? fixed_1 : 0); --csp; break; case ce2_or: csp[-1] = (csp[-1] | *csp ? fixed_1 : 0); --csp; break; case ce2_not: *csp = (*csp ? 0 : fixed_1); break; case ce2_store: { int i, n = fixed2int_var(*csp); float *to = Registry[fixed2int_var(csp[-3])].values + fixed2int_var(csp[-2]); const fixed *from = pcis->transient_array + fixed2int_var(csp[-1]); for (i = 0; i < n; ++i) to[i] = fixed2float(from[i]); } csp -= 4; break; case ce2_abs: if (*csp < 0) *csp = -*csp; break; case ce2_add: csp[-1] += *csp; --csp; break; case ce2_sub: csp[-1] -= *csp; --csp; break; case ce2_div: csp[-1] = float2fixed((double)csp[-1] / *csp); --csp; break; case ce2_load: /* The specification says there is no j (starting index */ /* in registry array) argument.... */ { int i, n = fixed2int_var(*csp); const float *from = Registry[fixed2int_var(csp[-2])].values; fixed *to = pcis->transient_array + fixed2int_var(csp[-1]); for (i = 0; i < n; ++i) to[i] = float2fixed(from[i]); } csp -= 3; break; case ce2_neg: *csp = -*csp; break; case ce2_eq: csp[-1] = (csp[-1] == *csp ? fixed_1 : 0); --csp; break; case ce2_drop: --csp; break; case ce2_put: pcis->transient_array[fixed2int_var(*csp)] = csp[-1]; csp -= 2; break; case ce2_get: *csp = pcis->transient_array[fixed2int_var(*csp)]; break; case ce2_ifelse: if (csp[-1] > *csp) csp[-3] = csp[-2]; csp -= 3; break; case ce2_random: CS_CHECK_PUSH(csp, cstack); ++csp; /****** NYI ******/ break; case ce2_mul: { double prod = fixed2float(csp[-1]) * *csp; csp[-1] = (prod > max_fixed ? max_fixed : prod < min_fixed ? min_fixed : (fixed)prod); } --csp; break; case ce2_sqrt: if (*csp >= 0) *csp = float2fixed(sqrt(fixed2float(*csp))); break; case ce2_dup: CS_CHECK_PUSH(csp, cstack); csp[1] = *csp; ++csp; break; case ce2_exch: { fixed top = *csp; *csp = csp[-1], csp[-1] = top; } break; case ce2_index: *csp = (*csp < 0 ? csp[-1] : csp[-1 - fixed2int_var(csp[-1])]); break; case ce2_roll: { int distance = fixed2int_var(*csp); int count = fixed2int_var(csp[-1]); cs_ptr bot; csp -= 2; if (count < 0 || count > csp + 1 - cstack) return_error(gs_error_invalidfont); if (count == 0) break; if (distance < 0) distance = count - (-distance % count); bot = csp + 1 - count; while (--distance >= 0) { fixed top = *csp; memmove(bot + 1, bot, (count - 1) * sizeof(fixed)); *bot = top; } } break; case ce2_hflex: csp[6] = fixed_half; /* fd/100 */ csp[4] = *csp, csp[5] = 0; /* dx6, dy6 */ csp[2] = csp[-1], csp[3] = -csp[-4]; /* dx5, dy5 */ *csp = csp[-2], csp[1] = 0; /* dx4, dy4 */ csp[-2] = csp[-3], csp[-1] = 0; /* dx3, dy3 */ csp[-3] = csp[-4], csp[-4] = csp[-5]; /* dx2, dy2 */ csp[-5] = 0; /* dy1 */ csp += 6; goto flex; case ce2_flex: *csp /= 100; /* fd/100 */ flex: { fixed x_join = csp[-12] + csp[-10] + csp[-8]; fixed y_join = csp[-11] + csp[-9] + csp[-7]; fixed x_end = x_join + csp[-6] + csp[-4] + csp[-2]; fixed y_end = y_join + csp[-5] + csp[-3] + csp[-1]; gs_point join, end; double flex_depth; if ((code = gs_distance_transform(fixed2float(x_join), fixed2float(y_join), &ctm_only(pcis->pis), &join)) < 0 || (code = gs_distance_transform(fixed2float(x_end), fixed2float(y_end), &ctm_only(pcis->pis), &end)) < 0 ) return code; /* * Use the X or Y distance depending on whether * the curve is more horizontal or more * vertical. */ if (any_abs(end.y) > any_abs(end.x)) flex_depth = join.x; else flex_depth = join.y; if (fabs(flex_depth) < fixed2float(*csp)) { /* Do flex as line. */ code = t1_hinter__rlineto(h, x_end, y_end); } else { /* * Do flex as curve. We can't jump to rrc, * because the flex operators don't clear * the stack (!). */ code = t1_hinter__rcurveto(h, csp[-12], csp[-11], csp[-10], csp[-9], csp[-8], csp[-7]); if (code < 0) return code; code = t1_hinter__rcurveto(h, csp[-6], csp[-5], csp[-4], csp[-3], csp[-2], csp[-1]); } if (code < 0) return code; csp -= 13; } cnext; case ce2_hflex1: csp[4] = fixed_half; /* fd/100 */ csp[2] = *csp; /* dx6 */ csp[3] = -(csp[-7] + csp[-5] + csp[-1]); /* dy6 */ *csp = csp[-2], csp[1] = csp[-1]; /* dx5, dy5 */ csp[-2] = csp[-3], csp[-1] = 0; /* dx4, dy4 */ csp[-3] = 0; /* dy3 */ csp += 4; goto flex; case ce2_flex1: { fixed dx = csp[-10] + csp[-8] + csp[-6] + csp[-4] + csp[-2]; fixed dy = csp[-9] + csp[-7] + csp[-5] + csp[-3] + csp[-1]; if (any_abs(dx) > any_abs(dy)) csp[1] = -dy; /* d6 is dx6 */ else csp[1] = *csp, *csp = -dx; /* d6 is dy6 */ } csp[2] = fixed_half; /* fd/100 */ csp += 2; goto flex; } break; /* Fill up the dispatch up to 32. */ case_c2_undefs: default: /* pacify compiler */ return_error(gs_error_invalidfont); } } }