/*
* Swap an entry from a higher level dictionary into a base dictionary.
* elt[0] is the key, elt[1] is the current value in the Level 2 dictionary
* (*pdict2).
*/
static int
swap_entry(i_ctx_t *i_ctx_p, ref elt[2], ref * pdict, ref * pdict2)
{
ref *pvalue;
#ifdef PACIFY_VALGRIND
ref old_value = { 0 }; /* current value in *pdict */
#else
ref old_value; /* current value in *pdict */
#endif
int found = dict_find(pdict, &elt[0], &pvalue);
switch (found) {
default: /* <0, error */
/*
* The only possible error here is a dictfull error, which is
* harmless.
*/
/* fall through */
case 0: /* missing */
make_null(&old_value);
break;
case 1: /* present */
old_value = *pvalue;
}
/*
* Temporarily flag the dictionaries as local, so that we don't
* get invalidaccess errors. (We know that they are both
* referenced from systemdict, so they are allowed to reference
* local objects even if they are global.)
*/
{
uint space2 = r_space(pdict2);
int code;
r_set_space(pdict2, avm_local);
idict_put(pdict2, &elt[0], &old_value);
if (r_has_type(&elt[1], t_null)) {
code = idict_undef(pdict, &elt[0]);
if (code == gs_error_undefined &&
r_has_type(&old_value, t_null)
)
code = 0;
} else {
uint space = r_space(pdict);
r_set_space(pdict, avm_local);
code = idict_put(pdict, &elt[0], &elt[1]);
r_set_space(pdict, space);
}
r_set_space(pdict2, space2);
return code;
}
}
/* This is the Level 2 >> operator. */
static int
zdicttomark(i_ctx_t *i_ctx_p)
{
uint count2 = ref_stack_counttomark(&o_stack);
ref rdict;
int code;
uint idx;
if (count2 == 0)
return_error(e_unmatchedmark);
count2--;
if ((count2 & 1) != 0)
return_error(e_rangecheck);
code = dict_create(count2 >> 1, &rdict);
if (code < 0)
return code;
/* << /a 1 /a 2 >> => << /a 1 >>, i.e., */
/* we must enter the keys in top-to-bottom order. */
for (idx = 0; idx < count2; idx += 2) {
code = idict_put(&rdict,
ref_stack_index(&o_stack, idx + 1),
ref_stack_index(&o_stack, idx));
if (code < 0) { /* There's no way to free the dictionary -- too bad. */
return code;
}
}
ref_stack_pop(&o_stack, count2);
ref_assign(osp, &rdict);
return code;
}
/*
* This forces a "put" even if the object is not writable, and (if the
* object is systemdict or the save level is 0) even if the value is in
* local VM. It is meant to be used only for replacing the value of
* FontDirectory in systemdict when switching between local and global VM,
* and a few similar applications. After initialization, this operator
* should no longer be accessible by name.
*/
static int
zforceput(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr op1 = op - 1;
os_ptr op2 = op - 2;
int code;
switch (r_type(op2)) {
case t_array:
check_int_ltu(*op1, r_size(op2));
if (r_space(op2) > r_space(op)) {
if (imemory_save_level(iimemory))
return_error(e_invalidaccess);
}
{
ref *eltp = op2->value.refs + (uint) op1->value.intval;
ref_assign_old(op2, eltp, op, "put");
}
break;
case t_dictionary:
if (op2->value.pdict == systemdict->value.pdict ||
!imemory_save_level(iimemory)
) {
uint space = r_space(op2);
r_set_space(op2, avm_local);
code = idict_put(op2, op1, op);
r_set_space(op2, space);
} else
code = idict_put(op2, op1, op);
if (code < 0)
return code;
break;
default:
return_error(e_typecheck);
}
pop(3);
return 0;
}
/* <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;
}
/*
* We make this into a separate procedure because
* the interpreter will almost always call it directly.
*/
int
zop_def(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr op1 = op - 1;
ref *pvslot;
/* The following combines a check_op(2) with a type check. */
switch (r_type(op1)) {
case t_name: {
/* We can use the fast single-probe lookup here. */
uint nidx = name_index(imemory, op1);
uint htemp;
if_dict_find_name_by_index_top(nidx, htemp, pvslot) {
if (dtop_can_store(op))
goto ra;
}
break; /* handle all slower cases */
}
case t_null:
return_error(e_typecheck);
case t__invalid:
return_error(e_stackunderflow);
}
/*
* Combine the check for a writable top dictionary with
* the global/local store check. See dstack.h for details.
*/
if (!dtop_can_store(op)) {
check_dict_write(*dsp);
/*
* If the dictionary is writable, the problem must be
* an invalid store.
*/
return_error(e_invalidaccess);
}
/*
* Save a level of procedure call in the common (redefinition)
* case. With the current interfaces, we pay a double lookup
* in the uncommon case.
*/
if (dict_find(dsp, op1, &pvslot) <= 0)
return idict_put(dsp, op1, op);
ra:
if ((pvslot->tas.type_attrs & (&i_ctx_p->memory)->test_mask) == 0)
alloc_save_change(idmemory, &dsp->value.pdict->values, (ref_packed *)pvslot, "dict_put(value)");
ref_assign_new_inline(pvslot,op);
return 0;
}
