int gs_setshapealpha(gs_state *pgs, double alpha) { if_debug2m('v', pgs->memory, "[v](0x%lx)shape.alpha = %g\n", (ulong)pgs, alpha); pgs->shape.alpha = (alpha < 0.0 ? 0.0 : alpha > 1.0 ? 1.0 : alpha); return 0; }
int gs_setopacityalpha(gs_gstate *pgs, double alpha) { if_debug2m('v', pgs->memory, "[v](0x%lx)opacity.alpha = %g\n", (ulong)pgs, alpha); pgs->opacity.alpha = (alpha < 0.0 ? 0.0 : alpha > 1.0 ? 1.0 : alpha); return 0; }
int gs_settextknockout(gs_state *pgs, bool knockout) { if_debug2m('v', pgs->memory, "[v](0x%lx)text_knockout = %s\n", (ulong)pgs, (knockout ? "true" : "false")); pgs->text_knockout = knockout; return 0; }
/* * Construct a configure image data object, and use it to overwrite the current * active palette. * * Returns 0 if successful, < 0 in case of error. */ static int install_cid_data(int len, /* length of data */ const byte * pbuff, /* the data provided with command */ pcl_state_t * pcs, /* current state */ bool fixed, /* from set simple color mode */ bool gl2 /* from IN command in GL/2 */ ) { pcl_cid_data_t cid; int code = 0; if (len < 6) return e_Range; cid.len = len; memcpy(&(cid.u.hdr), pbuff, sizeof(pcl_cid_hdr_t)); if_debug2m('c', pcs->memory, "[c] cid before check color space: %s encoding: %s\n", pcl_cid_cspace_get_debug_name(pcs->memory, pcl_cid_get_cspace(&cid)), pcl_cid_enc_get_debug_name(pcs->memory, pcl_cid_get_encoding(&cid))); /* check the header, this will also make corrections if possible */ code = check_cid_hdr(pcs, &cid); if_debug2m('c', pcs->memory, "[c] cid after check color space: %s encoding: %s\n", pcl_cid_cspace_get_debug_name(pcs->memory, pcl_cid_get_cspace(&cid)), pcl_cid_enc_get_debug_name(pcs->memory, pcl_cid_get_encoding(&cid))); if (code >= 0) { cid.original_cspace = pcl_cspace_num; if (cid.len > 6) code = build_cid_longform[pbuff[0]] (&cid, pbuff); } if (code < 0) { if (code == -1) code = e_Range; return code; } else return pcl_palette_set_cid(pcs, &cid, fixed, gl2); }
/* * Enter a key-value pair in a dictionary. * See idict.h for the possible return values. */ int dict_put(ref * pdref /* t_dictionary */ , const ref * pkey, const ref * pvalue, dict_stack_t *pds) { dict *pdict = pdref->value.pdict; gs_ref_memory_t *mem = dict_memory(pdict); gs_memory_t *pmem = dict_mem(pdict); int rcode = 0; int code; ref *pvslot, kname; /* Check the value. */ store_check_dest(pdref, pvalue); top:if ((code = dict_find(pdref, pkey, &pvslot)) <= 0) { /* not found *//* Check for overflow */ uint index; switch (code) { case 0: break; case gs_error_dictfull: if (!pmem->gs_lib_ctx->dict_auto_expand) return_error(gs_error_dictfull); code = dict_grow(pdref, pds); if (code < 0) return code; goto top; /* keep things simple */ default: /* gs_error_typecheck */ return code; } index = pvslot - pdict->values.value.refs; /* If the key is a string, convert it to a name. */ if (r_has_type(pkey, t_string)) { int code; if (!r_has_attr(pkey, a_read)) return_error(gs_error_invalidaccess); code = name_from_string(pmem, pkey, &kname); if (code < 0) return code; pkey = &kname; } if (dict_is_packed(pdict)) { ref_packed *kp; if (!r_has_type(pkey, t_name) || name_index(pmem, pkey) > packed_name_max_index ) { /* Change to unpacked representation. */ int code = dict_unpack(pdref, pds); if (code < 0) return code; goto top; } kp = pdict->keys.value.writable_packed + index; if (ref_must_save_in(mem, &pdict->keys)) { /* See initial comment for why it is safe */ /* not to save the change if the keys */ /* array itself is new. */ ref_do_save_in(mem, &pdict->keys, kp, "dict_put(key)"); } *kp = pt_tag(pt_literal_name) + name_index(pmem, pkey); } else { ref *kp = pdict->keys.value.refs + index; if_debug2m('d', (const gs_memory_t *)mem, "[d]0x%lx: fill key at 0x%lx\n", (ulong) pdict, (ulong) kp); store_check_dest(pdref, pkey); ref_assign_old_in(mem, &pdict->keys, kp, pkey, "dict_put(key)"); /* set key of pair */ } ref_save_in(mem, pdref, &pdict->count, "dict_put(count)"); pdict->count.value.intval++; /* If the key is a name, update its 1-element cache. */ if (r_has_type(pkey, t_name)) { name *pname = pkey->value.pname; if (pname->pvalue == pv_no_defn && CAN_SET_PVALUE_CACHE(pds, pdref, mem) ) { /* Set the cache. */ if_debug0m('d', (const gs_memory_t *)mem, "[d]set cache\n"); pname->pvalue = pvslot; } else { /* The cache can't be used. */ if_debug0m('d', (const gs_memory_t *)mem, "[d]no cache\n"); pname->pvalue = pv_other; } } rcode = 1; } if_debug8m('d', (const gs_memory_t *)mem, "[d]0x%lx: put key 0x%lx 0x%lx\n value at 0x%lx: old 0x%lx 0x%lx, new 0x%lx 0x%lx\n", (ulong) pdref->value.pdict, ((const ulong *)pkey)[0], ((const ulong *)pkey)[1], (ulong) pvslot, ((const ulong *)pvslot)[0], ((const ulong *)pvslot)[1], ((const ulong *)pvalue)[0], ((const ulong *)pvalue)[1]); ref_assign_old_in(mem, &pdref->value.pdict->values, pvslot, pvalue, "dict_put(value)"); return rcode; }
/* 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; }