/* convenience of reusing procedures that take 1 state parameter */ static int zreadhexstring_at(i_ctx_t *i_ctx_p, os_ptr op, uint start, int odd) { stream *s; uint len, nread; byte *str; int odd_byte = odd; stream_cursor_write cw; int status; check_read_file(s, op - 1); /*check_write_type(*op, t_string); *//* done by caller */ str = op->value.bytes; len = r_size(op); cw.ptr = str + start - 1; cw.limit = str + len - 1; for (;;) { status = s_hex_process(&s->cursor.r, &cw, &odd_byte, hex_ignore_garbage); if (status == 1) { /* filled the string */ ref_assign_inline(op - 1, op); make_true(op); return 0; } else if (status != 0) /* error or EOF */ break; /* Didn't fill, keep going. */ status = spgetc(s); if (status < 0) break; sputback(s); } nread = cw.ptr + 1 - str; if (status != EOFC) { /* Error */ nread |= odd_byte << 24; return handle_read_status(i_ctx_p, status, op - 1, &nread, zreadhexstring_continue); } /* Reached end-of-file before filling the string. */ /* Return an appropriate substring. */ ref_assign_inline(op - 1, op); r_set_size(op - 1, nread); make_false(op); return 0; }
/* Return a double result. */ static int double_result(i_ctx_t *i_ctx_p, int count, double result) { os_ptr op = osp; os_ptr op1 = op - count; ref_assign_inline(op1, op); memcpy(op1->value.bytes, &result, sizeof(double)); pop(count); return 0; }
/* Continuation operator for positive integers. */ static int for_pos_int_continue(i_ctx_t *i_ctx_p) { os_ptr op = osp; register es_ptr ep = esp; int var = ep[-3].value.intval; if (var > ep[-1].value.intval) { esp -= 5; /* pop everything */ return o_pop_estack; } push(1); make_int(op, var); ep[-3].value.intval = var + ep[-2].value.intval; ref_assign_inline(ep + 2, ep); /* saved proc */ esp = ep + 2; return o_push_estack; }
/* Continuation procedure */ static int for_samples_continue(i_ctx_t *i_ctx_p) { os_ptr op = osp; es_ptr ep = esp; int var = ep[-4].value.intval; float a = ep[-3].value.realval; int n = ep[-2].value.intval; float b = ep[-1].value.realval; if (var > n) { esp -= 6; /* pop everything */ return o_pop_estack; } push(1); make_real(op, ((n - var) * a + var * b) / n); ep[-4].value.intval = var + 1; ref_assign_inline(ep + 2, ep); /* saved proc */ esp = ep + 2; return o_push_estack; }
/* Remove the marks at the same time. */ static void refs_compact(const gs_memory_t *mem, obj_header_t * pre, obj_header_t * dpre, uint size) { ref_packed *dest; ref_packed *src; ref_packed *end; uint new_size; /* The next switch controls an optimization for the loop termination condition. It was useful during the development, when some assumptions were temporary wrong. We keep it for records. */ src = (ref_packed *) (pre + 1); end = (ref_packed *) ((byte *) src + size); /* * We know that a block of refs always ends with a * full-size ref, so we only need to check for reaching the end * of the block when we see one of those. */ if (dpre == pre) /* Loop while we don't need to copy. */ for (;;) { if (r_is_packed(src)) { if (!r_has_pmark(src)) break; if_debug1('8', " [8]packed ref 0x%lx \"copied\"\n", (ulong) src); *src &= ~lp_mark; src++; } else { /* full-size ref */ ref *const pref = (ref *)src; if (!r_has_attr(pref, l_mark)) break; if_debug1('8', " [8]ref 0x%lx \"copied\"\n", (ulong) src); r_clear_attrs(pref, l_mark); src += packed_per_ref; } } else *dpre = *pre; dest = (ref_packed *) ((char *)dpre + ((char *)src - (char *)pre)); for (;;) { if (r_is_packed(src)) { if (r_has_pmark(src)) { if_debug2('8', " [8]packed ref 0x%lx copied to 0x%lx\n", (ulong) src, (ulong) dest); *dest++ = *src & ~lp_mark; } src++; } else { /* full-size ref */ if (r_has_attr((ref *) src, l_mark)) { ref rtemp; if_debug2('8', " [8]ref 0x%lx copied to 0x%lx\n", (ulong) src, (ulong) dest); /* We can't just use ref_assign_inline, */ /* because the source and destination */ /* might overlap! */ ref_assign_inline(&rtemp, (ref *) src); r_clear_attrs(&rtemp, l_mark); ref_assign_inline((ref *) dest, &rtemp); src += packed_per_ref; dest += packed_per_ref; } else { /* check for end of block */ src += packed_per_ref; if (src >= end) break; } } } new_size = (byte *) dest - (byte *) (dpre + 1) + sizeof(ref); #ifdef DEBUG /* Check that the relocation came out OK. */ /* NOTE: this check only works within a single chunk. */ if ((byte *) src - (byte *) dest != r_size((ref *) src - 1) + sizeof(ref)) { lprintf3("Reloc error for refs 0x%lx: reloc = %lu, stored = %u\n", (ulong) dpre, (ulong) ((byte *) src - (byte *) dest), (uint) r_size((ref *) src - 1)); gs_abort(mem); } #endif /* Pad to a multiple of sizeof(ref). */ while (new_size & (sizeof(ref) - 1)) *dest++ = pt_tag(pt_integer), new_size += sizeof(ref_packed); /* We want to make the newly freed space into a free block, */ /* but we can only do this if we have enough room. */ if (size - new_size < sizeof(obj_header_t)) { /* Not enough room. Pad to original size. */ while (new_size < size) *dest++ = pt_tag(pt_integer), new_size += sizeof(ref_packed); } else { obj_header_t *pfree = (obj_header_t *) ((ref *) dest + 1); pfree->o_alone = 0; pfree->o_size = size - new_size - sizeof(obj_header_t); pfree->o_type = &st_bytes; } /* Re-create the final ref. */ r_set_type((ref *) dest, t_integer); dpre->o_size = new_size; }