/* Get a shading parameter. */
static int
shading_param(const_os_ptr op, const gs_shading_t ** ppsh)
{ /*
* Since shadings form a subclass hierarchy, we currently have
* no way to check whether a structure is actually a shading.
*/
if (!r_is_struct(op) ||
r_has_masked_attrs(op, a_executable | a_execute, a_all)
)
return_error(gs_error_typecheck);
*ppsh = (gs_shading_t *) op->value.pstruct;
return 0;
}
/*
* If a PostScript object is a Function procedure, return the function
* object, otherwise return 0.
*/
gs_function_t *
ref_function(const ref *op)
{
if (r_has_type(op, t_array) &&
r_has_masked_attrs(op, a_executable | a_execute,
a_executable | a_all) &&
r_size(op) == 2 &&
r_has_type_attrs(op->value.refs + 1, t_operator, a_executable) &&
op->value.refs[1].value.opproc == zexecfunction &&
r_is_struct(op->value.refs) &&
r_has_masked_attrs(op->value.refs, a_executable | a_execute,
a_executable | a_all)
)
return (gs_function_t *)op->value.refs->value.pstruct;
return 0;
}
static int
zwritecmap(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
ref *pcodemap;
gs_cmap_t *pcmap;
int code;
stream *s;
check_type(*op, t_dictionary);
if (dict_find_string(op, "CodeMap", &pcodemap) <= 0 ||
!r_is_struct(pcodemap)
)
return_error(e_typecheck);
check_write_file(s, op - 1);
pcmap = r_ptr(pcodemap, gs_cmap_t);
code = psf_write_cmap(s, pcmap, zfcmap_put_name_default, NULL, -1);
if (code >= 0)
pop(2);
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;
}
}
}
