void
xps_debug_fixdocseq(xps_context_t *ctx)
{
xps_document_t *fixdoc = ctx->first_fixdoc;
xps_page_t *page = ctx->first_page;
if (ctx->start_part)
dmprintf1(ctx->memory, "start part %s\n", ctx->start_part);
while (fixdoc)
{
dmprintf1(ctx->memory, "fixdoc %s\n", fixdoc->name);
fixdoc = fixdoc->next;
}
while (page)
{
dmprintf3(ctx->memory, "page %s w=%d h=%d\n", page->name, page->width, page->height);
page = page->next;
}
}
int
gx_begin_transparency_group(gs_imager_state * pis, gx_device * pdev,
const gs_pdf14trans_params_t * pparams)
{
gs_transparency_group_params_t tgp = {0};
gs_rect bbox;
if (pparams->Background_components != 0 &&
pparams->Background_components != pdev->color_info.num_components)
return_error(gs_error_rangecheck);
tgp.Isolated = pparams->Isolated;
tgp.Knockout = pparams->Knockout;
tgp.idle = pparams->idle;
tgp.mask_id = pparams->mask_id;
/* Needed so that we do proper blending */
tgp.group_color = pparams->group_color;
tgp.group_color_numcomps = pparams->group_color_numcomps;
tgp.iccprofile = pparams->iccprofile;
tgp.icc_hashcode = pparams->icc_hash;
pis->opacity.alpha = pparams->opacity.alpha;
pis->shape.alpha = pparams->shape.alpha;
pis->blend_mode = pparams->blend_mode;
bbox = pparams->bbox;
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const cs_names[] = {
GS_COLOR_SPACE_TYPE_NAMES
};
dmlprintf6(pdev->memory, "[v](0x%lx)gx_begin_transparency_group [%g %g %g %g] Num_grp_clr_comp = %d\n",
(ulong)pis, bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y,
pparams->group_color_numcomps);
if (tgp.ColorSpace)
dmprintf1(pdev->memory, " CS = %s",
cs_names[(int)gs_color_space_get_index(tgp.ColorSpace)]);
else
dmputs(pdev->memory, " (no CS)");
dmprintf2(pdev->memory, " Isolated = %d Knockout = %d\n",
tgp.Isolated, tgp.Knockout);
if (tgp.iccprofile)
dmprintf(pdev->memory, " Have ICC Profile for blending\n");
}
#endif
if (dev_proc(pdev, begin_transparency_group) != 0)
return (*dev_proc(pdev, begin_transparency_group)) (pdev, &tgp, &bbox, pis,
NULL);
else
return 0;
}
int
gs_setblendmode(gs_state *pgs, gs_blend_mode_t mode)
{
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const bm_names[] = { GS_BLEND_MODE_NAMES };
dmlprintf1(pgs->memory, "[v](0x%lx)blend_mode = ", (ulong)pgs);
if (mode >= 0 && mode < countof(bm_names))
dmprintf1(pgs->memory, "%s\n", bm_names[mode]);
else
dmprintf1(pgs->memory, "%d??\n", (int)mode);
}
#endif
/* Map Compatible to Normal so other code treats Compatible as Normal */
/* Often BLEND_MODE_Normal is checked for optimized handling, and */
/* Compatible is now specified to be the same. */
if (mode == BLEND_MODE_Compatible)
mode = BLEND_MODE_Normal;
if ((int)mode < 0 || (int)mode > MAX_BLEND_MODE)
return_error(gs_error_rangecheck);
pgs->blend_mode = mode;
return 0;
}
static void
trace_array_data(const gs_memory_t * mem, const char *label,
const px_value_t * pav)
{
px_data_type_t type = pav->type;
const byte *ptr = pav->value.array.data;
uint count = pav->value.array.size;
bool big_endian = (type & pxd_big_endian) != 0;
bool text = (type & pxd_ubyte) != 0;
uint i;
dmputs(mem, label);
dmputs(mem, (type & pxd_ubyte ? " <" : " {"));
for (i = 0; i < count; ++i) {
if (!(i & 15) && i) {
const char *p;
dmputs(mem, "\n ");
for (p = label; *p; ++p)
dmputc(mem, ' ');
}
if (type & pxd_ubyte) {
dmprintf1(mem, "%02x ", ptr[i]);
if (ptr[i] < 32 || ptr[i] > 126)
text = false;
} else if (type & pxd_uint16)
dmprintf1(mem, "%u ", uint16at(ptr + i * 2, big_endian));
else if (type & pxd_sint16)
dmprintf1(mem, "%d ", sint16at(ptr + i * 2, big_endian));
else if (type & pxd_uint32)
dmprintf1(mem, "%lu ", (ulong) uint32at(ptr + i * 4, big_endian));
else if (type & pxd_sint32)
dmprintf1(mem, "%ld ", (long)sint32at(ptr + i * 4, big_endian));
else if (type & pxd_real32)
dmprintf1(mem, "%g ", real32at(ptr + i * 4, big_endian));
else
dmputs(mem, "? ");
}
dmputs(mem, (type & pxd_ubyte ? ">\n" : "}\n"));
if (text) {
dmputs(mem, "%chars: \"");
debug_print_string(mem, ptr, count);
dmputs(mem, "\"\n");
}
}
int
gs_begin_transparency_group(gs_state *pgs,
const gs_transparency_group_params_t *ptgp,
const gs_rect *pbbox)
{
gs_pdf14trans_params_t params = { 0 };
const gs_color_space *blend_color_space;
gs_imager_state * pis = (gs_imager_state *)pgs;
cmm_profile_t *profile;
if (check_for_nontrans_pattern(pgs,
(unsigned char *)"gs_begin_transparency_group")) {
return(0);
}
/*
* Put parameters into a compositor parameter and then call the
* create_compositor. This will pass the data to the PDF 1.4
* transparency device.
*/
params.pdf14_op = PDF14_BEGIN_TRANS_GROUP;
params.Isolated = ptgp->Isolated;
params.Knockout = ptgp->Knockout;
params.image_with_SMask = ptgp->image_with_SMask;
params.opacity = pgs->opacity;
params.shape = pgs->shape;
params.blend_mode = pgs->blend_mode;
/* This function is called during the c-list writer side.
Store some information so that we know what the color space is
so that we can adjust according later during the clist reader.
We currently will use the concrete space for any space other than a
device space. However, if the device is a sep device it will blend
in DeviceN color space as required. */
blend_color_space = gs_currentcolorspace_inline(pgs);
if (gs_color_space_get_index(blend_color_space) > gs_color_space_index_DeviceCMYK) {
/* ICC and PS CIE based case. Note that unidirectional PS CIE color
spaces should not be allowed but end up occuring when processing
PDF files with -dUseCIEColor. We will end up using the appropriate
ICC default color space in these cases. */
blend_color_space = gs_currentcolorspace_inline(pgs);
} else {
blend_color_space = cs_concrete_space(blend_color_space, pis);
}
/* Note that if the /CS parameter was NOT present in the push
of the transparency group, then we must actually inherent
the previous group color space, or the color space of the
target device (process color model). Here we just want
to set it as a unknown type for clist writing, as we will take care
of using the parent group color space later during clist reading.
Also, if the group was not isolated we MUST use the parent group
color space regardless of what the group color space is specified to be
*/
if (ptgp->ColorSpace == NULL || params.Isolated != true) {
params.group_color = UNKNOWN;
params.group_color_numcomps = 0;
} else {
/* The /CS parameter was present. Use what was set. Currently
all our Device spaces are actually ICC based. The other options
are if -dUseCIEColor is set, in which case it could be
coming in as a PS CIE color space, which should not be allowed
but should default to one of the default ICC color spaces. Note
that CalRGB and CalGray, which are valid bidirectional color spaces
are converted to ICC profiles during installation. PS CIE building
to ICC is delayed. */
if ( gs_color_space_is_ICC(blend_color_space) ) {
/* Blending space is ICC based. If we are doing c-list rendering
we will need to write this color space into the clist.
*/
params.group_color = ICC;
params.group_color_numcomps =
blend_color_space->cmm_icc_profile_data->num_comps;
/* Get the ICC profile */
params.iccprofile = blend_color_space->cmm_icc_profile_data;
params.icc_hash = blend_color_space->cmm_icc_profile_data->hashcode;
} else {
/* Color space was NOT ICC based. PS CIE space and DeviceN are the only
other option. Use the ICC default based upon the component count. */
switch (cs_num_components(blend_color_space)) {
case 1:
profile = pgs->icc_manager->default_gray;
break;
case 3:
profile = pgs->icc_manager->default_rgb;
break;
case 4:
profile = pgs->icc_manager->default_cmyk;
break;
default:
/* We can end up here if we are in a deviceN color space and
we have a sep output device */
profile = NULL;
params.group_color = DEVICEN;
params.group_color_numcomps = cs_num_components(blend_color_space);
break;
}
if (profile != NULL) {
params.group_color = ICC;
params.group_color_numcomps = profile->num_comps;
params.iccprofile = profile;
params.icc_hash = profile->hashcode;
}
}
}
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const cs_names[] = {
GS_COLOR_SPACE_TYPE_NAMES
};
dmlprintf6(pgs->memory, "[v](0x%lx)begin_transparency_group [%g %g %g %g] Num_grp_clr_comp = %d\n",
(ulong)pgs, pbbox->p.x, pbbox->p.y, pbbox->q.x, pbbox->q.y,params.group_color_numcomps);
if (ptgp->ColorSpace)
dmprintf1(pgs->memory, " CS = %s",
cs_names[(int)gs_color_space_get_index(ptgp->ColorSpace)]);
else
dmputs(pgs->memory, " (no CS)");
dmprintf2(pgs->memory, " Isolated = %d Knockout = %d\n",
ptgp->Isolated, ptgp->Knockout);
}
#endif
params.bbox = *pbbox;
return gs_state_update_pdf14trans(pgs, ¶ms);
}
void
clist_teardown_render_threads(gx_device *dev)
{
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)dev;
gx_device_clist_reader *crdev = &cldev->reader;
gs_memory_t *mem = cdev->bandlist_memory;
int i;
if (crdev->render_threads != NULL) {
/* Wait for each thread to finish then free its memory */
for (i = (crdev->num_render_threads - 1); i >= 0; i--) {
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)thread->cdev;
if (thread->status == THREAD_BUSY)
gx_semaphore_wait(thread->sema_this);
/* Free control semaphores */
gx_semaphore_free(thread->sema_group);
gx_semaphore_free(thread->sema_this);
/* destroy the thread's buffer device */
thread_cdev->buf_procs.destroy_buf_device(thread->bdev);
if (thread->options) {
if (thread->options->free_buffer_fn && thread->buffer) {
thread->options->free_buffer_fn(thread->options->arg, dev, thread->memory, thread->buffer);
thread->buffer = NULL;
}
thread->options = NULL;
}
/* before freeing this device's memory, swap with cdev if it was the main_thread_data */
if (thread_cdev->data == crdev->main_thread_data) {
thread_cdev->data = cdev->data;
cdev->data = crdev->main_thread_data;
}
#ifdef DEBUG
if (gs_debug[':'])
dmprintf2(thread->memory, "%% Thread %d total usertime=%ld msec\n", i, thread->cputime);
dmprintf1(thread->memory, "\nThread %d ", i);
#endif
teardown_device_and_mem_for_thread((gx_device *)thread_cdev, thread->thread, false);
}
gs_free_object(mem, crdev->render_threads, "clist_teardown_render_threads");
crdev->render_threads = NULL;
/* Now re-open the clist temp files so we can write to them */
if (cdev->page_info.cfile == NULL) {
char fmode[4];
strcpy(fmode, "a+"); /* file already exists and we want to re-use it */
strncat(fmode, gp_fmode_binary_suffix, 1);
cdev->page_info.io_procs->fopen(cdev->page_info.cfname, fmode, &cdev->page_info.cfile,
mem, cdev->bandlist_memory, true);
cdev->page_info.io_procs->fseek(cdev->page_info.cfile, 0, SEEK_SET, cdev->page_info.cfname);
cdev->page_info.io_procs->fopen(cdev->page_info.bfname, fmode, &cdev->page_info.bfile,
mem, cdev->bandlist_memory, false);
cdev->page_info.io_procs->fseek(cdev->page_info.bfile, 0, SEEK_SET, cdev->page_info.bfname);
}
}
}
/* Set up and start the render threads */
static int
clist_setup_render_threads(gx_device *dev, int y, gx_process_page_options_t *options)
{
gx_device_printer *pdev = (gx_device_printer *)dev;
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)cldev;
gx_device_clist_reader *crdev = &cldev->reader;
gs_memory_t *mem = cdev->bandlist_memory;
gs_memory_t *chunk_base_mem = mem->thread_safe_memory;
gs_memory_status_t mem_status;
int i, band;
int code = 0;
int band_count = cdev->nbands;
int band_height = crdev->page_info.band_params.BandHeight;
crdev->num_render_threads = pdev->num_render_threads_requested;
if(gs_debug[':'] != 0)
dmprintf1(mem, "%% %d rendering threads requested.\n", pdev->num_render_threads_requested);
if (crdev->num_render_threads > band_count)
crdev->num_render_threads = band_count; /* don't bother starting more threads than bands */
/* Allocate and initialize an array of thread control structures */
crdev->render_threads = (clist_render_thread_control_t *)
gs_alloc_byte_array(mem, crdev->num_render_threads,
sizeof(clist_render_thread_control_t), "clist_setup_render_threads" );
/* fallback to non-threaded if allocation fails */
if (crdev->render_threads == NULL) {
emprintf(mem, " VMerror prevented threads from starting.\n");
return_error(gs_error_VMerror);
}
memset(crdev->render_threads, 0, crdev->num_render_threads *
sizeof(clist_render_thread_control_t));
crdev->main_thread_data = cdev->data; /* save data area */
/* Based on the line number requested, decide the order of band rendering */
/* Almost all devices go in increasing line order (except the bmp* devices ) */
crdev->thread_lookahead_direction = (y < (cdev->height - 1)) ? 1 : -1;
band = y / band_height;
/* If the 'mem' is not thread safe, we need to wrap it in a locking memory */
gs_memory_status(chunk_base_mem, &mem_status);
if (mem_status.is_thread_safe == false) {
return_error(gs_error_VMerror);
}
/* If we don't have one large enough already, create an icc cache list */
if (crdev->num_render_threads > crdev->icc_cache_list_len) {
void *old = crdev->icc_cache_list;
crdev->icc_cache_list = gs_alloc_byte_array(mem->thread_safe_memory,
crdev->num_render_threads,
sizeof(void*), "clist_render_setup_threads");
if (crdev->icc_cache_list == NULL) {
crdev->icc_cache_list = NULL;
return_error(gs_error_VMerror);
}
if (crdev->icc_cache_list_len > 0)
memcpy(crdev->icc_cache_list, old, sizeof(void *)*crdev->icc_cache_list_len);
memset(&crdev->icc_cache_list[crdev->icc_cache_list_len], 0,
(crdev->num_render_threads - crdev->icc_cache_list_len) * sizeof(void *));
crdev->icc_cache_list_len = crdev->num_render_threads;
gs_free_object(mem, old, "clist_render_setup_threads");
}
/* Loop creating the devices and semaphores for each thread, then start them */
for (i=0; (i < crdev->num_render_threads) && (band >= 0) && (band < band_count);
i++, band += crdev->thread_lookahead_direction) {
gx_device *ndev;
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
ndev = setup_device_and_mem_for_thread(chunk_base_mem, dev, false, &crdev->icc_cache_list[i]);
if (ndev == NULL) {
code = gs_error_VMerror; /* set code to an error for cleanup after the loop */
break;
}
thread->cdev = ndev;
thread->memory = ndev->memory;
thread->band = -1; /* a value that won't match any valid band */
thread->options = options;
thread->buffer = NULL;
if (options && options->init_buffer_fn) {
code = options->init_buffer_fn(options->arg, dev, thread->memory, dev->width, band_height, &thread->buffer);
if (code < 0)
break;
}
/* create the buf device for this thread, and allocate the semaphores */
if ((code = gdev_create_buf_device(cdev->buf_procs.create_buf_device,
&(thread->bdev), ndev,
band*crdev->page_band_height, NULL,
thread->memory, &(crdev->color_usage_array[0])) < 0))
break;
if ((thread->sema_this = gx_semaphore_alloc(thread->memory)) == NULL ||
(thread->sema_group = gx_semaphore_alloc(thread->memory)) == NULL) {
code = gs_error_VMerror;
break;
}
/* Start thread 'i' to do band */
if ((code = clist_start_render_thread(dev, i, band)) < 0)
break;
}
/* If the code < 0, the last thread creation failed -- clean it up */
if (code < 0) {
band -= crdev->thread_lookahead_direction; /* update for 'next_band' usage */
/* the following relies on 'free' ignoring NULL pointers */
gx_semaphore_free(crdev->render_threads[i].sema_group);
gx_semaphore_free(crdev->render_threads[i].sema_this);
if (crdev->render_threads[i].bdev != NULL)
cdev->buf_procs.destroy_buf_device(crdev->render_threads[i].bdev);
if (crdev->render_threads[i].cdev != NULL) {
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)crdev->render_threads[i].cdev;
/* Close the file handles, but don't delete (unlink) the files */
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_info.bfile, thread_cdev->page_info.bfname, false);
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_info.cfile, thread_cdev->page_info.cfname, false);
thread_cdev->do_not_open_or_close_bandfiles = true; /* we already closed the files */
gdev_prn_free_memory((gx_device *)thread_cdev);
gs_free_object(crdev->render_threads[i].memory, thread_cdev,
"clist_setup_render_threads");
}
if (crdev->render_threads[i].buffer != NULL && options && options->free_buffer_fn != NULL) {
options->free_buffer_fn(options->arg, dev, crdev->render_threads[i].memory, crdev->render_threads[i].buffer);
crdev->render_threads[i].buffer = NULL;
}
if (crdev->render_threads[i].memory != NULL) {
gs_memory_chunk_release(crdev->render_threads[i].memory);
crdev->render_threads[i].memory = NULL;
}
}
/* If we weren't able to create at least one thread, punt */
/* Although a single thread isn't any more efficient, the */
/* machinery still works, so that's OK. */
if (i == 0) {
if (crdev->render_threads[0].memory != NULL) {
gs_memory_chunk_release(crdev->render_threads[0].memory);
/* free up the locking wrapper if we allocated one */
if (chunk_base_mem != mem) {
gs_memory_locked_release((gs_memory_locked_t *)chunk_base_mem);
gs_free_object(mem, chunk_base_mem, "clist_setup_render_threads(locked allocator)");
}
}
gs_free_object(mem, crdev->render_threads, "clist_setup_render_threads");
crdev->render_threads = NULL;
/* restore the file pointers */
if (cdev->page_info.cfile == NULL) {
char fmode[4];
strcpy(fmode, "a+"); /* file already exists and we want to re-use it */
strncat(fmode, gp_fmode_binary_suffix, 1);
cdev->page_info.io_procs->fopen(cdev->page_info.cfname, fmode, &cdev->page_info.cfile,
mem, cdev->bandlist_memory, true);
cdev->page_info.io_procs->fseek(cdev->page_info.cfile, 0, SEEK_SET, cdev->page_info.cfname);
cdev->page_info.io_procs->fopen(cdev->page_info.bfname, fmode, &cdev->page_info.bfile,
mem, cdev->bandlist_memory, false);
cdev->page_info.io_procs->fseek(cdev->page_info.bfile, 0, SEEK_SET, cdev->page_info.bfname);
}
emprintf1(mem, "Rendering threads not started, code=%d.\n", code);
return_error(code);
}
crdev->num_render_threads = i;
crdev->curr_render_thread = 0;
crdev->next_band = band;
if(gs_debug[':'] != 0)
dmprintf1(mem, "%% Using %d rendering threads\n", i);
return 0;
}
static void
on_open_tag(void *zp, const char *ns_name, const char **atts)
{
xps_parser_t *parser = zp;
xps_context_t *ctx = parser->ctx;
xps_item_t *item;
xps_item_t *tail;
int namelen;
int attslen;
int textlen;
const char *name;
char *p;
int i;
if (parser->error)
return;
/* check namespace */
name = NULL;
p = strstr(ns_name, NS_XPS);
if (p == ns_name)
{
name = strchr(ns_name, ' ') + 1;
}
p = strstr(ns_name, NS_MC);
if (p == ns_name)
{
name = strchr(ns_name, ' ') + 1;
}
p = strstr(ns_name, NS_OXPS);
if (p == ns_name)
{
name = strchr(ns_name, ' ') + 1;
}
if (!name)
{
dmprintf1(ctx->memory, "unknown namespace: %s\n", ns_name);
name = ns_name;
}
/* count size to alloc */
namelen = strlen(name) + 1; /* zero terminated */
attslen = sizeof(char*); /* with space for sentinel */
textlen = 0;
for (i = 0; atts[i]; i++)
{
attslen += sizeof(char*);
if ((i & 1) == 0)
textlen += strlen(skip_namespace(atts[i])) + 1;
else
textlen += strlen(atts[i]) + 1;
}
item = xps_alloc(ctx, sizeof(xps_item_t) + attslen + namelen + textlen);
if (!item) {
parser->error = "out of memory";
gs_throw(gs_error_VMerror, "out of memory.\n");
return;
}
/* copy strings to new memory */
item->atts = (char**) (((char*)item) + sizeof(xps_item_t));
item->name = ((char*)item) + sizeof(xps_item_t) + attslen;
p = ((char*)item) + sizeof(xps_item_t) + attslen + namelen;
strcpy(item->name, name);
for (i = 0; atts[i]; i++)
{
item->atts[i] = p;
if ((i & 1) == 0)
strcpy(item->atts[i], skip_namespace(atts[i]));
else
strcpy(item->atts[i], atts[i]);
p += strlen(p) + 1;
}
item->atts[i] = 0;
/* link item into tree */
item->up = parser->head;
item->down = NULL;
item->next = NULL;
if (!parser->head)
{
parser->root = item;
parser->head = item;
return;
}
if (!parser->head->down)
{
parser->head->down = item;
parser->head->tail = item;
parser->head = item;
return;
}
tail = parser->head->tail;
tail->next = item;
parser->head->tail = item;
parser->head = item;
}
static int
vu_stream_error(stream_state * st, const char *str)
{
dmprintf1(st->memory, "pxl vendor stream error %s\n", str);
return 0;
}
/* Process a buffer of PCL XL commands. */
int
px_process(px_parser_state_t * st, px_state_t * pxs, stream_cursor_read * pr)
{
const byte *orig_p = pr->ptr;
const byte *next_p = orig_p; /* start of data not copied to saved */
const byte *p;
const byte *rlimit;
px_value_t *sp = &st->stack[st->stack_count];
#define stack_limit &st->stack[max_stack - 1]
gs_memory_t *memory = st->memory;
int code = 0;
uint left;
uint min_left;
px_tag_t tag;
const px_tag_syntax_t *syntax = 0;
st->args.parser = st;
st->parent_operator_count = 0; /* in case of error */
/* Check for leftover data from the previous call. */
parse:if (st->saved_count) { /* Fill up the saved buffer so we can make progress. */
int move = min(sizeof(st->saved) - st->saved_count,
pr->limit - next_p);
memcpy(&st->saved[st->saved_count], next_p + 1, move);
next_p += move;
p = st->saved - 1;
rlimit = p + st->saved_count + move;
} else { /* No leftover data, just read from the input. */
p = next_p;
rlimit = pr->limit;
}
top:if (st->data_left) { /* We're in the middle of reading an array or data block. */
if (st->data_proc) { /* This is a data block. */
uint avail = min(rlimit - p, st->data_left);
uint used;
st->args.source.available = avail;
st->args.source.data = p + 1;
code = (*st->data_proc) (&st->args, pxs);
/* If we get a 'remap_color' error, it means we are dealing with a
* pattern, and the device supports high level patterns. So we must
* use our high level pattern implementation.
*/
if (code == gs_error_Remap_Color) {
code = px_high_level_pattern(pxs->pgs);
code = (*st->data_proc) (&st->args, pxs);
}
used = st->args.source.data - (p + 1);
#ifdef DEBUG
if (gs_debug_c('I')) {
px_value_t data_array;
data_array.type = pxd_ubyte;
data_array.value.array.data = p + 1;
data_array.value.array.size = used;
trace_array_data(pxs->memory, "data:", &data_array);
}
#endif
p = st->args.source.data - 1;
st->data_left -= used;
if (code < 0) {
st->args.source.position = 0;
goto x;
} else if ((code == pxNeedData)
|| (code == pxPassThrough && st->data_left != 0)) {
code = 0; /* exit for more data */
goto x;
} else {
st->args.source.position = 0;
st->data_proc = 0;
if (st->data_left != 0) {
code = gs_note_error(errorExtraData);
goto x;
}
clear_stack();
}
} else { /* This is an array. */
uint size = sp->value.array.size;
uint scale = value_size(sp);
uint nbytes = size * scale;
byte *dest =
(byte *) sp->value.array.data + nbytes - st->data_left;
left = rlimit - p;
if (left < st->data_left) { /* We still don't have enough data to fill the array. */
memcpy(dest, p + 1, left);
st->data_left -= left;
p = rlimit;
code = 0;
goto x;
}
/* Complete the array and continue parsing. */
memcpy(dest, p + 1, st->data_left);
trace_array(memory, sp);
p += st->data_left;
}
st->data_left = 0;
} else if (st->data_proc) { /* An operator is awaiting data. */
/* Skip white space until we find some. */
code = 0; /* in case we exit */
/* special case - VendorUnique has a length attribute which
we've already parsed and error checked */
if (st->data_proc == pxVendorUnique) {
st->data_left =
st->stack[st->attribute_indices[pxaVUDataLength]].value.i;
goto top;
} else {
while ((left = rlimit - p) != 0) {
switch ((tag = p[1])) {
case pxtNull:
case pxtHT:
case pxtLF:
case pxtVT:
case pxtFF:
case pxtCR:
++p;
continue;
case pxt_dataLength:
if (left < 5)
goto x; /* can't look ahead */
st->data_left = get_uint32(st, p + 2);
if_debug2m('i', memory, "tag= 0x%2x data, length %u\n",
p[1], st->data_left);
p += 5;
goto top;
case pxt_dataLengthByte:
if (left < 2)
goto x; /* can't look ahead */
st->data_left = p[2];
if_debug2m('i', memory, "tag= 0x%2x data, length %u\n",
p[1], st->data_left);
p += 2;
goto top;
default:
{
code = gs_note_error(errorMissingData);
goto x;
}
}
}
}
}
st->args.source.position = 0;
st->args.source.available = 0;
while ((left = rlimit - p) != 0 &&
left >= (min_left = (syntax = &tag_syntax[tag = p[1]])->min_input)
) {
int count;
#ifdef DEBUG
if (gs_debug_c('i')) {
dmprintf1(memory, "tag= 0x%02x ", tag);
if (tag == pxt_attr_ubyte || tag == pxt_attr_uint16) {
px_attribute_t attr =
(tag == pxt_attr_ubyte ? p[2] : get_uint16(st, p + 2));
const char *aname = px_attribute_names[attr];
if (aname)
dmprintf1(memory, " @%s\n", aname);
else
dmprintf1(memory, " attribute %u ???\n", attr);
} else {
const char *format;
const char *tname;
bool operator = false;
if (tag < 0x40)
format = "%s\n", tname = px_tag_0_names[tag];
else if (tag < 0xc0)
format = "%s", tname = px_operator_names[tag - 0x40],
operator = true;
else {
tname = px_tag_c0_names[tag - 0xc0];
if (tag < 0xf0)
format = " %s"; /* data values follow */
else
format = "%s\n";
}
if (tname) {
dmprintf1(memory, format, tname);
if (operator)
dmprintf1(memory, " (%ld)\n", st->operator_count + 1);
} else
dmputs(memory, "???\n");
}
}
#endif
if ((st->macro_state & syntax->state_mask) != syntax->state_value) {
/*
* We should probably distinguish here between
* out-of-context operators and illegal tags, but it's too
* much trouble.
*/
code = gs_note_error(errorIllegalOperatorSequence);
if (tag >= 0x40 && tag < 0xc0)
st->last_operator = tag;
goto x;
}
st->macro_state ^= syntax->state_transition;
switch (tag >> 3) {
case 0:
switch (tag) {
case pxtNull:
++p;
continue;
default:
break;
}
break;
case 1:
switch (tag) {
case pxtHT:
case pxtLF:
case pxtVT:
case pxtFF:
case pxtCR:
++p;
continue;
default:
break;
}
break;
case 3:
if (tag == pxt1b) { /* ESC *//* Check for UEL */
if (memcmp(p + 1, "\033%-12345X", min(left, 9)))
break; /* not UEL, error */
if (left < 9)
goto x; /* need more data */
p += 9;
code = e_ExitLanguage;
goto x;
}
break;
case 4:
switch (tag) {
case pxtSpace:
/* break; will error, compatible with lj */
/* ++p;continue; silently ignores the space */
++p;
continue;
default:
break;
}
break;
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
/* Operators */
/* Make sure that we have all the required attributes, */
/* and no attributes that are neither required nor */
/* optional. (It's up to the operator to make any */
/* more precise checks than this. */
st->operator_count++;
/* if this is a passthrough operator we have to tell
the passthrough module if this operator was
preceded by another passthrough operator or a
different xl operator */
if (tag == pxtPassThrough) {
pxpcl_passthroughcontiguous(st->last_operator == tag);
} else if (st->last_operator == pxtPassThrough) {
pxpcl_endpassthroughcontiguous(pxs);
}
st->last_operator = tag;
{
const px_operator_definition_t *pod =
&px_operator_definitions[tag - 0x40];
int left = sp - st->stack;
const byte /*px_attribute_t */ * pal = pod->attrs;
px_value_t **ppv = st->args.pv;
bool required = true;
code = 0;
/*
* Scan the attributes. Illegal attributes take priority
* over missing attributes, which in turn take priority
* over illegal data types.
*/
for (;; ++pal, ++ppv) {
px_attribute_t attr = *pal;
uint index;
if (!attr) { /*
* We've reached the end of either the required or
* the optional attribute list.
*/
if (!required)
break;
required = false;
--ppv; /* cancel incrementing */
continue;
}
if ((index = st->attribute_indices[attr]) == 0) {
if (required)
code = gs_note_error(errorMissingAttribute);
else
*ppv = 0;
} else { /* Check the attribute data type and value. */
px_value_t *pv = *ppv = &st->stack[index];
const px_attr_value_type_t *pavt =
&px_attr_value_types[attr];
int acode;
if ((~pavt->mask & pv->type &
(pxd_structure | pxd_representation)) ||
(pavt->mask == (pxd_scalar | pxd_ubyte) &&
(pv->value.i < 0
|| pv->value.i > pavt->limit))
) {
if (code >= 0)
code =
gs_note_error
(errorIllegalAttributeDataType);
}
if (pavt->proc != 0
&& (acode = (*pavt->proc) (pv)) < 0) {
if (code >= 0)
code = acode;
}
--left;
}
}
/* Make sure there are no attributes left over. */
if (left)
code = gs_note_error(errorIllegalAttribute);
if (code >= 0) {
st->args.source.phase = 0;
code = (*pod->proc) (&st->args, pxs);
/* If we get a 'remap_color' error, it means we are dealing with a
* pattern, and the device supports high level patterns. So we must
* use our high level pattern implementation.
*/
if (code == gs_error_Remap_Color) {
code = px_high_level_pattern(pxs->pgs);
if (code < 0)
goto x;
code = (*pod->proc) (&st->args, pxs);
}
}
if (code < 0)
goto x;
/* Check whether the operator wanted source data. */
if (code == pxNeedData) {
if (!pxs->data_source_open) {
code = gs_note_error(errorDataSourceNotOpen);
goto x;
}
st->data_proc = pod->proc;
++p;
goto top;
}
}
clear_stack();
++p;
continue;
case 24:
sp[1].type = pxd_scalar;
count = 1;
goto data;
case 26:
sp[1].type = pxd_xy;
count = 2;
goto data;
case 28:
sp[1].type = pxd_box;
count = 4;
goto data;
/* Scalar, point, and box data */
data:{
int i;
if (sp == stack_limit) {
code = gs_note_error(errorInternalOverflow);
goto x;
}
++sp;
sp->attribute = 0;
p += 2;
#ifdef DEBUG
# define trace_scalar(mem, format, cast, alt)\
if ( gs_debug_c('i') )\
trace_data(mem, format, cast, sp->value.alt, count)
#else
# define trace_scalar(mem, format, cast, alt) DO_NOTHING
#endif
switch (tag & 7) {
case pxt_ubyte & 7:
sp->type |= pxd_ubyte;
for (i = 0; i < count; ++p, ++i)
sp->value.ia[i] = *p;
dux:trace_scalar(pxs->memory, " %lu", ulong,
ia);
--p;
continue;
case pxt_uint16 & 7:
sp->type |= pxd_uint16;
for (i = 0; i < count; p += 2, ++i)
sp->value.ia[i] = get_uint16(st, p);
goto dux;
case pxt_uint32 & 7:
sp->type |= pxd_uint32;
for (i = 0; i < count; p += 4, ++i)
sp->value.ia[i] = get_uint32(st, p);
goto dux;
case pxt_sint16 & 7:
sp->type |= pxd_sint16;
for (i = 0; i < count; p += 2, ++i)
sp->value.ia[i] = get_sint16(st, p);
dsx:trace_scalar(pxs->memory, " %ld", long,
ia);
--p;
continue;
case pxt_sint32 & 7:
sp->type |= pxd_sint32;
for (i = 0; i < count; p += 4, ++i)
sp->value.ia[i] = get_sint32(st, p);
goto dsx;
case pxt_real32 & 7:
sp->type |= pxd_real32;
for (i = 0; i < count; p += 4, ++i)
sp->value.ra[i] = get_real32(st, p);
trace_scalar(pxs->memory, " %g", double, ra);
--p;
continue;
default:
break;
}
}
break;
case 25:
/* Array data */
{
const byte *dp;
uint nbytes;
if (sp == stack_limit) {
code = gs_note_error(errorInternalOverflow);
goto x;
}
switch (p[2]) {
case pxt_ubyte:
sp[1].value.array.size = p[3];
dp = p + 4;
break;
case pxt_uint16:
if (left < 4) {
if_debug0m('i', memory, "...\n");
/* Undo the state transition. */
st->macro_state ^= syntax->state_transition;
goto x;
}
sp[1].value.array.size = get_uint16(st, p + 3);
dp = p + 5;
break;
default:
st->last_operator = tag; /* for error message */
code = gs_note_error(errorIllegalTag);
goto x;
}
nbytes = sp[1].value.array.size;
if_debug1m('i', memory, "[%u]\n", sp[1].value.array.size);
switch (tag) {
case pxt_ubyte_array:
sp[1].type = pxd_array | pxd_ubyte;
array:++sp;
if (st->big_endian)
sp->type |= pxd_big_endian;
sp->value.array.data = dp;
sp->attribute = 0;
/* Check whether we have enough data for the entire */
/* array. */
if (rlimit + 1 - dp < nbytes) { /* Exit now, continue reading when we return. */
uint avail = rlimit + 1 - dp;
code = px_save_array(sp, pxs, "partial array",
avail);
if (code < 0)
goto x;
sp->type |= pxd_on_heap;
st->data_left = nbytes - avail;
st->data_proc = 0;
p = rlimit;
goto x;
}
p = dp + nbytes - 1;
trace_array(memory, sp);
continue;
case pxt_uint16_array:
sp[1].type = pxd_array | pxd_uint16;
a16:nbytes <<= 1;
goto array;
case pxt_uint32_array:
sp[1].type = pxd_array | pxd_uint32;
a32:nbytes <<= 2;
goto array;
case pxt_sint16_array:
sp[1].type = pxd_array | pxd_sint16;
goto a16;
case pxt_sint32_array:
sp[1].type = pxd_array | pxd_sint32;
goto a32;
case pxt_real32_array:
sp[1].type = pxd_array | pxd_real32;
goto a32;
default:
break;
}
break;
}
break;
case 31:
{
px_attribute_t attr;
const byte *pnext;
switch (tag) {
case pxt_attr_ubyte:
attr = p[2];
pnext = p + 2;
goto a;
case pxt_attr_uint16:
attr = get_uint16(st, p + 2);
pnext = p + 3;
a:if (attr >=
px_attribute_next)
break;
/*
* We could check the attribute value type here, but
* in order to match the behavior of the H-P printers,
* we don't do it until we see the operator.
*
* It is legal to specify the same attribute more than
* once; the last value has priority. If this happens,
* since the order of attributes doesn't matter, we can
* just replace the former value on the stack.
*/
sp->attribute = attr;
if (st->attribute_indices[attr] != 0) {
px_value_t *old_sp =
&st->stack[st->attribute_indices[attr]];
/* If the old value is on the heap, free it. */
if (old_sp->type & pxd_on_heap)
gs_free_object(memory,
(void *)old_sp->value.
array.data,
"old value for duplicate attribute");
*old_sp = *sp--;
} else
st->attribute_indices[attr] = sp - st->stack;
p = pnext;
continue;
case pxt_dataLength:
/*
* Unexpected data length operators are normally not
* allowed, but there might be a zero-length data
* block immediately following a zero-size image,
* which doesn't ask for any data.
*/
if (uint32at(p + 2, true /*arbitrary */ ) == 0) {
p += 5;
continue;
}
break;
case pxt_dataLengthByte:
/* See the comment under pxt_dataLength above. */
if (p[2] == 0) {
p += 2;
continue;
}
break;
default:
break;
}
}
break;
default:
break;
}
/* Unknown tag value. Report an error. */
st->last_operator = tag; /* for error message */
code = gs_note_error(errorIllegalTag);
break;
}
x: /* Save any leftover input. */
left = rlimit - p;
if (rlimit != pr->limit) { /* We were reading saved input. */
if (left <= next_p - orig_p) { /* We finished reading the previously saved input. */
/* Continue reading current input, unless we got an error. */
p = next_p -= left;
rlimit = pr->limit;
st->saved_count = 0;
if (code >= 0)
goto parse;
} else { /* There's still some previously saved input left over. */
memmove(st->saved, p + 1, st->saved_count = left);
p = next_p;
rlimit = pr->limit;
left = rlimit - p;
}
}
/* Except in case of error, save any remaining input. */
if (code >= 0) {
if (left + st->saved_count > sizeof(st->saved)) { /* Fatal error -- shouldn't happen! */
code = gs_note_error(errorInternalOverflow);
st->saved_count = 0;
} else {
memcpy(&st->saved[st->saved_count], p + 1, left);
st->saved_count += left;
p = rlimit;
}
}
pr->ptr = p;
st->stack_count = sp - st->stack;
/* Move to the heap any arrays whose data was being referenced */
/* directly in the input buffer. */
for (; sp > st->stack; --sp)
if ((sp->type & (pxd_array | pxd_on_heap)) == pxd_array) {
int code = px_save_array(sp, pxs, "px stack array to heap",
sp->value.array.size * value_size(sp));
if (code < 0)
break;
sp->type |= pxd_on_heap;
}
if (code < 0 && syntax != 0) { /* Undo the state transition. */
st->macro_state ^= syntax->state_transition;
}
return code;
}
int
pxPassthrough(px_args_t * par, px_state_t * pxs)
{
stream_cursor_read r;
int code = 0;
uint used;
/* apparently if there is no open data source we open one. By the
spec this should already be open, in practice it is not. */
if (!pxs->data_source_open) {
if (gs_debug_c('i'))
dmprintf(pxs->memory,
"passthrough: data source not open upon entry\n");
pxs->data_source_open = true;
pxs->data_source_big_endian = true;
}
/* source available is part of the equation to determine if this
operator is being called for the first time */
if (par->source.available == 0) {
if (par->source.phase == 0) {
if (gs_debug_c('i'))
dmprintf(pxs->memory,
"passthrough starting getting more data\n");
if (!global_pcs)
pxPassthrough_init(pxs);
/* this is the first passthrough on this page */
if (global_pass_first) {
pxPassthrough_setpagestate(pxs);
pxPassthrough_pcl_state_nonpage_exceptions(pxs);
global_pass_first = false;
} else {
/* there was a previous passthrough check if there were
any intervening XL commands */
if (global_this_pass_contiguous == false)
pxPassthrough_pcl_state_nonpage_exceptions(pxs);
}
par->source.phase = 1;
}
return pxNeedData;
}
/* set pcl data stream pointers to xl's and process this batch of data. */
r.ptr = par->source.data - 1;
r.limit = par->source.data + par->source.available - 1;
code = pcl_process(&global_pcl_parser_state, global_pcs, &r);
/* updata xl's parser position to reflect what pcl has consumed. */
used = (r.ptr + 1 - par->source.data);
par->source.available -= used;
par->source.data = r.ptr + 1;
if (code < 0) {
dmprintf1(pxs->memory, "passthrough: error return %d\n", code);
return code;
}
/* always return need data and we exit at the top when the data is
exhausted. */
{
if (used > px_parser_data_left(par->parser)) {
dmprintf(pxs->memory, "error: read past end of stream\n");
return -1;
} else if (used < px_parser_data_left(par->parser)) {
return pxNeedData;
} else {
/* end of operator and data */
return 0;
}
}
}