static int
check_for_nontrans_pattern(gs_state *pgs, unsigned char *comp_name)
{
gx_device * dev = pgs->device;
bool is_patt_clist = gx_device_is_pattern_clist(dev);
bool is_patt_acum = gx_device_is_pattern_accum(dev);
/* Check if we are collecting data for a pattern that has no
transparency. In that case, we need to ignore the state changes */
if (is_patt_clist || is_patt_acum) {
if (is_patt_clist) {
gx_device_clist_writer *clwdev = (gx_device_clist_writer*) dev;
const gs_pattern1_instance_t *pinst = clwdev->pinst;
if (!(pinst->templat.uses_transparency)) {
if_debug1m('v', pgs->memory,
"[v]%s NOT sending in pattern\n",comp_name);
return(1);
}
}
if (is_patt_acum) {
gx_device_pattern_accum *padev = (gx_device_pattern_accum*) dev;
const gs_pattern1_instance_t *pinst = padev->instance;
if (!(pinst->templat.uses_transparency)) {
if_debug1m('v', pgs->memory,
"[v]%s NOT sending in pattern\n",comp_name);
return(1);
}
}
}
return(0);
}
/* Render a CIEBasedA color. */
int
gx_concretize_CIEA(const gs_client_color * pc, const gs_color_space * pcs_in,
frac * pconc, const gs_imager_state * pis, gx_device *dev)
{
int code = 0;
gs_color_space *pcs_icc;
gs_client_color scale_pc;
gs_color_space *pcs = (gs_color_space *) pcs_in;
if_debug1m('c', dev->memory, "[c]concretize CIEA %g\n", pc->paint.values[0]);
/* If we are comming in here then we have not completed
the conversion of the CIE A space to an ICC type. We
will finish that process now. */
if (pcs->icc_equivalent == NULL) {
code = gx_ciea_to_icc(&pcs_icc, pcs, pis->memory->stable_memory);
if (code < 0)
return gs_rethrow(code, "Failed to create ICC profile from CIEA");
} else {
/* Once the ICC color space is set, we should be doing all the remaps through the ICC equivalent */
pcs_icc = pcs->icc_equivalent;
}
/* Rescale the input based upon the input range since profile is
created to remap this range from 0 to 1 */
if (check_range(&(pcs->params.a->RangeA), 1)) {
return (pcs_icc->type->concretize_color)(pc, pcs_icc, pconc, pis, dev);
}
/* Do the rescale from 0 to 1 */
rescale_input_color(&(pcs->params.a->RangeA), 1, pc, &scale_pc);
/* Now the icc remap */
return (pcs_icc->type->concretize_color)(&scale_pc, pcs_icc, pconc, pis, dev);
}
static void
xps_add_fixed_document(xps_context_t *ctx, char *name)
{
xps_document_t *fixdoc;
/* Check for duplicates first */
for (fixdoc = ctx->first_fixdoc; fixdoc; fixdoc = fixdoc->next)
if (!strcmp(fixdoc->name, name))
return;
if_debug1m('|', ctx->memory, "doc: adding fixdoc %s\n", name);
fixdoc = xps_alloc(ctx, sizeof(xps_document_t));
if (!fixdoc) {
gs_throw(gs_error_VMerror, "out of memory: xps_add_fixed_document\n");
return;
}
fixdoc->name = xps_strdup(ctx, name);
fixdoc->next = NULL;
if (!ctx->first_fixdoc)
{
ctx->first_fixdoc = fixdoc;
ctx->last_fixdoc = fixdoc;
}
else
{
ctx->last_fixdoc->next = fixdoc;
ctx->last_fixdoc = fixdoc;
}
}
static int
c_alpha_write(const gs_composite_t * pcte, byte * data, uint * psize, gx_device_clist_writer *cdev)
{
uint size = *psize;
uint used;
if_debug1m('v', ((gx_device *)cdev)->memory, "[v]c_alpha_write(%d)\n", pacte->params.op);
if (pacte->params.op == composite_Dissolve) {
used = 1 + sizeof(pacte->params.delta);
if (size < used) {
*psize = used;
return_error(gs_error_rangecheck);
}
memcpy(data + 1, &pacte->params.delta, sizeof(pacte->params.delta));
} else {
used = 1;
if (size < used) {
*psize = used;
return_error(gs_error_rangecheck);
}
}
*data = (byte) pacte->params.op;
*psize = used;
return 0;
}
static void
xps_add_fixed_page(xps_context_t *ctx, char *name, int width, int height)
{
xps_page_t *page;
/* Check for duplicates first */
for (page = ctx->first_page; page; page = page->next)
if (!strcmp(page->name, name))
return;
if_debug1m('|', ctx->memory, "doc: adding page %s\n", name);
page = xps_alloc(ctx, sizeof(xps_page_t));
if (!page) {
gs_throw(gs_error_VMerror, "out of memory: xps_add_fixed_page\n");
return;
}
page->name = xps_strdup(ctx, name);
page->width = width;
page->height = height;
page->next = NULL;
if (!ctx->first_page)
{
ctx->first_page = page;
ctx->last_page = page;
}
else
{
ctx->last_page->next = page;
ctx->last_page = page;
}
}
static int
c_alpha_read(gs_composite_t ** ppcte, const byte * data, uint size,
gs_memory_t * mem)
{
gs_composite_alpha_params_t params;
int code, nbytes = 1;
if (size < 1 || *data > composite_op_last)
return_error(gs_error_rangecheck);
params.op = *data;
if_debug1m('v', mem, "[v]c_alpha_read(%d)\n", params.op);
if (params.op == composite_Dissolve) {
if (size < 1 + sizeof(params.delta))
return_error(gs_error_rangecheck);
memcpy(¶ms.delta, data + 1, sizeof(params.delta));
nbytes += sizeof(params.delta);
}
code = gs_create_composite_alpha(ppcte, ¶ms, mem);
return code < 0 ? code : nbytes;
}
/* DT terminator[,mode]; */
int
hpgl_DT(hpgl_args_t * pargs, hpgl_state_t * pgls)
{
const byte *p = pargs->source.ptr;
const byte *rlimit = pargs->source.limit;
byte ch = (byte) pargs->phase;
int mode = 1;
/* We use phase to remember the terminator character */
/* in case we had to restart execution. */
if (p >= rlimit)
return gs_error_NeedInput;
if (!ch)
switch ((ch = *++p)) {
case ';':
pargs->source.ptr = p;
pgls->g.label.terminator = 3;
pgls->g.label.print_terminator = false;
return 0;
case 0:
case 5:
case 27:
return e_Range;
default:
if (p >= rlimit)
return gs_error_NeedInput;
if (*++p == ',') {
pargs->source.ptr = p;
pargs->phase = ch;
if_debug1m('i', pgls->memory, "%c", ch);
}
}
if (hpgl_arg_c_int(pgls->memory, pargs, &mode) && (mode & ~1))
return e_Range;
pgls->g.label.terminator = ch;
pgls->g.label.print_terminator = !mode;
return 0;
}
int
gx_remap_CIEA(const gs_client_color * pc, const gs_color_space * pcs_in,
gx_device_color * pdc, const gs_imager_state * pis, gx_device * dev,
gs_color_select_t select)
{
int code;
gs_color_space *pcs_icc;
gs_client_color scale_pc;
gs_color_space *pcs = (gs_color_space *) pcs_in;
if_debug1m('c', dev->memory, "[c]remap CIEA [%g]\n",pc->paint.values[0]);
/* If we are coming in here then we may have not completed
the conversion of the CIE A space to an ICC type. We
will finish that process now. */
if (pcs->icc_equivalent == NULL) {
code = gx_ciea_to_icc(&pcs_icc, pcs, pis->memory->stable_memory);
if (code < 0)
return gs_rethrow(code, "Failed to create ICC profile from CIEA");
} else {
/* Once the ICC color space is set, we should be doing all the remaps through the ICC equivalent */
pcs_icc = pcs->icc_equivalent;
}
/* Rescale the input based upon the input range since profile is
created to remap this range from 0 to 1 */
if (check_range(&(pcs->params.a->RangeA), 1)) {
return (pcs_icc->type->remap_color)(pc,pcs_icc,pdc,pis,dev,select);
}
/* Do the rescale from 0 to 1 */
rescale_input_color(&(pcs->params.a->RangeA), 1, pc, &scale_pc);
/* Now the icc remap */
code = (pcs_icc->type->remap_color)(&scale_pc,pcs_icc,pdc,pis,dev,select);
/* Save unscaled data for high level device (e.g. pdfwrite) */
pdc->ccolor.paint.values[0] = pc->paint.values[0];
pdc->ccolor_valid = true;
return code;
}
/* Used for when we have to mash entire transform to CIEXYZ */
int
gx_psconcretize_CIEA(const gs_client_color * pc, const gs_color_space * pcs,
frac * pconc, float * cie_xyz, const gs_imager_state * pis)
{
const gs_cie_a *pcie = pcs->params.a;
cie_cached_value a = float2cie_cached(pc->paint.values[0]);
cie_cached_vector3 vlmn;
int code;
if_debug1m('c', pis->memory, "[c]concretize CIEA %g\n", pc->paint.values[0]);
code = gx_cie_check_rendering_inline(pcs, pconc, pis);
if (code < 0)
return code;
if (code == 1)
return 0;
/* Apply DecodeA and MatrixA. */
if (!pis->cie_joint_caches->skipDecodeABC)
vlmn = *LOOKUP_ENTRY(a, &pcie->caches.DecodeA);
else
vlmn.u = vlmn.v = vlmn.w = a;
GX_CIE_REMAP_FINISH(vlmn, pconc, cie_xyz, pis, pcs);
return 0;
}
/* <source> <dict> /JPXDecode <file> */
static int
z_jpx_decode(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
ref *sop = NULL;
ref *csname = NULL;
stream_jpxd_state state;
/* it's our responsibility to call set_defaults() */
state.memory = imemory->non_gc_memory;
if (s_jpxd_template.set_defaults)
(*s_jpxd_template.set_defaults)((stream_state *)&state);
if (r_has_type(op, t_dictionary)) {
check_dict_read(*op);
if ( dict_find_string(op, "Alpha", &sop) > 0) {
check_type(*sop, t_boolean);
if (sop->value.boolval)
state.alpha = true;
}
if ( dict_find_string(op, "ColorSpace", &sop) > 0) {
/* parse the value */
if (r_is_array(sop)) {
/* assume it's the first array element */
csname = sop->value.refs;
} else if (r_has_type(sop,t_name)) {
/* use the name directly */
csname = sop;
} else {
dmprintf(imemory, "warning: JPX ColorSpace value is an unhandled type!\n");
}
if (csname != NULL) {
ref sref;
/* get a reference to the name's string value */
name_string_ref(imemory, csname, &sref);
/* request raw index values if the colorspace is /Indexed */
if (!ISTRCMP(&sref, "Indexed"))
state.colorspace = gs_jpx_cs_indexed;
/* tell the filter what output we want for other spaces */
else if (!ISTRCMP(&sref, "DeviceGray"))
state.colorspace = gs_jpx_cs_gray;
else if (!ISTRCMP(&sref, "DeviceRGB"))
state.colorspace = gs_jpx_cs_rgb;
else if (!ISTRCMP(&sref, "DeviceCMYK"))
state.colorspace = gs_jpx_cs_cmyk;
else if (!ISTRCMP(&sref, "ICCBased")) {
/* The second array element should be the profile's
stream dict */
ref *csdict = sop->value.refs + 1;
ref *nref;
ref altname;
if (r_is_array(sop) && (r_size(sop) > 1) &&
r_has_type(csdict, t_dictionary)) {
check_dict_read(*csdict);
/* try to look up the alternate space */
if (dict_find_string(csdict, "Alternate", &nref) > 0) {
name_string_ref(imemory, csname, &altname);
if (!ISTRCMP(&altname, "DeviceGray"))
state.colorspace = gs_jpx_cs_gray;
else if (!ISTRCMP(&altname, "DeviceRGB"))
state.colorspace = gs_jpx_cs_rgb;
else if (!ISTRCMP(&altname, "DeviceCMYK"))
state.colorspace = gs_jpx_cs_cmyk;
}
/* else guess based on the number of components */
if (state.colorspace == gs_jpx_cs_unset &&
dict_find_string(csdict, "N", &nref) > 0) {
if_debug1m('w', imemory, "[w] JPX image has an external %"PRIpsint
" channel colorspace\n", nref->value.intval);
switch (nref->value.intval) {
case 1: state.colorspace = gs_jpx_cs_gray;
break;
case 3: state.colorspace = gs_jpx_cs_rgb;
break;
case 4: state.colorspace = gs_jpx_cs_cmyk;
break;
}
}
}
}
} else {
if_debug0m('w', imemory, "[w] Couldn't read JPX ColorSpace key!\n");
}
}
}
/* we pass npop=0, since we've no arguments left to consume */
/* we pass 0 instead of the usual rspace(sop) which will allocate storage
for filter state from the same memory pool as the stream it's coding.
this causes no trouble because we maintain no pointers */
return filter_read(i_ctx_p, 0, &s_jpxd_template,
(stream_state *) & state, 0);
}
/*
* To device space
*/
int
gx_remap_ICC(const gs_client_color * pcc, const gs_color_space * pcs,
gx_device_color * pdc, const gs_gstate * pgs, gx_device * dev,
gs_color_select_t select)
{
gsicc_link_t *icc_link;
gsicc_rendering_param_t rendering_params;
unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS], psrc_cm[GS_CLIENT_COLOR_MAX_COMPONENTS];
unsigned short *psrc_temp;
frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];
int k,i;
#ifdef DEBUG
int num_src_comps;
#endif
int num_des_comps;
int code;
cmm_dev_profile_t *dev_profile;
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (code < 0)
return code;
if (dev_profile == NULL)
return gs_throw(gs_error_Fatal, "Attempting to do ICC remap with no profile");
num_des_comps = gsicc_get_device_profile_comps(dev_profile);
rendering_params.black_point_comp = pgs->blackptcomp;
rendering_params.graphics_type_tag = dev->graphics_type_tag;
rendering_params.override_icc = false;
rendering_params.preserve_black = gsBKPRESNOTSPECIFIED;
rendering_params.rendering_intent = pgs->renderingintent;
rendering_params.cmm = gsCMM_DEFAULT;
/* Need to clear out psrc_cm in case we have separation bands that are
not color managed */
memset(psrc_cm,0,sizeof(unsigned short)*GS_CLIENT_COLOR_MAX_COMPONENTS);
/* This needs to be optimized */
if (pcs->cmm_icc_profile_data->data_cs == gsCIELAB ||
pcs->cmm_icc_profile_data->islab) {
psrc[0] = (unsigned short) (pcc->paint.values[0]*65535.0/100.0);
psrc[1] = (unsigned short) ((pcc->paint.values[1]+128)/255.0*65535.0);
psrc[2] = (unsigned short) ((pcc->paint.values[2]+128)/255.0*65535.0);
} else {
for (k = 0; k < pcs->cmm_icc_profile_data->num_comps; k++){
psrc[k] = (unsigned short) (pcc->paint.values[k]*65535.0);
}
}
/* Get a link from the cache, or create if it is not there. Need to get 16 bit profile */
icc_link = gsicc_get_link(pgs, dev, pcs, NULL, &rendering_params, pgs->memory);
if (icc_link == NULL) {
#ifdef DEBUG
gs_warn("Could not create ICC link: Check profiles");
#endif
return -1;
}
if (icc_link->is_identity) {
psrc_temp = &(psrc[0]);
} else {
/* Transform the color */
psrc_temp = &(psrc_cm[0]);
(icc_link->procs.map_color)(dev, icc_link, psrc, psrc_temp, 2);
}
#ifdef DEBUG
if (!icc_link->is_identity) {
num_src_comps = pcs->cmm_icc_profile_data->num_comps;
if_debug0m(gs_debug_flag_icc, dev->memory, "[icc] remap [ ");
for (k = 0; k < num_src_comps; k++) {
if_debug1m(gs_debug_flag_icc, dev->memory, "%d ", psrc[k]);
}
if_debug0m(gs_debug_flag_icc, dev->memory, "] --> [ ");
for (k = 0; k < num_des_comps; k++) {
if_debug1m(gs_debug_flag_icc, dev->memory, "%d ", psrc_temp[k]);
}
if_debug0m(gs_debug_flag_icc, dev->memory, "]\n");
}
#endif
/* Release the link */
gsicc_release_link(icc_link);
/* Now do the remap for ICC which amounts to the alpha application
the transfer function and potentially the halftoning */
/* Right now we need to go from unsigned short to frac. I really
would like to avoid this sort of stuff. That will come. */
for ( k = 0; k < num_des_comps; k++){
conc[k] = ushort2frac(psrc_temp[k]);
}
gx_remap_concrete_ICC(conc, pcs, pdc, pgs, dev, select);
/* Save original color space and color info into dev color */
i = pcs->cmm_icc_profile_data->num_comps;
for (i--; i >= 0; i--)
pdc->ccolor.paint.values[i] = pcc->paint.values[i];
pdc->ccolor_valid = true;
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;
}
/* Process a buffer */
#define LINE_LIMIT 79 /* not 80, to satisfy Genoa FTS */
static int
s_A85E_process(stream_state * st, stream_cursor_read * pr,
stream_cursor_write * pw, bool last)
{
stream_A85E_state *const ss = (stream_A85E_state *) st;
register const byte *p = pr->ptr;
register byte *q = pw->ptr;
byte *qn = q + (LINE_LIMIT - ss->count); /* value of q before next EOL */
const byte *rlimit = pr->limit;
byte *wlimit = pw->limit;
int status = 0;
int prev = ss->last_char;
int count;
if_debug3m('w', ss->memory, "[w85]initial ss->count = %d, rcount = %d, wcount = %d\n",
ss->count, (int)(rlimit - p), (int)(wlimit - q));
for (; (count = rlimit - p) >= 4; p += 4) {
ulong word =
((ulong) (((uint) p[1] << 8) + p[2]) << 16) +
(((uint) p[3] << 8) + p[4]);
if (word == 0) {
if (q >= qn) {
if (wlimit - q < 2) {
status = 1;
break;
}
*++q = prev = '\n';
qn = q + LINE_LIMIT;
if_debug1m('w', ss->memory, "[w85]EOL at %d bytes written\n",
(int)(q - pw->ptr));
} else {
if (q >= wlimit) {
status = 1;
break;
}
}
*++q = prev = 'z';
} else {
ulong v4 = word / 85; /* max 85^4 */
ulong v3 = v4 / 85; /* max 85^3 */
uint v2 = v3 / 85; /* max 85^2 */
uint v1 = v2 / 85; /* max 85 */
put: if (q + 5 > qn) {
if (q >= wlimit) {
status = 1;
break;
}
*++q = prev = '\n';
qn = q + LINE_LIMIT;
if_debug1m('w', ss->memory, "[w85]EOL at %d bytes written\n",
(int)(q - pw->ptr));
goto put;
}
if (wlimit - q < 5) {
status = 1;
break;
}
q[1] = (byte) v1 + '!';
q[2] = (byte) (v2 - v1 * 85) + '!';
q[3] = (byte) ((uint) v3 - v2 * 85) + '!';
q[4] = (byte) ((uint) v4 - (uint) v3 * 85) + '!';
q[5] = (byte) ((uint) word - (uint) v4 * 85) + '!';
/*
* '%%' or '%!' at the beginning of the line will confuse some
* document managers: insert (an) EOL(s) if necessary to prevent
* this.
*/
if (q[1] == '%') {
if (prev == '%') {
if (qn - q == LINE_LIMIT - 1) {
/* A line would begin with %%. */
*++q = prev = '\n';
qn = q + LINE_LIMIT;
if_debug1m('w', ss->memory,
"[w85]EOL for %%%% at %d bytes written\n",
(int)(q - pw->ptr));
goto put;
}
} else if (prev == '\n' && (q[2] == '%' || q[2] == '!')) {
/*
* We may have to insert more than one EOL if
* there are more than two %s in a row.
*/
int extra =
(q[2] == '!' ? 1 : /* else q[2] == '%' */
q[3] == '!' ? 2 :
q[3] != '%' ? 1 :
q[4] == '!' ? 3 :
q[4] != '%' ? 2 :
q[5] == '!' ? 4 :
q[5] != '%' ? 3 : 4);
if (wlimit - q < 5 + extra) {
status = 1;
break;
}
if_debug6m('w', ss->memory, "[w]%c%c%c%c%c extra = %d\n",
q[1], q[2], q[3], q[4], q[5], extra);
switch (extra) {
case 4:
q[9] = q[5], q[8] = '\n';
goto e3;
case 3:
q[8] = q[5];
e3:q[7] = q[4], q[6] = '\n';
goto e2;
case 2:
q[7] = q[5], q[6] = q[4];
e2:q[5] = q[3], q[4] = '\n';
goto e1;
case 1:
q[6] = q[5], q[5] = q[4], q[4] = q[3];
e1:q[3] = q[2], q[2] = '\n';
}
if_debug1m('w', ss->memory, "[w85]EOL at %d bytes written\n",
(int)(q + 2 * extra - pw->ptr));
qn = q + 2 * extra + LINE_LIMIT;
q += extra;
}
} else if (q[1] == '!' && prev == '%' &&
qn - q == LINE_LIMIT - 1
) {
/* A line would begin with %!. */
*++q = prev = '\n';
qn = q + LINE_LIMIT;
if_debug1m('w', ss->memory, "[w85]EOL for %%! at %d bytes written\n",
(int)(q - pw->ptr));
goto put;
}
prev = *(q += 5);
}
}
end:
ss->count = LINE_LIMIT - (qn - q);
/* Check for final partial word. */
if (last && status == 0 && count < 4) {
char buf[5];
int nchars = (count == 0 ? 2 : count + 3);
ulong word = 0;
ulong divisor = 85L * 85 * 85 * 85;
int i, space;
switch (count) {
case 3:
word += (uint) p[3] << 8;
case 2:
word += (ulong) p[2] << 16;
case 1:
word += (ulong) p[1] << 24;
for(i=0; i <= count; i++) {
ulong v = word / divisor; /* actually only a byte */
buf[i] = (byte) v + '!';
word -= v * divisor;
divisor /= 85;
}
/*case 0: */
}
space = count && buf[0] == '%' &&
( (prev == '\n' && ( buf[1] == '%' || buf[1] =='!')) ||
(prev == '%' && qn - q == LINE_LIMIT - 1)
);
if (wlimit - q < nchars+space)
status = 1;
else if (q + nchars+space > qn) {
*++q = prev = '\n';
qn = q + LINE_LIMIT;
goto end;
} else {
if (count) {
if (space)
*++q = ' ';
memcpy(q+1, buf, count+1);
q += count+1;
p += count;
}
*++q = '~';
*++q = '>';
}
}
if_debug3m('w', ss->memory, "[w85]final ss->count = %d, %d bytes read, %d written\n",
ss->count, (int)(p - pr->ptr), (int)(q - pw->ptr));
pr->ptr = p;
if (q > pw->ptr)
ss->last_char = *q;
pw->ptr = q;
return status;
}
int
xps_parse_fixed_page(xps_context_t *ctx, xps_part_t *part)
{
xps_item_t *root, *node;
xps_resource_t *dict;
char *width_att;
char *height_att;
char base_uri[1024];
char *s;
int code;
if_debug1m('|', ctx->memory, "doc: parsing page %s\n", part->name);
xps_strlcpy(base_uri, part->name, sizeof base_uri);
s = strrchr(base_uri, '/');
if (s)
s[1] = 0;
root = xps_parse_xml(ctx, part->data, part->size);
if (!root)
return gs_rethrow(-1, "cannot parse xml");
if (strcmp(xps_tag(root), "FixedPage"))
return gs_throw1(-1, "expected FixedPage element (found %s)", xps_tag(root));
width_att = xps_att(root, "Width");
height_att = xps_att(root, "Height");
if (!width_att)
return gs_throw(-1, "FixedPage missing required attribute: Width");
if (!height_att)
return gs_throw(-1, "FixedPage missing required attribute: Height");
dict = NULL;
/* Setup new page */
{
gs_memory_t *mem = ctx->memory;
gs_state *pgs = ctx->pgs;
gx_device *dev = gs_currentdevice(pgs);
gs_param_float_array fa;
float fv[2];
gs_c_param_list list;
gs_c_param_list_write(&list, mem);
fv[0] = atoi(width_att) / 96.0 * 72.0;
fv[1] = atoi(height_att) / 96.0 * 72.0;
fa.persistent = false;
fa.data = fv;
fa.size = 2;
code = param_write_float_array((gs_param_list *)&list, ".MediaSize", &fa);
if ( code >= 0 )
{
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *)&list);
}
gs_c_param_list_release(&list);
/* nb this is for the demo it is wrong and should be removed */
gs_initgraphics(pgs);
/* 96 dpi default - and put the origin at the top of the page */
gs_initmatrix(pgs);
code = gs_scale(pgs, 72.0/96.0, -72.0/96.0);
if (code < 0)
return gs_rethrow(code, "cannot set page transform");
code = gs_translate(pgs, 0.0, -atoi(height_att));
if (code < 0)
return gs_rethrow(code, "cannot set page transform");
code = gs_erasepage(pgs);
if (code < 0)
return gs_rethrow(code, "cannot clear page");
}
/* Pre-parse looking for transparency */
ctx->has_transparency = 0;
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "FixedPage.Resources") && xps_down(node))
if (xps_resource_dictionary_has_transparency(ctx, base_uri, xps_down(node)))
ctx->has_transparency = 1;
if (xps_element_has_transparency(ctx, base_uri, node))
ctx->has_transparency = 1;
}
/* save the state with the original device before we push */
gs_gsave(ctx->pgs);
if (ctx->use_transparency && ctx->has_transparency)
{
code = gs_push_pdf14trans_device(ctx->pgs, false);
if (code < 0)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot install transparency device");
}
}
/* Draw contents */
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "FixedPage.Resources") && xps_down(node))
{
code = xps_parse_resource_dictionary(ctx, &dict, base_uri, xps_down(node));
if (code)
{
gs_pop_pdf14trans_device(ctx->pgs, false);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot load FixedPage.Resources");
}
}
code = xps_parse_element(ctx, base_uri, dict, node);
if (code)
{
gs_pop_pdf14trans_device(ctx->pgs, false);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot parse child of FixedPage");
}
}
if (ctx->use_transparency && ctx->has_transparency)
{
code = gs_pop_pdf14trans_device(ctx->pgs, false);
if (code < 0)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot uninstall transparency device");
}
}
/* Flush page */
{
code = xps_show_page(ctx, 1, true); /* copies, flush */
if (code < 0)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot flush page");
}
}
/* restore the original device, discarding the pdf14 compositor */
gs_grestore(ctx->pgs);
if (dict)
{
xps_free_resource_dictionary(ctx, dict);
}
xps_free_item(ctx, root);
return 0;
}
