/* <num_copies> <flush_bool> .outputpage - */
static int
zoutputpage(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code;
check_type(op[-1], t_integer);
check_type(*op, t_boolean);
if (gs_debug[':']) {
gs_main_instance *minst = get_minst_from_memory((gs_memory_t *)i_ctx_p->memory.current->non_gc_memory);
print_resource_usage(minst, &(i_ctx_p->memory), "Outputpage start");
}
#ifdef PSI_INCLUDED
code = ps_end_page_top(imemory,
(int)op[-1].value.intval, op->value.boolval);
#else
code = gs_output_page(igs, (int)op[-1].value.intval,
op->value.boolval);
#endif
if (code < 0)
return code;
pop(2);
if (gs_debug[':']) {
gs_main_instance *minst = get_minst_from_memory((gs_memory_t *)i_ctx_p->memory.current->non_gc_memory);
print_resource_usage(minst, &(i_ctx_p->memory), "Outputpage end");
}
return 0;
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_string_end(void *lib,
int user_errors, int *pexit_code)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if (lib == NULL)
return gs_error_Fatal;
return gs_main_run_string_end(get_minst_from_memory(ctx->memory),
user_errors, pexit_code,
&(get_minst_from_memory(ctx->memory)->error_object));
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_file(void *lib, const char *file_name,
int user_errors, int *pexit_code)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if (lib == NULL)
return e_Fatal;
return gs_main_run_file(get_minst_from_memory(ctx->memory),
file_name, user_errors, pexit_code,
&(get_minst_from_memory(ctx->memory)->error_object));
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_string_with_length(void *lib,
const char *str, uint length, int user_errors, int *pexit_code)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if (lib == NULL)
return gs_error_Fatal;
return gs_main_run_string_with_length(get_minst_from_memory(ctx->memory),
str, length, user_errors, pexit_code,
&(get_minst_from_memory(ctx->memory)->error_object));
}
/* The startup code also calls this to open @-files. */
int
lib_file_open(gs_file_path_ptr lib_path, const gs_memory_t *mem, i_ctx_t *i_ctx_p,
const char *fname, uint flen, char *buffer, int blen, uint *pclen, ref *pfile)
{ /* i_ctx_p is NULL running arg (@) files.
* lib_path and mem are never NULL
*/
bool starting_arg_file = (i_ctx_p == NULL) ? true : i_ctx_p->starting_arg_file;
bool search_with_no_combine = false;
bool search_with_combine = false;
char fmode[4] = { 'r', 0, 0, 0 }; /* room for binary suffix */
gx_io_device *iodev = iodev_default(mem);
gs_main_instance *minst = get_minst_from_memory(mem);
int code;
/* when starting arg files (@ files) iodev_default is not yet set */
if (iodev == 0)
iodev = (gx_io_device *)gx_io_device_table[0];
strcat(fmode, gp_fmode_binary_suffix);
if (gp_file_name_is_absolute(fname, flen)) {
search_with_no_combine = true;
search_with_combine = false;
} else {
search_with_no_combine = starting_arg_file;
search_with_combine = true;
}
if (minst->search_here_first) {
if (search_with_no_combine) {
code = lib_file_open_search_with_no_combine(lib_path, mem, i_ctx_p,
fname, flen, buffer, blen, pclen, pfile,
iodev, starting_arg_file, fmode);
if (code <= 0) /* +ve means continue continue */
return code;
}
if (search_with_combine) {
code = lib_file_open_search_with_combine(lib_path, mem, i_ctx_p,
fname, flen, buffer, blen, pclen, pfile,
iodev, starting_arg_file, fmode);
if (code <= 0) /* +ve means continue searching */
return code;
}
} else {
if (search_with_combine) {
code = lib_file_open_search_with_combine(lib_path, mem, i_ctx_p,
fname, flen, buffer, blen, pclen, pfile,
iodev, starting_arg_file, fmode);
if (code <= 0) /* +ve means continue searching */
return code;
}
if (search_with_no_combine) {
code = lib_file_open_search_with_no_combine(lib_path, mem, i_ctx_p,
fname, flen, buffer, blen, pclen, pfile,
iodev, starting_arg_file, fmode);
if (code <= 0) /* +ve means continue searching */
return code;
}
}
return_error(e_undefinedfilename);
}
GSDLLEXPORT int GSDLLAPI
gsapi_init_with_argsA(void *lib, int argc, char **argv)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
int code;
gs_arg_get_codepoint *old;
if (lib == NULL)
return gs_error_Fatal;
old = gs_main_inst_get_arg_decode(get_minst_from_memory(ctx->memory));
code = gsapi_set_arg_encoding(lib, GS_ARG_ENCODING_LOCAL);
if (code != 0)
return code;
code = gsapi_init_with_args(lib, 2*argc, (char **)argv);
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), old);
return code;
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_string(void *lib,
const char *str, int user_errors, int *pexit_code)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
return gsapi_run_string_with_length(get_minst_from_memory(ctx->memory),
str, (uint)strlen(str), user_errors, pexit_code);
}
/* Initialise the interpreter */
GSDLLEXPORT int GSDLLAPI
gsapi_init_with_args(void *lib, int argc, char **argv)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if (lib == NULL)
return e_Fatal;
return gs_main_init_with_args(get_minst_from_memory(ctx->memory), argc, argv);
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_fileA(void *lib, const char *file_name,
int user_errors, int *pexit_code)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
int code;
gs_arg_get_codepoint *old;
if (lib == NULL)
return gs_error_Fatal;
old = gs_main_inst_get_arg_decode(get_minst_from_memory(ctx->memory));
code = gsapi_set_arg_encoding(lib, GS_ARG_ENCODING_LOCAL);
if (code != 0)
return code;
code = gsapi_run_file(lib, (const char *)file_name, user_errors, pexit_code);
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), old);
return code;
}
/* Set the display callback structure */
GSDLLEXPORT int GSDLLAPI
gsapi_set_display_callback(void *lib, display_callback *callback)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if (lib == NULL)
return gs_error_Fatal;
get_minst_from_memory(ctx->memory)->display = callback;
/* not in a language switched build */
return 0;
}
static void eprn_forget_defaultmatrix(gs_memory_t *memory)
{
#if EPRN_USE_GSTATE
/* Old ghostscript versions */
gs_setdefaultmatrix(igs, NULL);
#else
gs_setdefaultmatrix(get_minst_from_memory(memory)->i_ctx_p->pgs, NULL);
#endif
return;
}
GSDLLEXPORT int GSDLLAPI
gsapi_init_with_argsW(void *lib, int argc, wchar_t **argv)
{
#ifdef GS_NO_UTF8
/* Cannot call the W entrypoints in a GS_NO_UTF8 build */
return gs_error_Fatal;
#else
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
int code;
gs_arg_get_codepoint *old;
if (lib == NULL)
return gs_error_Fatal;
old = gs_main_inst_get_arg_decode(get_minst_from_memory(ctx->memory));
code = gsapi_set_arg_encoding(lib, GS_ARG_ENCODING_UTF16LE);
if (code != 0)
return code;
code = gsapi_init_with_args(lib, 2*argc, (char **)argv);
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), old);
return code;
#endif
}
/* Initialise the interpreter */
GSDLLEXPORT int GSDLLAPI
gsapi_set_arg_encoding(void *lib, int encoding)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if (lib == NULL)
return gs_error_Fatal;
#if defined(GS_NO_UTF8)
if (encoding == GS_ARG_ENCODING_LOCAL) {
/* For GS_NO_UTF8 builds, we don't use utf8 internally, and we assume
* that all inputs are 8 bit clean. */
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), clean8bit_get_codepoint);
return 0;
}
#else
if (encoding == GS_ARG_ENCODING_LOCAL) {
#if defined(__WIN32__) && !defined(METRO)
/* For windows, we need to set it up so that we convert from 'local'
* format (in this case whatever codepage is set) to utf8 format. At
* the moment, all the other OS we care about provide utf8 anyway.
*/
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), gp_local_arg_encoding_get_codepoint);
#else
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), NULL);
#endif /* WIN32 */
return 0;
}
if (encoding == GS_ARG_ENCODING_UTF8) {
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), NULL);
return 0;
}
if (encoding == GS_ARG_ENCODING_UTF16LE) {
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), utf16le_get_codepoint);
return 0;
}
#endif
return gs_error_Fatal;
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_fileW(void *lib, const wchar_t *file_name,
int user_errors, int *pexit_code)
{
#ifdef GS_NO_UTF8
/* Cannot call the W entrypoints in a GS_NO_UTF8 build */
return gs_error_Fatal;
#else
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
int code;
gs_arg_get_codepoint *old;
if (lib == NULL)
return gs_error_Fatal;
old = gs_main_inst_get_arg_decode(get_minst_from_memory(ctx->memory));
code = gsapi_set_arg_encoding(lib, GS_ARG_ENCODING_UTF16LE);
if (code != 0)
return code;
code = gsapi_run_file(lib, (const char *)file_name, user_errors, pexit_code);
gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), old);
return code;
#endif
}
GSDLLEXPORT int GSDLLAPI
gsapi_run_file(void *lib, const char *file_name,
int user_errors, int *pexit_code)
{
#ifndef GS_NO_UTF8
char *d, *temp;
const char *c = file_name;
char dummy[6];
int rune, code, len;
#endif
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
gs_main_instance *minst;
if (lib == NULL)
return gs_error_Fatal;
minst = get_minst_from_memory(ctx->memory);
#ifdef GS_NO_UTF8
return gs_main_run_file(minst, file_name, user_errors, pexit_code,
&(minst->error_object));
#else
/* Convert the file_name to utf8 */
if (minst->get_codepoint) {
len = 1;
while ((rune = minst->get_codepoint(NULL, &c)) >= 0)
len += codepoint_to_utf8(dummy, rune);
temp = (char *)gs_alloc_bytes_immovable(ctx->memory, len, "gsapi_run_file");
if (temp == NULL)
return 0;
c = file_name;
d = temp;
while ((rune = minst->get_codepoint(NULL, &c)) >= 0)
d += codepoint_to_utf8(d, rune);
*d = 0;
}
else {
temp = (char *)file_name;
}
code = gs_main_run_file(minst, temp, user_errors, pexit_code,
&(minst->error_object));
if (temp != file_name)
gs_free_object(ctx->memory, temp, "gsapi_run_file");
return code;
#endif
}
/* We do not support multiple instances, so make sure
* we use the default instance only once.
*/
GSDLLEXPORT void GSDLLAPI
gsapi_delete_instance(void *lib)
{
gs_lib_ctx_t *ctx = (gs_lib_ctx_t *)lib;
if ((ctx != NULL)) {
gs_main_instance *minst = get_minst_from_memory(ctx->memory);
ctx->caller_handle = NULL;
ctx->stdin_fn = NULL;
ctx->stdout_fn = NULL;
ctx->stderr_fn = NULL;
ctx->poll_fn = NULL;
minst->display = NULL;
/* Release the memory (frees up everything) */
gs_malloc_release(minst->heap);
--gsapi_instance_counter;
}
}
/* Get bytes from GlyphData or DataSource. */
static int
cid0_read_bytes(gs_font_cid0 *pfont, ulong base, uint count, byte *buf,
gs_glyph_data_t *pgd)
{
const font_data *pfdata = pfont_data(pfont);
byte *data = buf;
gs_font *gdfont = 0; /* pfont if newly allocated, 0 if not */
int code = 0;
/* Check for overflow. */
if (base != (long)base || base > base + count)
return_error(e_rangecheck);
if (r_has_type(&pfdata->u.cid0.DataSource, t_null)) {
/* Get the bytes from GlyphData (a string or array of strings). */
const ref *pgdata = &pfdata->u.cid0.GlyphData;
if (r_has_type(pgdata, t_string)) { /* single string */
uint size = r_size(pgdata);
if (base >= size || count > size - base)
return_error(e_rangecheck);
data = pgdata->value.bytes + base;
} else { /* array of strings */
/*
* The algorithm is similar to the one in
* string_array_access_proc in zfont42.c, but it also has to
* deal with the case where the requested string crosses array
* elements.
*/
ulong skip = base;
uint copied = 0;
uint index = 0;
ref rstr;
uint size;
for (;; skip -= size, ++index) {
int code = array_get(pfont->memory, pgdata, index, &rstr);
if (code < 0)
return code;
if (!r_has_type(&rstr, t_string))
return_error(e_typecheck);
size = r_size(&rstr);
if (skip < size)
break;
}
size -= skip;
if (count <= size) {
data = rstr.value.bytes + skip;
} else { /* multiple strings needed */
if (data == 0) { /* no buffer provided */
data = gs_alloc_string(pfont->memory, count,
"cid0_read_bytes");
if (data == 0)
return_error(e_VMerror);
gdfont = (gs_font *)pfont; /* newly allocated */
}
memcpy(data, rstr.value.bytes + skip, size);
copied = size;
while (copied < count) {
int code = array_get(pfont->memory, pgdata, ++index, &rstr);
if (code < 0)
goto err;
if (!r_has_type(&rstr, t_string)) {
code = gs_note_error(e_typecheck);
goto err;
}
size = r_size(&rstr);
if (size > count - copied)
size = count - copied;
memcpy(data + copied, rstr.value.bytes, size);
copied += size;
}
}
}
} else {
/* Get the bytes from DataSource (a stream). */
stream *s;
uint nread;
i_ctx_t *i_ctx_p = get_minst_from_memory(pfont->memory)->i_ctx_p;
check_read_known_file(i_ctx_p, s, &pfdata->u.cid0.DataSource, return_error);
if (sseek(s, base) < 0)
return_error(e_ioerror);
if (data == 0) { /* no buffer provided */
data = gs_alloc_string(pfont->memory, count, "cid0_read_bytes");
if (data == 0)
return_error(e_VMerror);
gdfont = (gs_font *)pfont; /* newly allocated */
}
if (sgets(s, data, count, &nread) < 0 || nread != count) {
code = gs_note_error(e_ioerror);
goto err;
}
}
gs_glyph_data_from_string(pgd, data, count, gdfont);
return code;
err:
if (data != buf)
gs_free_string(pfont->memory, data, count, "cid0_read_bytes");
return code;
}
