void add_implicit_placeholders(Term* forTerm)
{
Branch* contents = nested_contents(forTerm);
std::string listName = forTerm->input(0)->name;
Term* iterator = for_loop_get_iterator(contents);
std::string iteratorName = iterator->name;
std::vector<std::string> reboundNames;
list_names_that_this_branch_rebinds(contents, reboundNames);
int inputIndex = 1;
for (size_t i=0; i < reboundNames.size(); i++) {
std::string const& name = reboundNames[i];
if (name == listName)
continue;
if (name == iteratorName)
continue;
Term* original = find_name_at(forTerm, name.c_str());
// The name might not be found, for certain parser errors.
if (original == NULL)
continue;
Term* result = contents->get(name);
// Create input_placeholder
Term* input = apply(contents, FUNCS.input, TermList(), name_from_string(name));
Type* type = find_common_type(original->type, result->type);
change_declared_type(input, type);
contents->move(input, inputIndex);
set_input(forTerm, inputIndex, original);
// Repoint terms to use our new input_placeholder
for (BranchIterator it(contents); it.unfinished(); it.advance())
remap_pointers_quick(*it, original, input);
// Create output_placeholder
Term* term = apply(contents, FUNCS.output, TermList(result), name_from_string(name));
// Move output into the correct output slot
contents->move(term, contents->length() - 1 - inputIndex);
inputIndex++;
}
}
void setup_type(Type* type)
{
type->name = name_from_string("null");
type->toString = toString;
type->formatSource = formatSource;
type->getField = getField;
}
Name
TokenStream::consumeName(int match)
{
Name value = name_from_string(nextStr().c_str());
consume(match);
return value;
}
Term* start_building_for_loop(Term* forTerm, const char* iteratorName, Type* iteratorType)
{
Branch* contents = nested_contents(forTerm);
// Add input placeholder for the list input
Term* listInput = apply(contents, FUNCS.input, TermList());
// Add loop_index()
Term* index = apply(contents, FUNCS.loop_index, TermList(listInput));
hide_from_source(index);
// Add get_index to fetch the list's current element.
Term* iterator = apply(contents, FUNCS.get_index, TermList(listInput, index),
name_from_string(iteratorName));
if (iteratorType == NULL)
iteratorType = infer_type_of_get_index(forTerm->input(0));
change_declared_type(iterator, iteratorType);
hide_from_source(iterator);
// Add the zero branch
create_branch_unevaluated(contents, "#zero");
// Add an loop output index
Term* loopOutputIndex = apply(contents, FUNCS.loop_output_index, TermList());
return iterator;
}
void setup_type(Type* type)
{
if (type->name == name_None)
type->name = name_from_string("opaque_pointer");
type->storageType = STORAGE_TYPE_OPAQUE_POINTER;
type->toString = toString;
type->hashFunc = common_type_callbacks::shallow_hash_func;
}
/* <string> cvn <name> */
static int
zcvn(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
check_read_type(*op, t_string);
return name_from_string(imemory, op, op);
}
Type* create_typed_unsized_list_type(Type* elementType)
{
Type* type = create_type();
list_t::setup_type(type);
set_type(&type->parameter, elementType);
std::string name = std::string("List<") + name_to_string(elementType->name) + ">";
type->name = name_from_string(name.c_str());
return type;
}
void setup_type(Type* type)
{
reset_type(type);
type->name = name_from_string("int");
type->storageType = STORAGE_TYPE_INT;
type->reset = reset;
type->equals = equals;
type->hashFunc = hashFunc;
type->toString = to_string;
type->formatSource = format_source;
}
/*
* DeviceN and NChannel color spaces can have an attributes dict. In the
* attribute dict can be a Colorants dict which contains Separation color
* spaces. If the Colorant dict is present, the PS logic will build each of
* the Separation color spaces in a temp gstate and then call this procedure
* to attach the Separation color space to the DeviceN color space.
* The parameter to this procedure is a colorant name. The Separation
* color space is in the current (temp) gstate. The DeviceN color space is
* in the next gstate down in the gstate list (pgs->saved).
*/
static int
zattachdevicenattributespace(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_separation_name sep_name;
int code;
/* Pick up the names of the component */
switch (r_type(op)) {
case t_string:
code = name_from_string(imemory, op, op);
if (code < 0)
return code;
/* falls through */
case t_name:
sep_name = name_index(imemory, op);
break;
default:
return_error(e_typecheck);
}
code = gs_attachattributecolorspace(sep_name, igs);
pop(1);
return code;
}
void setup_type(Type* type)
{
type->name = name_from_string("void");
type->cast = cast;
type->toString = to_string;
}
/* 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;
}
/*
* 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;
}
/* The current color space is the alternate space for the DeviceN space. */
static int
zsetdevicenspace(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const ref *pcsa;
gs_separation_name *names;
gs_device_n_map *pmap;
uint num_components;
gs_color_space *pcs;
gs_color_space *pacs;
ref_colorspace cspace_old;
gs_function_t *pfn;
int code;
/* Verify that we have an array as our input parameter */
check_read_type(*op, t_array);
if (r_size(op) < 4 || r_size(op) > 5)
return_error(e_rangecheck);
/* pcsa is a pointer to the color names array (element 1 in input array) */
pcsa = op->value.const_refs + 1;
if (!r_is_array(pcsa))
return_error(e_typecheck);
num_components = r_size(pcsa);
if (num_components == 0)
return_error(e_rangecheck);
if (num_components > GS_CLIENT_COLOR_MAX_COMPONENTS)
return_error(e_limitcheck);
/* Check tint transform procedure. Note: Cheap trick to get pointer to it.
The tint transform procedure is element 3 in the input array */
check_proc(pcsa[2]);
/* The alternate color space has been selected as the current color space */
pacs = gs_currentcolorspace(igs);
code = gs_cspace_new_DeviceN(&pcs, num_components, pacs, imemory);
if (code < 0)
return code;
names = pcs->params.device_n.names;
pmap = pcs->params.device_n.map;
pcs->params.device_n.get_colorname_string = gs_get_colorname_string;
/* Pick up the names of the components */
{
uint i;
ref sname;
for (i = 0; i < num_components; ++i) {
array_get(imemory, pcsa, (long)i, &sname);
switch (r_type(&sname)) {
case t_string:
code = name_from_string(imemory, &sname, &sname);
if (code < 0) {
rc_decrement(pcs, ".setdevicenspace");
return code;
}
/* falls through */
case t_name:
names[i] = name_index(imemory, &sname);
break;
default:
rc_decrement(pcs, ".setdevicenspace");
return_error(e_typecheck);
}
}
}
/* Now set the current color space as DeviceN */
cspace_old = istate->colorspace;
/*
* pcsa is a pointer to element 1 (2nd element) in the DeviceN
* description array. Thus pcsa[2] is element #3 (4th element)
* which is the tint transform.
*/
istate->colorspace.procs.special.device_n.layer_names = pcsa[0];
istate->colorspace.procs.special.device_n.tint_transform = pcsa[2];
pfn = ref_function(pcsa + 2); /* See comment above */
if (!pfn)
code = gs_note_error(e_rangecheck);
if (code < 0) {
istate->colorspace = cspace_old;
rc_decrement_only(pcs, "zsetdevicenspace");
return code;
}
gs_cspace_set_devn_function(pcs, pfn);
code = gs_setcolorspace(igs, pcs);
/* release reference from construction */
rc_decrement_only(pcs, "zsetdevicenspace");
if (code < 0) {
istate->colorspace = cspace_old;
return code;
}
pop(1);
return 0;
}
Branch* load_module_from_file(const char* module_name, const char* filename)
{
Term* import = apply(kernel(), FUNCS.imported_file, TermList(), name_from_string(module_name));
load_script(nested_contents(import), filename);
return nested_contents(import);
}
