/* Copyright (C) 2001-2023 Artifex Software, Inc. All Rights Reserved. This software is provided AS-IS with no warranty, either express or implied. This software is distributed under license and may not be copied, modified or distributed except as expressly authorized under the terms of the license contained in the file LICENSE in this distribution. Refer to licensing information at http://www.artifex.com or contact Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco, CA 94129, USA, for further information. */ /* Private internal API to Ghostscript interpreter */ #include "string_.h" #include "ierrors.h" #include "gscdefs.h" #include "gstypes.h" #include "gdebug.h" #include "psapi.h" /* Public API */ #include "iref.h" #include "iminst.h" #include "imain.h" #include "imainarg.h" #include "gsmemory.h" #include "gsmalloc.h" #include "gslibctx.h" #include "gp.h" #include "gsargs.h" #include "ialloc.h" #include "icstate.h" #include "store.h" #include "iname.h" #include "interp.h" #include "gxgstate.h" /* This is the fallback for the number of threads to allow per process; i.e. just one. * This is only ever used if the gp_get_globals function returns 0 (i.e. only for * platforms that don't support threading). */ static int gsapi_instance_counter = 0; static const int gsapi_instance_max = 1; #ifdef METRO static int GSDLLCALL metro_stdin(void *v, char *buf, int len) { return 0; } static int GSDLLCALL metro_stdout(void *v, const char *str, int len) { #ifdef DEBUG OutputDebugStringWRT(str, len); #endif return len; } static int GSDLLCALL metro_stderr(void *v, const char *str, int len) { return metro_stdout(v, str, len); } #endif /* Create a new instance of Ghostscript. * First instance per process call with *pinstance == NULL * next instance in a proces call with *pinstance == copy of valid_instance pointer * *pinstance is set to a new instance pointer. */ int psapi_new_instance(gs_lib_ctx_t **pinstance, void *caller_handle) { gs_memory_t *mem = NULL; gs_main_instance *minst = NULL; if (pinstance == NULL) return gs_error_Fatal; if (gp_get_globals() == NULL) { /* This platform does not support the thread safe instance * handling. We'll drop back to the old mechanism we've used * to handle limiting ourselves to 1 instance in the past, * despite this being thread-unsafe itself. */ if ( gsapi_instance_counter >= gsapi_instance_max ) return gs_error_Fatal; ++gsapi_instance_counter; } mem = gs_malloc_init_with_context(*pinstance); if (mem == NULL) return gs_error_Fatal; minst = gs_main_alloc_instance(mem); if (minst == NULL) { gs_malloc_release(mem); return gs_error_Fatal; } mem->gs_lib_ctx->top_of_system = (void*) minst; mem->gs_lib_ctx->core->default_caller_handle = caller_handle; mem->gs_lib_ctx->core->custom_color_callback = NULL; #ifdef METRO if (mem->gs_lib_ctx->core->stdin_fn == NULL) mem->gs_lib_ctx->core->stdin_fn = metro_stdin; if (mem->gs_lib_ctx->core->stdout_fn == NULL) mem->gs_lib_ctx->core->stdout_fn = metro_stdout; if (mem->gs_lib_ctx->core->stderr_fn == NULL) mem->gs_lib_ctx->core->stderr_fn = metro_stderr; #endif mem->gs_lib_ctx->core->poll_fn = NULL; *pinstance = mem->gs_lib_ctx; return psapi_set_arg_encoding(*pinstance, PS_ARG_ENCODING_LOCAL); } /* Set an instance of Ghostscript to respond to UEL (universal * exit language) strings in the input. */ void psapi_act_on_uel(gs_lib_ctx_t *ctx) { ctx->core->act_on_uel = 1; } /* Destroy an instance of Ghostscript */ /* We do not support multiple instances, so make sure * we use the default instance only once. */ void psapi_delete_instance(gs_lib_ctx_t *ctx) { gs_memory_t *mem; gs_main_instance *minst; if (ctx == NULL) return; mem = (gs_memory_t *)(ctx->memory); minst = get_minst_from_memory(ctx->memory); ctx->core->default_caller_handle = NULL; ctx->core->stdin_fn = NULL; ctx->core->stdout_fn = NULL; ctx->core->stderr_fn = NULL; ctx->core->poll_fn = NULL; minst->display = NULL; if (minst->param_list) { gs_c_param_list_release(minst->param_list); gs_free_object(minst->heap, minst->param_list, "psapi_delete_instance"); } gs_c_param_list_release(&minst->enum_params); gs_free_object(minst->heap, minst->enum_keybuf, "psapi_delete_instance"); gs_free_object(mem, minst, "init_main_instance"); /* Release the memory (frees up everything) */ gs_malloc_release(mem); if (gp_get_globals() == NULL) --gsapi_instance_counter; } static int utf16le_get_codepoint(stream *s, const char **astr) { int c; int rune; int trail; /* This code spots the BOM for 16bit LE and ignores it. Strictly speaking * this may be wrong, as we are only supposed to ignore it at the beginning * of the string, but if anyone is stupid enough to use ZWNBSP (zero width * non breaking space) in the middle of their strings, then they deserve * what they get. */ /* We spot the BOM for 16bit BE and treat that as EOF. We'd rather give * up on dealing with a broken file than try to run something we know to * be wrong. */ do { if (s) { rune = spgetc(s); if (rune == EOF) return EOF; c = spgetc(s); if (c == EOF) return EOF; rune += c<<8; } else { rune = (*astr)[0] | ((*astr)[1]<<8); if (rune != 0) (*astr) += 2; else return EOF; } if (rune == 0xFEFF) /* BOM - ignore it */ continue; if (rune == 0xFFFE) /* BOM for BE - hopelessly broken */ return EOF; if (rune < 0xD800 || rune >= 0xE000) return rune; if (rune >= 0xDC00) /* Found a trailing surrogate pair. Skip it */ continue; lead: /* We've just read a leading surrogate */ rune -= 0xD800; rune <<= 10; if (s) { trail = spgetc(s); if (trail == EOF) return EOF; c = spgetc(s); if (c == EOF) return EOF; trail += c<<8; } else { trail = (*astr)[0] | ((*astr)[1]<<8); if (trail != 0) (*astr) += 2; else return EOF; } if (trail < 0xd800 || trail >= 0xE000) { if (rune == 0xFEFF) /* BOM - ignore it. */ continue; if (rune == 0xFFFE) /* BOM for BE - hopelessly broken. */ return EOF; /* No trail surrogate was found, so skip the lead surrogate and * return the rune we landed on. */ return trail; } if (trail < 0xdc00) { /* We found another leading surrogate. */ rune = trail; goto lead; } break; } while (1); return rune + (trail-0xDC00) + 0x10000; } /* Initialise the interpreter */ int psapi_set_arg_encoding(gs_lib_ctx_t *ctx, int encoding) { if (ctx == NULL) return gs_error_Fatal; if (encoding == PS_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 == PS_ARG_ENCODING_UTF8) { gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), NULL); return 0; } if (encoding == PS_ARG_ENCODING_UTF16LE) { gs_main_inst_arg_decode(get_minst_from_memory(ctx->memory), utf16le_get_codepoint); return 0; } return gs_error_Fatal; } int psapi_init_with_args(gs_lib_ctx_t *ctx, int argc, char **argv) { if (ctx == NULL) return gs_error_Fatal; return gs_main_init_with_args(get_minst_from_memory(ctx->memory), argc, argv); } int psapi_init_with_args01(gs_lib_ctx_t *ctx, int argc, char **argv) { if (ctx == NULL) return gs_error_Fatal; return gs_main_init_with_args01(get_minst_from_memory(ctx->memory), argc, argv); } int psapi_init_with_args2(gs_lib_ctx_t *ctx) { if (ctx == NULL) return gs_error_Fatal; return gs_main_init_with_args2(get_minst_from_memory(ctx->memory)); } int psapi_set_device_param(gs_lib_ctx_t *ctx, gs_param_list *plist) { gs_main_instance *minst = get_minst_from_memory(ctx->memory); return gs_putdeviceparams(minst->i_ctx_p->pgs->device, plist); } int psapi_get_device_params(gs_lib_ctx_t *ctx, gs_param_list *plist) { gs_main_instance *minst = get_minst_from_memory(ctx->memory); if (minst->i_ctx_p->pgs->device == NULL) return 0; return gs_getdeviceparams(minst->i_ctx_p->pgs->device, plist); } int psapi_set_param(gs_lib_ctx_t *ctx, gs_param_list *plist) { gs_main_instance *minst = get_minst_from_memory(ctx->memory); return gs_main_set_language_param(minst, plist); } int psapi_add_path(gs_lib_ctx_t *ctx, const char *path) { gs_main_instance *minst = get_minst_from_memory(ctx->memory); return gs_main_add_lib_path(minst, path); } /* The gsapi_run_* functions are like gs_main_run_* except * that the error_object is omitted. * An error object in minst is used instead. */ /* Setup up a suspendable run_string */ int psapi_run_string_begin(gs_lib_ctx_t *ctx, int user_errors, int *pexit_code) { gs_main_instance *minst; int code; if (ctx == NULL) return gs_error_Fatal; minst = get_minst_from_memory(ctx->memory); if (minst->mid_run_string == 1) return -1; minst->mid_run_string = 1; code = gs_main_run_string_begin(minst, user_errors, pexit_code, &(minst->error_object)); if (code < 0) minst->mid_run_string = 0; return code; } int psapi_run_string_continue(gs_lib_ctx_t *ctx, const char *str, unsigned int length, int user_errors, int *pexit_code) { gs_main_instance *minst; int code; if (ctx == NULL) return gs_error_Fatal; minst = get_minst_from_memory(ctx->memory); code = gs_main_run_string_continue(minst, str, length, user_errors, pexit_code, &(minst->error_object)); if (code < 0) minst->mid_run_string = 0; return code; } uint psapi_get_uel_offset(gs_lib_ctx_t *ctx) { if (ctx == NULL) return 0; return gs_main_get_uel_offset(get_minst_from_memory(ctx->memory)); } int psapi_run_string_end(gs_lib_ctx_t *ctx, int user_errors, int *pexit_code) { int code; gs_main_instance *minst; if (ctx == NULL) return gs_error_Fatal; minst = get_minst_from_memory(ctx->memory); code = gs_main_run_string_end(minst, user_errors, pexit_code, &(minst->error_object)); minst->mid_run_string = 0; return code; } int psapi_run_string_with_length(gs_lib_ctx_t *ctx, const char *str, unsigned int length, int user_errors, int *pexit_code) { if (ctx == 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)); } int psapi_run_string(gs_lib_ctx_t *ctx, const char *str, int user_errors, int *pexit_code) { if (ctx == NULL) return gs_error_Fatal; return gs_main_run_string(get_minst_from_memory(ctx->memory), str, user_errors, pexit_code, &(get_minst_from_memory(ctx->memory)->error_object)); } int psapi_run_file(gs_lib_ctx_t *ctx, const char *file_name, int user_errors, int *pexit_code) { char *d, *temp; const char *c = file_name; char dummy[6]; int rune, code, len; gs_main_instance *minst; if (ctx == NULL) return gs_error_Fatal; minst = get_minst_from_memory(ctx->memory); if (minst->mid_run_string == 1) return -1; /* 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_file2(minst, temp, user_errors, pexit_code, &(minst->error_object)); if (temp != file_name) gs_free_object(ctx->memory, temp, "gsapi_run_file"); return code; } /* Retrieve the memory allocator for the interpreter instance */ gs_memory_t * psapi_get_device_memory(gs_lib_ctx_t *ctx) { if (ctx == NULL) return NULL; return gs_main_get_device_memory(get_minst_from_memory(ctx->memory)); } /* Retrieve the memory allocator for the interpreter instance */ int psapi_set_device(gs_lib_ctx_t *ctx, gx_device *pdev) { if (ctx == NULL) return gs_error_Fatal; return gs_main_set_device(get_minst_from_memory(ctx->memory), pdev); } /* Exit the interpreter */ int psapi_exit(gs_lib_ctx_t *ctx) { if (ctx == NULL) return gs_error_Fatal; gs_to_exit(ctx->memory, 0); return 0; } int psapi_force_geometry(gs_lib_ctx_t *ctx, const float *resolutions, const long *dimensions) { int code; if (ctx == NULL) return gs_error_Fatal; code = gs_main_force_resolutions(get_minst_from_memory(ctx->memory), resolutions); if (code < 0) return code; return gs_main_force_dimensions(get_minst_from_memory(ctx->memory), dimensions); }