/* Fill in a gs_param_key_t from a name or int ref. */
static int
ref_to_key(const ref * pref, gs_param_key_t * key, iparam_list *plist)
{
if (r_has_type(pref, t_name)) {
ref nref;
name_string_ref(plist->memory, pref, &nref);
key->data = nref.value.const_bytes;
key->size = r_size(&nref);
key->persistent = false; /* names may be freed */
} else if (r_has_type(pref, t_integer)) {
char istr[sizeof(long) * 8 / 3 + 2];
int len;
byte *buf;
sprintf(istr, "%d", pref->value.intval);
len = strlen(istr);
/* GC will take care of freeing this: */
buf = gs_alloc_string(plist->memory, len, "ref_to_key");
if (!buf)
return_error(e_VMerror);
key->data = buf;
key->size = len;
key->persistent = true;
} else
return_error(e_typecheck);
return 0;
}
/* <obj> <pattern> .stringmatch <bool> */
static int
zstringmatch(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr op1 = op - 1;
bool result;
check_read_type(*op, t_string);
switch (r_type(op1)) {
case t_string:
check_read(*op1);
goto cmp;
case t_name:
name_string_ref(imemory, op1, op1); /* can't fail */
cmp:
result = string_match(op1->value.const_bytes, r_size(op1),
op->value.const_bytes, r_size(op),
NULL);
break;
default:
result = (r_size(op) == 1 && *op->value.bytes == '*');
}
make_bool(op1, result);
pop(1);
return 0;
}
/* Compare the encoding of a simple font with the registered encodings. */
void
lookup_gs_simple_font_encoding(gs_font_base * pfont)
{
const ref *pfe = &pfont_data(pfont)->Encoding;
int index = -1;
pfont->encoding_index = index;
if (r_type(pfe) == t_array && r_size(pfe) <= 256) {
/* Look for an encoding that's "close". */
uint esize = r_size(pfe);
int near_index = -1;
uint best = esize / 3; /* must match at least this many */
gs_const_string fstrs[256];
int i;
/* Get the string names of the glyphs in the font's Encoding. */
for (i = 0; i < esize; ++i) {
ref fchar;
if (array_get(pfont->memory, pfe, (long)i, &fchar) < 0 ||
!r_has_type(&fchar, t_name)
)
fstrs[i].data = 0, fstrs[i].size = 0;
else {
ref nsref;
name_string_ref(pfont->memory, &fchar, &nsref);
fstrs[i].data = nsref.value.const_bytes;
fstrs[i].size = r_size(&nsref);
}
}
/* Compare them against the known encodings. */
for (index = 0; index < NUM_KNOWN_REAL_ENCODINGS; ++index) {
uint match = esize;
for (i = esize; --i >= 0;) {
gs_const_string rstr;
gs_c_glyph_name(gs_c_known_encode((gs_char)i, index), &rstr);
if (rstr.size == fstrs[i].size &&
!memcmp(rstr.data, fstrs[i].data, rstr.size)
)
continue;
if (--match <= best)
break;
}
if (match > best) {
best = match;
near_index = index;
/* If we have a perfect match, stop now. */
if (best == esize)
break;
}
}
index = near_index;
if (best == esize)
pfont->encoding_index = index;
}
pfont->nearest_encoding_index = index;
}
/* <array|dict|name|packedarray|string> length <int> */
static int
zlength(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
switch (r_type(op)) {
case t_array:
case t_string:
case t_mixedarray:
case t_shortarray:
check_read(*op);
make_int(op, r_size(op));
return 0;
case t_dictionary:
check_dict_read(*op);
make_int(op, dict_length(op));
return 0;
case t_name: {
ref str;
name_string_ref(imemory, op, &str);
make_int(op, r_size(&str));
return 0;
}
case t_astruct:
if (gs_object_type(imemory, op->value.pstruct) != &st_bytes)
return_error(e_typecheck);
check_read(*op);
make_int(op, gs_object_size(imemory, op->value.pstruct));
return 0;
default:
return_op_typecheck(op);
}
}
/* <name> .namestring <string> */
static int
znamestring(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
check_type(*op, t_name);
name_string_ref(imemory, op, op);
return 0;
}
/*
* This routine translates a gs_separation_name value into a character string
* pointer and a string length.
*/
int
gs_get_colorname_string(const gs_memory_t *mem, gs_separation_name colorname_index,
unsigned char **ppstr, unsigned int *pname_size)
{
ref nref;
name_index_ref(mem, colorname_index, &nref);
name_string_ref(mem, &nref, &nref);
return obj_string_data(mem, &nref, (const unsigned char**) ppstr, pname_size);
}
/* If the font name isn't a name or a string, return an empty string. */
void
get_font_name(const gs_memory_t *mem, ref * pfname, const ref * op)
{
switch (r_type(op)) {
case t_string:
*pfname = *op;
break;
case t_name:
name_string_ref(mem, op, pfname);
break;
default:
/* This is weird, but legal.... */
make_empty_string(pfname, a_readonly);
}
}
/* Encode a character. */
gs_glyph
zfont_encode_char(gs_font *pfont, gs_char chr, gs_glyph_space_t gspace)
{
font_data *pdata = pfont_data(pfont);
const ref *pencoding = &pdata->Encoding;
ulong index = chr; /* work around VAX widening bug */
ref cname;
int code = array_get(pfont->memory, pencoding, (long)index, &cname);
if (code < 0 || !r_has_type(&cname, t_name))
return gs_no_glyph;
if (pfont->FontType == ft_user_defined && r_type(&pdata->BuildGlyph) == t_null) {
ref nsref, tname;
name_string_ref(pfont->memory, &cname, &nsref);
if (r_size(&nsref) == 7 &&
!memcmp(nsref.value.const_bytes, ".notdef", r_size(&nsref))) {
/* A special support for high level devices.
They need a glyph name but the font doesn't provide one
due to an instandard BuildChar.
Such fonts don't conform to PLRM section 5.3.7,
but we've got real examples that we want to handle (Bug 686982).
Construct a name here.
Low level devices don't pass here, because regular PS interpretation
doesn't need such names.
*/
char buf[20];
int code;
if (gspace == GLYPH_SPACE_NOGEN)
return gs_no_glyph;
sprintf(buf, "j%ld", chr); /* 'j' is arbutrary. */
code = name_ref(pfont->memory, (const byte *)buf, strlen(buf), &tname, 1);
if (code < 0) {
/* Can't propagate the error due to interface limitation,
return with .notdef */
} else
cname = tname;
}
}
return (gs_glyph)name_index(pfont->memory, &cname);
}
/* Get the value of a single parameter to the stack, or signal an error. */
static int
currentparam1(i_ctx_t *i_ctx_p, const param_set * pset)
{
os_ptr op = osp;
ref sref;
int code;
check_type(*op, t_name);
check_ostack(2);
name_string_ref(imemory, (const ref *)op, &sref);
code = current_param_list(i_ctx_p, pset, &sref);
if (code < 0)
return code;
if (osp == op)
return_error(gs_error_undefined);
/* We know osp == op + 2. */
ref_assign(op, op + 2);
pop(2);
return code;
}
/*
* Set *pchars and *plen to point to the data of a name or string, and
* return 0. If the object isn't a name or string, return e_typecheck.
* If the object is a string without read access, return e_invalidaccess.
*/
int
obj_string_data(const gs_memory_t *mem, const ref *op, const byte **pchars, uint *plen)
{
switch (r_type(op)) {
case t_name: {
ref nref;
name_string_ref(mem, op, &nref);
*pchars = nref.value.bytes;
*plen = r_size(&nref);
return 0;
}
case t_string:
check_read(*op);
*pchars = op->value.bytes;
*plen = r_size(op);
return 0;
default:
return_error(e_typecheck);
}
}
/* Get the name of a glyph. */
static int
zfont_glyph_name(gs_font *font, gs_glyph index, gs_const_string *pstr)
{
ref nref, sref;
if (index >= gs_min_cid_glyph) { /* Fabricate a numeric name. */
char cid_name[sizeof(gs_glyph) * 3 + 1];
int code;
sprintf(cid_name, "%lu", (ulong) index);
code = name_ref(font->memory, (const byte *)cid_name, strlen(cid_name),
&nref, 1);
if (code < 0)
return code;
} else
name_index_ref(font->memory, index, &nref);
name_string_ref(font->memory, &nref, &sref);
pstr->data = sref.value.const_bytes;
pstr->size = r_size(&sref);
return 0;
}
/* 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;
}
/* stringmatch */
int
zstringmatch(register os_ptr op)
{ os_ptr op1 = op - 1;
int result;
ref stref;
check_read_type(*op, t_string);
switch ( r_type(op1) )
{
case t_string:
check_read(*op1);
ref_assign(&stref, op1);
goto cmp;
case t_name:
name_string_ref(op1, &stref);
cmp: result = string_match(stref.value.bytes, r_size(&stref),
op->value.bytes, r_size(op), 0);
break;
default:
result = (r_size(op) == 1 && *op->value.bytes == '*');
}
make_bool(op1, result);
pop(1);
return 0;
}
/* 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;
}
/* <source> <dict> /JPXDecode <file> */
static int
z_jpx_decode(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
ref *sop = NULL;
ref *csname = NULL;
stream_jpxd_state state;
/* it's our responsibility to call set_defaults() */
state.memory = imemory->non_gc_memory;
if (s_jpxd_template.set_defaults)
(*s_jpxd_template.set_defaults)((stream_state *)&state);
if (r_has_type(op, t_dictionary)) {
check_dict_read(*op);
if ( dict_find_string(op, "Alpha", &sop) > 0) {
check_type(*sop, t_boolean);
if (sop->value.boolval)
state.alpha = true;
}
if ( dict_find_string(op, "ColorSpace", &sop) > 0) {
/* parse the value */
if (r_is_array(sop)) {
/* assume it's the first array element */
csname = sop->value.refs;
} else if (r_has_type(sop,t_name)) {
/* use the name directly */
csname = sop;
} else {
dmprintf(imemory, "warning: JPX ColorSpace value is an unhandled type!\n");
}
if (csname != NULL) {
ref sref;
/* get a reference to the name's string value */
name_string_ref(imemory, csname, &sref);
/* request raw index values if the colorspace is /Indexed */
if (!ISTRCMP(&sref, "Indexed"))
state.colorspace = gs_jpx_cs_indexed;
/* tell the filter what output we want for other spaces */
else if (!ISTRCMP(&sref, "DeviceGray"))
state.colorspace = gs_jpx_cs_gray;
else if (!ISTRCMP(&sref, "DeviceRGB"))
state.colorspace = gs_jpx_cs_rgb;
else if (!ISTRCMP(&sref, "DeviceCMYK"))
state.colorspace = gs_jpx_cs_cmyk;
else if (!ISTRCMP(&sref, "ICCBased")) {
/* The second array element should be the profile's
stream dict */
ref *csdict = sop->value.refs + 1;
ref *nref;
ref altname;
if (r_is_array(sop) && (r_size(sop) > 1) &&
r_has_type(csdict, t_dictionary)) {
check_dict_read(*csdict);
/* try to look up the alternate space */
if (dict_find_string(csdict, "Alternate", &nref) > 0) {
name_string_ref(imemory, csname, &altname);
if (!ISTRCMP(&altname, "DeviceGray"))
state.colorspace = gs_jpx_cs_gray;
else if (!ISTRCMP(&altname, "DeviceRGB"))
state.colorspace = gs_jpx_cs_rgb;
else if (!ISTRCMP(&altname, "DeviceCMYK"))
state.colorspace = gs_jpx_cs_cmyk;
}
/* else guess based on the number of components */
if (state.colorspace == gs_jpx_cs_unset &&
dict_find_string(csdict, "N", &nref) > 0) {
if_debug1m('w', imemory, "[w] JPX image has an external %"PRIpsint
" channel colorspace\n", nref->value.intval);
switch (nref->value.intval) {
case 1: state.colorspace = gs_jpx_cs_gray;
break;
case 3: state.colorspace = gs_jpx_cs_rgb;
break;
case 4: state.colorspace = gs_jpx_cs_cmyk;
break;
}
}
}
}
} else {
if_debug0m('w', imemory, "[w] Couldn't read JPX ColorSpace key!\n");
}
}
}
/* we pass npop=0, since we've no arguments left to consume */
/* we pass 0 instead of the usual rspace(sop) which will allocate storage
for filter state from the same memory pool as the stream it's coding.
this causes no trouble because we maintain no pointers */
return filter_read(i_ctx_p, 0, &s_jpxd_template,
(stream_state *) & state, 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;
}
int
obj_cvp(const ref * op, byte * str, uint len, uint * prlen,
int full_print, uint start_pos, const gs_memory_t *mem, bool restart)
{
char buf[50]; /* big enough for any float, double, or struct name */
const byte *data = (const byte *)buf;
uint size;
int code;
ref nref;
if (full_print) {
static const char * const type_strings[] = { REF_TYPE_PRINT_STRINGS };
switch (r_btype(op)) {
case t_boolean:
case t_integer:
break;
case t_real: {
/*
* To get fully accurate output results for IEEE
* single-precision floats (24 bits of mantissa), the ANSI %g
* default of 6 digits is not enough; 9 are needed.
* Unfortunately, using %.9g for floats (as opposed to doubles)
* produces unfortunate artifacts such as 0.01 5 mul printing as
* 0.049999997. Therefore, we print using %g, and if the result
* isn't accurate enough, print again using %.9g.
* Unfortunately, a few PostScript programs 'know' that the
* printed representation of floats fits into 6 digits (e.g.,
* with cvs). We resolve this by letting cvs, cvrs, and = do
* what the Adobe interpreters appear to do (use %g), and only
* produce accurate output for ==, for which there is no
* analogue of cvs. What a hack!
*/
float value = op->value.realval;
float scanned;
sprintf(buf, "%g", value);
sscanf(buf, "%f", &scanned);
if (scanned != value)
sprintf(buf, "%.9g", value);
ensure_dot(buf);
goto rs;
}
case t_operator:
case t_oparray:
code = obj_cvp(op, (byte *)buf + 2, sizeof(buf) - 4, &size, 0, 0, mem, restart);
if (code < 0)
return code;
buf[0] = buf[1] = buf[size + 2] = buf[size + 3] = '-';
size += 4;
goto nl;
case t_name:
if (r_has_attr(op, a_executable)) {
code = obj_string_data(mem, op, &data, &size);
if (code < 0)
return code;
goto nl;
}
if (start_pos > 0)
return obj_cvp(op, str, len, prlen, 0, start_pos - 1, mem, restart);
if (len < 1)
return_error(e_rangecheck);
code = obj_cvp(op, str + 1, len - 1, prlen, 0, 0, mem, restart);
if (code < 0)
return code;
str[0] = '/';
++*prlen;
return code;
case t_null:
data = (const byte *)"null";
goto rs;
case t_string:
if (!r_has_attr(op, a_read))
goto other;
size = r_size(op);
{
bool truncate = (full_print == 1 && size > CVP_MAX_STRING);
stream_cursor_read r;
stream_cursor_write w;
uint skip;
byte *wstr;
uint len1;
int status = 1;
if (start_pos == 0) {
if (len < 1)
return_error(e_rangecheck);
str[0] = '(';
skip = 0;
wstr = str + 1;
} else {
skip = start_pos - 1;
wstr = str;
}
len1 = len + (str - wstr);
r.ptr = op->value.const_bytes - 1;
r.limit = r.ptr + (truncate ? CVP_MAX_STRING : size);
while (skip && status == 1) {
uint written;
w.ptr = (byte *)buf - 1;
w.limit = w.ptr + min(skip + len1, sizeof(buf));
status = s_PSSE_template.process(NULL, &r, &w, false);
written = w.ptr - ((byte *)buf - 1);
if (written > skip) {
written -= skip;
memcpy(wstr, buf + skip, written);
wstr += written;
skip = 0;
break;
}
skip -= written;
}
/*
* We can reach here with status == 0 (and skip != 0) if
* start_pos lies within the trailing ")" or "...)".
*/
if (status == 0) {
#ifdef DEBUG
if (skip > (truncate ? 4 : 1)) {
return_error(e_Fatal);
}
#endif
}
w.ptr = wstr - 1;
w.limit = str - 1 + len;
if (status == 1)
status = s_PSSE_template.process(NULL, &r, &w, false);
*prlen = w.ptr - (str - 1);
if (status != 0)
return 1;
if (truncate) {
if (len - *prlen < 4 - skip)
return 1;
memcpy(w.ptr + 1, "...)" + skip, 4 - skip);
*prlen += 4 - skip;
} else {
if (len - *prlen < 1 - skip)
return 1;
memcpy(w.ptr + 1, ")" + skip, 1 - skip);
*prlen += 1 - skip;
}
}
return 0;
case t_astruct:
case t_struct:
if (r_is_foreign(op)) {
/* gs_object_type may not work. */
data = (const byte *)"-foreign-struct-";
goto rs;
}
if (!mem) {
data = (const byte *)"-(struct)-";
goto rs;
}
data = (const byte *)
gs_struct_type_name_string(
gs_object_type(mem,
(const obj_header_t *)op->value.pstruct));
size = strlen((const char *)data);
if (size > 4 && !memcmp(data + size - 4, "type", 4))
size -= 4;
if (size > sizeof(buf) - 2)
return_error(e_rangecheck);
buf[0] = '-';
memcpy(buf + 1, data, size);
buf[size + 1] = '-';
size += 2;
data = (const byte *)buf;
goto nl;
default:
other:
{
int rtype = r_btype(op);
if (rtype > countof(type_strings))
return_error(e_rangecheck);
data = (const byte *)type_strings[rtype];
if (data == 0)
return_error(e_rangecheck);
}
goto rs;
}
}
/* full_print = 0 */
switch (r_btype(op)) {
case t_boolean:
data = (const byte *)(op->value.boolval ? "true" : "false");
break;
case t_integer:
sprintf(buf, "%ld", op->value.intval);
break;
case t_string:
check_read(*op);
/* falls through */
case t_name:
code = obj_string_data(mem, op, &data, &size);
if (code < 0)
return code;
goto nl;
case t_oparray: {
uint index = op_index(op);
const op_array_table *opt = op_index_op_array_table(index);
name_index_ref(mem, opt->nx_table[index - opt->base_index], &nref);
name_string_ref(mem, &nref, &nref);
code = obj_string_data(mem, &nref, &data, &size);
if (code < 0)
return code;
goto nl;
}
case t_operator: {
/* Recover the name from the initialization table. */
uint index = op_index(op);
/*
* Check the validity of the index. (An out-of-bounds index
* is only possible when examining an invalid object using
* the debugger.)
*/
if (index > 0 && index < op_def_count) {
data = (const byte *)(op_index_def(index)->oname + 1);
break;
}
/* Internal operator, no name. */
sprintf(buf, "@0x%lx", (ulong) op->value.opproc);
break;
}
case t_real:
/*
* The value 0.0001 is a boundary case that the Adobe interpreters
* print in f-format but at least some gs versions print in
* e-format, presumably because of differences in the underlying C
* library implementation. Work around this here.
*/
if (op->value.realval == (float)0.0001) {
strcpy(buf, "0.0001");
} else {
sprintf(buf, "%g", op->value.realval);
}
ensure_dot(buf);
break;
default:
data = (const byte *)"--nostringval--";
}
rs: size = strlen((const char *)data);
nl: if (size < start_pos)
return_error(e_rangecheck);
if (!restart && size > len)
return_error(e_rangecheck);
size -= start_pos;
*prlen = min(size, len);
memmove(str, data + start_pos, *prlen);
return (size > len);
}
bool
obj_eq(const gs_memory_t *mem, const ref * pref1, const ref * pref2)
{
ref nref;
if (r_type(pref1) != r_type(pref2)) {
/*
* Only a few cases need be considered here:
* integer/real (and vice versa), name/string (and vice versa),
* arrays, and extended operators.
*/
switch (r_type(pref1)) {
case t_integer:
return (r_has_type(pref2, t_real) &&
pref2->value.realval == pref1->value.intval);
case t_real:
return (r_has_type(pref2, t_integer) &&
pref2->value.intval == pref1->value.realval);
case t_name:
if (!r_has_type(pref2, t_string))
return false;
name_string_ref(mem, pref1, &nref);
pref1 = &nref;
break;
case t_string:
if (!r_has_type(pref2, t_name))
return false;
name_string_ref(mem, pref2, &nref);
pref2 = &nref;
break;
/*
* Differing implementations of packedarray can be eq,
* if the length is zero, but an array is never eq to a
* packedarray.
*/
case t_mixedarray:
case t_shortarray:
/*
* Since r_type(pref1) is one of the above, this is a
* clever fast check for r_type(pref2) being the other.
*/
return ((int)r_type(pref1) + (int)r_type(pref2) ==
t_mixedarray + t_shortarray) &&
r_size(pref1) == 0 && r_size(pref2) == 0;
default:
if (r_btype(pref1) != r_btype(pref2))
return false;
}
}
/*
* Now do a type-dependent comparison. This would be very simple if we
* always filled in all the bytes of a ref, but we currently don't.
*/
switch (r_btype(pref1)) {
case t_array:
return ((pref1->value.refs == pref2->value.refs ||
r_size(pref1) == 0) &&
r_size(pref1) == r_size(pref2));
case t_mixedarray:
case t_shortarray:
return ((pref1->value.packed == pref2->value.packed ||
r_size(pref1) == 0) &&
r_size(pref1) == r_size(pref2));
case t_boolean:
return (pref1->value.boolval == pref2->value.boolval);
case t_dictionary:
return (pref1->value.pdict == pref2->value.pdict);
case t_file:
return (pref1->value.pfile == pref2->value.pfile &&
r_size(pref1) == r_size(pref2));
case t_integer:
return (pref1->value.intval == pref2->value.intval);
case t_mark:
case t_null:
return true;
case t_name:
return (pref1->value.pname == pref2->value.pname);
case t_oparray:
case t_operator:
return (op_index(pref1) == op_index(pref2));
case t_real:
return (pref1->value.realval == pref2->value.realval);
case t_save:
return (pref2->value.saveid == pref1->value.saveid);
case t_string:
return (!bytes_compare(pref1->value.bytes, r_size(pref1),
pref2->value.bytes, r_size(pref2)));
case t_device:
return (pref1->value.pdevice == pref2->value.pdevice);
case t_struct:
case t_astruct:
return (pref1->value.pstruct == pref2->value.pstruct);
case t_fontID:
/* This is complicated enough to deserve a separate procedure. */
return fid_eq(mem, r_ptr(pref1, gs_font), r_ptr(pref2, gs_font));
}
return false; /* shouldn't happen! */
}
/* <any> <any> .... /spec_op name .special_op <any> <any> .....
* The special_op operator takes at a minimum the name of the spec_op to execute
* and as many additional parameters as are required for the spec_op. It may
* return as many additional parameters as required.
*/
int
zspec_op(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gx_device *dev = gs_currentdevice(igs);
int i, nprocs = sizeof(spec_op_defs) / sizeof(spec_op_t), code, proc = -1;
ref opname, nref, namestr;
char *data;
/* At the very minimum we need a name object telling us which sepc_op to perform */
check_op(1);
if (!r_has_type(op, t_name))
return_error(gs_error_typecheck);
ref_assign(&opname, op);
/* Find the relevant spec_op name */
for (i=0;i<nprocs;i++) {
code = names_ref(imemory->gs_lib_ctx->gs_name_table, (const byte *)spec_op_defs[i].name, strlen(spec_op_defs[i].name), &nref, 0);
if (code < 0)
return code;
if (name_eq(&opname, &nref)) {
proc = i;
break;
}
}
if (proc < 0)
return_error(gs_error_undefined);
pop(1); /* We don't need the name of the spec_op any more */
op = osp;
switch(proc) {
case 0:
{
stack_param_list list;
dev_param_req_t request;
ref rkeys;
/* Get a single device parameter, we should be supplied with
* the name of the paramter, as a name object.
*/
check_op(1);
if (!r_has_type(op, t_name))
return_error(gs_error_typecheck);
ref_assign(&opname, op);
name_string_ref(imemory, &opname, &namestr);
data = (char *)gs_alloc_bytes(imemory, r_size(&namestr) + 1, "temporary special_op string");
if (data == 0)
return_error(gs_error_VMerror);
memset(data, 0x00, r_size(&namestr) + 1);
memcpy(data, namestr.value.bytes, r_size(&namestr));
/* Discard the parameter name now, we're done with it */
pop (1);
/* Make a null object so that the stack param list won't check for requests */
make_null(&rkeys);
stack_param_list_write(&list, &o_stack, &rkeys, iimemory);
/* Stuff the data into a structure for passing to the spec_op */
request.Param = data;
request.list = &list;
code = dev_proc(dev, dev_spec_op)(dev, gxdso_get_dev_param, &request, sizeof(dev_param_req_t));
gs_free_object(imemory, data, "temporary special_op string");
if (code < 0) {
if (code == gs_error_undefined) {
op = osp;
push(1);
make_bool(op, 0);
} else
return_error(code);
} else {
op = osp;
push(1);
make_bool(op, 1);
}
}
break;
default:
/* Belt and braces; it shold not be possible to get here, as the table
* containing the names should mirror the entries in this switch. If we
* found a name there should be a matching case here.
*/
return_error(gs_error_undefined);
break;
}
return 0;
}
