/* <obj> <typenames> .type <name> */
static int
ztype(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
ref tnref;
int code = array_get(imemory, op, (long)r_btype(op - 1), &tnref);
if (code < 0)
return code;
if (!r_has_type(&tnref, t_name)) {
/* Must be either a stack underflow or a t_[a]struct. */
check_op(2);
{ /* Get the type name from the structure. */
const char *sname =
gs_struct_type_name_string(gs_object_type(imemory,
op[-1].value.pstruct));
int code = name_ref(imemory, (const byte *)sname, strlen(sname),
(ref *) (op - 1), 0);
if (code < 0)
return code;
}
r_set_attrs(op - 1, a_executable);
} else {
ref_assign(op - 1, &tnref);
}
pop(1);
return 0;
}
/* r_size(op1) was set just above. */
static int
do_execstack(i_ctx_t *i_ctx_p, bool include_marks, os_ptr op1)
{
os_ptr op = osp;
ref *arefs = op1->value.refs;
uint asize = r_size(op1);
uint i;
ref *rq;
/*
* Copy elements from the stack to the array,
* optionally skipping executable nulls.
* Clear the executable bit in any internal operators, and
* convert t_structs and t_astructs (which can only appear
* in connection with stack marks, which means that they will
* probably be freed when unwinding) to something harmless.
*/
for (i = 0, rq = arefs + asize; rq != arefs; ++i) {
const ref *rp = ref_stack_index(&e_stack, (long)i);
if (r_has_type_attrs(rp, t_null, a_executable) && !include_marks)
continue;
--rq;
ref_assign_old(op1, rq, rp, "execstack");
switch (r_type(rq)) {
case t_operator: {
uint opidx = op_index(rq);
if (opidx == 0 || op_def_is_internal(op_index_def(opidx)))
r_clear_attrs(rq, a_executable);
break;
}
case t_struct:
case t_astruct: {
const char *tname = rq->value.pstruct ?
gs_struct_type_name_string(
gs_object_type(imemory, rq->value.pstruct))
: "NULL";
make_const_string(rq, a_readonly | avm_foreign,
strlen(tname), (const byte *)tname);
break;
}
default:
;
}
}
pop(op - op1);
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);
}
