ttfFont *ttfFont__create(gs_font_dir *dir) { gs_memory_t *mem = dir->memory->stable_memory; ttfFont *ttf; if (dir->ttm == NULL) { gx_ttfMemory *m = gs_alloc_struct(mem, gx_ttfMemory, &st_gx_ttfMemory, "ttfFont__create(gx_ttfMemory)"); if (!m) return 0; m->super.alloc_struct = gx_ttfMemory__alloc_struct; m->super.alloc_bytes = gx_ttfMemory__alloc_bytes; m->super.free = gx_ttfMemory__free; m->memory = mem; dir->ttm = m; } if(ttfInterpreter__obtain(&dir->ttm->super, &dir->tti)) return 0; if(gx_san__obtain(mem, &dir->san)) return 0; ttf = gs_alloc_struct(mem, ttfFont, &st_ttfFont, "ttfFont__create"); if (ttf == NULL) return 0; #ifdef DEBUG ttfFont__init(ttf, &dir->ttm->super, DebugRepaint, (gs_debug_c('Y') ? DebugPrint : NULL), mem); #else ttfFont__init(ttf, &dir->ttm->super, DebugRepaint, NULL, mem); #endif return ttf; }
/* Make a scaled copy of a 1-Input Stitching function. */ static int fn_1ItSg_make_scaled(const gs_function_1ItSg_t *pfn, gs_function_1ItSg_t **ppsfn, const gs_range_t *pranges, gs_memory_t *mem) { gs_function_1ItSg_t *psfn = gs_alloc_struct(mem, gs_function_1ItSg_t, &st_function_1ItSg, "fn_1ItSg_make_scaled"); int code; if (psfn == 0) return_error(gs_error_VMerror); psfn->params = pfn->params; psfn->params.Functions = 0; /* in case of failure */ psfn->params.Bounds = fn_copy_values(pfn->params.Bounds, pfn->params.k - 1, sizeof(float), mem); psfn->params.Encode = fn_copy_values(pfn->params.Encode, 2 * pfn->params.k, sizeof(float), mem); if ((code = (psfn->params.Bounds == 0 || psfn->params.Encode == 0 ? gs_note_error(gs_error_VMerror) : 0)) < 0 || (code = fn_common_scale((gs_function_t *)psfn, (const gs_function_t *)pfn, pranges, mem)) < 0 || (code = fn_scale_functions((gs_function_t ***)&psfn->params.Functions, pfn->params.Functions, pfn->params.n, pranges, false, mem)) < 0) { gs_function_free((gs_function_t *)psfn, true, mem); return code; } *ppsfn = psfn; return 0; }
/* * Allocate a data block for holding our data for the client specific * data for a color space. In our demo, we are only supporting the * Separation and DeviceN color spaces. We use a single data structure * to make the code simpler. We also provide sample hooks for a client * that wants to convert ALL CIEBased color spaces to XYZ (or Lab). */ static demo_color_space_data_t * allocate_client_data_block(int initial_ref_count, gs_memory_t *mem) { /* * We allocate this with normal GC structure declarations since * we need this to be able to allocate the gs_imager_state for XYZ * conversion. * Since this is in stable memory, we use a simple reference count. * See client_adjust_cspace_count. */ demo_color_space_data_t * pdata = (demo_color_space_data_t *)gs_alloc_struct(mem, demo_color_space_data_t, &st_demo_color_space_data, "allocate_client_data_block(pdata)"); if (pdata != NULL) { memset(pdata, 0, sizeof(demo_color_space_data_t)); /* * All client color space data blocks must have a pointer to a * reference count adjust routine as their first field. */ pdata->client_adjust_cspace_count = client_adjust_cspace_count; pdata->ref_count = 1; pdata->memory = mem; } return pdata; }
/* Define the default implementation of ImageType 3 processing. */ static IMAGE3_MAKE_MID_PROC(make_mid_default); /* check prototype */ static int make_mid_default(gx_device **pmidev, gx_device *dev, int width, int height, gs_memory_t *mem) { gx_device_memory *midev = gs_alloc_struct(mem, gx_device_memory, &st_device_memory, "make_mid_default"); int code; if (midev == 0) return_error(gs_error_VMerror); gs_make_mem_mono_device(midev, mem, NULL); midev->bitmap_memory = mem; midev->width = width; midev->height = height; check_device_separable((gx_device *)midev); gx_device_fill_in_procs((gx_device *)midev); code = dev_proc(midev, open_device)((gx_device *)midev); if (code < 0) { gs_free_object(mem, midev, "make_mid_default"); return code; } midev->is_open = true; dev_proc(midev, fill_rectangle) ((gx_device *)midev, 0, 0, width, height, (gx_color_index)0); *pmidev = (gx_device *)midev; return 0; }
/* * Allocate a path on the heap, and initialize it. If shared is NULL, * allocate a segments object; if shared is an existing path, share its * segments. */ gx_path * gx_path_alloc_shared(const gx_path * shared, gs_memory_t * mem, client_name_t cname) { gx_path *ppath = gs_alloc_struct(mem, gx_path, &st_path, cname); if (ppath == 0) return 0; ppath->procs = &default_path_procs; if (shared) { if (shared->segments == &shared->local_segments) { lprintf1("Attempt to share (local) segments of path 0x%lx!\n", (ulong) shared); gs_free_object(mem, ppath, cname); return 0; } *ppath = *shared; rc_increment(ppath->segments); } else { int code = path_alloc_segments(&ppath->segments, mem, cname); if (code < 0) { gs_free_object(mem, ppath, cname); return 0; } gx_path_init_contents(ppath); } ppath->memory = mem; ppath->allocation = path_allocated_on_heap; return ppath; }
int gs_font_cid2_from_type42(gs_font_cid2 **ppfcid, gs_font_type42 *pfont42, int wmode, gs_memory_t *mem) { gs_font_cid2 *pfcid = gs_alloc_struct(mem, gs_font_cid2, &st_gs_font_cid2, "gs_font_cid2_from_type42"); if (pfcid == 0) return_error(gs_error_VMerror); /* CIDFontType 2 is a subclass (extension) of FontType 42. */ memcpy(pfcid, pfont42, sizeof(*pfont42)); pfcid->memory = mem; pfcid->next = pfcid->prev = 0; /* probably not necessary */ pfcid->is_resource = 0; gs_font_notify_init((gs_font *)pfcid); pfcid->id = gs_next_ids(mem, 1); pfcid->base = (gs_font *)pfcid; pfcid->FontType = ft_CID_TrueType; /* Fill in the rest of the CIDFont data. */ cid_system_info_set_null(&pfcid->cidata.common.CIDSystemInfo); pfcid->cidata.common.CIDCount = pfont42->data.numGlyphs; pfcid->cidata.common.GDBytes = 2; /* not used */ pfcid->cidata.MetricsCount = 0; pfcid->cidata.CIDMap_proc = identity_CIDMap_proc; /* Since MetricsCount == 0, don't need orig_procs. */ *ppfcid = pfcid; return 0; }
/* Obtain a spot analyzer device. */ int gx_san__obtain(gs_memory_t *mem, gx_device_spot_analyzer **ppadev) { gx_device_spot_analyzer *padev; int code; if (*ppadev != 0) { (*ppadev)->lock++; return 0; } padev = gs_alloc_struct(mem, gx_device_spot_analyzer, &st_device_spot_analyzer, "gx_san__obtain"); if (padev == 0) return_error(gs_error_VMerror); gx_device_init((gx_device *)padev, (const gx_device *)&gx_spot_analyzer_device, mem, false); code = gs_opendevice((gx_device *)padev); if (code < 0) { gs_free_object(mem, padev, "gx_san__obtain"); return code; } padev->lock = 1; *ppadev = padev; return 0; }
gsicc_link_cache_t * gsicc_cache_new(gs_memory_t *memory) { gsicc_link_cache_t *result; /* We want this to be maintained in stable_memory. It should be be effected by the save and restores */ result = gs_alloc_struct(memory->stable_memory, gsicc_link_cache_t, &st_icc_linkcache, "gsicc_cache_new"); if ( result == NULL ) return(NULL); result->lock = gx_monitor_alloc(memory->stable_memory); result->wait = gx_semaphore_alloc(memory->stable_memory); if (result->lock == NULL || result->wait == NULL) { gs_free_object(memory->stable_memory, result, "gsicc_cache_new"); return(NULL); } result->num_waiting = 0; rc_init_free(result, memory->stable_memory, 1, rc_gsicc_link_cache_free); result->head = NULL; result->num_links = 0; result->memory = memory->stable_memory; if_debug2(gs_debug_flag_icc,"[icc] Allocating link cache = 0x%x memory = 0x%x\n", result, result->memory); return(result); }
int gs_push_device_filter(gs_memory_t *mem, gs_state *pgs, gs_device_filter_t *df) { gs_device_filter_stack_t *dfs; gx_device *new_dev = NULL; int code; dfs = gs_alloc_struct(mem, gs_device_filter_stack_t, &st_gs_device_filter_stack, "gs_push_device_filter"); if (dfs == NULL) return_error(gs_error_VMerror); rc_increment(pgs->device); dfs->next_device = pgs->device; code = df->push(df, mem, pgs, &new_dev, pgs->device); if (code < 0) { gs_free_object(mem, dfs, "gs_push_device_filter"); return code; } dfs->next = pgs->dfilter_stack; pgs->dfilter_stack = dfs; dfs->df = df; rc_init(dfs, mem, 1); gs_setdevice_no_init(pgs, new_dev); rc_decrement_only(new_dev, "gs_push_device_filter"); return code; }
static gsicc_link_t * gsicc_alloc_link(gs_memory_t *memory, gsicc_hashlink_t hashcode) { gsicc_link_t *result; gx_semaphore_t *wait; /* The link has to be added in stable memory. We want them to be maintained across the gsave and grestore process */ result = gs_alloc_struct(memory->stable_memory, gsicc_link_t, &st_icc_link, "gsicc_alloc_link"); wait = gx_semaphore_alloc(memory->stable_memory); if (wait == NULL) { gs_free_object(memory, result, "gsicc_alloc_link(wait)"); result = NULL; } if (result != NULL) { /* set up placeholder values */ result->next = NULL; result->contextptr = NULL; result->link_handle = NULL; result->hashcode.link_hashcode = hashcode.link_hashcode; result->hashcode.des_hash = 0; result->hashcode.src_hash = 0; result->hashcode.rend_hash = 0; result->ref_count = 1; /* prevent it from being freed */ result->includes_softproof = 0; result->is_identity = false; result->valid = false; /* not yet complete */ result->num_waiting = 0; result->wait = wait; } return(result); }
/* * make a new dictionary entry. */ static int pl_dict_build_new_entry(pl_dict_t * pdict, const byte * kdata, uint ksize, void *value, pl_dict_entry_t * link) { /* Make a new entry. */ byte *kstr; gs_memory_t *mem = pdict->memory; pl_dict_entry_t *pde; pde = gs_alloc_struct(mem, pl_dict_entry_t, &st_pl_dict_entry, "pl_dict_put(entry)"); kstr = (ksize <= pl_dict_max_short_key ? pde->short_key : gs_alloc_string(mem, ksize, "pl_dict_put(key)")); if (pde == 0 || kstr == 0) { if (kstr && kstr != pde->short_key) gs_free_string(mem, kstr, ksize, "pl_dict_put(key)"); gs_free_object(mem, pde, "pl_dict_put(entry)"); return -1; } memcpy(kstr, kdata, ksize); pde->key.data = (ksize <= pl_dict_max_short_key ? 0 : kstr); pde->key.size = ksize; pde->link = link; pde->value = value; pde->next = pdict->entries; pdict->entries = pde; pdict->entry_count++; return 0; }
/* Make a scaled copy of an Arrayed Output function. */ static int fn_AdOt_make_scaled(const gs_function_AdOt_t *pfn, gs_function_AdOt_t **ppsfn, const gs_range_t *pranges, gs_memory_t *mem) { gs_function_AdOt_t *psfn = gs_alloc_struct(mem, gs_function_AdOt_t, &st_function_AdOt, "fn_AdOt_make_scaled"); int code; if (psfn == 0) return_error(gs_error_VMerror); psfn->params = pfn->params; psfn->params.Functions = 0; /* in case of failure */ if ((code = fn_common_scale((gs_function_t *)psfn, (const gs_function_t *)pfn, pranges, mem)) < 0 || (code = fn_scale_functions((gs_function_t ***)&psfn->params.Functions, pfn->params.Functions, pfn->params.n, pranges, true, mem)) < 0) { gs_function_free((gs_function_t *)psfn, true, mem); return code; } *ppsfn = psfn; return 0; }
void gs_gscolor1_init(gs_memory_t *mem) { gs_color_space *pcs = gs_alloc_struct(mem, gs_color_space, &st_color_space, "gs_cs_static_DeviceCMYK"); pcs->type = &gs_color_space_type_DeviceCMYK; gs_cs_static_DeviceCMYK = pcs; }
/* Create a RasterOp source device. */ int gx_alloc_rop_texture_device(gx_device_rop_texture ** prsdev, gs_memory_t * mem, client_name_t cname) { *prsdev = gs_alloc_struct(mem, gx_device_rop_texture, &st_device_rop_texture, cname); return (*prsdev == 0 ? gs_note_error(gs_error_VMerror) : 0); }
/* -------------------- public routines below ----------------- */ int pxJR3BeginImage(px_args_t * par, px_state_t * pxs) { int code = 0; if (!par->source.available) { px_vendor_state_t *v_state = gs_alloc_struct(pxs->memory, px_vendor_state_t, &st_px_vendor_state, "pxJR3BeginImage(vendor_state)"); byte *row; UINT16 *qvalues; if (v_state == 0) return_error(errorInsufficientMemory); if (par->pv[8]) { /* SourceWidth */ v_state->SourceWidth = par->pv[8]->value.i; v_state->data_per_row = par->pv[8]->value.i; v_state->color_space = pxs->pxgs->color_space; if (v_state->color_space != eGraySub) v_state->data_per_row *= 3; } v_state->state = vu_blank; v_state->rowwritten = 0; row = gs_alloc_byte_array(pxs->memory, 1, v_state->data_per_row, "pxJR3BeginImage(row)"); if (row == 0) return_error(errorInsufficientMemory); qvalues = (UINT16 *) gs_alloc_byte_array(pxs->memory, 192, sizeof(UINT16), "pxJR3BeginImage(qvalues)"); if (qvalues == 0) return_error(errorInsufficientMemory); pxs->vendor_state = v_state; pxs->vendor_state->row = row; pxs->vendor_state->qvalues = qvalues; pxs->vendor_state->qcount = 0; } if (par->pv[1]) { ulong len = par->pv[1]->value.i; /* zero or two payloads */ if (len) { code = vu_tag_dispatch(par, pxs); /* Multiple payloads, reset to read 2nd */ if (code == 0 && par->source.position < len) code = vu_tag_dispatch(par, pxs); } } return code; }
/* Note that all lines have the same notes. */ int gx_path_add_lines_notes(gx_path *ppath, const gs_fixed_point *ppts, int count, segment_notes notes) { subpath *psub; segment *prev; line_segment *lp = 0; int i; int code = 0; if (count <= 0) return 0; path_unshare(ppath); path_open(); psub = ppath->current_subpath; prev = psub->last; /* * We could do better than the following, but this is a start. * Note that we don't make any attempt to undo partial additions * if we fail partway through; this is equivalent to what would * happen with multiple calls on gx_path_add_line. */ for (i = 0; i < count; i++) { fixed x = ppts[i].x; fixed y = ppts[i].y; line_segment *next; if (ppath->bbox_set && outside_bbox(ppath, x, y)) { code = gs_note_error(gs_error_rangecheck); break; } if (!(next = gs_alloc_struct(gs_memory_stable(ppath->memory), line_segment, &st_line, "gx_path_add_lines")) ) { code = gs_note_error(gs_error_VMerror); break; } lp = next; lp->type = s_line; lp->notes = notes; prev->next = (segment *) lp; lp->prev = prev; lp->pt.x = x; lp->pt.y = y; prev = (segment *) lp; trace_segment("[P]", (segment *) lp); } if (lp != 0) ppath->position.x = lp->pt.x, ppath->position.y = lp->pt.y, psub->last = (segment *) lp, lp->next = 0, path_update_draw(ppath); return code; }
/* Allocate and initialize a 1-Input Stitching function. */ int gs_function_1ItSg_init(gs_function_t ** ppfn, const gs_function_1ItSg_params_t * params, gs_memory_t * mem) { static const gs_function_head_t function_1ItSg_head = { function_type_1InputStitching, { (fn_evaluate_proc_t) fn_1ItSg_evaluate, (fn_is_monotonic_proc_t) fn_1ItSg_is_monotonic, (fn_get_info_proc_t) fn_1ItSg_get_info, (fn_get_params_proc_t) fn_1ItSg_get_params, (fn_make_scaled_proc_t) fn_1ItSg_make_scaled, (fn_free_params_proc_t) gs_function_1ItSg_free_params, fn_common_free, (fn_serialize_proc_t) gs_function_1ItSg_serialize, } }; int n = (params->Range == 0 ? 0 : params->n); float prev = params->Domain[0]; int i; *ppfn = 0; /* in case of error */ for (i = 0; i < params->k; ++i) { const gs_function_t *psubfn = params->Functions[i]; if (psubfn->params.m != 1) return_error(gs_error_rangecheck); if (n == 0) n = psubfn->params.n; else if (psubfn->params.n != n) return_error(gs_error_rangecheck); /* There are only k - 1 Bounds, not k. */ if (i < params->k - 1) { if (params->Bounds[i] < prev) return_error(gs_error_rangecheck); prev = params->Bounds[i]; } } if (params->Domain[1] < prev) return_error(gs_error_rangecheck); fn_check_mnDR((const gs_function_params_t *)params, 1, n); { gs_function_1ItSg_t *pfn = gs_alloc_struct(mem, gs_function_1ItSg_t, &st_function_1ItSg, "gs_function_1ItSg_init"); if (pfn == 0) return_error(gs_error_VMerror); pfn->params = *params; pfn->params.m = 1; pfn->params.n = n; pfn->head = function_1ItSg_head; *ppfn = (gs_function_t *) pfn; } return 0; }
/* Initialize the graphics stack. */ gs_state * int_gstate_alloc(const gs_dual_memory_t * dmem) { int_gstate *iigs; ref proc0; int_remap_color_info_t *prci; gs_ref_memory_t *lmem = dmem->space_local; gs_ref_memory_t *gmem = dmem->space_global; gs_state *pgs = gs_state_alloc((gs_memory_t *)lmem); iigs = gs_alloc_struct((gs_memory_t *)lmem, int_gstate, &st_int_gstate, "int_gstate_alloc(int_gstate)"); int_gstate_map_refs(iigs, make_null); make_empty_array(&iigs->dash_pattern_array, a_all); gs_alloc_ref_array(lmem, &proc0, a_readonly + a_executable, 2, "int_gstate_alloc(proc0)"); make_oper(proc0.value.refs, 0, zpop); make_real(proc0.value.refs + 1, 0.0); iigs->black_generation = proc0; iigs->undercolor_removal = proc0; make_false(&iigs->use_cie_color); /* * Even though the gstate itself is allocated in local VM, the * container for the color remapping procedure must be allocated in * global VM so that the gstate can be copied into global VM. */ prci = gs_alloc_struct((gs_memory_t *)gmem, int_remap_color_info_t, &st_int_remap_color_info, "int_gstate_alloc(remap color info)"); make_struct(&iigs->remap_color_info, imemory_space(gmem), prci); clear_pagedevice(iigs); gs_state_set_client(pgs, iigs, &istate_procs, true); /* PostScript code wants limit clamping enabled. */ gs_setlimitclamp(pgs, true); /* * gsave and grestore only work properly * if there are always at least 2 entries on the stack. * We count on the PostScript initialization code to do a gsave. */ return pgs; }
/* Create an interpreter pattern structure. */ int int_pattern_alloc(int_pattern **ppdata, const ref *op, gs_memory_t *mem) { int_pattern *pdata = gs_alloc_struct(mem, int_pattern, &st_int_pattern, "int_pattern"); if (pdata == 0) return_error(e_VMerror); pdata->dict = *op; *ppdata = pdata; return 0; }
gs_image_enum * gs_image_enum_alloc(gs_memory_t * mem, client_name_t cname) { gs_image_enum *penum = gs_alloc_struct(mem, gs_image_enum, &st_gs_image_enum, cname); if (penum != 0) { penum->memory = mem; image_enum_init(penum); } return penum; }
/* * Allocate and initialize text state bookkeeping. */ pdf_text_state_t * pdf_text_state_alloc(gs_memory_t *mem) { pdf_text_state_t *pts = gs_alloc_struct(mem, pdf_text_state_t, &st_pdf_text_state, "pdf_text_state_alloc"); if (pts == 0) return 0; *pts = ts_default; return pts; }
/* Create a system or user name table (in the stable memory of mem). */ int create_names_array(ref **ppnames, gs_memory_t *mem, client_name_t cname) { ref *pnames = (ref *) gs_alloc_struct(gs_memory_stable(mem), names_array_ref_t, &st_names_array_ref, cname); if (pnames == 0) return_error(gs_error_VMerror); make_empty_array(pnames, a_readonly); *ppnames = pnames; return 0; }
static int alpha_buffer_init(gs_state * pgs, fixed extra_x, fixed extra_y, int alpha_bits, bool devn) { gx_device *dev = gs_currentdevice_inline(pgs); int log2_alpha_bits = ilog2(alpha_bits); gs_fixed_rect bbox; gs_int_rect ibox; uint width, raster, band_space; uint height; gs_log2_scale_point log2_scale; gs_memory_t *mem; gx_device_memory *mdev; log2_scale.x = log2_scale.y = log2_alpha_bits; gx_path_bbox(pgs->path, &bbox); ibox.p.x = fixed2int(bbox.p.x - extra_x) - 1; ibox.p.y = fixed2int(bbox.p.y - extra_y) - 1; ibox.q.x = fixed2int_ceiling(bbox.q.x + extra_x) + 1; ibox.q.y = fixed2int_ceiling(bbox.q.y + extra_y) + 1; width = (ibox.q.x - ibox.p.x) << log2_scale.x; raster = bitmap_raster(width); band_space = raster << log2_scale.y; height = (abuf_nominal / band_space) << log2_scale.y; if (height == 0) height = 1 << log2_scale.y; mem = pgs->memory; mdev = gs_alloc_struct(mem, gx_device_memory, &st_device_memory, "alpha_buffer_init"); if (mdev == 0) return 0; /* if no room, don't buffer */ /* We may have to update the marking parameters if we have a pdf14 device as our target. Need to do while dev is still active in pgs */ if (dev_proc(dev, dev_spec_op)(dev, gxdso_is_pdf14_device, NULL, 0) > 0) { gs_update_trans_marking_params(pgs); } gs_make_mem_abuf_device(mdev, mem, dev, &log2_scale, alpha_bits, ibox.p.x << log2_scale.x, devn); mdev->width = width; mdev->height = height; mdev->bitmap_memory = mem; if ((*dev_proc(mdev, open_device)) ((gx_device *) mdev) < 0) { /* No room for bits, punt. */ gs_free_object(mem, mdev, "alpha_buffer_init"); return 0; } gx_set_device_only(pgs, (gx_device *) mdev); scale_paths(pgs, log2_scale.x, log2_scale.y, true); return 1; }
/* Allocate and initialize an Exponential Interpolation function. */ int gs_function_ElIn_init(gs_function_t ** ppfn, const gs_function_ElIn_params_t * params, gs_memory_t * mem) { static const gs_function_head_t function_ElIn_head = { function_type_ExponentialInterpolation, { (fn_evaluate_proc_t) fn_ElIn_evaluate, (fn_is_monotonic_proc_t) fn_ElIn_is_monotonic, gs_function_get_info_default, (fn_get_params_proc_t) fn_ElIn_get_params, (fn_make_scaled_proc_t) fn_ElIn_make_scaled, (fn_free_params_proc_t) gs_function_ElIn_free_params, fn_common_free, (fn_serialize_proc_t) gs_function_ElIn_serialize, } }; int code; *ppfn = 0; /* in case of error */ code = fn_check_mnDR((const gs_function_params_t *)params, 1, params->n); if (code < 0) return code; if ((params->C0 == 0 || params->C1 == 0) && params->n != 1) return_error(gs_error_rangecheck); if (params->N != floor(params->N)) { /* Non-integral exponent, all inputs must be non-negative. */ if (params->Domain[0] < 0) return_error(gs_error_rangecheck); } if (params->N < 0) { /* Negative exponent, input must not be zero. */ if (params->Domain[0] <= 0 && params->Domain[1] >= 0) return_error(gs_error_rangecheck); } { gs_function_ElIn_t *pfn = gs_alloc_struct(mem, gs_function_ElIn_t, &st_function_ElIn, "gs_function_ElIn_init"); if (pfn == 0) return_error(gs_error_VMerror); pfn->params = *params; pfn->params.m = 1; pfn->head = function_ElIn_head; *ppfn = (gs_function_t *) pfn; } return 0; }
/* Allocate & init a gx_page_queue_entry */ gx_page_queue_entry_t * /* rets ptr to allocated object, 0 if VM error */ gx_page_queue_entry_alloc( gx_page_queue_t * queue /* queue that entry is being alloc'd for */ ) { gx_page_queue_entry_t *entry = gs_alloc_struct(queue->memory, gx_page_queue_entry_t, &st_gx_page_queue_entry, "gx_page_queue_entry_alloc"); if (entry != 0) { entry->next = 0; entry->queue = queue; } return entry; }
static int push_transparency_stack(gs_state *pgs, gs_transparency_state_type_t type, client_name_t cname) { gs_transparency_state_t *pts = gs_alloc_struct(pgs->memory, gs_transparency_state_t, &st_transparency_state, cname); if (pts == 0) return_error(gs_error_VMerror); pts->saved = pgs->transparency_stack; pts->type = type; pgs->transparency_stack = pts; return 0; }
static margin * alloc_margin(line_list * ll) { margin *m; if (ll->free_margin_list != 0) { m = ll->free_margin_list; ll->free_margin_list = ll->free_margin_list->next; } else if (ll->local_margin_alloc_count < MAX_LOCAL_ACTIVE) { m = ll->local_margins + ll->local_margin_alloc_count; ++ ll->local_margin_alloc_count; } else { m = gs_alloc_struct(ll->memory, margin, &st_margin, "filling contiguity margin"); /* The allocation happens only if ll->local_margins[MAX_LOCAL_ACTIVE] is exceeded. We believe it does very seldom. */ } return m; }
/* Create an alpha-compositing object. */ int gs_create_composite_alpha(gs_composite_t ** ppcte, const gs_composite_alpha_params_t * params, gs_memory_t * mem) { gs_composite_alpha_t *pcte; pcte = gs_alloc_struct(mem, gs_composite_alpha_t, &st_composite_alpha, "gs_create_composite_alpha"); if (pcte == NULL) return_error(gs_error_VMerror); pcte->type = &gs_composite_alpha_type; pcte->id = gs_next_ids(mem, 1); pcte->params = *params; pcte->idle = false; *ppcte = (gs_composite_t *) pcte; return 0; }
int s_alloc_param_printer(gs_param_list ** pplist, const param_printer_params_t * ppp, stream * s, gs_memory_t * mem) { printer_param_list_t *prlist = gs_alloc_struct(mem, printer_param_list_t, &st_printer_param_list, "s_alloc_param_printer"); int code; *pplist = (gs_param_list *)prlist; if (prlist == 0) return_error(gs_error_VMerror); code = s_init_param_printer(prlist, ppp, s); prlist->memory = mem; return code; }
/* * Create an imdi memory device for page or band buffering, * possibly preceded by a plane extraction device. */ int wtsimdi_create_buf_device(gx_device **pbdev, gx_device *target, const gx_render_plane_t *render_plane, gs_memory_t *mem, bool for_band) { int plane_index = (render_plane ? render_plane->index : -1); int depth; const gx_device_memory *mdproto; gx_device_memory *mdev; if (plane_index >= 0) depth = render_plane->depth; else depth = target->color_info.depth; mdproto = gdev_mem_device_for_bits(depth); if (mdproto == 0) return_error(gs_error_rangecheck); if (mem) { mdev = gs_alloc_struct(mem, gx_device_memory, &st_device_memory, "create_buf_device"); if (mdev == 0) return_error(gs_error_VMerror); } else { mdev = (gx_device_memory *)*pbdev; } if (target == (gx_device *)mdev) { /* The following is a special hack for setting up printer devices. */ assign_dev_procs(mdev, mdproto); check_device_separable((gx_device *)mdev); gx_device_fill_in_procs((gx_device *)mdev); } else gs_make_mem_device(mdev, mdproto, mem, (for_band ? 1 : 0), (target == (gx_device *)mdev ? NULL : target)); mdev->width = target->width; /* * The matrix in the memory device is irrelevant, * because all we do with the device is call the device-level * output procedures, but we may as well set it to * something halfway reasonable. */ gs_deviceinitialmatrix(target, &mdev->initial_matrix); /****** QUESTIONABLE, BUT BETTER THAN OMITTING ******/ mdev->color_info = target->color_info; *pbdev = (gx_device *)mdev; return 0; }