/*
* Swap an entry from a higher level dictionary into a base dictionary.
* elt[0] is the key, elt[1] is the current value in the Level 2 dictionary
* (*pdict2).
*/
static int
swap_entry(i_ctx_t *i_ctx_p, ref elt[2], ref * pdict, ref * pdict2)
{
ref *pvalue;
#ifdef PACIFY_VALGRIND
ref old_value = { 0 }; /* current value in *pdict */
#else
ref old_value; /* current value in *pdict */
#endif
int found = dict_find(pdict, &elt[0], &pvalue);
switch (found) {
default: /* <0, error */
/*
* The only possible error here is a dictfull error, which is
* harmless.
*/
/* fall through */
case 0: /* missing */
make_null(&old_value);
break;
case 1: /* present */
old_value = *pvalue;
}
/*
* Temporarily flag the dictionaries as local, so that we don't
* get invalidaccess errors. (We know that they are both
* referenced from systemdict, so they are allowed to reference
* local objects even if they are global.)
*/
{
uint space2 = r_space(pdict2);
int code;
r_set_space(pdict2, avm_local);
idict_put(pdict2, &elt[0], &old_value);
if (r_has_type(&elt[1], t_null)) {
code = idict_undef(pdict, &elt[0]);
if (code == gs_error_undefined &&
r_has_type(&old_value, t_null)
)
code = 0;
} else {
uint space = r_space(pdict);
r_set_space(pdict, avm_local);
code = idict_put(pdict, &elt[0], &elt[1]);
r_set_space(pdict, space);
}
r_set_space(pdict2, space2);
return code;
}
}
/* Create a dictionary using the given allocator. */
int
dict_alloc(gs_ref_memory_t * mem, uint size, ref * pdref)
{
ref arr;
int code =
gs_alloc_ref_array(mem, &arr, a_all, sizeof(dict) / sizeof(ref),
"dict_alloc");
dict *pdict;
ref dref;
if (code < 0)
return code;
pdict = (dict *) arr.value.refs;
make_tav(&dref, t_dictionary,
r_space(&arr) | imemory_new_mask(mem) | a_all,
pdict, pdict);
make_struct(&pdict->memory, avm_foreign, mem);
code = dict_create_contents(size, &dref, dict_default_pack);
if (code < 0) {
gs_free_ref_array(mem, &arr, "dict_alloc");
return code;
}
*pdref = dref;
return 0;
}
/* <source> <dict> /JBIG2Decode <file> */
static int
z_jbig2decode(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
ref *sop = NULL;
s_jbig2_global_data_t *gref;
stream_jbig2decode_state state;
/* Extract the global context reference, if any, from the parameter
dictionary and embed it in our stream state. The original object
ref is under the JBIG2Globals key.
We expect the postscript code to resolve this and call
z_jbig2makeglobalctx() below to create an astruct wrapping the
global decoder data and store it under the .jbig2globalctx key
*/
s_jbig2decode_set_global_data((stream_state*)&state, NULL);
if (r_has_type(op, t_dictionary)) {
check_dict_read(*op);
if ( dict_find_string(op, ".jbig2globalctx", &sop) > 0) {
gref = r_ptr(sop, s_jbig2_global_data_t);
s_jbig2decode_set_global_data((stream_state*)&state, gref);
}
}
/* we pass npop=0, since we've no arguments left to consume */
return filter_read(i_ctx_p, 0, &s_jbig2decode_template,
(stream_state *) & state, (sop ? r_space(sop) : 0));
}
/* <gstate> currentgstate <gstate> */
int
zcurrentgstate(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_state *pgs;
int_gstate *pistate;
int code;
gs_memory_t *mem;
check_stype(*op, st_igstate_obj);
check_write(*op);
code = gstate_unshare(i_ctx_p);
if (code < 0)
return code;
pgs = igstate_ptr(op);
pistate = gs_int_gstate(pgs);
code = gstate_check_space(i_ctx_p, istate, r_space(op));
if (code < 0)
return code;
#define gsref_save(p) ref_save(op, p, "currentgstate")
int_gstate_map_refs(pistate, gsref_save);
#undef gsref_save
mem = gs_state_swap_memory(pgs, imemory);
code = gs_currentgstate(pgs, igs);
gs_state_swap_memory(pgs, mem);
if (code < 0)
return code;
int_gstate_map_refs(pistate, ref_mark_new);
return 0;
}
/* <any> .systemvmcheck <bool> */
static int
zsystemvmcheck(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
make_bool(op, (r_space(op) == avm_system ? true : false));
return 0;
}
bool start_planning()
{
//std::vector<double> start_Config;
//std::vector<double> goal_Config;
ob::PathPtr path;
//Construct the robot state space
ob::StateSpacePtr r_space(new ob::RealVectorStateSpace(motoman_arm_DOF)) ;
ob::RealVectorBounds Joint_bounds(motoman_arm_DOF) ;
//Joint bounds
setStateSpaceLimits(Joint_bounds) ;
r_space->as<ob::RealVectorStateSpace>()->setBounds(Joint_bounds);
//Setup sample space
ob::SpaceInformationPtr sample_si(new ob::SpaceInformation(r_space)) ;
//Setup Validity Checker
ValidityChecker checker(sample_si) ;
ompl::base::StateValidityCheckerPtr validity_checker(&checker, dealocate_StateValidityChecker_fn);
sample_si->setStateValidityChecker(validity_checker);
sample_si->setStateValidityCheckingResolution(0.03); // 3%
sample_si->setup();
//Set start and end state
ob::ScopedState<> start_state = SetStateConfig(start_Config,sample_si) ;
start_state.print(std::cout) ;
ob::ScopedState<> goal_state= SetStateConfig(goal_Config,sample_si) ;
goal_state.print(std::cout) ;
//Create Problem Definition
ob::ProblemDefinitionPtr pdef(new ob::ProblemDefinition(sample_si)) ;
pdef->setStartAndGoalStates(start_state,goal_state) ;
//Make the planner
ob::PlannerPtr planner(new og::RRTstar(sample_si)) ;
planner->setProblemDefinition(pdef) ;
planner->setup() ;
//Planning
ob::PlannerStatus solved = planner->solve(planning_time) ;
if(solved)
{
//Generate the path
path = pdef->getSolutionPath() ;
std::cout<< "Path Found" << std::endl ;
path->print(std::cout) ;
return true ;
}
else
{
std::cout << "Can't find solution" << std::endl ;
return false ;
}
}
/* The caller guarantees that *op is a dictionary. */
int
build_gs_sub_font(i_ctx_t *i_ctx_p, const ref *op, gs_font **ppfont,
font_type ftype, gs_memory_type_ptr_t pstype,
const build_proc_refs * pbuild, const ref *pencoding,
ref *fid_op)
{
gs_matrix mat, omat;
ref fname; /* t_string */
gs_font *pfont;
font_data *pdata;
/*
* Make sure that we allocate the font data
* in the same VM as the font dictionary.
*/
uint space = ialloc_space(idmemory);
int code = sub_font_params(imemory, op, &mat, &omat, &fname);
if (code < 0)
return code;
ialloc_set_space(idmemory, r_space(op));
pfont = gs_font_alloc(imemory, pstype, &gs_font_procs_default, NULL,
"buildfont(font)");
pdata = ialloc_struct(font_data, &st_font_data,
"buildfont(data)");
if (pfont == 0 || pdata == 0)
code = gs_note_error(e_VMerror);
else if (fid_op)
code = add_FID(i_ctx_p, fid_op, pfont, iimemory);
if (code < 0) {
ifree_object(pdata, "buildfont(data)");
ifree_object(pfont, "buildfont(font)");
ialloc_set_space(idmemory, space);
return code;
}
refset_null((ref *) pdata, sizeof(font_data) / sizeof(ref));
ref_assign_new(&pdata->dict, op);
ref_assign_new(&pdata->BuildChar, &pbuild->BuildChar);
ref_assign_new(&pdata->BuildGlyph, &pbuild->BuildGlyph);
if (pencoding)
ref_assign_new(&pdata->Encoding, pencoding);
pfont->client_data = pdata;
pfont->FontType = ftype;
pfont->FontMatrix = mat;
pfont->orig_FontMatrix = omat;
pfont->BitmapWidths = false;
pfont->ExactSize = fbit_use_bitmaps;
pfont->InBetweenSize = fbit_use_outlines;
pfont->TransformedChar = fbit_use_outlines;
pfont->WMode = 0;
pfont->procs.encode_char = zfont_encode_char;
pfont->procs.glyph_name = zfont_glyph_name;
ialloc_set_space(idmemory, space);
copy_font_name(&pfont->font_name, &fname);
*ppfont = pfont;
return 0;
}
/* Make a transformed font (common code for makefont/scalefont). */
static int
make_font(i_ctx_t *i_ctx_p, const gs_matrix * pmat)
{
os_ptr op = osp;
os_ptr fp = op - 1;
gs_font *oldfont, *newfont;
int code;
ref *pencoding = 0;
code = font_param(fp, &oldfont);
if (code < 0)
return code;
{
uint space = ialloc_space(idmemory);
ialloc_set_space(idmemory, r_space(fp));
if (dict_find_string(fp, "Encoding", &pencoding) > 0 &&
!r_is_array(pencoding)
)
code = gs_note_error(e_invalidfont);
else {
/*
* Temporarily substitute the new dictionary
* for the old one, in case the Encoding changed.
*/
ref olddict;
olddict = *pfont_dict(oldfont);
*pfont_dict(oldfont) = *fp;
code = gs_makefont(ifont_dir, oldfont, pmat, &newfont);
*pfont_dict(oldfont) = olddict;
}
ialloc_set_space(idmemory, space);
}
if (code < 0)
return code;
/*
* We have to allow for the possibility that the font's Encoding
* is different from that of the base font. Note that the
* font_data of the new font was simply copied from the old one.
*/
if (pencoding != 0 &&
!obj_eq(imemory, pencoding, &pfont_data(newfont)->Encoding)
) {
if (newfont->FontType == ft_composite)
return_error(e_rangecheck);
/* We should really do validity checking here.... */
ref_assign(&pfont_data(newfont)->Encoding, pencoding);
lookup_gs_simple_font_encoding((gs_font_base *) newfont);
}
*fp = *pfont_dict(newfont);
pop(1);
return 0;
}
/* <source> DCTDecode/filter <file> */
static int
zDCTD(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_memory_t *mem;
stream_DCT_state state;
dict_param_list list;
jpeg_decompress_data *jddp;
int code;
const ref *dop;
uint dspace;
if (r_has_type(op, t_dictionary))
dop = op, dspace = r_space(op);
else
dop = 0, dspace = 0;
mem = (gs_memory_t *)find_stream_memory(i_ctx_p, 0, &dspace);
state.memory = mem;
/* First allocate space for IJG parameters. */
jddp = gs_alloc_struct_immovable(mem,jpeg_decompress_data,
&st_jpeg_decompress_data, "zDCTD");
if (jddp == 0)
return_error(e_VMerror);
if (s_DCTD_template.set_defaults)
(*s_DCTD_template.set_defaults) ((stream_state *) & state);
state.data.decompress = jddp;
jddp->memory = state.jpeg_memory = mem; /* set now for allocation */
jddp->scanline_buffer = NULL; /* set this early for safe error exit */
state.report_error = filter_report_error; /* in case create fails */
if ((code = gs_jpeg_create_decompress(&state)) < 0)
goto fail; /* correct to do jpeg_destroy here */
/* Read parameters from dictionary */
if ((code = dict_param_list_read(&list, dop, NULL, false, iimemory)) < 0)
goto fail;
if ((code = s_DCTD_put_params((gs_param_list *) & list, &state)) < 0)
goto rel;
/* Create the filter. */
jddp->templat = s_DCTD_template;
code = filter_read(i_ctx_p, 0, &jddp->templat,
(stream_state *) & state, dspace);
if (code >= 0) /* Success! */
return code;
/*
* We assume that if filter_read fails, the stream has not been
* registered for closing, so s_DCTD_release will never be called.
* Therefore we free the allocated memory before failing.
*/
rel:
iparam_list_release(&list);
fail:
gs_jpeg_destroy(&state);
gs_free_object(mem, jddp, "zDCTD fail");
return code;
}
/*
* This forces a "put" even if the object is not writable, and (if the
* object is systemdict or the save level is 0) even if the value is in
* local VM. It is meant to be used only for replacing the value of
* FontDirectory in systemdict when switching between local and global VM,
* and a few similar applications. After initialization, this operator
* should no longer be accessible by name.
*/
static int
zforceput(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr op1 = op - 1;
os_ptr op2 = op - 2;
int code;
switch (r_type(op2)) {
case t_array:
check_int_ltu(*op1, r_size(op2));
if (r_space(op2) > r_space(op)) {
if (imemory_save_level(iimemory))
return_error(e_invalidaccess);
}
{
ref *eltp = op2->value.refs + (uint) op1->value.intval;
ref_assign_old(op2, eltp, op, "put");
}
break;
case t_dictionary:
if (op2->value.pdict == systemdict->value.pdict ||
!imemory_save_level(iimemory)
) {
uint space = r_space(op2);
r_set_space(op2, avm_local);
code = idict_put(op2, op1, op);
r_set_space(op2, space);
} else
code = idict_put(op2, op1, op);
if (code < 0)
return code;
break;
default:
return_error(e_typecheck);
}
pop(3);
return 0;
}
/* <names> .installsystemnames - */
static int
zinstallsystemnames(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
if (r_space(op) != avm_global || imemory_save_level(iimemory_global) != 0)
return_error(gs_error_invalidaccess);
check_read_type(*op, t_shortarray);
ref_assign_old(NULL, system_names_p, op, ".installsystemnames");
pop(1);
return 0;
}
int
cie_cache_joint(i_ctx_t *i_ctx_p, const ref_cie_render_procs * pcrprocs,
const gs_cie_common *pcie, gs_state * pgs)
{
const gs_cie_render *pcrd = gs_currentcolorrendering(pgs);
gx_cie_joint_caches *pjc = gx_unshare_cie_caches(pgs);
gs_ref_memory_t *imem = (gs_ref_memory_t *) gs_state_memory(pgs);
ref pqr_procs;
uint space;
int code;
int i;
if (pcrd == 0) /* cache is not set up yet */
return 0;
if (pjc == 0) /* must already be allocated */
return_error(e_VMerror);
if (r_has_type(&pcrprocs->TransformPQR, t_null)) {
/*
* This CRD came from a driver, not from a PostScript dictionary.
* Resample TransformPQR in C code.
*/
return gs_cie_cs_complete(pgs, true);
}
gs_cie_compute_points_sd(pjc, pcie, pcrd);
code = ialloc_ref_array(&pqr_procs, a_readonly, 3 * (1 + 4 + 4 * 6),
"cie_cache_common");
if (code < 0)
return code;
/* When we're done, deallocate the procs and complete the caches. */
check_estack(3);
cie_cache_push_finish(i_ctx_p, cie_tpqr_finish, imem, pgs);
*++esp = pqr_procs;
space = r_space(&pqr_procs);
for (i = 0; i < 3; i++) {
ref *p = pqr_procs.value.refs + 3 + (4 + 4 * 6) * i;
const float *ppt = (float *)&pjc->points_sd;
int j;
make_array(pqr_procs.value.refs + i, a_readonly | a_executable | space,
4, p);
make_array(p, a_readonly | space, 4 * 6, p + 4);
p[1] = pcrprocs->TransformPQR.value.refs[i];
make_oper(p + 2, 0, cie_exec_tpqr);
make_oper(p + 3, 0, cie_post_exec_tpqr);
for (j = 0, p += 4; j < 4 * 6; j++, p++, ppt++)
make_real(p, *ppt);
}
return cie_prepare_cache3(i_ctx_p, &pcrd->RangePQR,
pqr_procs.value.const_refs,
pjc->TransformPQR.caches,
pjc, imem, "Transform.PQR");
}
/* Find the memory that will be used for allocating the stream. */
static gs_ref_memory_t *
find_stream_memory(i_ctx_t *i_ctx_p, int npop, uint *space)
{
uint use_space = max(*space, avm_global);
os_ptr sop = osp - npop;
if (r_has_type(sop, t_dictionary)) {
--sop;
}
*space = max(use_space, r_space(sop));
return idmemory->spaces_indexed[*space >> r_space_shift];
}
static int
dict_copy_elements(const ref * pdrfrom /* t_dictionary */ ,
ref * pdrto /* t_dictionary */ , int options,
dict_stack_t *pds)
{
int space = r_space(pdrto);
int index;
ref elt[2];
ref *pvslot;
int code;
if (space != avm_max) {
/* Do the store check before starting the copy. */
index = dict_first(pdrfrom);
while ((index = dict_next(pdrfrom, index, elt)) >= 0)
if (!(options & COPY_NEW_ONLY) ||
dict_find(pdrto, &elt[0], &pvslot) <= 0
) {
store_check_space(space, &elt[0]);
store_check_space(space, &elt[1]);
}
}
/* Now copy the contents. */
index = dict_first(pdrfrom);
while ((index = dict_next(pdrfrom, index, elt)) >= 0) {
ref *pvalue = pv_no_defn;
if ((options & COPY_NEW_ONLY) &&
dict_find(pdrto, &elt[0], &pvslot) > 0
)
continue;
if ((options & COPY_FOR_RESIZE) &&
r_has_type(&elt[0], t_name) &&
(pvalue = elt[0].value.pname->pvalue, pv_valid(pvalue))
)
elt[0].value.pname->pvalue = pv_no_defn;
if ((code = dict_put(pdrto, &elt[0], &elt[1], pds)) < 0) {
/*
* If COPY_FOR_RESIZE is set, the dict_put isn't supposed to
* be able to fail, but we don't want to depend on this.
*/
if (pvalue != pv_no_defn)
elt[0].value.pname->pvalue = pvalue;
return code;
}
}
return 0;
}
/* the VM space where the dictionary is allocated. */
static int
dict_create_contents(uint size, const ref * pdref, bool pack)
{
dict *pdict = pdref->value.pdict;
gs_ref_memory_t *mem = dict_memory(pdict);
uint new_mask = imemory_new_mask(mem);
uint asize = dict_round_size((size == 0 ? 1 : size));
int code;
register uint i;
if (asize == 0 || asize > max_array_size - 1) /* too large */
return_error(gs_error_limitcheck);
asize++; /* allow room for wraparound entry */
code = gs_alloc_ref_array(mem, &pdict->values, a_all, asize,
"dict_create_contents(values)");
if (code < 0)
return code;
r_set_attrs(&pdict->values, new_mask);
refset_null_new(pdict->values.value.refs, asize, new_mask);
if (pack) {
uint ksize = (asize + packed_per_ref - 1) / packed_per_ref;
ref arr;
ref_packed *pkp;
ref_packed *pzp;
code = gs_alloc_ref_array(mem, &arr, a_all, ksize,
"dict_create_contents(packed keys)");
if (code < 0)
return code;
pkp = (ref_packed *) arr.value.refs;
make_tasv(&pdict->keys, t_shortarray,
r_space(&arr) | a_all | new_mask,
asize, packed, pkp);
for (pzp = pkp, i = 0; i < asize || i % packed_per_ref; pzp++, i++)
*pzp = packed_key_empty;
*pkp = packed_key_deleted; /* wraparound entry */
} else { /* not packed */
int code = dict_create_unpacked_keys(asize, pdref);
if (code < 0)
return code;
}
make_tav(&pdict->count, t_integer, new_mask, intval, 0);
make_tav(&pdict->maxlength, t_integer, new_mask, intval, size);
return 0;
}
/* Copy refs from one place to another. */
int
refcpy_to_old(ref * aref, uint index, const ref * from,
uint size, gs_dual_memory_t *idmemory, client_name_t cname)
{
ref *to = aref->value.refs + index;
int code = refs_check_space(from, size, r_space(aref));
if (code < 0)
return code;
/* We have to worry about aliasing.... */
if (to <= from || from + size <= to)
while (size--)
ref_assign_old(aref, to, from, cname), to++, from++;
else
for (from += size, to += size; size--;)
from--, to--, ref_assign_old(aref, to, from, cname);
return 0;
}
/* v [ws wd bs bd] proc -> -mark- ws wd bs bd v proc + exec */
static int
cie_exec_tpqr(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const ref *ppt = op[-1].value.const_refs;
uint space = r_space(op - 1);
int i;
check_op(3);
push(4);
*op = op[-4]; /* proc */
op[-1] = op[-6]; /* v */
for (i = 0; i < 4; i++)
make_const_array(op - 5 + i, a_readonly | space,
6, ppt + i * 6);
make_mark(op - 6);
return zexec(i_ctx_p);
}
/* The caller guarantees that *op is a dictionary. */
int
build_gs_simple_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font_base ** ppfont,
font_type ftype, gs_memory_type_ptr_t pstype,
const build_proc_refs * pbuild,
build_font_options_t options)
{
double bbox[4];
gs_uid uid;
int code;
gs_font_base *pfont;
uint space = ialloc_space(idmemory);
code = font_bbox_param(imemory, op, bbox);
if (code < 0)
return code;
/*
* Make sure that we allocate uid
* in the same VM as the font dictionary
* (see build_gs_sub_font).
*/
ialloc_set_space(idmemory, r_space(op));
code = dict_uid_param(op, &uid, 0, imemory, i_ctx_p);
ialloc_set_space(idmemory, space);
if (code < 0)
return code;
if ((options & bf_UniqueID_ignored) && uid_is_UniqueID(&uid))
uid_set_invalid(&uid);
code = build_gs_font(i_ctx_p, op, (gs_font **) ppfont, ftype, pstype,
pbuild, options);
if (code != 0) /* invalid or scaled font */
return code;
pfont = *ppfont;
pfont->procs.init_fstack = gs_default_init_fstack;
pfont->procs.define_font = gs_no_define_font;
pfont->procs.decode_glyph = gs_font_map_glyph_to_unicode;
pfont->procs.make_font = zbase_make_font;
pfont->procs.next_char_glyph = gs_default_next_char_glyph;
pfont->FAPI = 0;
pfont->FAPI_font_data = 0;
init_gs_simple_font(pfont, bbox, &uid);
lookup_gs_simple_font_encoding(pfont);
get_GlyphNames2Unicode(i_ctx_p, (gs_font *)pfont, op);
return 0;
}
/* <name> <proc> .makeoperator <oper> */
static int
zmakeoperator(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
op_array_table *opt;
uint count;
ref *tab;
check_type(op[-1], t_name);
check_proc(*op);
switch (r_space(op)) {
case avm_global:
opt = &i_ctx_p->op_array_table_global;
break;
case avm_local:
opt = &i_ctx_p->op_array_table_local;
break;
default:
return_error(e_invalidaccess);
}
count = opt->count;
tab = opt->table.value.refs;
/*
* restore doesn't reset op_array_table.count, but it does
* remove entries from op_array_table.table. Since we fill
* the table in order, we can detect that a restore has occurred
* by checking whether what should be the most recent entry
* is occupied. If not, we scan backwards over the vacated entries
* to find the true end of the table.
*/
while (count > 0 && r_has_type(&tab[count - 1], t_null))
--count;
if (count == r_size(&opt->table))
return_error(e_limitcheck);
ref_assign_old(&opt->table, &tab[count], op, "makeoperator");
opt->nx_table[count] = name_index(imemory, op - 1);
op_index_ref(imemory, opt->base_index + count, op - 1);
opt->count = count + 1;
pop(1);
return 0;
}
/* <dict> .initialize_dsc_parser - */
static int
zinitialize_dsc_parser(i_ctx_t *i_ctx_p)
{
ref local_ref;
int code;
os_ptr const op = osp;
dict * const pdict = op->value.pdict;
gs_memory_t * const mem = (gs_memory_t *)dict_memory(pdict);
dsc_data_t * const data =
gs_alloc_struct(mem, dsc_data_t, &st_dsc_data_t,
"DSC parser init");
data->dsc_data_ptr = dsc_init((void *) "Ghostscript DSC parsing");
if (!data->dsc_data_ptr)
return_error(e_VMerror);
dsc_set_error_function(data->dsc_data_ptr, dsc_error_handler);
make_astruct(&local_ref, a_readonly | r_space(op), (byte *) data);
code = idict_put_string(op, dsc_dict_name, &local_ref);
if (code >= 0)
pop(1);
return code;
}
/* Get ColorRenderingType 1 procedures from the PostScript dictionary. */
static int
zcrd1_proc_params(const gs_memory_t *mem,
os_ptr op, ref_cie_render_procs * pcprocs)
{
int code;
ref *pRT;
code = dict_proc3_param(mem, op, "EncodeLMN", &pcprocs->EncodeLMN);
if (code < 0)
return code;
code = dict_proc3_param(mem, op, "EncodeABC", &pcprocs->EncodeABC);
if (code < 0)
return code;
code = dict_proc3_param(mem, op, "TransformPQR", &pcprocs->TransformPQR);
if (code < 0)
return code;
if (code == 1)
return gs_note_error(e_undefined);
if (dict_find_string(op, "RenderTable", &pRT) > 0) {
const ref *prte;
int size;
int i;
check_read_type(*pRT, t_array);
size = r_size(pRT);
if (size < 5)
return_error(e_rangecheck);
prte = pRT->value.const_refs;
for (i = 5; i < size; i++)
check_proc_only(prte[i]);
make_const_array(&pcprocs->RenderTableT, a_readonly | r_space(pRT),
size - 5, prte + 5);
} else
make_null(&pcprocs->RenderTableT);
return 0;
}
/* copy for gstates */
int
zcopy_gstate(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr op1 = op - 1;
gs_state *pgs;
gs_state *pgs1;
int_gstate *pistate;
gs_memory_t *mem;
int code;
check_stype(*op, st_igstate_obj);
check_stype(*op1, st_igstate_obj);
check_write(*op);
code = gstate_unshare(i_ctx_p);
if (code < 0)
return code;
pgs = igstate_ptr(op);
pgs1 = igstate_ptr(op1);
pistate = gs_int_gstate(pgs);
code = gstate_check_space(i_ctx_p, gs_int_gstate(pgs1), r_space(op));
if (code < 0)
return code;
#define gsref_save(p) ref_save(op, p, "copygstate")
int_gstate_map_refs(pistate, gsref_save);
#undef gsref_save
mem = gs_state_swap_memory(pgs, imemory);
code = gs_copygstate(pgs, pgs1);
gs_state_swap_memory(pgs, mem);
if (code < 0)
return code;
int_gstate_map_refs(pistate, ref_mark_new);
*op1 = *op;
pop(1);
return 0;
}
static int
zreusablestream(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr source_op = op - 1;
long length = max_long;
bool close_source;
int code;
check_type(*op, t_boolean);
close_source = op->value.boolval;
if (r_has_type(source_op, t_string)) {
uint size = r_size(source_op);
check_read(*source_op);
code = make_rss(i_ctx_p, source_op, source_op->value.const_bytes,
size, r_space(source_op), 0L, size, false);
} else if (r_has_type(source_op, t_astruct)) {
uint size = gs_object_size(imemory, source_op->value.pstruct);
if (gs_object_type(imemory, source_op->value.pstruct) != &st_bytes)
return_error(e_rangecheck);
check_read(*source_op);
code = make_rss(i_ctx_p, source_op,
(const byte *)source_op->value.pstruct, size,
r_space(source_op), 0L, size, true);
} else if (r_has_type(source_op, t_array)) { /* no packedarrays */
int i, blk_cnt, blk_sz;
ref *blk_ref;
ulong filelen = 0;
check_read(*source_op);
blk_cnt = r_size(source_op);
blk_ref = source_op->value.refs;
if (blk_cnt > 0) {
blk_sz = r_size(blk_ref);
for (i = 0; i < blk_cnt; i++) {
int len;
check_read_type(blk_ref[i], t_string);
len = r_size(&blk_ref[i]);
if (len > blk_sz || (len < blk_sz && i < blk_cnt - 1))
return_error(e_rangecheck); /* last block can be smaller */
filelen += len;
}
}
if (filelen == 0) {
code = make_rss(i_ctx_p, source_op, (unsigned char *)"", 0,
r_space(source_op), 0, 0, false);
} else {
code = make_aos(i_ctx_p, source_op, blk_sz, r_size(&blk_ref[blk_cnt - 1]), filelen);
}
} else {
long offset = 0;
stream *source;
stream *s;
check_read_file(i_ctx_p, source, source_op);
s = source;
rs:
if (s->cbuf_string.data != 0) { /* string stream */
long pos = stell(s);
long avail = sbufavailable(s) + pos;
offset += pos;
code = make_rss(i_ctx_p, source_op, s->cbuf_string.data,
s->cbuf_string.size,
imemory_space((const gs_ref_memory_t *)s->memory),
offset, min(avail, length), false);
} else if (s->file != 0) { /* file stream */
if (~s->modes & (s_mode_read | s_mode_seek))
return_error(e_ioerror);
code = make_rfs(i_ctx_p, source_op, s, offset + stell(s), length);
} else if (s->state->templat == &s_SFD_template) {
/* SubFileDecode filter */
const stream_SFD_state *const sfd_state =
(const stream_SFD_state *)s->state;
if (sfd_state->eod.size != 0)
return_error(e_rangecheck);
offset += sfd_state->skip_count - sbufavailable(s);
if (sfd_state->count != 0) {
long left = max(sfd_state->count, 0) + sbufavailable(s);
if (left < length)
length = left;
}
s = s->strm;
goto rs;
}
else /* some other kind of stream */
return_error(e_rangecheck);
if (close_source) {
stream *rs = fptr(source_op);
rs->strm = source; /* only for close_source */
rs->close_strm = true;
}
}
if (code >= 0)
pop(1);
return code;
}
/* Resize a dictionary. */
int
dict_resize(ref * pdref, uint new_size, dict_stack_t *pds)
{
dict *pdict = pdref->value.pdict;
gs_ref_memory_t *mem = dict_memory(pdict);
uint new_mask = imemory_new_mask(mem);
ushort orig_attrs = r_type_attrs(&pdict->values) & (a_all | a_executable);
dict dnew;
ref drto;
int code;
if (new_size < d_length(pdict)) {
if (!mem->gs_lib_ctx->dict_auto_expand)
return_error(gs_error_dictfull);
new_size = d_length(pdict);
}
make_tav(&drto, t_dictionary, r_space(pdref) | a_all | new_mask,
pdict, &dnew);
dnew.memory = pdict->memory;
if ((code = dict_create_contents(new_size, &drto, dict_is_packed(pdict))) < 0)
return code;
/*
* We must suppress the store check, in case we are expanding
* systemdict or another global dictionary that is allowed
* to reference local objects.
*/
r_set_space(&drto, avm_local);
/*
* If we are expanding a permanent dictionary, we must make sure that
* dict_put doesn't think this is a second definition for any
* single-definition names. This in turn requires that
* dstack_dict_is_permanent must be true for the second ("to")
* argument of dict_copy_elements, which requires temporarily
* setting *pdref = drto.
*/
if (CAN_SET_PVALUE_CACHE(pds, pdref, mem)) {
ref drfrom;
drfrom = *pdref;
*pdref = drto;
dict_copy_elements(&drfrom, pdref, COPY_FOR_RESIZE, pds);
*pdref = drfrom;
} else {
dict_copy_elements(pdref, &drto, 0, pds);
}
/* Save or free the old dictionary. */
if (ref_must_save_in(mem, &pdict->values))
ref_do_save_in(mem, pdref, &pdict->values, "dict_resize(values)");
else
gs_free_ref_array(mem, &pdict->values, "dict_resize(old values)");
if (ref_must_save_in(mem, &pdict->keys))
ref_do_save_in(mem, pdref, &pdict->keys, "dict_resize(keys)");
else
gs_free_ref_array(mem, &pdict->keys, "dict_resize(old keys)");
ref_assign(&pdict->keys, &dnew.keys);
ref_assign(&pdict->values, &dnew.values);
r_store_attrs(&pdict->values, a_all | a_executable, orig_attrs);
ref_save_in(dict_memory(pdict), pdref, &pdict->maxlength,
"dict_resize(maxlength)");
d_set_maxlength(pdict, new_size);
if (pds)
dstack_set_top(pds); /* just in case this is the top dict */
return 0;
}
/* initialize the dictionaries that hold operator definitions. */
int
obj_init(i_ctx_t **pi_ctx_p, gs_dual_memory_t *idmem)
{
int level = gs_op_language_level();
ref system_dict;
i_ctx_t *i_ctx_p;
int code;
/*
* Create systemdict. The context machinery requires that
* we do this before initializing the interpreter.
*/
code = dict_alloc(idmem->space_global,
(level >= 3 ? SYSTEMDICT_LL3_SIZE :
level >= 2 ? SYSTEMDICT_LEVEL2_SIZE : SYSTEMDICT_SIZE),
&system_dict);
if (code < 0)
return code;
/* Initialize the interpreter. */
code = gs_interp_init(pi_ctx_p, &system_dict, idmem);
if (code < 0)
return code;
i_ctx_p = *pi_ctx_p;
{
#define icount countof(initial_dictionaries)
ref idicts[icount];
int i;
const op_def *const *tptr;
min_dstack_size = MIN_DSTACK_SIZE;
refset_null(idicts, icount);
/* Put systemdict on the dictionary stack. */
if (level >= 2) {
dsp += 2;
/*
* For the moment, let globaldict be an alias for systemdict.
*/
dsp[-1] = system_dict;
min_dstack_size++;
} else {
++dsp;
}
*dsp = system_dict;
/* Create dictionaries which are to be homes for operators. */
for (tptr = op_defs_all; *tptr != 0; tptr++) {
const op_def *def;
for (def = *tptr; def->oname != 0; def++)
if (op_def_is_begin_dict(def)) {
if (make_initial_dict(i_ctx_p, def->oname, idicts) == 0)
return_error(e_VMerror);
}
}
/* Set up the initial dstack. */
for (i = 0; i < countof(initial_dstack); i++) {
const char *dname = initial_dstack[i];
++dsp;
if (!strcmp(dname, "userdict"))
dstack_userdict_index = dsp - dsbot;
ref_assign(dsp, make_initial_dict(i_ctx_p, dname, idicts));
}
/* Enter names of referenced initial dictionaries into systemdict. */
initial_enter_name("systemdict", systemdict);
for (i = 0; i < icount; i++) {
ref *idict = &idicts[i];
if (!r_has_type(idict, t_null)) {
/*
* Note that we enter the dictionary in systemdict
* even if it is in local VM. There is a special
* provision in the garbage collector for this:
* see ivmspace.h for more information.
* In order to do this, we must temporarily
* identify systemdict as local, so that the
* store check in dict_put won't fail.
*/
uint save_space = r_space(systemdict);
r_set_space(systemdict, avm_local);
code = initial_enter_name(initial_dictionaries[i].name,
idict);
r_set_space(systemdict, save_space);
if (code < 0)
return code;
}
}
#undef icount
}
gs_interp_reset(i_ctx_p);
{
ref vnull, vtrue, vfalse;
make_null(&vnull);
make_true(&vtrue);
make_false(&vfalse);
if ((code = initial_enter_name("null", &vnull)) < 0 ||
(code = initial_enter_name("true", &vtrue)) < 0 ||
(code = initial_enter_name("false", &vfalse)) < 0
)
return code;
}
/* Create the error name table */
{
int n = countof(gs_error_names) - 1;
int i;
ref era;
code = ialloc_ref_array(&era, a_readonly, n, "ErrorNames");
if (code < 0)
return code;
for (i = 0; i < n; i++)
if ((code = name_enter_string(imemory, (const char *)gs_error_names[i],
era.value.refs + i)) < 0)
return code;
return initial_enter_name("ErrorNames", &era);
}
}
/* 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;
}
}
