static int zcurrentfile(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref *fp; push(1); /* Check the cache first */ if (esfile != 0) { #ifdef DEBUG /* Check that esfile is valid. */ ref *efp = zget_current_file(i_ctx_p); if (esfile != efp) { lprintf2("currentfile: esfile=0x%lx, efp=0x%lx\n", (ulong) esfile, (ulong) efp); ref_assign(op, efp); } else #endif ref_assign(op, esfile); } else if ((fp = zget_current_file(i_ctx_p)) == 0) { /* Return an invalid file object. */ /* This doesn't make a lot of sense to me, */ /* but it's what the PostScript manual specifies. */ make_invalid_file(i_ctx_p, op); } else { ref_assign(op, fp); esfile_set_cache(fp); } /* Make the returned value literal. */ r_clear_attrs(op, a_executable); return 0; }
static byte * gs_heap_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num, client_name_t cname) { if (gs_heap_object_type(mem, data) != &st_bytes) lprintf2("%s: resizing non-string 0x%lx!\n", client_name_string(cname), (ulong) data); return gs_heap_resize_object(mem, data, new_num, cname); }
/* Run the initialization procedures of the individual operator files. */ int zop_init(i_ctx_t *i_ctx_p) { const op_def *const *tptr; int code; /* Because of a bug in Sun's SC1.0 compiler, */ /* we have to spell out the typedef for op_def_ptr here: */ const op_def *def; for (tptr = op_defs_all; *tptr != 0; tptr++) { for (def = *tptr; def->oname != 0; def++) DO_NOTHING; if (def->proc != 0) { code = def->proc(i_ctx_p); if (code < 0) { lprintf2("op_init proc 0x%lx returned error %d!\n", (ulong)def->proc, code); return code; } } } /* Initialize the predefined names other than operators. */ /* Do this here in case op_init changed any of them. */ { ref vcr, vpr, vpf, vre, vrd; make_const_string(&vcr, a_readonly | avm_foreign, strlen(gs_copyright), (const byte *)gs_copyright); make_const_string(&vpr, a_readonly | avm_foreign, strlen(gs_product), (const byte *)gs_product); make_const_string(&vpf, a_readonly | avm_foreign, strlen(gs_productfamily), (const byte *)gs_productfamily); make_int(&vre, gs_revision); make_int(&vrd, gs_revisiondate); if ((code = initial_enter_name("copyright", &vcr)) < 0 || (code = initial_enter_name("product", &vpr)) < 0 || (code = initial_enter_name("productfamily", &vpf)) < 0 || (code = initial_enter_name("revision", &vre)) < 0 || (code = initial_enter_name("revisiondate", &vrd)) < 0) return code; } return 0; }
int gx_image_data(gx_image_enum_common_t * info, const byte ** plane_data, int data_x, uint raster, int height) { int num_planes = info->num_planes; gx_image_plane_t planes[GS_IMAGE_MAX_COMPONENTS]; int i; #ifdef DEBUG if (num_planes > GS_IMAGE_MAX_COMPONENTS) { lprintf2("num_planes=%d > GS_IMAGE_MAX_COMPONENTS=%d!\n", num_planes, GS_IMAGE_MAX_COMPONENTS); return_error(gs_error_Fatal); } #endif for (i = 0; i < num_planes; ++i) { planes[i].data = plane_data[i]; planes[i].data_x = data_x; planes[i].raster = raster; } return gx_image_plane_data(info, planes, height); }
static void gs_heap_free_object(gs_memory_t * mem, void *ptr, client_name_t cname) { gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem; gs_malloc_block_t *bp; gs_memory_type_ptr_t pstype; struct_proc_finalize((*finalize)); if_debug3('a', "[a-]gs_free(%s) 0x%lx(%u)\n", client_name_string(cname), (ulong) ptr, (ptr == 0 ? 0 : ((gs_malloc_block_t *) ptr)[-1].size)); if (ptr == 0) return; pstype = ((gs_malloc_block_t *) ptr)[-1].type; finalize = pstype->finalize; if (finalize != 0) { if_debug3('u', "[u]finalizing %s 0x%lx (%s)\n", struct_type_name_string(pstype), (ulong) ptr, client_name_string(cname)); (*finalize) (ptr); } if (mmem->monitor) gx_monitor_enter(mmem->monitor); /* Exclusive access */ bp = mmem->allocated; /* If 'finalize' releases a memory, this function could be called recursively and change mmem->allocated. */ if (ptr == bp + 1) { mmem->allocated = bp->next; mmem->used -= bp->size + sizeof(gs_malloc_block_t); if (mmem->allocated) mmem->allocated->prev = 0; if (mmem->monitor) gx_monitor_leave(mmem->monitor); /* Done with exclusive access */ gs_alloc_fill(bp, gs_alloc_fill_free, bp->size + sizeof(gs_malloc_block_t)); free(bp); } else { gs_malloc_block_t *np; /* * bp == 0 at this point is an error, but we'd rather have an * error message than an invalid access. */ if (bp) { for (; (np = bp->next) != 0; bp = np) { if (ptr == np + 1) { bp->next = np->next; if (np->next) np->next->prev = bp; mmem->used -= np->size + sizeof(gs_malloc_block_t); if (mmem->monitor) gx_monitor_leave(mmem->monitor); /* Done with exclusive access */ gs_alloc_fill(np, gs_alloc_fill_free, np->size + sizeof(gs_malloc_block_t)); free(np); return; } } } if (mmem->monitor) gx_monitor_leave(mmem->monitor); /* Done with exclusive access */ lprintf2("%s: free 0x%lx not found!\n", client_name_string(cname), (ulong) ptr); free((char *)((gs_malloc_block_t *) ptr - 1)); } }