static int
z_aes_d(i_ctx_t * i_ctx_p)
{
os_ptr op = osp; /* i_ctx_p->op_stack.stack.p defined in osstack.h */
ref *sop = NULL;
stream_aes_state state;
int use_padding;
/* extract the key from the parameter dictionary */
check_type(*op, t_dictionary);
check_dict_read(*op);
if (dict_find_string(op, "Key", &sop) <= 0)
return_error(gs_error_rangecheck);
s_aes_set_key(&state, sop->value.const_bytes, r_size(sop));
/* extract the padding flag, which defaults to true for compatibility */
if (dict_bool_param(op, "Padding", 1, &use_padding) < 0)
return_error(gs_error_rangecheck);
s_aes_set_padding(&state, use_padding);
/* we pass npop=0, since we've no arguments left to consume */
/* FIXME: passing 0 instead of the usual rspace(sop) will allocate
storage for filter state from the same memory pool as the stream
it's coding. this caused no trouble when we were the arcfour cipher
and maintained no pointers. */
return filter_read(i_ctx_p, 0, &s_aes_template,
(stream_state *) & state, 0);
}
/* from a dictionary. */
static int
dict_spot_params(const ref * pdict, gs_spot_halftone * psp,
ref * psproc, ref * ptproc)
{
int code;
check_dict_read(*pdict);
if ((code = dict_float_param(pdict, "Frequency", 0.0,
&psp->screen.frequency)) != 0 ||
(code = dict_float_param(pdict, "Angle", 0.0,
&psp->screen.angle)) != 0 ||
(code = dict_proc_param(pdict, "SpotFunction", psproc, false)) != 0 ||
(code = dict_bool_param(pdict, "AccurateScreens",
gs_currentaccuratescreens(),
&psp->accurate_screens)) < 0 ||
(code = dict_proc_param(pdict, "TransferFunction", ptproc, false)) < 0
)
return (code < 0 ? code : e_undefined);
psp->transfer = (code > 0 ? (gs_mapping_proc) 0 : gs_mapped_transfer);
psp->transfer_closure.proc = 0;
psp->transfer_closure.data = 0;
return 0;
}
/* Extract and check the parameters for a gs_pixel_image_t. */
int
pixel_image_params(i_ctx_t *i_ctx_p, const ref *op, gs_pixel_image_t *pim,
image_params *pip, int max_bits_per_component,
bool has_alpha, gs_color_space *csp)
{
int num_components =
gs_color_space_num_components(csp);
int code;
if (num_components < 1)
return_error(e_rangecheck); /* Pattern space not allowed */
pim->ColorSpace = csp;
code = data_image_params(imemory, op, (gs_data_image_t *) pim, pip, true,
num_components, max_bits_per_component,
has_alpha);
if (code < 0)
return code;
pim->format =
(pip->MultipleDataSources ? gs_image_format_component_planar :
gs_image_format_chunky);
return dict_bool_param(op, "CombineWithColor", false,
&pim->CombineWithColor);
}
/* of the same length as filters, or null. */
static int
zrsdparams(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
ref *pFilter;
ref *pDecodeParms;
int Intent = 0;
bool AsyncRead;
ref empty_array, filter1_array, parms1_array;
uint i;
int code;
make_empty_array(&empty_array, a_readonly);
if (dict_find_string(op, "Filter", &pFilter) > 0) {
if (!r_is_array(pFilter)) {
if (!r_has_type(pFilter, t_name))
return_error(e_typecheck);
make_array(&filter1_array, a_readonly, 1, pFilter);
pFilter = &filter1_array;
}
} else
pFilter = &empty_array;
/* If Filter is undefined, ignore DecodeParms. */
if (pFilter != &empty_array &&
dict_find_string(op, "DecodeParms", &pDecodeParms) > 0
) {
if (pFilter == &filter1_array) {
make_array(&parms1_array, a_readonly, 1, pDecodeParms);
pDecodeParms = &parms1_array;
} else if (!r_is_array(pDecodeParms))
return_error(e_typecheck);
else if (r_size(pFilter) != r_size(pDecodeParms))
return_error(e_rangecheck);
} else
pDecodeParms = 0;
for (i = 0; i < r_size(pFilter); ++i) {
ref f, fname, dp;
array_get(imemory, pFilter, (long)i, &f);
if (!r_has_type(&f, t_name))
return_error(e_typecheck);
name_string_ref(imemory, &f, &fname);
if (r_size(&fname) < 6 ||
memcmp(fname.value.bytes + r_size(&fname) - 6, "Decode", 6)
)
return_error(e_rangecheck);
if (pDecodeParms) {
array_get(imemory, pDecodeParms, (long)i, &dp);
if (!(r_has_type(&dp, t_dictionary) || r_has_type(&dp, t_null)))
return_error(e_typecheck);
}
}
code = dict_int_param(op, "Intent", 0, 3, 0, &Intent);
if (code < 0 && code != e_rangecheck) /* out-of-range int is ok, use 0 */
return code;
if ((code = dict_bool_param(op, "AsyncRead", false, &AsyncRead)) < 0
)
return code;
push(1);
op[-1] = *pFilter;
if (pDecodeParms)
*op = *pDecodeParms;
else
make_null(op);
return 0;
}
static int
zmatchmedia(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr preq = op - 3;
os_ptr pattr = op - 2;
os_ptr ppol = op - 1;
os_ptr pkeys = op; /* *const */
int policy_default;
float best_mismatch = (float)max_long; /* adhoc */
float mepos_penalty;
float mbest = best_mismatch;
match_record_t match;
ref no_priority;
ref *ppriority;
int mepos, orient;
bool roll;
int code;
int ai;
struct mkd_ {
ref key, dict;
} aelt;
if (r_has_type(pattr, t_null)) {
check_op(4);
make_null(op - 3);
make_true(op - 2);
pop(2);
return 0;
}
check_type(*preq, t_dictionary);
check_dict_read(*preq);
check_type(*pattr, t_dictionary);
check_dict_read(*pattr);
check_type(*ppol, t_dictionary);
check_dict_read(*ppol);
check_array(*pkeys);
check_read(*pkeys);
switch (code = dict_int_null_param(preq, "MediaPosition", 0, 0x7fff,
0, &mepos)) {
default:
return code;
case 2:
case 1:
mepos = -1;
case 0:;
}
switch (code = dict_int_null_param(preq, "Orientation", 0, 3,
0, &orient)) {
default:
return code;
case 2:
case 1:
orient = -1;
case 0:;
}
code = dict_bool_param(preq, "RollFedMedia", false, &roll);
if (code < 0)
return code;
code = dict_int_param(ppol, "PolicyNotFound", 0, 7, 0,
&policy_default);
if (code < 0)
return code;
if (dict_find_string(pattr, "Priority", &ppriority) > 0) {
check_array_only(*ppriority);
check_read(*ppriority);
} else {
make_empty_array(&no_priority, a_readonly);
ppriority = &no_priority;
}
match.no_match_priority = r_size(ppriority);
reset_match(&match);
for (ai = dict_first(pattr);
(ai = dict_next(pattr, ai, (ref * /*[2]*/)&aelt)) >= 0;
) {
if (r_has_type(&aelt.dict, t_dictionary) &&
r_has_attr(dict_access_ref(&aelt.dict), a_read) &&
r_has_type(&aelt.key, t_integer)
) {
bool match_all;
uint ki, pi;
code = dict_bool_param(&aelt.dict, "MatchAll", false,
&match_all);
if (code < 0)
return code;
for (ki = 0; ki < r_size(pkeys); ki++) {
ref key;
ref kstr;
ref *prvalue;
ref *pmvalue;
ref *ppvalue;
int policy;
array_get(imemory, pkeys, ki, &key);
if (dict_find(&aelt.dict, &key, &pmvalue) <= 0)
continue;
if (dict_find(preq, &key, &prvalue) <= 0 ||
r_has_type(prvalue, t_null)
) {
if (match_all)
goto no;
else
continue;
}
/* Look for the Policies entry for this key. */
if (dict_find(ppol, &key, &ppvalue) > 0) {
check_type_only(*ppvalue, t_integer);
policy = ppvalue->value.intval;
} else
policy = policy_default;
/*
* Match a requested attribute value with the attribute value in the
* description of a medium. For all attributes except PageSize,
* matching means equality. PageSize is special; see match_page_size
* below.
*/
if (r_has_type(&key, t_name) &&
(name_string_ref(imemory, &key, &kstr),
r_size(&kstr) == 8 &&
!memcmp(kstr.value.bytes, "PageSize", 8))
) {
gs_matrix ignore_mat;
gs_point ignore_msize;
if (zmatch_page_size(imemory, prvalue, pmvalue,
policy, orient, roll,
&best_mismatch,
&ignore_mat,
&ignore_msize)
<= 0)
goto no;
} else if (!obj_eq(imemory, prvalue, pmvalue))
goto no;
}
mepos_penalty = (mepos < 0 || aelt.key.value.intval == mepos) ?
0 : .001;
/* We have a match. Save the match in case no better match is found */
if (r_has_type(&match.match_key, t_null))
match.match_key = aelt.key;
/*
* If it is a better match than the current best it supersedes it
* regardless of priority. If the match is the same, then update
* to the current only if the key value is lower.
*/
if (best_mismatch + mepos_penalty <= mbest) {
if (best_mismatch + mepos_penalty < mbest ||
(r_has_type(&match.match_key, t_integer) &&
match.match_key.value.intval > aelt.key.value.intval)) {
reset_match(&match);
match.match_key = aelt.key;
mbest = best_mismatch + mepos_penalty;
}
}
/* In case of a tie, see if the new match has priority. */
for (pi = match.priority; pi > 0;) {
ref pri;
pi--;
array_get(imemory, ppriority, pi, &pri);
if (obj_eq(imemory, &aelt.key, &pri)) { /* Yes, higher priority. */
match.best_key = aelt.key;
match.priority = pi;
break;
}
}
no:;
}
}
if (r_has_type(&match.match_key, t_null)) {
make_false(op - 3);
pop(3);
} else {
if (r_has_type(&match.best_key, t_null))
op[-3] = match.match_key;
else
op[-3] = match.best_key;
make_true(op - 2);
pop(2);
}
return 0;
}
/* Extract and check the parameters for a gs_data_image_t. */
int
data_image_params(const gs_memory_t *mem,
const ref *op, gs_data_image_t *pim,
image_params *pip, bool require_DataSource,
int num_components, int max_bits_per_component,
bool has_alpha)
{
int code;
int decode_size;
ref *pds;
check_type(*op, t_dictionary);
check_dict_read(*op);
if ((code = dict_int_param(op, "Width", 0, max_int_in_fixed / 2,
-1, &pim->Width)) < 0 ||
(code = dict_int_param(op, "Height", 0, max_int_in_fixed / 2,
-1, &pim->Height)) < 0 ||
(code = dict_matrix_param(mem, op, "ImageMatrix",
&pim->ImageMatrix)) < 0 ||
(code = dict_bool_param(op, "MultipleDataSources", false,
&pip->MultipleDataSources)) < 0 ||
(code = dict_int_param(op, "BitsPerComponent", 1,
max_bits_per_component, -1,
&pim->BitsPerComponent)) < 0 ||
(code = decode_size = dict_floats_param(mem, op, "Decode",
num_components * 2,
&pim->Decode[0], NULL)) < 0 ||
(code = dict_bool_param(op, "Interpolate", false,
&pim->Interpolate)) < 0
)
return code;
pip->pDecode = &pim->Decode[0];
/* Extract and check the data sources. */
if ((code = dict_find_string(op, "DataSource", &pds)) <= 0) {
if (require_DataSource)
return (code < 0 ? code : gs_note_error(e_rangecheck));
return 1; /* no data source */
}
if (pip->MultipleDataSources) {
ref *ds = pip->DataSource;
long i, n = num_components + (has_alpha ? 1 : 0);
if (!r_is_array(pds))
return_error(e_typecheck);
if (r_size(pds) != n)
return_error(e_rangecheck);
for (i = 0; i < n; ++i)
array_get(mem, pds, i, &ds[i]);
if (r_type(&ds[0]) == t_string) {
/* We don't have a problem with the strings of different length
* but Adobe does and CET tast 12-02.ps reports this as an error.
*/
if (has_alpha)
n--;
for (i = 1; i < n; ++i) {
if (r_type(&ds[i]) == t_string && r_size(&ds[i]) != r_size(&ds[0])) {
return_error(e_rangecheck);
}
}
}
} else
pip->DataSource[0] = *pds;
return 0;
}
/* Common setup for encoding and decoding filters */
static int
bhc_setup(os_ptr op, stream_BHC_state * pbhcs)
{
int code;
int num_counts;
int data[max_hc_length + 1 + 256 + max_zero_run + 1];
uint dsize;
int i;
uint num_values, accum;
ushort *counts;
ushort *values;
check_type(*op, t_dictionary);
check_dict_read(*op);
if ((code = dict_bool_param(op, "FirstBitLowOrder", false,
&pbhcs->FirstBitLowOrder)) < 0 ||
(code = dict_int_param(op, "MaxCodeLength", 1, max_hc_length,
max_hc_length, &num_counts)) < 0 ||
(code = dict_bool_param(op, "EndOfData", true,
&pbhcs->EndOfData)) < 0 ||
(code = dict_uint_param(op, "EncodeZeroRuns", 2, 256,
256, &pbhcs->EncodeZeroRuns)) < 0 ||
/* Note: the code returned from the following call */
/* is actually the number of elements in the array. */
(code = dict_int_array_param(imemory, op, "Tables", countof(data),
data)) <= 0
)
return (code < 0 ? code : gs_note_error(e_rangecheck));
dsize = code;
if (dsize <= num_counts + 2)
return_error(e_rangecheck);
for (i = 0, num_values = 0, accum = 0; i <= num_counts;
i++, accum <<= 1
) {
int count = data[i];
if (count < 0)
return_error(e_rangecheck);
num_values += count;
accum += count;
}
if (dsize != num_counts + 1 + num_values ||
accum != 1 << (num_counts + 1) ||
pbhcs->EncodeZeroRuns >
(pbhcs->EndOfData ? num_values - 1 : num_values)
)
return_error(e_rangecheck);
for (; i < num_counts + 1 + num_values; i++) {
int value = data[i];
if (value < 0 || value >= num_values)
return_error(e_rangecheck);
}
pbhcs->definition.counts = counts =
(ushort *) ialloc_byte_array(num_counts + 1, sizeof(ushort),
"bhc_setup(counts)");
pbhcs->definition.values = values =
(ushort *) ialloc_byte_array(num_values, sizeof(ushort),
"bhc_setup(values)");
if (counts == 0 || values == 0) {
ifree_object(values, "bhc_setup(values)");
ifree_object(counts, "bhc_setup(counts)");
return_error(e_VMerror);
}
for (i = 0; i <= num_counts; i++)
counts[i] = data[i];
pbhcs->definition.counts = counts;
pbhcs->definition.num_counts = num_counts;
for (i = 0; i < num_values; i++)
values[i] = data[i + num_counts + 1];
pbhcs->definition.values = values;
pbhcs->definition.num_values = num_values;
return 0;
}
/* or a negative error code. */
int
build_gs_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font ** ppfont, font_type ftype,
gs_memory_type_ptr_t pstype, const build_proc_refs * pbuild,
build_font_options_t options)
{
ref kname; /* t_string */
ref *pftype;
ref *pencoding = 0;
bool bitmapwidths;
int exactsize, inbetweensize, transformedchar;
int wmode;
int code;
gs_font *pfont;
ref *pfid;
ref *aop = dict_access_ref(op);
bool cpsi_mode = gs_currentcpsimode(imemory);
get_font_name(imemory, &kname, op - 1);
if (dict_find_string(op, "FontType", &pftype) <= 0 ||
!r_has_type(pftype, t_integer) ||
pftype->value.intval != (int)ftype
)
return_error(e_invalidfont);
if (dict_find_string(op, "Encoding", &pencoding) <= 0) {
if (!(options & bf_Encoding_optional))
return_error(e_invalidfont);
pencoding = 0;
} else {
if (!r_is_array(pencoding))
return_error(e_invalidfont);
}
if (pencoding) { /* observed Adobe behavior */
int count = r_size(pencoding);
int type = ftype ? t_name : t_integer;
bool fixit = false;
while (count--) {
ref r;
if ((code = array_get(imemory, pencoding, count, &r)) < 0 ||
!(r_has_type(&r, type) || r_has_type(&r, t_null))) {
if (!cpsi_mode && ftype == ft_user_defined) {
if (code < 0 || r_has_type(&r, t_null)) {
return_error(e_typecheck);
}
fixit = true;
break;
}
else {
return_error(e_typecheck);
}
}
}
/* For at least Type 3 fonts, Adobe Distiller will "fix" an Encoding array, as in, for example
* Bug 692681 where the arrays contain integers rather than names. Once the font is instantiated
* the integers have been converted to names.
* It is preferable to to this manipulation here, rather than in Postscript, because we are less
* restricted by read-only attributes and VM save levels.
*/
if (fixit) {
ref penc;
uint size = 0;
char buf[32], *bptr;
avm_space curglob = ialloc_space(idmemory);
avm_space useglob = r_is_local(pencoding) ? avm_local : avm_global;
ialloc_set_space(idmemory, useglob);
count = r_size(pencoding);
if ((code = ialloc_ref_array(&penc, (r_type_attrs(pencoding) & a_readonly), count, "build_gs_font")) < 0)
return code;
while (count--) {
ref r;
if (array_get(imemory, pencoding, count, &r) < 0){
return_error(e_typecheck);
}
/* For type 3, we know the Encoding entries must be names */
if (r_has_type(&r, t_name)){
ref_assign(&(penc.value.refs[count]), &r);
}
else {
if ((code = obj_cvs(imemory, &r, (byte *)buf, 32, &size, (const byte **)(&bptr))) < 0) {
return(code);
}
if ((code = name_ref(imemory, (const byte *)bptr, size, &r, true)) < 0)
return code;
ref_assign(&(penc.value.refs[count]), &r);
}
}
if ((code = dict_put_string(osp, "Encoding", &penc, NULL)) < 0)
return code;
ialloc_set_space(idmemory, curglob);
}
}
if ((code = dict_int_param(op, "WMode", 0, 1, 0, &wmode)) < 0 ||
(code = dict_bool_param(op, "BitmapWidths", false, &bitmapwidths)) < 0 ||
(code = dict_int_param(op, "ExactSize", 0, 2, fbit_use_bitmaps, &exactsize)) < 0 ||
(code = dict_int_param(op, "InBetweenSize", 0, 2, fbit_use_outlines, &inbetweensize)) < 0 ||
(code = dict_int_param(op, "TransformedChar", 0, 2, fbit_use_outlines, &transformedchar)) < 0
)
return code;
code = dict_find_string(op, "FID", &pfid);
if (code > 0 && r_has_type(pfid, t_fontID)) { /* silently ignore invalid FID per CET 13-05.ps */
/*
* If this font has a FID entry already, it might be a scaled font
* made by makefont or scalefont; in a Level 2 environment, it might
* be an existing font being registered under a second name, or a
* re-encoded font (which was invalid in Level 1, but dvips did it
* anyway).
*/
pfont = r_ptr(pfid, gs_font);
/*
* If the following condition is false this is a re-encoded font,
* or some other questionable situation in which the FID
* was preserved. Pretend the FID wasn't there.
*/
if (obj_eq(pfont->memory, pfont_dict(pfont), op)) {
if (pfont->base == pfont) { /* original font */
if (!level2_enabled)
return_error(e_invalidfont);
*ppfont = pfont;
return 1;
} else { /* This was made by makefont or scalefont. */
/* Just insert the new name. */
gs_matrix mat;
ref fname; /* t_string */
code = sub_font_params(imemory, op, &mat, NULL, &fname);
if (code < 0)
return code;
code = 1;
copy_font_name(&pfont->font_name, &fname);
goto set_name;
}
}
}
/* This is a new font. */
if (!r_has_attr(aop, a_write))
return_error(e_invalidaccess);
{
ref encoding;
/*
* Since add_FID may resize the dictionary and cause
* pencoding to become invalid, save the Encoding.
*/
if (pencoding) {
encoding = *pencoding;
pencoding = &encoding;
}
code = build_gs_sub_font(i_ctx_p, op, &pfont, ftype, pstype,
pbuild, pencoding, op);
if (code < 0)
return code;
}
pfont->BitmapWidths = bitmapwidths;
pfont->ExactSize = (fbit_type)exactsize;
pfont->InBetweenSize = (fbit_type)inbetweensize;
pfont->TransformedChar = (fbit_type)transformedchar;
pfont->WMode = wmode;
pfont->procs.font_info = zfont_info;
code = 0;
set_name:
copy_font_name(&pfont->key_name, &kname);
*ppfont = pfont;
return code;
}
/* <source> <dict> eexecDecode/filter <file> */
static int
zexD(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream_exD_state state;
int code;
(*s_exD_template.set_defaults)((stream_state *)&state);
if (r_has_type(op, t_dictionary)) {
uint cstate;
bool is_eexec;
check_dict_read(*op);
if ((code = dict_uint_param(op, "seed", 0, 0xffff, 0x10000,
&cstate)) < 0 ||
(code = dict_int_param(op, "lenIV", 0, max_int, 4,
&state.lenIV)) < 0 ||
(code = dict_bool_param(op, "eexec", false,
&is_eexec)) < 0 ||
(code = dict_bool_param(op, "keep_spaces", false,
&state.keep_spaces)) < 0
)
return code;
state.cstate = cstate;
state.binary = (is_eexec ? -1 : 1);
code = 1;
} else {
state.binary = 1;
code = eexec_param(op, &state.cstate);
}
if (code < 0)
return code;
/*
* If we're reading a .PFB file, let the filter know about it,
* so it can read recklessly to the end of the binary section.
*/
if (r_has_type(op - 1, t_file)) {
stream *s = (op - 1)->value.pfile;
if (s->state != 0 && s->state->templat == &s_PFBD_template) {
stream_PFBD_state *pss = (stream_PFBD_state *)s->state;
state.pfb_state = pss;
/*
* If we're reading the binary section of a PFB stream,
* avoid the conversion from binary to hex and back again.
*/
if (pss->record_type == 2) {
/*
* The PFB decoder may have converted some data to hex
* already. Convert it back if necessary.
*/
if (pss->binary_to_hex && sbufavailable(s) > 0) {
state.binary = 0; /* start as hex */
state.hex_left = sbufavailable(s);
} else {
state.binary = 1;
}
pss->binary_to_hex = 0;
}
}
}
return filter_read(i_ctx_p, code, &s_exD_template, (stream_state *)&state, 0);
}
/* Common framework for building shadings. */
static int
build_shading(i_ctx_t *i_ctx_p, build_shading_proc_t proc)
{
os_ptr op = osp;
int code;
float box[4];
gs_shading_params_t params;
gs_shading_t *psh;
ref *pvalue;
check_type(*op, t_dictionary);
params.ColorSpace = 0;
params.cie_joint_caches = 0;
params.Background = 0;
/* Collect parameters common to all shading types. */
{
gs_color_space *pcs = gs_currentcolorspace(igs);
int num_comp = gs_color_space_num_components(pcs);
if (num_comp < 0) { /* Pattern color space */
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "ColorSpace");
return_error(gs_error_typecheck);
}
params.ColorSpace = pcs;
rc_increment_cs(pcs);
if (dict_find_string(op, "Background", &pvalue) > 0) {
gs_client_color *pcc =
ialloc_struct(gs_client_color, &st_client_color,
"build_shading");
if (pcc == 0) {
code = gs_note_error(gs_error_VMerror);
goto fail;
}
pcc->pattern = 0;
params.Background = pcc;
code = dict_floats_param(imemory, op, "Background",
gs_color_space_num_components(pcs),
pcc->paint.values, NULL);
if (code < 0) {
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "Background");
goto fail;
}
}
}
if (dict_find_string(op, "BBox", &pvalue) <= 0)
params.have_BBox = false;
else if ((code = dict_floats_param(imemory, op, "BBox",
4, box, NULL)) == 4) {
/* Adobe Interpreters accept denormalised BBox - bug 688937 */
if (box[0] <= box[2]) {
params.BBox.p.x = box[0];
params.BBox.q.x = box[2];
} else {
params.BBox.p.x = box[2];
params.BBox.q.x = box[0];
}
if (box[1] <= box[3]) {
params.BBox.p.y = box[1];
params.BBox.q.y = box[3];
} else {
params.BBox.p.y = box[3];
params.BBox.q.y = box[1];
}
params.have_BBox = true;
} else {
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "BBox");
goto fail;
}
code = dict_bool_param(op, "AntiAlias", false, ¶ms.AntiAlias);
if (code < 0) {
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "AntiAlias");
goto fail;
}
/* Finish building the shading. */
code = (*proc)(i_ctx_p, op, ¶ms, &psh, imemory);
if (code < 0)
goto fail;
if (gx_color_space_needs_cie_caches(psh->params.ColorSpace)) {
rc_decrement(psh->params.cie_joint_caches, "build_shading");
psh->params.cie_joint_caches = gx_currentciecaches(igs);
rc_increment(psh->params.cie_joint_caches);
}
make_istruct_new(op, 0, psh);
return code;
fail:
gs_free_object(imemory, params.Background, "Background");
if (params.ColorSpace) {
rc_decrement_only_cs(params.ColorSpace, "build_shading");
}
return (code < 0 ? code : gs_note_error(gs_error_rangecheck));
}