/* Libération de la zone d'adresse zone et de taille
* size
*
* @param void *zone : zone à libérer
* @param unsigned long size: taille supposée du bloc à libérer
*
* @ret 0 si tout s'est bien passé, 1 sinon */
int mem_free(void *zone, unsigned long size) {
/* Cas à ne pas traiter */
if ( zone == NULL || size == 0 || size > mem_size || zone < mem_heap || zone > (void * ) ((char *) mem_heap + mem_size) ) {
return 1;
}
/* Calcul de la taille réelle du bloc à libérer */
unsigned long real_size = r_size(size);
/* Si le bloc dépasse de la mémoire allouée (heap), alors return 1 */
if ( ((char *) zone + real_size) > ((char *) mem_heap + mem_size) ) {
return 1;
}
/* Cas où le heap est vide */
if ( mem_free_zone == NULL ) {
mem_free_zone = zone;
((free_zone_t *) mem_free_zone)->size = real_size;
((free_zone_t *) mem_free_zone)->next = (free_zone_t *) mem_free_zone;
return 0;
} else {
/* Cas où le heap ne contient qu'un bloc */
if ( ((free_zone_t *) mem_free_zone)->next == (free_zone_t *) mem_free_zone ) {
((free_zone_t *) mem_free_zone)->next = (free_zone_t *) zone;
((free_zone_t *) zone)->size = real_size;
((free_zone_t *) zone)->next = (free_zone_t *) mem_free_zone;
if ( zone < mem_free_zone ) {
mem_free_zone = zone;
}
mem_fusion(mem_free_zone);
return 0;
} else {
free_zone_t *senti = (free_zone_t *) mem_free_zone;
free_zone_t *prev = NULL;
/* Recherche du premier bloc libre suivant zone */
if ( (void *) senti < zone ) {
/* Si ce n'est pas mem_heap */
do {
senti = senti->next;
} while ( senti != mem_free_zone && (void *) senti < zone );
if ( (void *) senti < zone ) {
/* cas où aucun bloc de la ZL n'est après zone dans la mémoire */
/* zone doit être inséré en queue de chaîne de ZL */
while ( (void *) senti->next != mem_free_zone ) {
senti = senti->next;
}
senti->next = (free_zone_t *) zone;
senti->next->size = real_size;
senti->next->next = (free_zone_t *) mem_free_zone;
mem_fusion(mem_free_zone);
return 0;
} else {
/* Recherche du précédent */
prev = senti;
while ( prev->next != senti ) {
prev = prev->next;
}
/* Insertion de zone entre prev et next */
prev->next = (free_zone_t *) zone;
prev->next->size = real_size;
prev->next->next = senti;
mem_fusion(mem_free_zone);
return 0;
}
/* Insertion en tête de ZL */
} else {
/* Recherche de l'élément précédent de la chaîne circulaire */
prev = (free_zone_t *) mem_free_zone;
while ( prev->next != (free_zone_t *) mem_free_zone ) {
prev = prev->next;
}
prev->next = zone;
prev->next->size = real_size;
prev->next->next = (free_zone_t *) mem_free_zone;
mem_free_zone = zone;
mem_fusion(mem_free_zone);
return 0;
}
}
}
}
/* The current color space is the alternate space for the separation space. */
static int
zsetseparationspace(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const ref *pcsa;
gs_color_space *pcs;
gs_color_space * pacs;
ref_colorspace cspace_old;
ref sname, name_none, name_all;
gs_function_t *pfn = NULL;
separation_type sep_type;
int code;
const gs_memory_t * mem = imemory;
/* Verify that we have an array as our input parameter */
check_read_type(*op, t_array);
if (r_size(op) != 4)
return_error(e_rangecheck);
/* The alternate color space has been selected as the current color space */
pacs = gs_currentcolorspace(igs);
if (!pacs->type->can_be_alt_space)
return_error(e_rangecheck);
/*
* pcsa is a pointer to element 1 (2nd element) in the Separation colorspace
* description array. Thus pcsa[2] is element #3 (4th element) which is the
* tint transform.
*/
pcsa = op->value.const_refs + 1;
sname = *pcsa;
switch (r_type(&sname)) {
default:
return_error(e_typecheck);
case t_string:
code = name_from_string(mem, &sname, &sname);
if (code < 0)
return code;
/* falls through */
case t_name:
break;
}
if ((code = name_ref(mem, (const byte *)"All", 3, &name_all, 0)) < 0)
return code;
if ((code = name_ref(mem, (const byte *)"None", 4, &name_none, 0)) < 0)
return code;
sep_type = ( name_eq(&sname, &name_all) ? SEP_ALL :
name_eq(&sname, &name_none) ? SEP_NONE : SEP_OTHER);
/* Check tint transform procedure. */
/* See comment above about psca */
check_proc(pcsa[2]);
pfn = ref_function(pcsa + 2);
if (pfn == NULL)
return_error(e_rangecheck);
cspace_old = istate->colorspace;
/* Now set the current color space as Separation */
code = gs_cspace_new_Separation(&pcs, pacs, imemory);
if (code < 0)
return code;
pcs->params.separation.sep_type = sep_type;
pcs->params.separation.sep_name = name_index(mem, &sname);
pcs->params.separation.get_colorname_string = gs_get_colorname_string;
istate->colorspace.procs.special.separation.layer_name = pcsa[0];
istate->colorspace.procs.special.separation.tint_transform = pcsa[2];
if (code >= 0)
code = gs_cspace_set_sepr_function(pcs, pfn);
if (code >= 0)
code = gs_setcolorspace(igs, pcs);
/* release reference from construction */
rc_decrement_only(pcs, "zsetseparationspace");
if (code < 0) {
istate->colorspace = cspace_old;
return code;
}
pop(1);
return 0;
}
/* <bitmap> <cid> <type32font> <str22> .makeglyph32 <<same with substr>> */
static int
zmakeglyph32(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
bool long_form;
uint msize;
double metrics[10];
int wx, llx, lly, urx, ury;
int width, height, raster;
gs_font *pfont;
int code;
byte *str;
check_array(op[-4]);
msize = r_size(op - 4);
switch (msize) {
case 10:
long_form = true;
break;
case 6:
long_form = false;
break;
default:
return_error(gs_error_rangecheck);
}
code = num_params(op[-4].value.refs + msize - 1, msize, metrics);
if (code < 0)
return code;
if (~code & 0x3c) /* check llx .. ury for integers */
return_error(gs_error_typecheck);
check_read_type(op[-3], t_string);
llx = (int)metrics[2];
lly = (int)metrics[3];
urx = (int)metrics[4];
ury = (int)metrics[5];
width = urx - llx;
height = ury - lly;
raster = (width + 7) >> 3;
if (width < 0 || height < 0 || r_size(op - 3) != raster * height)
return_error(gs_error_rangecheck);
check_int_leu(op[-2], 65535);
code = font_param(op - 1, &pfont);
if (code < 0)
return code;
if (pfont->FontType != ft_CID_bitmap)
return_error(gs_error_invalidfont);
check_write_type(*op, t_string);
if (r_size(op) < 22)
return_error(gs_error_rangecheck);
str = op->value.bytes;
if (long_form || metrics[0] != (wx = (int)metrics[0]) ||
metrics[1] != 0 || height == 0 ||
((wx | width | height | (llx + 128) | (lly + 128)) & ~255) != 0
) {
/* Use the long form. */
int i, n = (long_form ? 10 : 6);
str[0] = 0;
str[1] = long_form;
for (i = 0; i < n; ++i) {
int v = (int)metrics[i]; /* no floating point widths yet */
str[2 + 2 * i] = (byte)(v >> 8);
str[2 + 2 * i + 1] = (byte)v;
}
r_set_size(op, 2 + n * 2);
} else {
static int
zmatchmedia(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr preq = op - 3;
os_ptr pattr = op - 2;
os_ptr ppol = op - 1;
os_ptr pkeys = op; /* *const */
int policy_default;
float best_mismatch = (float)max_long; /* adhoc */
float mepos_penalty;
float mbest = best_mismatch;
match_record_t match;
ref no_priority;
ref *ppriority;
int mepos, orient;
bool roll;
int code;
int ai;
struct mkd_ {
ref key, dict;
} aelt;
if (r_has_type(pattr, t_null)) {
check_op(4);
make_null(op - 3);
make_true(op - 2);
pop(2);
return 0;
}
check_type(*preq, t_dictionary);
check_dict_read(*preq);
check_type(*pattr, t_dictionary);
check_dict_read(*pattr);
check_type(*ppol, t_dictionary);
check_dict_read(*ppol);
check_array(*pkeys);
check_read(*pkeys);
switch (code = dict_int_null_param(preq, "MediaPosition", 0, 0x7fff,
0, &mepos)) {
default:
return code;
case 2:
case 1:
mepos = -1;
case 0:;
}
switch (code = dict_int_null_param(preq, "Orientation", 0, 3,
0, &orient)) {
default:
return code;
case 2:
case 1:
orient = -1;
case 0:;
}
code = dict_bool_param(preq, "RollFedMedia", false, &roll);
if (code < 0)
return code;
code = dict_int_param(ppol, "PolicyNotFound", 0, 7, 0,
&policy_default);
if (code < 0)
return code;
if (dict_find_string(pattr, "Priority", &ppriority) > 0) {
check_array_only(*ppriority);
check_read(*ppriority);
} else {
make_empty_array(&no_priority, a_readonly);
ppriority = &no_priority;
}
match.no_match_priority = r_size(ppriority);
reset_match(&match);
for (ai = dict_first(pattr);
(ai = dict_next(pattr, ai, (ref * /*[2]*/)&aelt)) >= 0;
) {
if (r_has_type(&aelt.dict, t_dictionary) &&
r_has_attr(dict_access_ref(&aelt.dict), a_read) &&
r_has_type(&aelt.key, t_integer)
) {
bool match_all;
uint ki, pi;
code = dict_bool_param(&aelt.dict, "MatchAll", false,
&match_all);
if (code < 0)
return code;
for (ki = 0; ki < r_size(pkeys); ki++) {
ref key;
ref kstr;
ref *prvalue;
ref *pmvalue;
ref *ppvalue;
int policy;
array_get(imemory, pkeys, ki, &key);
if (dict_find(&aelt.dict, &key, &pmvalue) <= 0)
continue;
if (dict_find(preq, &key, &prvalue) <= 0 ||
r_has_type(prvalue, t_null)
) {
if (match_all)
goto no;
else
continue;
}
/* Look for the Policies entry for this key. */
if (dict_find(ppol, &key, &ppvalue) > 0) {
check_type_only(*ppvalue, t_integer);
policy = ppvalue->value.intval;
} else
policy = policy_default;
/*
* Match a requested attribute value with the attribute value in the
* description of a medium. For all attributes except PageSize,
* matching means equality. PageSize is special; see match_page_size
* below.
*/
if (r_has_type(&key, t_name) &&
(name_string_ref(imemory, &key, &kstr),
r_size(&kstr) == 8 &&
!memcmp(kstr.value.bytes, "PageSize", 8))
) {
gs_matrix ignore_mat;
gs_point ignore_msize;
if (zmatch_page_size(imemory, prvalue, pmvalue,
policy, orient, roll,
&best_mismatch,
&ignore_mat,
&ignore_msize)
<= 0)
goto no;
} else if (!obj_eq(imemory, prvalue, pmvalue))
goto no;
}
mepos_penalty = (mepos < 0 || aelt.key.value.intval == mepos) ?
0 : .001;
/* We have a match. Save the match in case no better match is found */
if (r_has_type(&match.match_key, t_null))
match.match_key = aelt.key;
/*
* If it is a better match than the current best it supersedes it
* regardless of priority. If the match is the same, then update
* to the current only if the key value is lower.
*/
if (best_mismatch + mepos_penalty <= mbest) {
if (best_mismatch + mepos_penalty < mbest ||
(r_has_type(&match.match_key, t_integer) &&
match.match_key.value.intval > aelt.key.value.intval)) {
reset_match(&match);
match.match_key = aelt.key;
mbest = best_mismatch + mepos_penalty;
}
}
/* In case of a tie, see if the new match has priority. */
for (pi = match.priority; pi > 0;) {
ref pri;
pi--;
array_get(imemory, ppriority, pi, &pri);
if (obj_eq(imemory, &aelt.key, &pri)) { /* Yes, higher priority. */
match.best_key = aelt.key;
match.priority = pi;
break;
}
}
no:;
}
}
if (r_has_type(&match.match_key, t_null)) {
make_false(op - 3);
pop(3);
} else {
if (r_has_type(&match.best_key, t_null))
op[-3] = match.match_key;
else
op[-3] = match.best_key;
make_true(op - 2);
pop(2);
}
return 0;
}
static int
zeqproc(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
ref2_t stack[MAX_DEPTH + 1];
ref2_t *top = stack;
make_array(&stack[0].proc1, 0, 1, op - 1);
make_array(&stack[0].proc2, 0, 1, op);
for (;;) {
long i;
if (r_size(&top->proc1) == 0) {
/* Finished these arrays, go up to next level. */
if (top == stack) {
/* We're done matching: it succeeded. */
make_true(op - 1);
pop(1);
return 0;
}
--top;
continue;
}
/* Look at the next elements of the arrays. */
i = r_size(&top->proc1) - 1;
array_get(imemory, &top->proc1, i, &top[1].proc1);
array_get(imemory, &top->proc2, i, &top[1].proc2);
r_dec_size(&top->proc1, 1);
++top;
/*
* Amazingly enough, the objects' executable attributes are not
* required to match. This means { x load } will match { /x load },
* even though this is clearly wrong.
*/
#if 0
if (r_has_attr(&top->proc1, a_executable) !=
r_has_attr(&top->proc2, a_executable)
)
break;
#endif
if (obj_eq(imemory, &top->proc1, &top->proc2)) {
/* Names don't match strings. */
if (r_type(&top->proc1) != r_type(&top->proc2) &&
(r_type(&top->proc1) == t_name ||
r_type(&top->proc2) == t_name)
)
break;
--top; /* no recursion */
continue;
}
if (r_is_array(&top->proc1) && r_is_array(&top->proc2) &&
r_size(&top->proc1) == r_size(&top->proc2) &&
top < stack + (MAX_DEPTH - 1)
) {
/* Descend into the arrays. */
continue;
}
break;
}
/* An exit from the loop indicates that matching failed. */
make_false(op - 1);
pop(1);
return 0;
}
/* untraced space, so relocate all refs, not just marked ones. */
void
igc_reloc_refs(ref_packed * from, ref_packed * to, gc_state_t * gcst)
{
int min_trace = gcst->min_collect;
ref_packed *rp = from;
bool do_all = gcst->relocating_untraced;
vm_spaces spaces = gcst->spaces;
const gs_memory_t *cmem = space_system->stable_memory;
while (rp < to) {
ref *pref;
#ifdef DEBUG
const void *before = 0;
const void *after = 0;
# define DO_RELOC(var, stat)\
BEGIN before = (var); stat; after = (var); END
# define SET_RELOC(var, expr)\
BEGIN before = (var); after = (var) = (expr); END
#else
# define DO_RELOC(var, stat) stat
# define SET_RELOC(var, expr) var = expr
#endif
if (r_is_packed(rp)) {
rp++;
continue;
}
/* The following assignment is logically unnecessary; */
/* we do it only for convenience in debugging. */
pref = (ref *) rp;
if_debug3('8', " [8]relocating %s %d ref at 0x%lx\n",
(r_has_attr(pref, l_mark) ? "marked" : "unmarked"),
r_btype(pref), (ulong) pref);
if ((r_has_attr(pref, l_mark) || do_all) &&
r_space(pref) >= min_trace
) {
switch (r_type(pref)) {
/* Struct cases */
case t_file:
DO_RELOC(pref->value.pfile, RELOC_VAR(pref->value.pfile));
break;
case t_device:
DO_RELOC(pref->value.pdevice,
RELOC_VAR(pref->value.pdevice));
break;
case t_fontID:
case t_struct:
case t_astruct:
DO_RELOC(pref->value.pstruct,
RELOC_VAR(pref->value.pstruct));
break;
/* Non-trivial non-struct cases */
case t_dictionary:
rputc('d');
SET_RELOC(pref->value.pdict,
(dict *)igc_reloc_ref_ptr((ref_packed *)pref->value.pdict, gcst));
break;
case t_array:
{
uint size = r_size(pref);
if (size != 0) { /* value.refs might be NULL */
/*
* If the array is large, we allocated it in its
* own object (at least originally -- this might
* be a pointer to a subarray.) In this case,
* we know it is the only object in its
* containing st_refs object, so we know that
* the mark containing the relocation appears
* just after it.
*/
if (size < max_size_st_refs / sizeof(ref)) {
rputc('a');
SET_RELOC(pref->value.refs,
(ref *) igc_reloc_ref_ptr(
(ref_packed *) pref->value.refs, gcst));
} else {
rputc('A');
/*
* See the t_shortarray case below for why we
* decrement size.
*/
--size;
SET_RELOC(pref->value.refs,
(ref *) igc_reloc_ref_ptr(
(ref_packed *) (pref->value.refs + size),
gcst) - size);
}
}
}
break;
case t_mixedarray:
if (r_size(pref) != 0) { /* value.refs might be NULL */
rputc('m');
SET_RELOC(pref->value.packed,
igc_reloc_ref_ptr(pref->value.packed, gcst));
}
break;
case t_shortarray:
{
uint size = r_size(pref);
/*
* Since we know that igc_reloc_ref_ptr works by
* scanning forward, and we know that all the
* elements of this array itself are marked, we can
* save some scanning time by relocating the pointer
* to the end of the array rather than the
* beginning.
*/
if (size != 0) { /* value.refs might be NULL */
rputc('s');
/*
* igc_reloc_ref_ptr has to be able to determine
* whether the pointer points into a space that
* isn't being collected. It does this by
* checking whether the referent of the pointer
* is marked. For this reason, we have to pass
* a pointer to the last real element of the
* array, rather than just beyond it.
*/
--size;
SET_RELOC(pref->value.packed,
igc_reloc_ref_ptr(pref->value.packed + size,
gcst) - size);
}
}
break;
case t_name:
{
void *psub = name_ref_sub_table(cmem, pref);
void *rsub = RELOC_OBJ(psub); /* gcst implicit */
SET_RELOC(pref->value.pname,
(name *)
((char *)rsub + ((char *)pref->value.pname -
(char *)psub)));
} break;
case t_string:
{
gs_string str;
str.data = pref->value.bytes;
str.size = r_size(pref);
DO_RELOC(str.data, RELOC_STRING_VAR(str));
pref->value.bytes = str.data;
}
break;
case t_oparray:
rputc('o');
SET_RELOC(pref->value.const_refs,
(const ref *)igc_reloc_ref_ptr((const ref_packed *)pref->value.const_refs, gcst));
break;
default:
goto no_reloc; /* don't print trace message */
}
if_debug2('8', " [8]relocated 0x%lx => 0x%lx\n",
(ulong)before, (ulong)after);
}
no_reloc:
rp += packed_per_ref;
}
}
/* Remove the marks at the same time. */
static void
refs_compact(const gs_memory_t *mem, obj_header_t * pre, obj_header_t * dpre, uint size)
{
ref_packed *dest;
ref_packed *src;
ref_packed *end;
uint new_size;
/* The next switch controls an optimization
for the loop termination condition.
It was useful during the development,
when some assumptions were temporary wrong.
We keep it for records. */
src = (ref_packed *) (pre + 1);
end = (ref_packed *) ((byte *) src + size);
/*
* We know that a block of refs always ends with a
* full-size ref, so we only need to check for reaching the end
* of the block when we see one of those.
*/
if (dpre == pre) /* Loop while we don't need to copy. */
for (;;) {
if (r_is_packed(src)) {
if (!r_has_pmark(src))
break;
if_debug1('8', " [8]packed ref 0x%lx \"copied\"\n",
(ulong) src);
*src &= ~lp_mark;
src++;
} else { /* full-size ref */
ref *const pref = (ref *)src;
if (!r_has_attr(pref, l_mark))
break;
if_debug1('8', " [8]ref 0x%lx \"copied\"\n", (ulong) src);
r_clear_attrs(pref, l_mark);
src += packed_per_ref;
}
} else
*dpre = *pre;
dest = (ref_packed *) ((char *)dpre + ((char *)src - (char *)pre));
for (;;) {
if (r_is_packed(src)) {
if (r_has_pmark(src)) {
if_debug2('8', " [8]packed ref 0x%lx copied to 0x%lx\n",
(ulong) src, (ulong) dest);
*dest++ = *src & ~lp_mark;
}
src++;
} else { /* full-size ref */
if (r_has_attr((ref *) src, l_mark)) {
ref rtemp;
if_debug2('8', " [8]ref 0x%lx copied to 0x%lx\n",
(ulong) src, (ulong) dest);
/* We can't just use ref_assign_inline, */
/* because the source and destination */
/* might overlap! */
ref_assign_inline(&rtemp, (ref *) src);
r_clear_attrs(&rtemp, l_mark);
ref_assign_inline((ref *) dest, &rtemp);
src += packed_per_ref;
dest += packed_per_ref;
} else { /* check for end of block */
src += packed_per_ref;
if (src >= end)
break;
}
}
}
new_size = (byte *) dest - (byte *) (dpre + 1) + sizeof(ref);
#ifdef DEBUG
/* Check that the relocation came out OK. */
/* NOTE: this check only works within a single chunk. */
if ((byte *) src - (byte *) dest != r_size((ref *) src - 1) + sizeof(ref)) {
lprintf3("Reloc error for refs 0x%lx: reloc = %lu, stored = %u\n",
(ulong) dpre, (ulong) ((byte *) src - (byte *) dest),
(uint) r_size((ref *) src - 1));
gs_abort(mem);
}
#endif
/* Pad to a multiple of sizeof(ref). */
while (new_size & (sizeof(ref) - 1))
*dest++ = pt_tag(pt_integer),
new_size += sizeof(ref_packed);
/* We want to make the newly freed space into a free block, */
/* but we can only do this if we have enough room. */
if (size - new_size < sizeof(obj_header_t)) { /* Not enough room. Pad to original size. */
while (new_size < size)
*dest++ = pt_tag(pt_integer),
new_size += sizeof(ref_packed);
} else {
obj_header_t *pfree = (obj_header_t *) ((ref *) dest + 1);
pfree->o_alone = 0;
pfree->o_size = size - new_size - sizeof(obj_header_t);
pfree->o_type = &st_bytes;
}
/* Re-create the final ref. */
r_set_type((ref *) dest, t_integer);
dpre->o_size = new_size;
}
/* Get the number of elements in an encoded number array/string. */
uint
num_array_size(const ref * op, int format)
{
return (format == num_array ? r_size(op) :
(r_size(op) - 4) / encoded_number_bytes(format));
}
/* Finish building a FunctionType 3 (1-Input Stitching) function. */
int
gs_build_function_3(i_ctx_t *i_ctx_p, const ref *op, const gs_function_params_t * mnDR,
int depth, gs_function_t ** ppfn, gs_memory_t *mem)
{
gs_function_1ItSg_params_t params;
int code;
extern bool CPSI_mode;
*(gs_function_params_t *) & params = *mnDR;
params.Functions = 0;
params.Bounds = 0;
params.Encode = 0;
{
ref *pFunctions;
gs_function_t **ptr;
int i;
if ((code = dict_find_string(op, "Functions", &pFunctions)) <= 0)
return (code < 0 ? code : gs_note_error(e_rangecheck));
check_array_only(*pFunctions);
params.k = r_size(pFunctions);
code = alloc_function_array(params.k, &ptr, mem);
if (code < 0)
return code;
params.Functions = (const gs_function_t * const *)ptr;
for (i = 0; i < params.k; ++i) {
ref subfn;
array_get(mem, pFunctions, (long)i, &subfn);
code = fn_build_sub_function(i_ctx_p, &subfn, &ptr[i], depth, mem, 0, 0);
if (code < 0)
goto fail;
}
}
if ((code = fn_build_float_array(op, "Bounds", true, false, ¶ms.Bounds, mem)) != params.k - 1)
goto fail;
if (CPSI_mode) {
/* Adobe implementation doesn't check the Encode length. */
/* Extra elements are ignored; missing elements are filled with 0. */
/* CET 12-14m.ps depends on this bug */
uint sz, k2 = 2 * params.k;
ref *encode;
float *p = (float *)gs_alloc_byte_array(mem, k2, sizeof(float), "Encode");
params.Encode = p;
if (p == 0) {
code = gs_note_error(e_VMerror);
goto fail;
}
if (dict_find_string(op, "Encode", &encode) <= 0) {
code = gs_note_error(e_undefined);
goto fail;
}
if (!r_is_array(encode)) {
code = gs_note_error(e_typecheck);
goto fail;
}
sz = min(k2, r_size(encode));
code = process_float_array(mem, encode, sz, p);
if (code < 0)
goto fail;
while (sz < k2)
p[sz++] = 0.0;
} else if ((code = fn_build_float_array(op, "Encode", true, true, ¶ms.Encode, mem)) != 2 * params.k)
goto fail;
if (params.Range == 0)
params.n = params.Functions[0]->params.n;
code = gs_function_1ItSg_init(ppfn, ¶ms, mem);
if (code >= 0)
return 0;
fail:
gs_function_1ItSg_free_params(¶ms, mem);
return (code < 0 ? code : gs_note_error(e_rangecheck));
}
/* <dict> <string> .parse_dsc_comments <dict> <dsc code> */
static int
zparse_dsc_comments(i_ctx_t *i_ctx_p)
{
#define MAX_DSC_MSG_SIZE (DSC_LINE_LENGTH + 4) /* Allow for %% and CR/LF */
os_ptr const opString = osp;
os_ptr const opDict = opString - 1;
uint ssize;
int comment_code, code;
char dsc_buffer[MAX_DSC_MSG_SIZE + 2];
const cmdlist_t *pCmdList = DSCcmdlist;
const char * const *pBadList = BadCmdlist;
ref * pvalue;
CDSC * dsc_data = NULL;
dict_param_list list;
/*
* Verify operand types and length of DSC comment string. If a comment
* is too long then we simply truncate it. Russell's parser gets to
* handle any errors that may result. (Crude handling but the comment
* is bad, so ...).
*/
check_type(*opString, t_string);
check_dict_write(*opDict);
ssize = r_size(opString);
if (ssize > MAX_DSC_MSG_SIZE) /* need room for EOL + \0 */
ssize = MAX_DSC_MSG_SIZE;
/*
* Pick up the comment string to be parsed.
*/
memcpy(dsc_buffer, opString->value.bytes, ssize);
dsc_buffer[ssize] = 0x0d; /* Russell wants a 'line end' */
dsc_buffer[ssize + 1] = 0; /* Terminate string */
/*
* Skip data block comments (see comments in front of BadCmdList).
*/
while (*pBadList && strncmp(*pBadList, dsc_buffer, strlen(*pBadList)))
pBadList++;
if (*pBadList) { /* If found in list, then skip comment */
comment_code = 0; /* Force NOP */
}
else {
/*
* Parse comments - use Russell Lang's DSC parser. We need to get
* data area for Russell Lang's parser. Note: We have saved the
* location of the data area for the parser in our DSC dict.
*/
code = dict_find_string(opDict, dsc_dict_name, &pvalue);
dsc_data = r_ptr(pvalue, dsc_data_t)->dsc_data_ptr;
if (code < 0)
return code;
comment_code = dsc_scan_data(dsc_data, dsc_buffer, ssize + 1);
if_debug1('%', "[%%].parse_dsc_comments: code = %d\n", comment_code);
/*
* We ignore any errors from Russell's parser. The only value that
* it will return for an error is -1 so there is very little information.
* We also do not want bad DSC comments to abort processing of an
* otherwise valid PS file.
*/
if (comment_code < 0)
comment_code = 0;
}
/*
* Transfer data from DSC structure to postscript variables.
* Look up proper handler in the local cmd decode list.
*/
while (pCmdList->code && pCmdList->code != comment_code )
pCmdList++;
if (pCmdList->dsc_proc) {
code = dict_param_list_write(&list, opDict, NULL, iimemory);
if (code < 0)
return code;
code = (pCmdList->dsc_proc)((gs_param_list *)&list, dsc_data);
iparam_list_release(&list);
if (code < 0)
return code;
}
/* Put DSC comment name onto operand stack (replace string). */
return name_enter_string(imemory, pCmdList->comment_name, opString);
}
/* or a negative error code. */
int
build_gs_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font ** ppfont, font_type ftype,
gs_memory_type_ptr_t pstype, const build_proc_refs * pbuild,
build_font_options_t options)
{
ref kname; /* t_string */
ref *pftype;
ref *pencoding = 0;
bool bitmapwidths;
int exactsize, inbetweensize, transformedchar;
int wmode;
int code;
gs_font *pfont;
ref *pfid;
ref *aop = dict_access_ref(op);
bool cpsi_mode = gs_currentcpsimode(imemory);
get_font_name(imemory, &kname, op - 1);
if (dict_find_string(op, "FontType", &pftype) <= 0 ||
!r_has_type(pftype, t_integer) ||
pftype->value.intval != (int)ftype
)
return_error(e_invalidfont);
if (dict_find_string(op, "Encoding", &pencoding) <= 0) {
if (!(options & bf_Encoding_optional))
return_error(e_invalidfont);
pencoding = 0;
} else {
if (!r_is_array(pencoding))
return_error(e_invalidfont);
}
if (pencoding) { /* observed Adobe behavior */
int count = r_size(pencoding);
int type = ftype ? t_name : t_integer;
bool fixit = false;
while (count--) {
ref r;
if ((code = array_get(imemory, pencoding, count, &r)) < 0 ||
!(r_has_type(&r, type) || r_has_type(&r, t_null))) {
if (!cpsi_mode && ftype == ft_user_defined) {
if (code < 0 || r_has_type(&r, t_null)) {
return_error(e_typecheck);
}
fixit = true;
break;
}
else {
return_error(e_typecheck);
}
}
}
/* For at least Type 3 fonts, Adobe Distiller will "fix" an Encoding array, as in, for example
* Bug 692681 where the arrays contain integers rather than names. Once the font is instantiated
* the integers have been converted to names.
* It is preferable to to this manipulation here, rather than in Postscript, because we are less
* restricted by read-only attributes and VM save levels.
*/
if (fixit) {
ref penc;
uint size = 0;
char buf[32], *bptr;
avm_space curglob = ialloc_space(idmemory);
avm_space useglob = r_is_local(pencoding) ? avm_local : avm_global;
ialloc_set_space(idmemory, useglob);
count = r_size(pencoding);
if ((code = ialloc_ref_array(&penc, (r_type_attrs(pencoding) & a_readonly), count, "build_gs_font")) < 0)
return code;
while (count--) {
ref r;
if (array_get(imemory, pencoding, count, &r) < 0){
return_error(e_typecheck);
}
/* For type 3, we know the Encoding entries must be names */
if (r_has_type(&r, t_name)){
ref_assign(&(penc.value.refs[count]), &r);
}
else {
if ((code = obj_cvs(imemory, &r, (byte *)buf, 32, &size, (const byte **)(&bptr))) < 0) {
return(code);
}
if ((code = name_ref(imemory, (const byte *)bptr, size, &r, true)) < 0)
return code;
ref_assign(&(penc.value.refs[count]), &r);
}
}
if ((code = dict_put_string(osp, "Encoding", &penc, NULL)) < 0)
return code;
ialloc_set_space(idmemory, curglob);
}
}
if ((code = dict_int_param(op, "WMode", 0, 1, 0, &wmode)) < 0 ||
(code = dict_bool_param(op, "BitmapWidths", false, &bitmapwidths)) < 0 ||
(code = dict_int_param(op, "ExactSize", 0, 2, fbit_use_bitmaps, &exactsize)) < 0 ||
(code = dict_int_param(op, "InBetweenSize", 0, 2, fbit_use_outlines, &inbetweensize)) < 0 ||
(code = dict_int_param(op, "TransformedChar", 0, 2, fbit_use_outlines, &transformedchar)) < 0
)
return code;
code = dict_find_string(op, "FID", &pfid);
if (code > 0 && r_has_type(pfid, t_fontID)) { /* silently ignore invalid FID per CET 13-05.ps */
/*
* If this font has a FID entry already, it might be a scaled font
* made by makefont or scalefont; in a Level 2 environment, it might
* be an existing font being registered under a second name, or a
* re-encoded font (which was invalid in Level 1, but dvips did it
* anyway).
*/
pfont = r_ptr(pfid, gs_font);
/*
* If the following condition is false this is a re-encoded font,
* or some other questionable situation in which the FID
* was preserved. Pretend the FID wasn't there.
*/
if (obj_eq(pfont->memory, pfont_dict(pfont), op)) {
if (pfont->base == pfont) { /* original font */
if (!level2_enabled)
return_error(e_invalidfont);
*ppfont = pfont;
return 1;
} else { /* This was made by makefont or scalefont. */
/* Just insert the new name. */
gs_matrix mat;
ref fname; /* t_string */
code = sub_font_params(imemory, op, &mat, NULL, &fname);
if (code < 0)
return code;
code = 1;
copy_font_name(&pfont->font_name, &fname);
goto set_name;
}
}
}
/* This is a new font. */
if (!r_has_attr(aop, a_write))
return_error(e_invalidaccess);
{
ref encoding;
/*
* Since add_FID may resize the dictionary and cause
* pencoding to become invalid, save the Encoding.
*/
if (pencoding) {
encoding = *pencoding;
pencoding = &encoding;
}
code = build_gs_sub_font(i_ctx_p, op, &pfont, ftype, pstype,
pbuild, pencoding, op);
if (code < 0)
return code;
}
pfont->BitmapWidths = bitmapwidths;
pfont->ExactSize = (fbit_type)exactsize;
pfont->InBetweenSize = (fbit_type)inbetweensize;
pfont->TransformedChar = (fbit_type)transformedchar;
pfont->WMode = wmode;
pfont->procs.font_info = zfont_info;
code = 0;
set_name:
copy_font_name(&pfont->key_name, &kname);
*ppfont = pfont;
return code;
}
/* <any> <any> .... /spec_op name .special_op <any> <any> .....
* The special_op operator takes at a minimum the name of the spec_op to execute
* and as many additional parameters as are required for the spec_op. It may
* return as many additional parameters as required.
*/
int
zspec_op(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gx_device *dev = gs_currentdevice(igs);
int i, nprocs = sizeof(spec_op_defs) / sizeof(spec_op_t), code, proc = -1;
ref opname, nref, namestr;
char *data;
/* At the very minimum we need a name object telling us which sepc_op to perform */
check_op(1);
if (!r_has_type(op, t_name))
return_error(gs_error_typecheck);
ref_assign(&opname, op);
/* Find the relevant spec_op name */
for (i=0;i<nprocs;i++) {
code = names_ref(imemory->gs_lib_ctx->gs_name_table, (const byte *)spec_op_defs[i].name, strlen(spec_op_defs[i].name), &nref, 0);
if (code < 0)
return code;
if (name_eq(&opname, &nref)) {
proc = i;
break;
}
}
if (proc < 0)
return_error(gs_error_undefined);
pop(1); /* We don't need the name of the spec_op any more */
op = osp;
switch(proc) {
case 0:
{
stack_param_list list;
dev_param_req_t request;
ref rkeys;
/* Get a single device parameter, we should be supplied with
* the name of the paramter, as a name object.
*/
check_op(1);
if (!r_has_type(op, t_name))
return_error(gs_error_typecheck);
ref_assign(&opname, op);
name_string_ref(imemory, &opname, &namestr);
data = (char *)gs_alloc_bytes(imemory, r_size(&namestr) + 1, "temporary special_op string");
if (data == 0)
return_error(gs_error_VMerror);
memset(data, 0x00, r_size(&namestr) + 1);
memcpy(data, namestr.value.bytes, r_size(&namestr));
/* Discard the parameter name now, we're done with it */
pop (1);
/* Make a null object so that the stack param list won't check for requests */
make_null(&rkeys);
stack_param_list_write(&list, &o_stack, &rkeys, iimemory);
/* Stuff the data into a structure for passing to the spec_op */
request.Param = data;
request.list = &list;
code = dev_proc(dev, dev_spec_op)(dev, gxdso_get_dev_param, &request, sizeof(dev_param_req_t));
gs_free_object(imemory, data, "temporary special_op string");
if (code < 0) {
if (code == gs_error_undefined) {
op = osp;
push(1);
make_bool(op, 0);
} else
return_error(code);
} else {
op = osp;
push(1);
make_bool(op, 1);
}
}
break;
default:
/* Belt and braces; it shold not be possible to get here, as the table
* containing the names should mirror the entries in this switch. If we
* found a name there should be a matching case here.
*/
return_error(gs_error_undefined);
break;
}
return 0;
}
/* .getbitsrect <height> <substring> */
static int
zgetbitsrect(i_ctx_t *i_ctx_p)
{ /*
* alpha? is 0 for no alpha, -1 for alpha first, 1 for alpha last.
* std_depth is null for native pixels, depth/component for
* standard color space.
*/
os_ptr op = osp;
gx_device *dev;
gs_int_rect rect;
gs_get_bits_params_t params;
int w, h;
gs_get_bits_options_t options =
GB_ALIGN_ANY | GB_RETURN_COPY | GB_OFFSET_0 | GB_RASTER_STANDARD |
GB_PACKING_CHUNKY;
int depth;
uint raster;
int num_rows;
int code;
check_read_type(op[-7], t_device);
dev = op[-7].value.pdevice;
check_int_leu(op[-6], dev->width);
rect.p.x = op[-6].value.intval;
check_int_leu(op[-5], dev->height);
rect.p.y = op[-5].value.intval;
check_int_leu(op[-4], dev->width);
w = op[-4].value.intval;
check_int_leu(op[-3], dev->height);
h = op[-3].value.intval;
check_type(op[-2], t_integer);
/*
* We use if/else rather than switch because the value is long,
* which is not supported as a switch value in pre-ANSI C.
*/
if (op[-2].value.intval == -1)
options |= GB_ALPHA_FIRST;
else if (op[-2].value.intval == 0)
options |= GB_ALPHA_NONE;
else if (op[-2].value.intval == 1)
options |= GB_ALPHA_LAST;
else
return_error(gs_error_rangecheck);
if (r_has_type(op - 1, t_null)) {
options |= GB_COLORS_NATIVE;
depth = dev->color_info.depth;
} else {
static const gs_get_bits_options_t depths[17] = {
0, GB_DEPTH_1, GB_DEPTH_2, 0, GB_DEPTH_4, 0, 0, 0, GB_DEPTH_8,
0, 0, 0, GB_DEPTH_12, 0, 0, 0, GB_DEPTH_16
};
gs_get_bits_options_t depth_option;
int std_depth;
check_int_leu(op[-1], 16);
std_depth = (int)op[-1].value.intval;
depth_option = depths[std_depth];
if (depth_option == 0)
return_error(gs_error_rangecheck);
options |= depth_option | GB_COLORS_NATIVE;
depth = (dev->color_info.num_components +
(options & GB_ALPHA_NONE ? 0 : 1)) * std_depth;
}
if (w == 0)
return_error(gs_error_rangecheck);
raster = (w * depth + 7) >> 3;
check_write_type(*op, t_string);
num_rows = r_size(op) / raster;
h = min(h, num_rows);
if (h == 0)
return_error(gs_error_rangecheck);
rect.q.x = rect.p.x + w;
rect.q.y = rect.p.y + h;
params.options = options;
params.data[0] = op->value.bytes;
code = (*dev_proc(dev, get_bits_rectangle))(dev, &rect, ¶ms, NULL);
if (code < 0)
return code;
make_int(op - 7, h);
op[-6] = *op;
r_set_size(op - 6, h * raster);
pop(6);
return 0;
}
/* <num> <radix_int> <string> cvrs <substring> */
static int
zcvrs(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int radix;
check_type(op[-1], t_integer);
if (op[-1].value.intval < 2 || op[-1].value.intval > 36)
return_error(e_rangecheck);
radix = op[-1].value.intval;
check_write_type(*op, t_string);
if (radix == 10) {
switch (r_type(op - 2)) {
case t_integer:
case t_real:
{
int code = convert_to_string(imemory, op - 2, op);
if (code < 0)
return code;
pop(2);
return 0;
}
case t__invalid:
return_error(e_stackunderflow);
default:
return_error(e_rangecheck); /* CET 24-05 wants rangecheck */
}
} else {
uint ival;
byte digits[sizeof(ulong) * 8];
byte *endp = &digits[countof(digits)];
byte *dp = endp;
switch (r_type(op - 2)) {
case t_integer:
ival = (uint) op[-2].value.intval;
break;
case t_real:
{
float fval = op[-2].value.realval;
if (!REAL_CAN_BE_INT(fval))
return_error(e_rangecheck);
ival = (ulong) (long)fval;
} break;
case t__invalid:
return_error(e_stackunderflow);
default:
return_error(e_rangecheck); /* CET 24-05 wants rangecheck */
}
do {
int dit = ival % radix;
*--dp = dit + (dit < 10 ? '0' : ('A' - 10));
ival /= radix;
}
while (ival);
if (endp - dp > r_size(op))
return_error(e_rangecheck);
memcpy(op->value.bytes, dp, (uint) (endp - dp));
r_set_size(op, endp - dp);
}
op[-2] = *op;
pop(2);
return 0;
}
/* Extract and check the parameters for a gs_data_image_t. */
int
data_image_params(const gs_memory_t *mem,
const ref *op, gs_data_image_t *pim,
image_params *pip, bool require_DataSource,
int num_components, int max_bits_per_component,
bool has_alpha)
{
int code;
int decode_size;
ref *pds;
check_type(*op, t_dictionary);
check_dict_read(*op);
if ((code = dict_int_param(op, "Width", 0, max_int_in_fixed / 2,
-1, &pim->Width)) < 0 ||
(code = dict_int_param(op, "Height", 0, max_int_in_fixed / 2,
-1, &pim->Height)) < 0 ||
(code = dict_matrix_param(mem, op, "ImageMatrix",
&pim->ImageMatrix)) < 0 ||
(code = dict_bool_param(op, "MultipleDataSources", false,
&pip->MultipleDataSources)) < 0 ||
(code = dict_int_param(op, "BitsPerComponent", 1,
max_bits_per_component, -1,
&pim->BitsPerComponent)) < 0 ||
(code = decode_size = dict_floats_param(mem, op, "Decode",
num_components * 2,
&pim->Decode[0], NULL)) < 0 ||
(code = dict_bool_param(op, "Interpolate", false,
&pim->Interpolate)) < 0
)
return code;
pip->pDecode = &pim->Decode[0];
/* Extract and check the data sources. */
if ((code = dict_find_string(op, "DataSource", &pds)) <= 0) {
if (require_DataSource)
return (code < 0 ? code : gs_note_error(e_rangecheck));
return 1; /* no data source */
}
if (pip->MultipleDataSources) {
ref *ds = pip->DataSource;
long i, n = num_components + (has_alpha ? 1 : 0);
if (!r_is_array(pds))
return_error(e_typecheck);
if (r_size(pds) != n)
return_error(e_rangecheck);
for (i = 0; i < n; ++i)
array_get(mem, pds, i, &ds[i]);
if (r_type(&ds[0]) == t_string) {
/* We don't have a problem with the strings of different length
* but Adobe does and CET tast 12-02.ps reports this as an error.
*/
if (has_alpha)
n--;
for (i = 1; i < n; ++i) {
if (r_type(&ds[i]) == t_string && r_size(&ds[i]) != r_size(&ds[0])) {
return_error(e_rangecheck);
}
}
}
} else
pip->DataSource[0] = *pds;
return 0;
}
/* strings of the permitgroup array. */
static int
check_file_permissions_reduced(i_ctx_t *i_ctx_p, const char *fname, int len,
const char *permitgroup)
{
long i;
ref *permitlist = NULL;
/* an empty string (first character == 0) if '\' character is */
/* recognized as a file name separator as on DOS & Windows */
const char *win_sep2 = "\\";
bool use_windows_pathsep = (gs_file_name_check_separator(win_sep2, 1, win_sep2) == 1);
uint plen = gp_file_name_parents(fname, len);
/* Assuming a reduced file name. */
if (dict_find_string(&(i_ctx_p->userparams), permitgroup, &permitlist) <= 0)
return 0; /* if Permissions not found, just allow access */
for (i=0; i<r_size(permitlist); i++) {
ref permitstring;
const string_match_params win_filename_params = {
'*', '?', '\\', true, true /* ignore case & '/' == '\\' */
};
const byte *permstr;
uint permlen;
int cwd_len = 0;
if (array_get(imemory, permitlist, i, &permitstring) < 0 ||
r_type(&permitstring) != t_string
)
break; /* any problem, just fail */
permstr = permitstring.value.bytes;
permlen = r_size(&permitstring);
/*
* Check if any file name is permitted with "*".
*/
if (permlen == 1 && permstr[0] == '*')
return 0; /* success */
/*
* If the filename starts with parent references,
* the permission element must start with same number of parent references.
*/
if (plen != 0 && plen != gp_file_name_parents((const char *)permstr, permlen))
continue;
cwd_len = gp_file_name_cwds((const char *)permstr, permlen);
/*
* If the permission starts with "./", absolute paths
* are not permitted.
*/
if (cwd_len > 0 && gp_file_name_is_absolute(fname, len))
continue;
/*
* If the permission starts with "./", relative paths
* with no "./" are allowed as well as with "./".
* 'fname' has no "./" because it is reduced.
*/
if (string_match( (const unsigned char*) fname, len,
permstr + cwd_len, permlen - cwd_len,
use_windows_pathsep ? &win_filename_params : NULL))
return 0; /* success */
}
/* not found */
return e_invalidfileaccess;
}
/* Check a stack to make sure all its elements are older than a save. */
static int
restore_check_stack(const i_ctx_t *i_ctx_p, const ref_stack_t * pstack,
const alloc_save_t * asave, bool is_estack)
{
ref_stack_enum_t rsenum;
ref_stack_enum_begin(&rsenum, pstack);
do {
const ref *stkp = rsenum.ptr;
uint size = rsenum.size;
for (; size; stkp++, size--) {
const void *ptr;
switch (r_type(stkp)) {
case t_array:
/*
* Zero-length arrays are a special case: see the
* t_*array case (label rr:) in igc.c:gc_trace.
*/
if (r_size(stkp) == 0) {
/*stkp->value.refs = (void *)0;*/
continue;
}
ptr = stkp->value.refs;
break;
case t_dictionary:
ptr = stkp->value.pdict;
break;
case t_file:
/* Don't check executable or closed literal */
/* files on the e-stack. */
{
stream *s;
if (is_estack &&
(r_has_attr(stkp, a_executable) ||
file_is_invalid(s, stkp))
)
continue;
}
ptr = stkp->value.pfile;
break;
case t_name:
/* Names are special because of how they are allocated. */
if (alloc_name_is_since_save((const gs_memory_t *)pstack->memory,
stkp, asave))
return_error(e_invalidrestore);
continue;
case t_string:
/* Don't check empty executable strings */
/* on the e-stack. */
if (r_size(stkp) == 0 &&
r_has_attr(stkp, a_executable) && is_estack
)
continue;
ptr = stkp->value.bytes;
break;
case t_mixedarray:
case t_shortarray:
/* See the t_array case above. */
if (r_size(stkp) == 0) {
/*stkp->value.packed = (void *)0;*/
continue;
}
ptr = stkp->value.packed;
break;
case t_device:
ptr = stkp->value.pdevice;
break;
case t_fontID:
case t_struct:
case t_astruct:
ptr = stkp->value.pstruct;
break;
case t_save:
/* See the comment in isave.h regarding the following. */
if (i_ctx_p->language_level <= 2)
continue;
ptr = alloc_find_save(&gs_imemory, stkp->value.saveid);
/*
* Invalid save objects aren't supposed to be possible
* in LL3, but just in case....
*/
if (ptr == 0)
return_error(e_invalidrestore);
if (ptr == asave)
continue;
break;
default:
continue;
}
if (alloc_is_since_save(ptr, asave))
return_error(e_invalidrestore);
}
} while (ref_stack_enum_next(&rsenum));
return 0; /* OK */
}
/* <name_string> <access_string> file <file> */
int /* exported for zsysvm.c */
zfile(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
char file_access[4];
gs_parsed_file_name_t pname;
int code = parse_file_access_string(op, file_access);
stream *s;
if (code < 0)
return code;
code = parse_file_name(op-1, &pname, i_ctx_p->LockFilePermissions, imemory);
if (code < 0)
return code;
/*
* HACK: temporarily patch the current context pointer into the
* state pointer for stdio-related devices. See ziodev.c for
* more information.
*/
if (pname.iodev && pname.iodev->dtype == iodev_dtype_stdio) {
bool statement = (strcmp(pname.iodev->dname, "%statementedit%") == 0);
bool lineedit = (strcmp(pname.iodev->dname, "%lineedit%") == 0);
if (pname.fname)
return_error(e_invalidfileaccess);
if (statement || lineedit) {
/* These need special code to support callouts */
gx_io_device *indev = gs_findiodevice(imemory,
(const byte *)"%stdin", 6);
stream *ins;
if (strcmp(file_access, "r"))
return_error(e_invalidfileaccess);
indev->state = i_ctx_p;
code = (indev->procs.open_device)(indev, file_access, &ins, imemory);
indev->state = 0;
if (code < 0)
return code;
check_ostack(2);
push(2);
make_stream_file(op - 3, ins, file_access);
make_bool(op-2, statement);
make_int(op-1, 0);
make_string(op, icurrent_space, 0, NULL);
return zfilelineedit(i_ctx_p);
}
pname.iodev->state = i_ctx_p;
code = (*pname.iodev->procs.open_device)(pname.iodev,
file_access, &s, imemory);
pname.iodev->state = NULL;
} else {
if (pname.iodev == NULL)
pname.iodev = iodev_default(imemory);
code = zopen_file(i_ctx_p, &pname, file_access, &s, imemory);
}
if (code < 0)
return code;
code = ssetfilename(s, op[-1].value.const_bytes, r_size(op - 1));
if (code < 0) {
sclose(s);
return_error(e_VMerror);
}
make_stream_file(op - 1, s, file_access);
pop(1);
return code;
}
/* See gsmemory.h for why the argument is const and the result is not. */
ref_packed *
igc_reloc_ref_ptr_nocheck(const ref_packed * prp, gc_state_t *gcst)
{
/*
* Search forward for relocation. This algorithm is intrinsically very
* inefficient; we hope eventually to replace it with a better one.
*/
const ref_packed *rp = prp;
uint dec = 0;
#ifdef ALIGNMENT_ALIASING_BUG
const ref *rpref;
# define RP_REF(rp) (rpref = (const ref *)rp, rpref)
#else
# define RP_REF(rp) ((const ref *)rp)
#endif
for (;;) {
if (r_is_packed(rp)) {
/*
* Normally, an unmarked packed ref will be an
* integer whose value is the amount of relocation.
* However, the relocation value might have been
* too large to fit. If this is the case, for
* each such unmarked packed ref we pass over,
* we have to decrement the final relocation.
*/
rputc((*rp & lp_mark ? '1' : '0'));
if (!(*rp & lp_mark)) {
if (*rp != pt_tag(pt_integer) + packed_max_value) {
/* This is a stored relocation value. */
rputc('\n');
rp = print_reloc(prp, "ref",
(const ref_packed *)
((const char *)prp -
(*rp & packed_value_mask) + dec));
break;
}
/*
* We know this is the first of an aligned block
* of packed refs. Skip over the entire block,
* decrementing the final relocation.
*/
dec += sizeof(ref_packed) * align_packed_per_ref;
rp += align_packed_per_ref;
} else
rp++;
continue;
}
if (!ref_type_uses_size_or_null(r_type(RP_REF(rp)))) {
/* reloc is in r_size */
rputc('\n');
rp = print_reloc(prp, "ref",
(const ref_packed *)
(r_size(RP_REF(rp)) == 0 ? prp :
(const ref_packed *)((const char *)prp -
r_size(RP_REF(rp)) + dec)));
break;
}
rputc('u');
rp += packed_per_ref;
}
/* Use a severely deprecated pun to remove the const property. */
{
union { const ref_packed *r; ref_packed *w; } u;
u.r = rp;
return u.w;
}
#undef RP_REF
}
/* <prefix|null> <access_string> .tempfile <name_string> <file> */
static int
ztempfile(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const char *pstr;
char fmode[4];
int code = parse_file_access_string(op, fmode);
char prefix[gp_file_name_sizeof];
char fname[gp_file_name_sizeof];
uint fnlen;
FILE *sfile;
stream *s;
byte *buf, *sbody;
if (code < 0)
return code;
strcat(fmode, gp_fmode_binary_suffix);
if (r_has_type(op - 1, t_null))
pstr = gp_scratch_file_name_prefix;
else {
uint psize;
check_read_type(op[-1], t_string);
psize = r_size(op - 1);
if (psize >= gp_file_name_sizeof)
return_error(e_rangecheck);
memcpy(prefix, op[-1].value.const_bytes, psize);
prefix[psize] = 0;
pstr = prefix;
}
if (gp_file_name_is_absolute(pstr, strlen(pstr))) {
if (check_file_permissions(i_ctx_p, pstr, strlen(pstr),
"PermitFileWriting") < 0) {
return_error(e_invalidfileaccess);
}
} else if (!prefix_is_simple(pstr)) {
return_error(e_invalidfileaccess);
}
s = file_alloc_stream(imemory, "ztempfile(stream)");
if (s == 0)
return_error(e_VMerror);
buf = gs_alloc_bytes(imemory, file_default_buffer_size,
"ztempfile(buffer)");
if (buf == 0)
return_error(e_VMerror);
sfile = gp_open_scratch_file(imemory, pstr, fname, fmode);
if (sfile == 0) {
gs_free_object(imemory, buf, "ztempfile(buffer)");
return_error(e_invalidfileaccess);
}
fnlen = strlen(fname);
sbody = ialloc_string(fnlen, ".tempfile(fname)");
if (sbody == 0) {
gs_free_object(imemory, buf, "ztempfile(buffer)");
return_error(e_VMerror);
}
memcpy(sbody, fname, fnlen);
file_init_stream(s, sfile, fmode, buf, file_default_buffer_size);
code = ssetfilename(s, (const unsigned char*) fname, fnlen);
if (code < 0) {
gx_io_device *iodev_dflt = iodev_default(imemory);
sclose(s);
iodev_dflt->procs.delete_file(iodev_dflt, fname);
ifree_string(sbody, fnlen, ".tempfile(fname)");
return_error(e_VMerror);
}
make_string(op - 1, a_readonly | icurrent_space, fnlen, sbody);
make_stream_file(op, s, fmode);
return code;
}
/* <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);
state.jpx_memory = imemory->non_gc_memory;
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 {
dprintf("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_debug1('w', "[w] JPX image has an external %d"
" 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_debug0('w', "[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);
}
static int
ref_param_read_typed(gs_param_list * plist, gs_param_name pkey,
gs_param_typed_value * pvalue)
{
iparam_list *const iplist = (iparam_list *) plist;
iparam_loc loc;
ref elt;
int code = ref_param_read(iplist, pkey, &loc, -1);
if (code != 0)
return code;
switch (r_type(loc.pvalue)) {
case t_array:
case t_mixedarray:
case t_shortarray:
iparam_check_read(loc);
if (r_size(loc.pvalue) <= 0) {
/* 0-length array; can't get type info */
pvalue->type = gs_param_type_array;
pvalue->value.d.list = 0;
pvalue->value.d.size = 0;
return 0;
}
/*
* We have to guess at the array type. First we guess based
* on the type of the first element of the array. If that
* fails, we try again with more general types.
*/
array_get(plist->memory, loc.pvalue, 0, &elt);
switch (r_type(&elt)) {
case t_integer:
pvalue->type = gs_param_type_int_array;
code = ref_param_read_int_array(plist, pkey,
&pvalue->value.ia);
if (code != e_typecheck)
return code;
/* This might be a float array. Fall through. */
*loc.presult = 0; /* reset error */
case t_real:
pvalue->type = gs_param_type_float_array;
return ref_param_read_float_array(plist, pkey,
&pvalue->value.fa);
case t_string:
pvalue->type = gs_param_type_string_array;
return ref_param_read_string_array(plist, pkey,
&pvalue->value.sa);
case t_name:
pvalue->type = gs_param_type_name_array;
return ref_param_read_string_array(plist, pkey,
&pvalue->value.na);
default:
break;
}
return gs_note_error(e_typecheck);
case t_boolean:
pvalue->type = gs_param_type_bool;
pvalue->value.b = loc.pvalue->value.boolval;
return 0;
case t_dictionary:
code = ref_param_begin_read_collection(plist, pkey,
&pvalue->value.d, gs_param_collection_dict_any);
if (code < 0)
return code;
pvalue->type = gs_param_type_dict;
/* fixup new dict's type & int_keys field if contents have int keys */
{
gs_param_enumerator_t enumr;
gs_param_key_t key;
ref_type keytype;
param_init_enumerator(&enumr);
if (!(*((iparam_list *) plist)->enumerate)
((iparam_list *) pvalue->value.d.list, &enumr, &key, &keytype)
&& keytype == t_integer) {
((dict_param_list *) pvalue->value.d.list)->int_keys = 1;
pvalue->type = gs_param_type_dict_int_keys;
}
}
return 0;
case t_integer:
pvalue->type = gs_param_type_long;
pvalue->value.l = loc.pvalue->value.intval;
return 0;
case t_name:
pvalue->type = gs_param_type_name;
return ref_param_read_string_value(plist->memory, &loc, &pvalue->value.n);
case t_null:
pvalue->type = gs_param_type_null;
return 0;
case t_real:
pvalue->value.f = loc.pvalue->value.realval;
pvalue->type = gs_param_type_float;
return 0;
case t_string:
case t_astruct:
pvalue->type = gs_param_type_string;
return ref_param_read_string_value(plist->memory, &loc, &pvalue->value.s);
default:
break;
}
return gs_note_error(e_typecheck);
}
static int
zbind(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
uint depth = 1;
ref defn;
register os_ptr bsp;
switch (r_type(op)) {
case t_array:
if (!r_has_attr(op, a_write)) {
return 0; /* per PLRM3 */
}
case t_mixedarray:
case t_shortarray:
defn = *op;
break;
case t_oparray:
defn = *op->value.const_refs;
break;
default:
return_op_typecheck(op);
}
push(1);
*op = defn;
bsp = op;
/*
* We must not make the top-level procedure read-only,
* but we must bind it even if it is read-only already.
*
* Here are the invariants for the following loop:
* `depth' elements have been pushed on the ostack;
* For i < depth, p = ref_stack_index(&o_stack, i):
* *p is an array (or packedarray) ref.
*/
while (depth) {
while (r_size(bsp)) {
ref_packed *const tpp = (ref_packed *)bsp->value.packed; /* break const */
r_dec_size(bsp, 1);
if (r_is_packed(tpp)) {
/* Check for a packed executable name */
ushort elt = *tpp;
if (r_packed_is_exec_name(&elt)) {
ref nref;
ref *pvalue;
name_index_ref(imemory, packed_name_index(&elt),
&nref);
if ((pvalue = dict_find_name(&nref)) != 0 &&
r_is_ex_oper(pvalue)
) {
store_check_dest(bsp, pvalue);
/*
* Always save the change, since this can only
* happen once.
*/
ref_do_save(bsp, tpp, "bind");
*tpp = pt_tag(pt_executable_operator) +
op_index(pvalue);
}
}
bsp->value.packed = tpp + 1;
} else {
ref *const tp = bsp->value.refs++;
switch (r_type(tp)) {
case t_name: /* bind the name if an operator */
if (r_has_attr(tp, a_executable)) {
ref *pvalue;
if ((pvalue = dict_find_name(tp)) != 0 &&
r_is_ex_oper(pvalue)
) {
store_check_dest(bsp, pvalue);
ref_assign_old(bsp, tp, pvalue, "bind");
}
}
break;
case t_array: /* push into array if writable */
if (!r_has_attr(tp, a_write))
break;
case t_mixedarray:
case t_shortarray:
if (r_has_attr(tp, a_executable)) {
/* Make reference read-only */
r_clear_attrs(tp, a_write);
if (bsp >= ostop) {
/* Push a new stack block. */
ref temp;
int code;
temp = *tp;
osp = bsp;
code = ref_stack_push(&o_stack, 1);
if (code < 0) {
ref_stack_pop(&o_stack, depth);
return_error(code);
}
bsp = osp;
*bsp = temp;
} else
*++bsp = *tp;
depth++;
}
}
}
}
bsp--;
depth--;
if (bsp < osbot) { /* Pop back to the previous stack block. */
osp = bsp;
ref_stack_pop_block(&o_stack);
bsp = osp;
}
}
osp = bsp;
return 0;
}
/* Append a user path to the current path. */
static inline int
upath_append_aux(os_ptr oppath, i_ctx_t *i_ctx_p, int *pnargs, bool upath_compat)
{
upath_state ups = UPS_INITIAL;
ref opcodes;
if (r_has_type(oppath, t__invalid))
return_error(e_stackunderflow);
if (!r_is_array(oppath))
return_error(e_typecheck);
check_read(*oppath);
gs_newpath(igs);
/****** ROUND tx AND ty ******/
if ( r_size(oppath) == 2 &&
array_get(imemory, oppath, 1, &opcodes) >= 0 &&
r_has_type(&opcodes, t_string)
) { /* 1st element is operands, 2nd is operators */
ref operands;
int code, format;
int repcount = 1;
const byte *opp;
uint ocount, i = 0;
array_get(imemory, oppath, 0, &operands);
code = num_array_format(&operands);
if (code < 0)
return code;
format = code;
check_read(opcodes);
opp = opcodes.value.bytes;
ocount = r_size(&opcodes);
while (ocount--) {
byte opx = *opp++;
if (opx > UPATH_REPEAT)
repcount = opx - UPATH_REPEAT;
else if (opx > UPATH_MAX_OP)
return_error(e_rangecheck);
else { /* operator */
const up_data_t data = up_data[opx];
*pnargs = 0; /* in case of error */
if (upath_compat && opx == upath_op_ucache) {
/* CPSI does not complain about incorrect ucache
placement, even though PLRM3 says it's illegal. */
ups = ups > UPS_UCACHE ? ups : data.state_after;
} else {
if (!(ups & data.states_before))
return_error(e_typecheck);
ups = data.state_after;
}
do {
os_ptr op = osp;
byte opargs = data.num_args;
while (opargs--) {
push(1);
(*pnargs)++; /* in case of error */
code = num_array_get(imemory, &operands, format, i++, op);
switch (code) {
case t_integer:
r_set_type_attrs(op, t_integer, 0);
break;
case t_real:
r_set_type_attrs(op, t_real, 0);
break;
default:
return_error(e_typecheck);
}
}
code = (*up_ops[opx])(i_ctx_p);
if (code < 0)
return code;
}
while (--repcount);
repcount = 1;
}
}
} else { /* Ordinary executable array. */
const ref *arp = oppath;
uint ocount = r_size(oppath);
long index = 0;
int argcount = 0;
op_proc_t oproc;
int opx, code;
for (; index < ocount; index++) {
ref rup;
ref *defp;
os_ptr op = osp;
up_data_t data;
*pnargs = argcount;
array_get(imemory, arp, index, &rup);
switch (r_type(&rup)) {
case t_integer:
case t_real:
argcount++;
push(1);
*op = rup;
break;
case t_name:
if (!r_has_attr(&rup, a_executable) ||
dict_find(systemdict, &rup, &defp) <= 0 ||
r_btype(defp) != t_operator)
return_error(e_typecheck); /* all errors = typecheck */
goto xop;
case t_operator:
defp = &rup;
xop:if (!r_has_attr(defp, a_executable))
return_error(e_typecheck);
oproc = real_opproc(defp);
for (opx = 0; opx <= UPATH_MAX_OP; opx++)
if (oproc == up_ops[opx])
break;
if (opx > UPATH_MAX_OP)
return_error(e_typecheck);
data = up_data[opx];
if (argcount != data.num_args)
return_error(e_typecheck);
if (upath_compat && opx == upath_op_ucache) {
/* CPSI does not complain about incorrect ucache
placement, even though PLRM3 says it's illegal. */
ups = ups > UPS_UCACHE ? ups : data.state_after;
} else {
if (!(ups & data.states_before))
return_error(e_typecheck);
ups = data.state_after;
}
code = (*up_ops[opx])(i_ctx_p);
if (code < 0) {
if (code == e_nocurrentpoint)
return_error(e_rangecheck); /* CET 11-22 */
return code;
}
argcount = 0;
break;
default:
return_error(e_typecheck);
}
}
if (argcount) {
*pnargs = argcount;
return_error(e_typecheck); /* leftover args */
}
}
if (ups < UPS_SETBBOX)
return_error(e_typecheck); /* no setbbox */
if (ups == UPS_SETBBOX && upath_compat) {
/*
* In CPSI compatibility mode, an empty path with a setbbox also
* does a moveto (but only if the path is empty). Since setbbox
* was the last operator, its operands are still on the o-stack.
*/
osp += 2;
return zmoveto(i_ctx_p);
}
return 0;
}
/* (password) <encryption dict> check_r6_password (key) true|false */
static int
zcheck_r6_password(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
ref *CryptDict, *Oref, *OEref, *Uref, *UEref, *Pref;
int code, PWlen;
unsigned char validation[32];
unsigned char output[32];
ref stref;
byte *body;
check_op(2);
CryptDict = op--;
Pref = op;
if (!r_has_type(CryptDict, t_dictionary))
return_error(e_typecheck);
if (!r_has_type(Pref, t_string))
return_error(e_typecheck);
code = dict_find_string(CryptDict, "O", &Oref);
if (code < 0 || !r_has_type(Oref, t_string)) {
return_error(e_typecheck);
}
code = dict_find_string(CryptDict, "OE", &OEref);
if (code < 0 || !r_has_type(OEref, t_string)) {
return_error(e_typecheck);
}
code = dict_find_string(CryptDict, "U", &Uref);
if (code < 0 || !r_has_type(Uref, t_string)) {
return_error(e_typecheck);
}
code = dict_find_string(CryptDict, "UE", &UEref);
if (code < 0 || !r_has_type(UEref, t_string)) {
return_error(e_typecheck);
}
pop(2);
op = osp;
PWlen = r_size(Pref);
/* First, try the password as the user password */
pdf_compute_encryption_key_r6((unsigned char *)Pref->value.const_bytes, PWlen, (unsigned char *)Oref->value.const_bytes,
(unsigned char *)OEref->value.const_bytes, (unsigned char *)Uref->value.const_bytes, (unsigned char *)UEref->value.const_bytes, 0, validation, output);
if (memcmp(validation, Uref->value.const_bytes, 32) != 0){
/* It wasn't the user password, maybe its the owner password */
pdf_compute_encryption_key_r6((unsigned char *)Pref->value.const_bytes, PWlen, (unsigned char *)Oref->value.const_bytes,
(unsigned char *)OEref->value.const_bytes, (unsigned char *)Uref->value.const_bytes, (unsigned char *)UEref->value.const_bytes, 1, validation, output);
if (memcmp(validation, Oref->value.const_bytes, 32) != 0){
/* Doesn't seem to be a valid password.... */
push(1);
make_bool(op, 0);
return 0;
}
}
body = ialloc_string(32, "r6 encryption key");
if (body == 0)
return_error(e_VMerror);
push(1);
memcpy(body, output, 32);
make_string(&stref, a_all | icurrent_space, 32, body);
ref_assign(op, &stref);
push(1);
make_bool(op, 1);
return 0;
}
/* <string|name> <font_dict> .buildfont9 <string|name> <font> */
static int
zbuildfont9(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
build_proc_refs build;
int code = build_proc_name_refs(imemory, &build, NULL, "%Type9BuildGlyph");
gs_font_cid_data common;
ref GlyphDirectory, GlyphData, DataSource;
ref *prfda, cfnstr;
ref *pCIDFontName, CIDFontName;
gs_font_type1 **FDArray;
uint FDArray_size;
int FDBytes;
uint CIDMapOffset;
gs_font_base *pfont;
gs_font_cid0 *pfcid;
uint i;
/*
* If the CIDFont's data have been loaded into VM, GlyphData will be
* a string or an array of strings; if they are loaded incrementally
* from a file, GlyphData will be an integer, and DataSource will be
* a (reusable) stream.
*/
if (code < 0 ||
(code = cid_font_data_param(op, &common, &GlyphDirectory)) < 0 ||
(code = dict_find_string(op, "FDArray", &prfda)) < 0 ||
(code = dict_find_string(op, "CIDFontName", &pCIDFontName)) <= 0 ||
(code = dict_int_param(op, "FDBytes", 0, MAX_FDBytes, -1, &FDBytes)) < 0
)
return code;
/*
* Since build_gs_simple_font may resize the dictionary and cause
* pointers to become invalid, save CIDFontName
*/
CIDFontName = *pCIDFontName;
if (r_has_type(&GlyphDirectory, t_null)) {
/* Standard CIDFont, require GlyphData and CIDMapOffset. */
ref *pGlyphData;
if ((code = dict_find_string(op, "GlyphData", &pGlyphData)) < 0 ||
(code = dict_uint_param(op, "CIDMapOffset", 0, max_uint - 1,
max_uint, &CIDMapOffset)) < 0)
return code;
GlyphData = *pGlyphData;
if (r_has_type(&GlyphData, t_integer)) {
ref *pds;
stream *ignore_s;
if ((code = dict_find_string(op, "DataSource", &pds)) < 0)
return code;
check_read_file(i_ctx_p, ignore_s, pds);
DataSource = *pds;
} else {
if (!r_has_type(&GlyphData, t_string) && !r_is_array(&GlyphData))
return_error(e_typecheck);
make_null(&DataSource);
}
} else {
make_null(&GlyphData);
make_null(&DataSource);
CIDMapOffset = 0;
}
if (!r_is_array(prfda))
return_error(e_invalidfont);
FDArray_size = r_size(prfda);
if (FDArray_size == 0)
return_error(e_invalidfont);
FDArray = ialloc_struct_array(FDArray_size, gs_font_type1 *,
&st_gs_font_type1_ptr_element,
"buildfont9(FDarray)");
if (FDArray == 0)
return_error(e_VMerror);
memset(FDArray, 0, sizeof(gs_font_type1 *) * FDArray_size);
for (i = 0; i < FDArray_size; ++i) {
ref rfd;
array_get(imemory, prfda, (long)i, &rfd);
code = fd_array_element(i_ctx_p, &FDArray[i], &rfd);
if (code < 0)
goto fail;
}
code = build_gs_outline_font(i_ctx_p, op, &pfont, ft_CID_encrypted,
&st_gs_font_cid0, &build,
bf_Encoding_optional | bf_UniqueID_ignored,
build_gs_simple_font);
if (code < 0)
goto fail;
if (code == 1) {
/* The font already has a FID, don't need to build it again.
Release FDArray and return normally.
fixme: FDArray fonts are thrown for garbager.
We're not safe to build them after
build_gs_simple_font(..., &pfont, ...),
because a failure in building them would throw
an underbuilt font with unclear consequences.
*/
ifree_object(FDArray, "buildfont9(FDarray)");
return 0;
}
pfont->procs.enumerate_glyph = gs_font_cid0_enumerate_glyph;
pfont->procs.glyph_outline = z9_glyph_outline;
pfont->procs.glyph_info = z9_glyph_info;
pfcid = (gs_font_cid0 *)pfont;
pfcid->cidata.common = common;
pfcid->cidata.CIDMapOffset = CIDMapOffset;
pfcid->cidata.FDArray = FDArray;
pfcid->cidata.FDArray_size = FDArray_size;
pfcid->cidata.FDBytes = FDBytes;
pfcid->cidata.glyph_data = z9_glyph_data;
pfcid->cidata.proc_data = 0; /* for GC */
if (pfcid->font_name.size == 0) {
get_font_name(imemory, &cfnstr, &CIDFontName);
copy_font_name(&pfcid->font_name, &cfnstr);
}
ref_assign(&pfont_data(pfont)->u.cid0.GlyphDirectory, &GlyphDirectory);
ref_assign(&pfont_data(pfont)->u.cid0.GlyphData, &GlyphData);
ref_assign(&pfont_data(pfont)->u.cid0.DataSource, &DataSource);
code = define_gs_font(i_ctx_p, (gs_font *)pfont);
if (code >= 0)
code = gs_notify_register(&pfont->notify_list, notify_remove_font_type9, pfont);
if (code >= 0) {
for (i = 0; i < FDArray_size; ++i) {
FDArray[i]->dir = pfont->dir;
FDArray[i]->data.parent = pfont;
}
return code;
}
fail:
ifree_object(FDArray, "buildfont9(FDarray)");
return code;
}
/* Initialize the operator table. */
int
op_init(i_ctx_t *i_ctx_p)
{
const op_def *const *tptr;
int code;
/* Enter each operator into the appropriate dictionary. */
for (tptr = op_defs_all; *tptr != 0; tptr++) {
ref *pdict = systemdict;
const op_def *def;
const char *nstr;
for (def = *tptr; (nstr = def->oname) != 0; def++)
if (op_def_is_begin_dict(def)) {
ref nref;
code = name_ref(imemory, (const byte *)nstr, strlen(nstr), &nref, -1);
if (code < 0)
return code;
if (!dict_find(systemdict, &nref, &pdict))
return_error(e_Fatal);
if (!r_has_type(pdict, t_dictionary))
return_error(e_Fatal);
} else {
ref oper;
uint index_in_table = def - *tptr;
uint opidx = (tptr - op_defs_all) * OP_DEFS_MAX_SIZE +
index_in_table;
if (index_in_table >= OP_DEFS_MAX_SIZE) {
lprintf1("opdef overrun! %s\n", def->oname);
return_error(e_Fatal);
}
gs_interp_make_oper(&oper, def->proc, opidx);
/* The first character of the name is a digit */
/* giving the minimum acceptable number of operands. */
/* Check to make sure it's within bounds. */
if (*nstr - '0' > gs_interp_max_op_num_args)
return_error(e_Fatal);
nstr++;
/*
* Skip internal operators, and the second occurrence of
* operators with special indices.
*/
if (*nstr != '%' && r_size(&oper) == opidx) {
code =
i_initial_enter_name_in(i_ctx_p, pdict, nstr, &oper);
if (code < 0)
return code;
}
}
}
/* Allocate the tables for `operator' procedures. */
/* Make one of them local so we can have local operators. */
if ((code = alloc_op_array_table(i_ctx_p, OP_ARRAY_TABLE_GLOBAL_SIZE,
avm_global, &op_array_table_global) < 0))
return code;
op_array_table_global.base_index = op_def_count;
if ((code = gs_register_ref_root(imemory, NULL,
(void **)&op_array_table_global.root_p,
"op_array_table(global)")) < 0 ||
(code = gs_register_struct_root(imemory, NULL,
(void **)&op_array_table_global.nx_table,
"op_array nx_table(global)")) < 0 ||
(code = alloc_op_array_table(i_ctx_p, OP_ARRAY_TABLE_LOCAL_SIZE,
avm_local, &op_array_table_local) < 0)
)
return code;
op_array_table_local.base_index =
op_array_table_global.base_index +
r_size(&op_array_table_global.table);
if ((code = gs_register_ref_root(imemory, NULL,
(void **)&op_array_table_local.root_p,
"op_array_table(local)")) < 0 ||
(code = gs_register_struct_root(imemory, NULL,
(void **)&op_array_table_local.nx_table,
"op_array nx_table(local)")) < 0
)
return code;
return 0;
}
/* Get bytes from GlyphData or DataSource. */
static int
cid0_read_bytes(gs_font_cid0 *pfont, ulong base, uint count, byte *buf,
gs_glyph_data_t *pgd)
{
const font_data *pfdata = pfont_data(pfont);
byte *data = buf;
gs_font *gdfont = 0; /* pfont if newly allocated, 0 if not */
int code = 0;
/* Check for overflow. */
if (base != (long)base || base > base + count)
return_error(e_rangecheck);
if (r_has_type(&pfdata->u.cid0.DataSource, t_null)) {
/* Get the bytes from GlyphData (a string or array of strings). */
const ref *pgdata = &pfdata->u.cid0.GlyphData;
if (r_has_type(pgdata, t_string)) { /* single string */
uint size = r_size(pgdata);
if (base >= size || count > size - base)
return_error(e_rangecheck);
data = pgdata->value.bytes + base;
} else { /* array of strings */
/*
* The algorithm is similar to the one in
* string_array_access_proc in zfont42.c, but it also has to
* deal with the case where the requested string crosses array
* elements.
*/
ulong skip = base;
uint copied = 0;
uint index = 0;
ref rstr;
uint size;
for (;; skip -= size, ++index) {
int code = array_get(pfont->memory, pgdata, index, &rstr);
if (code < 0)
return code;
if (!r_has_type(&rstr, t_string))
return_error(e_typecheck);
size = r_size(&rstr);
if (skip < size)
break;
}
size -= skip;
if (count <= size) {
data = rstr.value.bytes + skip;
} else { /* multiple strings needed */
if (data == 0) { /* no buffer provided */
data = gs_alloc_string(pfont->memory, count,
"cid0_read_bytes");
if (data == 0)
return_error(e_VMerror);
gdfont = (gs_font *)pfont; /* newly allocated */
}
memcpy(data, rstr.value.bytes + skip, size);
copied = size;
while (copied < count) {
int code = array_get(pfont->memory, pgdata, ++index, &rstr);
if (code < 0)
goto err;
if (!r_has_type(&rstr, t_string)) {
code = gs_note_error(e_typecheck);
goto err;
}
size = r_size(&rstr);
if (size > count - copied)
size = count - copied;
memcpy(data + copied, rstr.value.bytes, size);
copied += size;
}
}
}
} else {
/* Get the bytes from DataSource (a stream). */
stream *s;
uint nread;
i_ctx_t *i_ctx_p = get_minst_from_memory(pfont->memory)->i_ctx_p;
check_read_known_file(i_ctx_p, s, &pfdata->u.cid0.DataSource, return_error);
if (sseek(s, base) < 0)
return_error(e_ioerror);
if (data == 0) { /* no buffer provided */
data = gs_alloc_string(pfont->memory, count, "cid0_read_bytes");
if (data == 0)
return_error(e_VMerror);
gdfont = (gs_font *)pfont; /* newly allocated */
}
if (sgets(s, data, count, &nread) < 0 || nread != count) {
code = gs_note_error(e_ioerror);
goto err;
}
}
gs_glyph_data_from_string(pgd, data, count, gdfont);
return code;
err:
if (data != buf)
gs_free_string(pfont->memory, data, count, "cid0_read_bytes");
return code;
}
int seticc(i_ctx_t * i_ctx_p, int ncomps, ref *ICCdict, float *range_buff)
{
int code, k;
gs_color_space * pcs;
gs_color_space * palt_cs;
ref * pstrmval;
stream * s = 0L;
cmm_profile_t *picc_profile;
gs_imager_state * pis = (gs_imager_state *)igs;
int i, expected = 0;
ref * pnameval;
static const char *const icc_std_profile_names[] = {
GSICC_STANDARD_PROFILES
};
static const char *const icc_std_profile_keys[] = {
GSICC_STANDARD_PROFILES_KEYS
};
palt_cs = gs_currentcolorspace(igs);
/* verify the DataSource entry */
if (dict_find_string(ICCdict, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(i_ctx_p, s, pstrmval);
/* build the color space object */
code = gs_cspace_build_ICC(&pcs, NULL, gs_state_memory(igs));
if (code < 0)
return gs_rethrow(code, "building color space object");
/* For now, dump the profile into a buffer
and obtain handle from the buffer when we need it.
We may want to change this later.
This depends to some degree on what the CMS is capable of doing.
I don't want to get bogged down on stream I/O at this point.
Note also, if we are going to be putting these into the clist we will
want to have this buffer. */
/* Check if we have the /Name entry. This is used to associate with
specs that have enumerated types to indicate sRGB sGray etc */
if (dict_find_string(ICCdict, "Name", &pnameval) > 0){
uint size = r_size(pnameval);
char *str = (char *)gs_alloc_bytes(gs_state_memory(igs), size+1, "seticc");
memcpy(str, (const char *)pnameval->value.bytes, size);
str[size] = 0;
/* Compare this to the standard profile names */
picc_profile = NULL;
for (k = 0; k < GSICC_NUMBER_STANDARD_PROFILES; k++) {
if ( strcmp( str, icc_std_profile_keys[k] ) == 0 ) {
picc_profile = gsicc_get_profile_handle_file(icc_std_profile_names[k],
strlen(icc_std_profile_names[k]), gs_state_memory(igs));
break;
}
}
} else {
picc_profile = gsicc_profile_new(s, gs_state_memory(igs), NULL, 0);
}
if (picc_profile == NULL) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return -1;
}
code = gsicc_set_gscs_profile(pcs, picc_profile, gs_state_memory(igs));
if (code < 0) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return code;
}
picc_profile->num_comps = ncomps;
/* We have to get the profile handle due to the fact that we need to know
if it has a data space that is CIELAB */
picc_profile->profile_handle =
gsicc_get_profile_handle_buffer(picc_profile->buffer,
picc_profile->buffer_size,
gs_state_memory(igs));
if (picc_profile->profile_handle == NULL) {
/* Free up everything, the profile is not valid. We will end up going
ahead and using a default based upon the number of components */
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return -1;
}
picc_profile->data_cs = gscms_get_profile_data_space(picc_profile->profile_handle);
switch( picc_profile->data_cs ) {
case gsCIEXYZ:
case gsCIELAB:
case gsRGB:
expected = 3;
break;
case gsGRAY:
expected = 1;
break;
case gsCMYK:
expected = 4;
break;
case gsNCHANNEL:
case gsNAMED: /* Silence warnings */
case gsUNDEFINED: /* Silence warnings */
break;
}
if (!expected || ncomps != expected) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return_error(e_rangecheck);
}
/* Lets go ahead and get the hash code and check if we match one of the default spaces */
/* Later we may want to delay this, but for now lets go ahead and do it */
gsicc_init_hash_cs(picc_profile, pis);
/* Set the range according to the data type that is associated with the
ICC input color type. Occasionally, we will run into CIELAB to CIELAB
profiles for spot colors in PDF documents. These spot colors are typically described
as separation colors with tint transforms that go from a tint value
to a linear mapping between the CIELAB white point and the CIELAB tint
color. This results in a CIELAB value that we need to use to fill. We
need to detect this to make sure we do the proper scaling of the data. For
CIELAB images in PDF, the source is always normal 8 or 16 bit encoded data
in the range from 0 to 255 or 0 to 65535. In that case, there should not
be any encoding and decoding to CIELAB. The PDF content will not include
an ICC profile but will set the color space to \Lab. In this case, we use
our seticc_lab operation to install the LAB to LAB profile, but we detect
that we did that through the use of the is_lab flag in the profile descriptor.
When then avoid the CIELAB encode and decode */
if (picc_profile->data_cs == gsCIELAB) {
/* If the input space to this profile is CIELAB, then we need to adjust the limits */
/* See ICC spec ICC.1:2004-10 Section 6.3.4.2 and 6.4. I don't believe we need to
worry about CIEXYZ profiles or any of the other odds ones. Need to check that though
at some point. */
picc_profile->Range.ranges[0].rmin = 0.0;
picc_profile->Range.ranges[0].rmax = 100.0;
picc_profile->Range.ranges[1].rmin = -128.0;
picc_profile->Range.ranges[1].rmax = 127.0;
picc_profile->Range.ranges[2].rmin = -128.0;
picc_profile->Range.ranges[2].rmax = 127.0;
picc_profile->islab = true;
} else {
for (i = 0; i < ncomps; i++) {
picc_profile->Range.ranges[i].rmin = range_buff[2 * i];
picc_profile->Range.ranges[i].rmax = range_buff[2 * i + 1];
}
}
/* Now see if we are in an overide situation. We have to wait until now
in case this is an LAB profile which we will not overide */
if (gs_currentoverrideicc(pis) && picc_profile->data_cs != gsCIELAB) {
/* Free up the profile structure */
switch( picc_profile->data_cs ) {
case gsRGB:
pcs->cmm_icc_profile_data = pis->icc_manager->default_rgb;
break;
case gsGRAY:
pcs->cmm_icc_profile_data = pis->icc_manager->default_gray;
break;
case gsCMYK:
pcs->cmm_icc_profile_data = pis->icc_manager->default_cmyk;
break;
default:
break;
}
/* Have one increment from the color space. Having these tied
together is not really correct. Need to fix that. ToDo. MJV */
rc_adjust(picc_profile, -2, "seticc");
rc_increment(pcs->cmm_icc_profile_data);
}
/* Set the color space. We are done. No joint cache here... */
code = gs_setcolorspace(igs, pcs);
/* The context has taken a reference to the colorspace. We no longer need
* ours, so drop it. */
rc_decrement_only(pcs, "seticc");
/* In this case, we already have a ref count of 2 on the icc profile
one for when it was created and one for when it was set. We really
only want one here so adjust */
rc_decrement(picc_profile,"seticc");
/* Remove the ICC dict from the stack */
pop(1);
return code;
}
/* Allocation d'une zone mémoire de taille
* size initialement libre
*
* @param unsigned long size: taille de bloc souhaitée
*
* @ret pointeur vers la zone mémoire allouée (de taille réelle real_size)
* @ret (void *) 0 en cas d'erreur ou s'il n'existe
* plus de d'emplacement libre de taille size
*/
void *mem_alloc(unsigned long size) {
free_zone_t *senti = (free_zone_t *) mem_free_zone;
free_zone_t *prev = (free_zone_t *) mem_free_zone;
/* Vérification de la validité de la taille
* Ainsi que de la mémoire libre */
if ( mem_free_zone == NULL || size <= 0 ) {
return (void *) 0;
}
/* mem_heap est non nul à partir d'ici */
/* Calcul de la taille réelle du bloc à allouer */
unsigned long real_size = r_size(size);
/* Recherche de la première zone mémoire de taille suffisante si existante */
/* Vérification du premier bloc */
if ( senti->size < real_size ) {
senti = senti->next;
}
/* Recherche du premier bloc libre qui convient
Si le bloc a une taille strictement supérieure à real_size
Il faut qu'il reste au moins sizeof(free_zone_t) */
while ( senti != mem_free_zone && not_ok((void *) senti, real_size) ) {
senti = senti->next;
}
/* Allocation de la totalité d'un bloc */
if ( senti->size == real_size ) {
/* Affectation de la totalité du heap restant */
if ( senti->next == senti ) {
mem_free_zone = NULL;
} else {
/* rechaînage de la dernière zone vers mem_heap */
mem_free_zone = (void *) (senti->next);
prev = senti->next;
/* recherche de la dernière zone libre */
while ( prev->next != senti ) {
prev = prev->next;
}
/* rechainage */
prev->next = (free_zone_t *) mem_free_zone;
}
return (void *) senti;
} else if ( senti->size > real_size ) {
/* Allocation du dernier bloc restant */
if ( senti->next == senti ) {
mem_free_zone = (char *) senti + real_size;
((free_zone_t *) mem_free_zone)->size = (senti->size - real_size);
((free_zone_t *) mem_free_zone)->next = (free_zone_t *) mem_free_zone;
} else {
/* rechaînage de la dernière zone vers mem_heap */
prev = senti->next;
/* recherche de la dernière zone libre */
while ( prev->next != senti ) {
prev = prev->next;
}
/* rechaînage & modification du bloc partiellement alloué */
prev->next = (free_zone_t *) ( (char *) senti + real_size);
prev = senti;
senti = (free_zone_t *) ( (char *) senti + real_size);
senti->size = prev->size - real_size;
senti->next = prev->next;
senti = prev;
}
return (void *) senti;
} else {
/* Aucun bloc ne convient */
return (void *) 0;
}
}