/* <dict> .builddevicecolorrendering1 <crd> */ static int zbuilddevicecolorrendering1(i_ctx_t *i_ctx_p) { os_ptr op = osp; gs_memory_t *mem = gs_state_memory(igs); dict_param_list list; gs_cie_render *pcrd = 0; int code; check_type(*op, t_dictionary); code = dict_param_list_read(&list, op, NULL, false, iimemory); if (code < 0) return code; code = gs_cie_render1_build(&pcrd, mem, ".builddevicecolorrendering1"); if (code >= 0) { code = param_get_cie_render1(pcrd, (gs_param_list *) & list, gs_currentdevice(igs)); if (code >= 0) { /****** FIX refct ******/ /*rc_decrement(pcrd, ".builddevicecolorrendering1"); *//* build sets rc = 1 */ } } iparam_list_release(&list); if (code < 0) { rc_free_struct(pcrd, ".builddevicecolorrendering1"); return code; } istate->colorrendering.dict = *op; make_istruct_new(op, a_readonly, pcrd); return 0; }
/* <dict> .setsystemparams - */ static int zsetsystemparams(i_ctx_t *i_ctx_p) { os_ptr op = osp; int code; dict_param_list list; gs_param_list *const plist = (gs_param_list *)&list; password pass; check_type(*op, t_dictionary); code = dict_param_list_read(&list, op, NULL, false, iimemory); if (code < 0) return code; code = dict_read_password(&pass, systemdict, "SystemParamsPassword"); if (code < 0) return code; code = param_check_password(plist, &pass); if (code != 0) { if (code > 0) code = gs_note_error(gs_error_invalidaccess); goto out; } code = param_read_password(plist, "StartJobPassword", &pass); switch (code) { default: /* invalid */ goto out; case 1: /* missing */ break; case 0: code = dict_write_password(&pass, systemdict, "StartJobPassword", ! i_ctx_p->LockFilePermissions); if (code < 0) goto out; } code = param_read_password(plist, "SystemParamsPassword", &pass); switch (code) { default: /* invalid */ goto out; case 1: /* missing */ break; case 0: code = dict_write_password(&pass, systemdict, "SystemParamsPassword", ! i_ctx_p->LockFilePermissions); if (code < 0) goto out; } code = setparams(i_ctx_p, plist, &system_param_set); out: iparam_list_release(&list); if (code < 0) return code; 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; }
/* We break this out for use when switching contexts. */ int set_user_params(i_ctx_t *i_ctx_p, const ref *paramdict) { dict_param_list list; int code; check_type(*paramdict, t_dictionary); code = dict_param_list_read(&list, paramdict, NULL, false, iimemory); if (code < 0) return code; code = setparams(i_ctx_p, (gs_param_list *)&list, &user_param_set); iparam_list_release(&list); return code; }
/* <dict> .settrapparams - */ static int zsettrapparams(i_ctx_t *i_ctx_p) { os_ptr op = osp; dict_param_list list; int code; check_type(*op, t_dictionary); code = dict_param_list_read(&list, op, NULL, false, iimemory); if (code < 0) return code; code = gs_settrapparams(&i_trap_params, (gs_param_list *) & list); iparam_list_release(&list); if (code < 0) return code; pop(1); return 0; }
static int ref_param_begin_read_collection(gs_param_list * plist, gs_param_name pkey, gs_param_dict * pvalue, gs_param_collection_type_t coll_type) { iparam_list *const iplist = (iparam_list *) plist; iparam_loc loc; bool int_keys = coll_type != 0; int code = ref_param_read(iplist, pkey, &loc, -1); dict_param_list *dlist; if (code != 0) return code; dlist = (dict_param_list *) gs_alloc_bytes(plist->memory, size_of(dict_param_list), "ref_param_begin_read_collection"); if (dlist == 0) return_error(e_VMerror); if (r_has_type(loc.pvalue, t_dictionary)) { code = dict_param_list_read(dlist, loc.pvalue, NULL, false, iplist->ref_memory); dlist->int_keys = int_keys; if (code >= 0) pvalue->size = dict_length(loc.pvalue); } else if (int_keys && r_is_array(loc.pvalue)) { code = array_indexed_param_list_read(dlist, loc.pvalue, NULL, false, iplist->ref_memory); if (code >= 0) pvalue->size = r_size(loc.pvalue); } else code = gs_note_error(e_typecheck); if (code < 0) { gs_free_object(plist->memory, dlist, "ref_param_begin_write_collection"); return iparam_note_error(loc, code); } pvalue->list = (gs_param_list *) dlist; return 0; }