/* - currenthsbcolor <hue> <saturation> <brightness> */ private int zcurrenthsbcolor(i_ctx_t *i_ctx_p) { os_ptr op = osp; float par[3]; gs_currenthsbcolor(igs, par); push(3); make_floats(op - 2, par, 3); return 0; }
/* - .currentmatrix <xx> <xy> <yx> <yy> <tx> <ty> */ static int zcurrentmatrix(i_ctx_t *i_ctx_p) { os_ptr op = osp; gs_matrix mat; int code = gs_currentmatrix(igs, &mat); if (code < 0) return code; push(6); code = make_floats(op - 5, &mat.xx, 6); if (code < 0) pop(6); return code; }
/* <in1> ... <function_struct> %execfunction <out1> ... */ int zexecfunction(i_ctx_t *i_ctx_p) { os_ptr op = osp; /* * Since this operator's name begins with %, the name is not defined * in systemdict. The only place this operator can ever appear is * in the execute-only closure created by .buildfunction. * Therefore, in principle it is unnecessary to check the argument. * However, we do a little checking anyway just on general * principles. Note that since the argument may be an instance of * any subclass of gs_function_t, we currently have no way to check * its type. */ if (!r_is_struct(op) || !r_has_masked_attrs(op, a_executable | a_execute, a_executable | a_all) ) return_error(gs_error_typecheck); { gs_function_t *pfn = (gs_function_t *) op->value.pstruct; int m = pfn->params.m, n = pfn->params.n; int diff = n - (m + 1); if (diff > 0) check_ostack(diff); { float params[20]; /* arbitrary size, just to avoid allocs */ float *in; float *out; int code = 0; if (m + n <= countof(params)) { in = params; } else { in = (float *)ialloc_byte_array(m + n, sizeof(float), "%execfunction(in/out)"); if (in == 0) code = gs_note_error(gs_error_VMerror); } out = in + m; if (code < 0 || (code = float_params(op - 1, m, in)) < 0 || (code = gs_function_evaluate(pfn, in, out)) < 0 ) DO_NOTHING; else { if (diff > 0) push(diff); /* can't fail */ else if (diff < 0) { pop(-diff); op = osp; } code = make_floats(op + 1 - n, out, n); } if (in != params) ifree_object(in, "%execfunction(in)"); return code; } } }