/* <file> <string> .peekstring <substring> <filled_bool> */ static int zpeekstring(i_ctx_t *i_ctx_p) { os_ptr op = osp; stream *s; uint len, rlen; check_read_file(s, op - 1); check_write_type(*op, t_string); len = r_size(op); while ((rlen = sbufavailable(s)) < len) { int status = s->end_status; switch (status) { case EOFC: break; case 0: /* * The following is a HACK. It should reallocate the buffer to hold * at least len bytes. However, this raises messy problems about * which allocator to use and how it should interact with restore. */ if (len >= s->bsize) return_error(e_rangecheck); s_process_read_buf(s); continue; default: return handle_read_status(i_ctx_p, status, op - 1, NULL, zpeekstring); } break; } if (rlen > len) rlen = len; /* Don't remove the data from the buffer. */ memcpy(op->value.bytes, sbufptr(s), rlen); r_set_size(op, rlen); op[-1] = *op; make_bool(op, (rlen == len ? 1 : 0)); return 0; }
/* Continue processing data from an image with file data sources. */ static int image_file_continue(i_ctx_t *i_ctx_p) { gs_image_enum *penum = r_ptr(esp, gs_image_enum); int num_sources = ETOP_NUM_SOURCES(esp)->value.intval; for (;;) { uint min_avail = max_int; gs_const_string plane_data[gs_image_max_planes]; int code; int px; const ref *pp; bool at_eof = false; /* * Do a first pass through the files to ensure that at least * one has data available in its buffer. */ for (px = 0, pp = ETOP_SOURCE(esp, 0); px < num_sources; ++px, pp -= 2 ) { int num_aliases = pp[1].value.intval; stream *s = pp->value.pfile; int min_left; uint avail; if (num_aliases <= 0) num_aliases = ETOP_SOURCE(esp, -num_aliases)[1].value.intval; while ((avail = sbufavailable(s)) <= (min_left = sbuf_min_left(s)) + num_aliases - 1) { int next = s->end_status; switch (next) { case 0: s_process_read_buf(s); continue; case EOFC: at_eof = true; break; /* with no data available */ case INTC: case CALLC: return s_handle_read_exception(i_ctx_p, next, pp, NULL, 0, image_file_continue); default: /* case ERRC: */ return_error(e_ioerror); } break; /* for EOFC */ } /* * Note that in the EOF case, we can get here with no data * available. */ if (avail >= min_left) avail = (avail - min_left) / num_aliases; /* may be 0 */ if (avail < min_avail) min_avail = avail; plane_data[px].data = sbufptr(s); plane_data[px].size = avail; } /* * Now pass the available buffered data to the image processor. * Even if there is no available data, we must call * gs_image_next_planes one more time to finish processing any * retained data. */ { int pi; uint used[gs_image_max_planes]; code = gs_image_next_planes(penum, plane_data, used); /* Now that used has been set, update the streams. */ for (pi = 0, pp = ETOP_SOURCE(esp, 0); pi < num_sources; ++pi, pp -= 2 ) sbufskip(pp->value.pfile, used[pi]); if (code == e_RemapColor) return code; } if (at_eof) code = 1; if (code) { int code1; esp = zimage_pop_estack(esp); code1 = image_cleanup(i_ctx_p); return (code < 0 ? code : code1 < 0 ? code1 : o_pop_estack); } } }