/* Continuation operator for enumerating files */
static int
file_continue(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
es_ptr pscratch = esp - 2;
file_enum *pfen = r_ptr(esp - 1, file_enum);
long devlen = esp[-3].value.intval;
gx_io_device *iodev = r_ptr(esp - 4, gx_io_device);
uint len = r_size(pscratch);
uint code;
if (len < devlen)
return_error(e_rangecheck); /* not even room for device len */
memcpy((char *)pscratch->value.bytes, iodev->dname, devlen);
code = iodev->procs.enumerate_next(pfen, (char *)pscratch->value.bytes + devlen,
len - devlen);
if (code == ~(uint) 0) { /* all done */
esp -= 5; /* pop proc, pfen, devlen, iodev , mark */
return o_pop_estack;
} else if (code > len) /* overran string */
return_error(e_rangecheck);
else {
push(1);
ref_assign(op, pscratch);
r_set_size(op, code + devlen);
push_op_estack(file_continue); /* come again */
*++esp = pscratch[2]; /* proc */
return o_push_estack;
}
}
/* Cleanup procedure for enumerating files */
static int
file_cleanup(i_ctx_t *i_ctx_p)
{
gx_io_device *iodev = r_ptr(esp + 2, gx_io_device);
iodev->procs.enumerate_close(r_ptr(esp + 5, file_enum));
return 0;
}
/* Clean up after installing the halftone. */
static int
sethalftone_cleanup(i_ctx_t *i_ctx_p)
{
gx_device_halftone *pdht = r_ptr(&esp[4], gx_device_halftone);
gs_halftone *pht = r_ptr(&esp[3], gs_halftone);
gs_free_object(pdht->rc.memory, pdht,
"sethalftone_cleanup(device halftone)");
gs_free_object(pht->rc.memory, pht,
"sethalftone_cleanup(halftone)");
return 0;
}
/* Clean up after installing the color screen. */
static int
setcolorscreen_cleanup(i_ctx_t *i_ctx_p)
{
gs_halftone *pht = r_ptr(esp + 6, gs_halftone);
gx_device_halftone *pdht = r_ptr(esp + 7, gx_device_halftone);
gs_free_object(pdht->rc.memory, pdht,
"setcolorscreen_cleanup(device halftone)");
gs_free_object(pht->rc.memory, pht,
"setcolorscreen_cleanup(halftone)");
return 0;
}
/* we call this from ps code to instantiate a jbig2_global_context
object which the JBIG2Decode filter uses if available. The
pointer to the global context is stored in an astruct object
and returned that way since it lives outside the interpreters
memory management */
static int
z_jbig2makeglobalctx(i_ctx_t * i_ctx_p)
{
void *global = NULL;
s_jbig2_global_data_t *st;
os_ptr op = osp;
byte *data;
int size;
int code = 0;
check_type(*op, t_astruct);
size = gs_object_size(imemory, op->value.pstruct);
data = r_ptr(op, byte);
code = s_jbig2decode_make_global_data(data, size,
&global);
if (size > 0 && global == NULL) {
dlprintf("failed to create parsed JBIG2GLOBALS object.");
return_error(e_unknownerror);
}
st = ialloc_struct(s_jbig2_global_data_t,
&st_jbig2_global_data_t,
"jbig2decode parsed global context");
if (st == NULL) return_error(e_VMerror);
st->data = global;
make_astruct(op, a_readonly | icurrent_space, (byte*)st);
return code;
}
/* <source> <dict> /JBIG2Decode <file> */
static int
z_jbig2decode(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
ref *sop = NULL;
s_jbig2_global_data_t *gref;
stream_jbig2decode_state state;
/* Extract the global context reference, if any, from the parameter
dictionary and embed it in our stream state. The original object
ref is under the JBIG2Globals key.
We expect the postscript code to resolve this and call
z_jbig2makeglobalctx() below to create an astruct wrapping the
global decoder data and store it under the .jbig2globalctx key
*/
s_jbig2decode_set_global_data((stream_state*)&state, NULL);
if (r_has_type(op, t_dictionary)) {
check_dict_read(*op);
if ( dict_find_string(op, ".jbig2globalctx", &sop) > 0) {
gref = r_ptr(sop, s_jbig2_global_data_t);
s_jbig2decode_set_global_data((stream_state*)&state, gref);
}
}
/* we pass npop=0, since we've no arguments left to consume */
return filter_read(i_ctx_p, 0, &s_jbig2decode_template,
(stream_state *) & state, (sop ? r_space(sop) : 0));
}
/* Validate a font parameter. */
int
font_param(const ref * pfdict, gs_font ** ppfont)
{ /*
* Check that pfdict is a read-only dictionary, that it has a FID
* entry whose value is a fontID, and that the fontID points to a
* gs_font structure whose associated PostScript dictionary is
* pfdict.
*/
ref *pid;
gs_font *pfont;
const font_data *pdata;
check_type(*pfdict, t_dictionary);
if (dict_find_string(pfdict, "FID", &pid) <= 0 ||
!r_has_type(pid, t_fontID)
)
return_error(e_invalidfont);
pfont = r_ptr(pid, gs_font);
if (pfont == 0)
return_error(e_invalidfont); /* unregistered font */
pdata = pfont->client_data;
if (!obj_eq(pfont->memory, &pdata->dict, pfdict))
return_error(e_invalidfont);
*ppfont = pfont;
return 0;
}
/* Finish up after loading the rendering caches. */
static int
cie_cache_render_finish(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_cie_render *pcrd = r_ptr(op, gs_cie_render);
int code;
if (pcrd->RenderTable.lookup.table != 0 &&
!pcrd->caches.RenderTableT_is_identity
) {
/* Convert the RenderTableT cache from floats to fracs. */
int j;
for (j = 0; j < pcrd->RenderTable.lookup.m; j++)
gs_cie_cache_to_fracs(&pcrd->caches.RenderTableT[j].floats,
&pcrd->caches.RenderTableT[j].fracs);
}
pcrd->status = CIE_RENDER_STATUS_SAMPLED;
pcrd->EncodeLMN = EncodeLMN_from_cache;
pcrd->EncodeABC = EncodeABC_from_cache;
pcrd->RenderTable.T = RenderTableT_from_cache;
code = gs_cie_render_complete(pcrd);
if (code < 0)
return code;
pop(1);
return 0;
}
/* Install the halftone after sampling. */
static int
sethalftone_finish(i_ctx_t *i_ctx_p)
{
gx_device_halftone *pdht = r_ptr(esp, gx_device_halftone);
int code;
if (pdht->components)
pdht->order = pdht->components[0].corder;
code = gx_ht_install(igs, r_ptr(esp - 1, gs_halftone), pdht);
if (code < 0)
return code;
istate->halftone = esp[-2];
esp -= 4;
sethalftone_cleanup(i_ctx_p);
return o_pop_estack;
}
/* <dict> <crd> .setcolorrendering1 - */
static int
zsetcolorrendering1(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
es_ptr ep = esp;
ref_cie_render_procs procs;
int code;
check_type(op[-1], t_dictionary);
check_stype(*op, st_cie_render1);
code = zcrd1_proc_params(imemory, op - 1, &procs);
if (code < 0)
return code;
code = gs_setcolorrendering(igs, r_ptr(op, gs_cie_render));
if (code < 0)
return code;
if (gs_cie_cs_common(igs) != 0 &&
(code = cie_cache_joint(i_ctx_p, &procs, gs_cie_cs_common(igs), igs)) < 0
)
return code;
istate->colorrendering.dict = op[-1];
istate->colorrendering.procs = procs;
pop(2);
return (esp == ep ? 0 : o_push_estack);
}
/* Install the color screen after sampling. */
static int
setcolorscreen_finish(i_ctx_t *i_ctx_p)
{
gx_device_halftone *pdht = r_ptr(esp, gx_device_halftone);
int code;
pdht->order = pdht->components[0].corder;
code = gx_ht_install(igs, r_ptr(esp - 1, gs_halftone), pdht);
if (code < 0)
return code;
memcpy(&istate->screen_procs.red, esp - 5, sizeof(ref) * 4);
make_null(&istate->halftone);
esp -= 7;
setcolorscreen_cleanup(i_ctx_p);
return o_pop_estack;
}
/* Clean up after screen enumeration */
static int
screen_cleanup(i_ctx_t *i_ctx_p)
{
gs_screen_enum *penum = r_ptr(esp + snumpush, gs_screen_enum);
gs_free_object(penum->halftone.rc.memory, penum, "screen_cleanup");
return 0;
}
/* Clean up after enumerating an image */
static int
image_cleanup(i_ctx_t *i_ctx_p)
{
es_ptr ep_top = esp + NUM_PUSH(EBOT_NUM_SOURCES(esp)->value.intval);
gs_image_enum *penum = r_ptr(ep_top, gs_image_enum);
return gs_image_cleanup_and_free_enum(penum, igs);
}
/* Clean up after a pathforall */
static int
path_cleanup(i_ctx_t *i_ctx_p)
{
gs_path_enum *penum = r_ptr(esp + 6, gs_path_enum);
gs_path_enum_cleanup(penum);
ifree_object(penum, "path_cleanup");
return 0;
}
/* *op is the scanner state. */
static int
ztoken_continue(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
scanner_state *pstate;
check_stype(*op, st_scanner_state_dynamic);
pstate = r_ptr(op, scanner_state);
return token_continue(i_ctx_p, pstate, false);
}
/* Install the color screen after sampling. */
static int
setcolorscreen_finish(i_ctx_t *i_ctx_p)
{
gx_device_halftone *pdht = r_ptr(esp, gx_device_halftone);
int code;
pdht->order = pdht->components[0].corder;
code = gx_ht_install(igs, r_ptr(esp - 1, gs_halftone), pdht);
if (code < 0)
return code;
istate->screen_procs.red = esp[-5];
istate->screen_procs.green = esp[-4];
istate->screen_procs.blue = esp[-3];
istate->screen_procs.gray = esp[-2];
make_null(&istate->halftone);
esp -= 7;
setcolorscreen_cleanup(i_ctx_p);
return o_pop_estack;
}
/* Find the current show enumerator on the e-stack. */
gs_text_enum_t *
op_show_find(i_ctx_t *i_ctx_p)
{
uint index = op_show_find_index(i_ctx_p);
if (index == 0)
return 0; /* no mark */
return r_ptr(ref_stack_index(&e_stack, index - (snumpush - 1)),
gs_text_enum_t);
}
/* <string> <index> <int> put - */
static int
zput(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr op1 = op - 1;
os_ptr op2 = op1 - 1;
byte *sdata;
uint ssize;
switch (r_type(op2)) {
case t_dictionary:
if (i_ctx_p->in_superexec == 0)
check_dict_write(*op2);
{
int code = idict_put(op2, op1, op);
if (code < 0)
return code; /* error */
}
break;
case t_array:
check_write(*op2);
check_int_ltu(*op1, r_size(op2));
store_check_dest(op2, op);
{
ref *eltp = op2->value.refs + (uint) op1->value.intval;
ref_assign_old(op2, eltp, op, "put");
}
break;
case t_mixedarray: /* packed arrays are read-only */
case t_shortarray:
return_error(e_invalidaccess);
case t_string:
sdata = op2->value.bytes;
ssize = r_size(op2);
str: check_write(*op2);
check_int_ltu(*op1, ssize);
check_int_leu(*op, 0xff);
sdata[(uint)op1->value.intval] = (byte)op->value.intval;
break;
case t_astruct:
if (gs_object_type(imemory, op2->value.pstruct) != &st_bytes)
return_error(e_typecheck);
sdata = r_ptr(op2, byte);
ssize = gs_object_size(imemory, op2->value.pstruct);
goto str;
default:
return_op_typecheck(op2);
}
pop(3);
return 0;
}
/* *op is of type t_astruct(igstate_obj). */
static int
gstate_unshare(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
ref *pgsref = &r_ptr(op, igstate_obj)->gstate;
gs_state *pgs = r_ptr(pgsref, gs_state);
gs_state *pnew;
int_gstate *isp;
if (!ref_must_save(pgsref))
return 0;
/* Copy the gstate. */
pnew = gs_gstate(pgs);
if (pnew == 0)
return_error(e_VMerror);
isp = gs_int_gstate(pnew);
int_gstate_map_refs(isp, ref_mark_new);
ref_do_save(op, pgsref, "gstate_unshare");
make_istruct_new(pgsref, 0, pnew);
return 0;
}
/*
* Continuation for procedure data source. We use the topmost aliasing slot
* to remember whether we've just called the procedure (1) or whether we're
* returning from a RemapColor callout (0).
*/
static int
image_proc_continue(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_image_enum *penum = r_ptr(esp, gs_image_enum);
int px = ETOP_PLANE_INDEX(esp)->value.intval;
int num_sources = ETOP_NUM_SOURCES(esp)->value.intval;
uint size, used[gs_image_max_planes];
gs_const_string plane_data[gs_image_max_planes];
const byte *wanted;
int i, code;
if (!r_has_type_attrs(op, t_string, a_read)) {
check_op(1);
/* Procedure didn't return a (readable) string. Quit. */
esp = zimage_pop_estack(esp);
image_cleanup(i_ctx_p);
return_error(!r_has_type(op, t_string) ? e_typecheck : e_invalidaccess);
}
size = r_size(op);
if (size == 0 && ETOP_SOURCE(esp, 0)[1].value.intval == 0)
code = 1;
else {
for (i = 0; i < num_sources; i++)
plane_data[i].size = 0;
plane_data[px].data = op->value.bytes;
plane_data[px].size = size;
code = gs_image_next_planes(penum, plane_data, used);
if (code == e_RemapColor) {
op->value.bytes += used[px]; /* skip used data */
r_dec_size(op, used[px]);
ETOP_SOURCE(esp, 0)[1].value.intval = 0; /* RemapColor callout */
return code;
}
}
if (code) { /* Stop now. */
esp = zimage_pop_estack(esp);
pop(1);
image_cleanup(i_ctx_p);
return (code < 0 ? code : o_pop_estack);
}
pop(1);
wanted = gs_image_planes_wanted(penum);
do {
if (++px == num_sources)
px = 0;
} while (!wanted[px]);
ETOP_PLANE_INDEX(esp)->value.intval = px;
return image_proc_process(i_ctx_p);
}
/* Free the procs array and complete the joint caches. */
static int
cie_tpqr_finish(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_state *pgs = r_ptr(op, gs_state);
gs_cie_render *pcrd =
(gs_cie_render *)gs_currentcolorrendering(pgs); /* break const */
int code;
ifree_ref_array(op - 1, "cie_tpqr_finish");
pcrd->TransformPQR = TransformPQR_from_cache;
code = gs_cie_cs_complete(pgs, false);
pop(2);
return code;
}
/* BitsPerSample. */
static int
dict_threshold2_params(const ref * pdict, gs_threshold2_halftone * ptp,
ref * ptproc, gs_memory_t *mem)
{
ref *tstring;
int code =
dict_threshold_common_params(pdict,
(gs_threshold_halftone_common *)ptp,
&tstring, ptproc);
int bps;
uint size;
int cw2, ch2;
if (code < 0 ||
(code = cw2 = dict_int_param(pdict, "Width2", 0, 0x7fff, 0,
&ptp->width2)) < 0 ||
(code = ch2 = dict_int_param(pdict, "Height2", 0, 0x7fff, 0,
&ptp->height2)) < 0 ||
(code = dict_int_param(pdict, "BitsPerSample", 8, 16, -1, &bps)) < 0
)
return code;
if ((bps != 8 && bps != 16) || cw2 != ch2 ||
(!cw2 && (ptp->width2 == 0 || ptp->height2 == 0))
)
return_error(e_rangecheck);
ptp->bytes_per_sample = bps / 8;
switch (r_type(tstring)) {
case t_string:
size = r_size(tstring);
gs_bytestring_from_string(&ptp->thresholds, tstring->value.const_bytes,
size);
break;
case t_astruct:
if (gs_object_type(mem, tstring->value.pstruct) != &st_bytes)
return_error(e_typecheck);
size = gs_object_size(mem, tstring->value.pstruct);
gs_bytestring_from_bytes(&ptp->thresholds, r_ptr(tstring, byte),
0, size);
break;
default:
return_error(e_typecheck);
}
check_read(*tstring);
if (size != (ptp->width * ptp->height + ptp->width2 * ptp->height2) *
ptp->bytes_per_sample)
return_error(e_rangecheck);
return 0;
}
/* <bytestring1> <index> <string2> putinterval - */
static int
zputinterval(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr opindex = op - 1;
os_ptr opto = opindex - 1;
int code;
switch (r_type(opto)) {
default:
return_error(e_typecheck);
case t__invalid:
if (r_type(op) != t_array && r_type(op) != t_string && r_type(op) != t__invalid)
return_error(e_typecheck); /* to match Distiller */
else
return_error(e_stackunderflow);
case t_mixedarray:
case t_shortarray:
return_error(e_invalidaccess);
case t_array:
case t_string:
check_write(*opto);
check_int_leu(*opindex, r_size(opto));
code = copy_interval(i_ctx_p, opto, (uint)(opindex->value.intval),
op, "putinterval");
break;
case t_astruct: {
uint dsize, ssize, index;
check_write(*opto);
if (gs_object_type(imemory, opto->value.pstruct) != &st_bytes)
return_error(e_typecheck);
dsize = gs_object_size(imemory, opto->value.pstruct);
check_int_leu(*opindex, dsize);
index = (uint)opindex->value.intval;
check_read_type(*op, t_string);
ssize = r_size(op);
if (ssize > dsize - index)
return_error(e_rangecheck);
memcpy(r_ptr(opto, byte) + index, op->value.const_bytes, ssize);
code = 0;
break;
}
}
if (code >= 0)
pop(3);
return code;
}
/* Check the operand of a restore. */
static int
restore_check_operand(os_ptr op, alloc_save_t ** pasave,
gs_dual_memory_t *idmem)
{
vm_save_t *vmsave;
ulong sid;
alloc_save_t *asave;
check_type(*op, t_save);
vmsave = r_ptr(op, vm_save_t);
if (vmsave == 0) /* invalidated save */
return_error(e_invalidrestore);
sid = op->value.saveid;
asave = alloc_find_save(idmem, sid);
if (asave == 0)
return_error(e_invalidrestore);
*pasave = asave;
return 0;
}
static int
image_proc_process(i_ctx_t *i_ctx_p)
{
int px = ETOP_PLANE_INDEX(esp)->value.intval;
gs_image_enum *penum = r_ptr(esp, gs_image_enum);
const byte *wanted = gs_image_planes_wanted(penum);
int num_sources = ETOP_NUM_SOURCES(esp)->value.intval;
const ref *pp;
ETOP_SOURCE(esp, 0)[1].value.intval = 0; /* procedure callout */
while (!wanted[px]) {
if (++px == num_sources)
px = 0;
ETOP_PLANE_INDEX(esp)->value.intval = px;
}
pp = ETOP_SOURCE(esp, px);
push_op_estack(image_proc_continue);
*++esp = *pp;
return o_push_estack;
}
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;
}
static int
path_continue(i_ctx_t *i_ctx_p)
{
gs_path_enum *penum = r_ptr(esp, gs_path_enum);
gs_point ppts[3];
int code;
/* Make sure we have room on the o-stack for the worst case */
/* before we enumerate the next path element. */
check_ostack(6); /* 3 points for curveto */
code = gs_path_enum_next(penum, ppts);
switch (code) {
case 0: /* all done */
esp -= 6;
path_cleanup(i_ctx_p);
return o_pop_estack;
default: /* error */
return code;
case gs_pe_moveto:
esp[2] = esp[-4]; /* moveto proc */
pf_push(i_ctx_p, ppts, 1);
break;
case gs_pe_lineto:
esp[2] = esp[-3]; /* lineto proc */
pf_push(i_ctx_p, ppts, 1);
break;
case gs_pe_curveto:
esp[2] = esp[-2]; /* curveto proc */
pf_push(i_ctx_p, ppts, 3);
break;
case gs_pe_closepath:
esp[2] = esp[-1]; /* closepath proc */
break;
}
push_op_estack(path_continue);
++esp; /* include pushed procedure */
return o_push_estack;
}
/* <dict> <crd> .setdevicecolorrendering1 - */
static int
zsetdevicecolorrendering1(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code;
ref_cie_render_procs procs;
check_type(op[-1], t_dictionary);
check_stype(*op, st_cie_render1);
code = gs_setcolorrendering(igs, r_ptr(op, gs_cie_render));
if (code < 0)
return code;
refset_null((ref *)&procs, sizeof(procs) / sizeof(ref));
if (gs_cie_cs_common(igs) != 0 &&
(code = cie_cache_joint(i_ctx_p, &procs, gs_cie_cs_common(igs), igs)) < 0
)
return code;
istate->colorrendering.dict = op[-1];
refset_null((ref *)&istate->colorrendering.procs,
sizeof(istate->colorrendering.procs) / sizeof(ref));
pop(2);
return 0;
}
/* Continue from an OtherSubr callout while building the path. */
static int
type1_callout_dispatch(i_ctx_t *i_ctx_p, int (*cont)(i_ctx_t *),
int num_args)
{
ref other_subr;
gs_type1exec_state *pcxs = r_ptr(esp, gs_type1exec_state);
int code;
icont:
code = type1_continue_dispatch(i_ctx_p, pcxs, NULL, &other_subr,
num_args);
switch (code) {
case 0: /* callout done, cont is on e-stack */
return 0;
default: /* code < 0 or done, error */
op_type1_free(i_ctx_p);
return ((code < 0 ? code : gs_note_error(e_invalidfont)));
case type1_result_callothersubr: /* unknown OtherSubr */
return type1_push_OtherSubr(i_ctx_p, pcxs, cont, &other_subr);
case type1_result_sbw: /* [h]sbw, just continue */
goto icont;
}
}
/* Read a string value. */
static int
ref_param_read_string_value(gs_memory_t *mem, const iparam_loc * ploc, gs_param_string * pvalue)
{
const ref *pref = ploc->pvalue;
switch (r_type(pref)) {
case t_name: {
ref nref;
name_string_ref(mem, pref, &nref);
pvalue->data = nref.value.const_bytes;
pvalue->size = r_size(&nref);
pvalue->persistent = true;
}
break;
case t_string:
iparam_check_read(*ploc);
pvalue->data = pref->value.const_bytes;
pvalue->size = r_size(pref);
pvalue->persistent = false;
break;
case t_astruct:
/* Note: technically, instead of the "mem" argument, we
should be using the plists's ref_memory. However, in a
simple call to .putdeviceparams, they are identical. */
iparam_check_read(*ploc);
if (gs_object_type(mem, pref->value.pstruct) != &st_bytes)
return iparam_note_error(*ploc, e_typecheck);
pvalue->data = r_ptr(pref, byte);
pvalue->size = gs_object_size(mem, pref->value.pstruct);
pvalue->persistent = false;
break;
default:
return iparam_note_error(*ploc, e_typecheck);
}
return 0;
}
