XPAPI int xpost_add_definitions(Xpost_Context *ctx, int cnt, char *defs[])
{
int i;
Xpost_Object ud;
if (!ctx) return 0;
XPOST_LOG_INFO("adding %d defs", cnt);
ud = xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 2);
for (i = 0; i < cnt; i++)
{
char *eq = strchr(defs[i], '=');
XPOST_LOG_INFO("%s", defs[i]);
if (eq)
{
*eq++ = '\0';
xpost_dict_put(ctx, ud,
xpost_name_cons(ctx, defs[i]),
get_token(ctx, eq));
eq[-1] = '=';
}
else
{
xpost_dict_put(ctx, ud,
xpost_name_cons(ctx, defs[i]),
null);
}
}
return 1;
}
int xpost_oper_init_stack_ops (Xpost_Context *ctx,
Xpost_Object sd)
{
Xpost_Operator *optab;
Xpost_Object n,op;
unsigned int optadr;
assert(ctx->gl->base);
xpost_memory_table_get_addr(ctx->gl,
XPOST_MEMORY_TABLE_SPECIAL_OPERATOR_TABLE, &optadr);
optab = (void *)(ctx->gl->base + optadr);
op = xpost_operator_cons(ctx, "pop", (Xpost_Op_Func)Apop, 0, 1, anytype);
INSTALL;
op = xpost_operator_cons(ctx, "exch", (Xpost_Op_Func)AAexch, 2, 2, anytype, anytype);
INSTALL;
op = xpost_operator_cons(ctx, "dup", (Xpost_Op_Func)Adup, 2, 1, anytype);
INSTALL;
op = xpost_operator_cons(ctx, "copy", (Xpost_Op_Func)Icopy, 0, 1, integertype);
INSTALL;
op = xpost_operator_cons(ctx, "index", (Xpost_Op_Func)Iindex, 1, 1, integertype);
INSTALL;
//xpost_dict_dump_memory (ctx->gl, sd); fflush(NULL);
op = xpost_operator_cons(ctx, "roll", (Xpost_Op_Func)IIroll, 0, 2, integertype, integertype);
INSTALL;
op = xpost_operator_cons(ctx, "clear", (Xpost_Op_Func)Zclear, 0, 0);
INSTALL;
op = xpost_operator_cons(ctx, "count", (Xpost_Op_Func)Zcount, 1, 0);
INSTALL;
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "mark"), mark);
op = xpost_operator_cons(ctx, "cleartomark", (Xpost_Op_Func)xpost_op_cleartomark, 0, 0);
INSTALL;
op = xpost_operator_cons(ctx, "counttomark", (Xpost_Op_Func)xpost_op_counttomark, 1, 0);
INSTALL;
return 0;
}
/* copy userdict names to systemdict
Problem: This is clearly an invalidaccess,
and yet is required by the PLRM. Discussion:
https://groups.google.com/d/msg/comp.lang.postscript/VjCI0qxkGY4/y0urjqRA1IoJ
The ignoreinvalidaccess exception has been isolated to this one case.
*/
static int copyudtosd(Xpost_Context *ctx, Xpost_Object ud, Xpost_Object sd)
{
Xpost_Object ed, de;
ctx->ignoreinvalidaccess = 1;
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "userdict"), ud);
ed = xpost_dict_get(ctx, ud, xpost_name_cons(ctx, "errordict"));
if (xpost_object_get_type(ed) == invalidtype)
return undefined;
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "errordict"), ed);
de = xpost_dict_get(ctx, ud, xpost_name_cons(ctx, "$error"));
if (xpost_object_get_type(de) == invalidtype)
return undefined;
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "$error"), de);
ctx->ignoreinvalidaccess = 0;
return 0;
}
static
int setpacking (Xpost_Context *ctx,
Xpost_Object b)
{
Xpost_Object sd = xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 0);
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "currentpacking"), b);
return 0;
}
/* any type name
return type of any as a nametype object */
static
int Atype(Xpost_Context *ctx,
Xpost_Object o)
{
if (xpost_object_get_type(o) >= XPOST_OBJECT_NTYPES)
//return unregistered;
o = invalid; /* normalize to the all-zero invalid object */
xpost_stack_push(ctx->lo, ctx->os, xpost_object_cvx(xpost_name_cons(ctx, xpost_object_type_names[xpost_object_get_type(o)])));
return 0;
}
/* string cvn name
convert string to name */
static
int Scvn(Xpost_Context *ctx,
Xpost_Object s)
{
char *t;
Xpost_Object name;
t = alloca(s.comp_.sz+1);
memcpy(t, xpost_string_get_pointer(ctx, s), s.comp_.sz);
t[s.comp_.sz] = '\0';
name = xpost_name_cons(ctx, t);
if (xpost_object_get_type(name) == invalidtype)
return VMerror;
if (xpost_object_is_exe(s))
name = xpost_object_cvx(name);
else
name = xpost_object_cvlit(name);
xpost_stack_push(ctx->lo, ctx->os, name);
return 0;
}
int xpost_oper_init_packedarray_ops (Xpost_Context *ctx,
Xpost_Object sd)
{
Xpost_Operator *optab;
Xpost_Object n,op;
unsigned int optadr;
assert(ctx->gl->base);
xpost_memory_table_get_addr(ctx->gl,
XPOST_MEMORY_TABLE_SPECIAL_OPERATOR_TABLE, &optadr);
optab = (void *)(ctx->gl->base + optadr);
op = xpost_operator_cons(ctx, "packedarray", (Xpost_Op_Func)packedarray, 1, 1, integertype);
INSTALL;
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "currentpacking"), xpost_bool_cons(0));
op = xpost_operator_cons(ctx, "setpacking", (Xpost_Op_Func)setpacking, 0, 1, booleantype);
INSTALL;
/* xpost_dict_dump_memory (ctx->gl, sd); fflush(NULL);
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "mark"), mark); */
return 0;
}
/* FIXME remove duplication of effort here and in bin/xpost_main.c
(ie. there should be 1 table, not 2)
Generates postscript code to initialize the selected device
currentglobal false setglobal % allocate in local memory
device_requires_loading? { loadXXXdevice } if % load if necessary
userdict /DEVICE 612 792 newXXXdevice put % instantiate the device
setglobal % reset previous allocation mode
initialization of the device is deferred until the start procedure has
initialized graphics (importantly, the ppmimage base class).
the loadXXXdevice operators all specialize the ppmimage base class
and so must wait until it is available.
also creates the definitions PACKAGE_DATA_DIR PACKAGE_INSTALL_DIR and EXE_DIR
*/
static
void setlocalconfig(Xpost_Context *ctx,
Xpost_Object sd,
const char *device,
const char *outfile,
const char *bufferin,
char **bufferout,
Xpost_Showpage_Semantics semantics,
Xpost_Set_Size set_size,
int width,
int height)
{
const char *device_strings[][3] =
{
{ "pgm", "", "newPGMIMAGEdevice" },
{ "ppm", "", "newPPMIMAGEdevice" },
{ "null", "", "newnulldevice" },
{ "xcb", "loadxcbdevice", "newxcbdevice" },
{ "gdi", "loadwin32device", "newwin32device" },
{ "gl", "loadwin32device", "newwin32device" },
{ "bgr", "loadbgrdevice", "newbgrdevice" },
{ "raster", "loadrasterdevice", "newrasterdevice" },
{ "png", "loadpngdevice", "newpngdevice" },
{ "jpeg", "loadjpegdevice", "newjpegdevice" },
{ NULL, NULL, NULL }
};
const char *strtemplate = "currentglobal false setglobal "
"%s userdict /DEVICE %s %s put "
"setglobal";
Xpost_Object namenewdev;
Xpost_Object newdevstr;
int i;
char *devstr;
char *subdevice;
char *dimensions;
ctx->vmmode = GLOBAL;
#ifdef _WIN32
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "WIN32"), xpost_bool_cons(1));
#endif
devstr = strdup(device); /* Parse device string for mode selector "dev:mode" */
if ((subdevice=strchr(devstr, ':'))) {
*subdevice++ = '\0';
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "SUBDEVICE"),
xpost_object_cvlit(xpost_string_cons(ctx, strlen(subdevice), subdevice)));
}
/* define the /newdefaultdevice name called by /start */
for (i = 0; device_strings[i][0]; i++)
{
if (strcmp(devstr, device_strings[i][0]) == 0)
{
break;
}
}
if (set_size == XPOST_USE_SIZE){
dimensions = malloc(2 + (int)ceil(log10(width)) + (int)ceil(log10(height)));
sprintf(dimensions, "%d %d", width, height);
} else {
static char x[] = "612 792";
dimensions = x;
}
newdevstr = xpost_string_cons(ctx,
strlen(strtemplate) - 6
+ strlen(device_strings[i][1])
+ strlen(dimensions)
+ strlen(device_strings[i][2]) + 1,
NULL);
sprintf(xpost_string_get_pointer(ctx, newdevstr), strtemplate,
device_strings[i][1], dimensions, device_strings[i][2]);
--newdevstr.comp_.sz; /* trim the '\0' */
namenewdev = xpost_name_cons(ctx, "newdefaultdevice");
xpost_dict_put(ctx, sd, namenewdev, xpost_object_cvx(newdevstr));
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "ShowpageSemantics"), xpost_int_cons(semantics));
if (outfile)
{
xpost_dict_put(ctx, sd,
xpost_name_cons(ctx, "OutputFileName"),
xpost_object_cvlit(xpost_string_cons(ctx, strlen(outfile), outfile)));
}
if (bufferin)
{
Xpost_Object s = xpost_object_cvlit(xpost_string_cons(ctx, sizeof(bufferin), NULL));
xpost_object_set_access(ctx, s, XPOST_OBJECT_TAG_ACCESS_NONE);
memcpy(xpost_string_get_pointer(ctx, s), &bufferin, sizeof(bufferin));
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "OutputBufferIn"), s);
}
if (bufferout)
{
Xpost_Object s = xpost_object_cvlit(xpost_string_cons(ctx, sizeof(bufferout), NULL));
xpost_object_set_access(ctx, s, XPOST_OBJECT_TAG_ACCESS_NONE);
memcpy(xpost_string_get_pointer(ctx, s), &bufferout, sizeof(bufferout));
xpost_dict_put(ctx, sd, xpost_name_cons(ctx, "OutputBufferOut"), s);
}
ctx->vmmode = LOCAL;
free(devstr);
}
/* called by mainloop() after propagated error codes.
pushes postscript-level error procedures
and resumes normal execution.
*/
static
void _onerror(Xpost_Context *ctx,
unsigned int err)
{
Xpost_Object sd;
Xpost_Object ed;
Xpost_Object dollarerror;
if (err > unknownerror) err = unknownerror;
if (!validate_context(ctx))
XPOST_LOG_ERR("context not valid");
if (itpdata->in_onerror > 5)
{
fprintf(stderr, "LOOP in error handler\nabort\n");
++ctx->quit;
/*exit(undefinedresult); */
}
++itpdata->in_onerror;
#ifdef EMITONERROR
fprintf(stderr, "err: %s\n", errorname[err]);
#endif
/* reset stack */
if ((xpost_object_get_type(ctx->currentobject) == operatortype) &&
(ctx->currentobject.tag & XPOST_OBJECT_TAG_DATA_FLAG_OPARGSINHOLD))
{
int n = ctx->currentobject.mark_.pad0;
int i;
for (i = 0; i < n; i++)
{
xpost_stack_push(ctx->lo, ctx->os,
xpost_stack_bottomup_fetch(ctx->lo, ctx->hold, i));
}
}
/* printf("1\n"); */
sd = xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 0);
/* printf("2\n"); */
dollarerror = xpost_dict_get(ctx, sd, namedollarerror);
if (xpost_object_get_type(dollarerror) == invalidtype)
{
XPOST_LOG_ERR("cannot load $error dict for error: %s",
errorname[err]);
xpost_stack_push(ctx->lo, ctx->es,
xpost_object_cvx(xpost_name_cons(ctx, "stop")));
/*itpdata->in_onerror = 0; */
return;
}
/* printf("3\n"); */
/* printf("4\n"); */
/* printf("5\n"); */
xpost_stack_push(ctx->lo, ctx->os, ctx->currentobject);
#if 0
/* printf("6\n"); */
xpost_stack_push(ctx->lo, ctx->os, xpost_object_cvlit(xpost_name_cons(ctx, errorname[err])));
/* printf("7\n"); */
xpost_stack_push(ctx->lo, ctx->es, xpost_object_cvx(xpost_name_cons(ctx, "signalerror")));
#endif
ed = xpost_dict_get(ctx, sd, nameerrordict);
xpost_stack_push(ctx->lo, ctx->es,
xpost_dict_get(ctx, ed,
xpost_name_cons(ctx, errorname[err])));
/* printf("8\n"); */
itpdata->in_onerror = 0;
}
/* initialize the name string stacks and name search trees (per memory file).
seed the search trees.
initialize and populate the optab and systemdict (global memory file).
push systemdict on dict stack.
allocate and push globaldict on dict stack.
allocate and push userdict on dict stack.
return 1 on success, 0 on failure
*/
static
int _xpost_interpreter_extra_context_init(Xpost_Context *ctx, const char *device)
{
int ret;
ret = xpost_name_init(ctx); /* NAMES NAMET */
if (!ret)
{
xpost_memory_file_exit(ctx->lo);
xpost_memory_file_exit(ctx->gl);
return 0;
}
ctx->vmmode = GLOBAL;
ret = xpost_operator_init_optab(ctx); /* allocate and zero the optab structure */
if (!ret)
{
xpost_memory_file_exit(ctx->lo);
xpost_memory_file_exit(ctx->gl);
return 0;
}
/* seed the tree with a word from the middle of the alphabet */
/* middle of the start */
/* middle of the end */
if (xpost_object_get_type(xpost_name_cons(ctx, "maxlength")) == invalidtype)
return 0;
if (xpost_object_get_type(xpost_name_cons(ctx, "getinterval")) == invalidtype)
return 0;
if (xpost_object_get_type(xpost_name_cons(ctx, "setmiterlimit")) == invalidtype)
return 0;
if (xpost_object_get_type((namedollarerror = xpost_name_cons(ctx, "$error"))) == invalidtype)
return 0;
if (xpost_object_get_type((nameerrordict = xpost_name_cons(ctx, "errordict"))) == invalidtype)
return 0;
xpost_oplib_init_ops(ctx); /* populate the optab (and systemdict) with operators */
{
Xpost_Object gd; /*globaldict */
gd = xpost_dict_cons (ctx, 100);
if (xpost_object_get_type(gd) == nulltype)
{
XPOST_LOG_ERR("cannot allocate globaldict");
return 0;
}
ret = xpost_dict_put(ctx, xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 0), xpost_name_cons(ctx, "globaldict"), gd);
if (ret)
return 0;
xpost_stack_push(ctx->lo, ctx->ds, gd);
}
ctx->vmmode = LOCAL;
/* seed the tree with a word from the middle of the alphabet */
/* middle of the start */
/* middle of the end */
if (xpost_object_get_type(xpost_name_cons(ctx, "minimal")) == invalidtype)
return 0;
if (xpost_object_get_type(xpost_name_cons(ctx, "interest")) == invalidtype)
return 0;
if (xpost_object_get_type(xpost_name_cons(ctx, "solitaire")) == invalidtype)
return 0;
{
Xpost_Object ud; /*userdict */
ud = xpost_dict_cons (ctx, 100);
if (xpost_object_get_type(ud) == nulltype)
{
XPOST_LOG_ERR("cannot allocate userdict");
return 0;
}
ret = xpost_dict_put(ctx, ud, xpost_name_cons(ctx, "userdict"), ud);
if (ret)
return 0;
xpost_stack_push(ctx->lo, ctx->ds, ud);
}
ctx->device_str = device;
return 1;
}
/*
destroy the given context and associated memory files (if not in use by a shared context)
exit interpreter if all contexts are destroyed.
*/
XPAPI void xpost_destroy(Xpost_Context *ctx)
{
if (!xpost_dict_known_key(ctx, ctx->gl, xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 0), xpost_name_cons(ctx, "QUIET")))
{
printf("bye!\n");
fflush(NULL);
}
/*xpost_garbage_collect(itpdata->ctab->gl, 1, 1); */
/*xpost_garbage_collect(itpdata->ctab->lo, 1, 1); */
#if 0
#ifndef XPOST_NO_GC
xpost_garbage_collect(ctx->gl, 1, 1);
xpost_garbage_collect(ctx->lo, 1, 0);
#endif
#endif
/* exit if all contexts are destroyed */
/*xpost_interpreter_exit(itpdata); */
/*free(itpdata); */
}
/*
execute ps program until quit, fall-through to quit,
SHOWPAGE_RETURN semantic, or error (default action: message, purge and quit).
*/
XPAPI int xpost_run(Xpost_Context *ctx, Xpost_Input_Type input_type, const void *inputptr, size_t set_size)
{
Xpost_Object lsav = null;
int llev = 0;
unsigned int vs;
const char *ps_str = NULL;
const char *ps_file = NULL;
const FILE *ps_file_ptr = NULL;
int ret;
Xpost_Object device;
Xpost_Object semantic;
switch(input_type)
{
case XPOST_INPUT_FILENAME:
ps_file = inputptr;
break;
case XPOST_INPUT_STRING:
ps_str = inputptr;
ps_file_ptr = tmpfile();
if (set_size)
fwrite(ps_str, 1, set_size, (FILE*)ps_file_ptr);
else
fwrite(ps_str, 1, strlen(ps_str), (FILE*)ps_file_ptr);
rewind((FILE*)ps_file_ptr);
break;
case XPOST_INPUT_FILEPTR:
ps_file_ptr = inputptr;
break;
case XPOST_INPUT_RESUME: /* resuming a returned session, skip startup */
goto run;
}
/* prime the exec stack
so it starts with a 'start*' procedure,
and if it ever gets to the bottom, it quits.
These procedures are all defined in data/init.ps
*/
xpost_stack_push(ctx->lo, ctx->es, xpost_operator_cons(ctx, "quit", NULL,0,0));
/*
if ps_file is NULL:
if stdin is a tty
`start` proc defined in init.ps runs `executive` which prompts for user input
else
'startstdin' executes stdin but does not prompt
if ps_file is not NULL:
'startfile' executes a named file wrapped in a stopped context with handleerror
*/
if (ps_file)
{
/*printf("ps_file\n"); */
xpost_stack_push(ctx->lo, ctx->os, xpost_object_cvlit(xpost_string_cons(ctx, strlen(ps_file), ps_file)));
xpost_stack_push(ctx->lo, ctx->es, xpost_object_cvx(xpost_name_cons(ctx, "startfilename")));
}
else if (ps_file_ptr)
{
xpost_stack_push(ctx->lo, ctx->os, xpost_object_cvlit(xpost_file_cons(ctx->lo, ps_file_ptr)));
xpost_stack_push(ctx->lo, ctx->es, xpost_object_cvx(xpost_name_cons(ctx, "startfile")));
}
else
{
if (xpost_isatty(fileno(stdin)))
xpost_stack_push(ctx->lo, ctx->es, xpost_object_cvx(xpost_name_cons(ctx, "start")));
else
xpost_stack_push(ctx->lo, ctx->es, xpost_object_cvx(xpost_name_cons(ctx, "startstdin")));
}
(void) xpost_save_create_snapshot_object(ctx->gl);
lsav = xpost_save_create_snapshot_object(ctx->lo);
/* Run! */
run:
ctx->quit = 0;
ctx->state = C_RUN;
ret = mainloop(ctx);
semantic = xpost_dict_get(ctx,
xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 0),
xpost_name_cons(ctx, "ShowpageSemantics"));
if (semantic.int_.val == XPOST_SHOWPAGE_RETURN)
return ret == 1 ? yieldtocaller : 0;
XPOST_LOG_INFO("destroying device");
device = xpost_dict_get(ctx,
xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 2),
xpost_name_cons(ctx, "DEVICE"));
XPOST_LOG_INFO("device type=%s", xpost_object_type_names[xpost_object_get_type(device)]);
/*xpost_operator_dump(ctx, 1); // is this pointer value constant? */
if (xpost_object_get_type(device) == arraytype){
XPOST_LOG_INFO("running proc");
xpost_stack_push(ctx->lo, ctx->es, xpost_operator_cons(ctx, "quit", NULL,0,0));
xpost_stack_push(ctx->lo, ctx->es, device);
ctx->quit = 0;
mainloop(ctx);
device = xpost_stack_pop(ctx->lo, ctx->os);
}
if (xpost_object_get_type(device) == dicttype)
{
Xpost_Object Destroy;
XPOST_LOG_INFO("destroying device dict");
Destroy = xpost_dict_get(ctx, device, xpost_name_cons(ctx, "Destroy"));
if (xpost_object_get_type(Destroy) == operatortype)
{
int res;
xpost_stack_push(ctx->lo, ctx->os, device);
res = xpost_operator_exec(ctx, Destroy.mark_.padw);
if (res)
XPOST_LOG_ERR("%s error destroying device", errorname[res]);
else
XPOST_LOG_INFO("destroyed device");
}
}
xpost_save_restore_snapshot(ctx->gl);
xpost_memory_table_get_addr(ctx->lo,
XPOST_MEMORY_TABLE_SPECIAL_SAVE_STACK, &vs);
if (xpost_object_get_type(lsav) == savetype)
{
for ( llev = xpost_stack_count(ctx->lo, vs);
llev > lsav.save_.lev;
llev-- )
{
xpost_save_restore_snapshot(ctx->lo);
}
}
return noerror;
}
/*
create an executable context using the given device,
output configuration, and semantics.
*/
XPAPI Xpost_Context *xpost_create(const char *device,
Xpost_Output_Type output_type,
const void *outputptr,
Xpost_Showpage_Semantics semantics,
Xpost_Output_Message output_msg,
Xpost_Set_Size set_size,
int width,
int height)
{
Xpost_Object sd, ud;
int ret;
const char *outfile = NULL;
const char *bufferin = NULL;
char **bufferout = NULL;
int quiet;
switch (output_msg)
{
case XPOST_OUTPUT_MESSAGE_QUIET:
quiet = 1;
_xpost_interpreter_is_tracing = 0;
break;
case XPOST_OUTPUT_MESSAGE_VERBOSE:
quiet = 0;
_xpost_interpreter_is_tracing = 0;
break;
case XPOST_OUTPUT_MESSAGE_TRACING:
quiet = 0;
_xpost_interpreter_is_tracing = 1;
break;
default:
XPOST_LOG_ERR("Wrong output message value");
return NULL;;
}
switch (output_type)
{
case XPOST_OUTPUT_FILENAME:
outfile = outputptr;
break;
case XPOST_OUTPUT_BUFFERIN:
bufferin = outputptr;
break;
case XPOST_OUTPUT_BUFFEROUT:
bufferout = (char **)outputptr;
break;
case XPOST_OUTPUT_DEFAULT:
break;
}
#if 0
test_memory();
if (!test_garbage_collect(xpost_interpreter_cid_init,
xpost_interpreter_cid_get_context,
xpost_interpreter_get_initializing,
xpost_interpreter_set_initializing,
xpost_interpreter_alloc_local_memory,
xpost_interpreter_alloc_global_memory))
return NULL;
#endif
nextid = 0; /*reset process counter */
/* Allocate and initialize all interpreter data structures. */
ret = initalldata(device);
if (!ret)
{
return NULL;
}
/* extract systemdict and userdict for additional definitions */
sd = xpost_stack_bottomup_fetch(xpost_ctx->lo, xpost_ctx->ds, 0);
ud = xpost_stack_bottomup_fetch(xpost_ctx->lo, xpost_ctx->ds, 2);
setlocalconfig(xpost_ctx, sd,
device, outfile, bufferin, bufferout,
semantics, set_size, width, height);
if (quiet)
{
xpost_dict_put(xpost_ctx,
sd /*xpost_stack_bottomup_fetch(ctx->lo, ctx->ds, 0)*/ ,
xpost_name_cons(xpost_ctx, "QUIET"),
null);
}
xpost_stack_clear(xpost_ctx->lo, xpost_ctx->hold);
xpost_interpreter_set_initializing(0);
loadinitps(xpost_ctx);
ret = copyudtosd(xpost_ctx, ud, sd);
if (ret)
{
XPOST_LOG_ERR("%s error in copyudtosd", errorname[ret]);
return NULL;
}
/* make systemdict readonly FIXME: use new access semantics */
xpost_dict_put(xpost_ctx, sd, xpost_name_cons(xpost_ctx, "systemdict"), sd);
xpost_object_set_access(xpost_ctx, sd, XPOST_OBJECT_TAG_ACCESS_READ_ONLY);
#if 0
if (!xpost_stack_bottomup_replace(xpost_ctx->lo, xpost_ctx->ds, 0, xpost_object_set_access(xpost_ctx, sd, XPOST_OBJECT_TAG_ACCESS_READ_ONLY)))
{
XPOST_LOG_ERR("cannot replace systemdict in dict stack");
return NULL;
}
#endif
xpost_interpreter_set_initializing(0);
return xpost_ctx;
}
int main(void)
{
if (!xpost_init())
{
fprintf(stderr, "Fail to initialize xpost name test\n");
return -1;
}
printf("\n^test nm\n");
//init(&ctx);
init();
ctx->vmmode = LOCAL;
printf("pop ");
xpost_object_dump(xpost_name_cons(ctx, "pop"));
printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
//xpost_stack_dump(ctx->gl, xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK)); puts("");
printf("apple ");
xpost_object_dump(xpost_name_cons(ctx, "apple"));
xpost_object_dump(xpost_name_cons(ctx, "apple"));
//printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
//xpost_stack_dump(ctx->gl, xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK)); puts("");
printf("banana ");
xpost_object_dump(xpost_name_cons(ctx, "banana"));
xpost_object_dump(xpost_name_cons(ctx, "banana"));
//printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
//xpost_stack_dump(ctx->gl, xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK)); puts("");
printf("currant ");
xpost_object_dump(xpost_name_cons(ctx, "currant"));
xpost_object_dump(xpost_name_cons(ctx, "currant"));
//printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
//xpost_stack_dump(ctx->gl, xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK)); puts("");
printf("apple ");
xpost_object_dump(xpost_name_cons(ctx, "apple"));
printf("banana ");
xpost_object_dump(xpost_name_cons(ctx, "banana"));
printf("currant ");
xpost_object_dump(xpost_name_cons(ctx, "currant"));
printf("date ");
//printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
xpost_object_dump(xpost_name_cons(ctx, "date"));
//printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
xpost_stack_dump(ctx->gl, xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK)); puts("");
//printf("NAMES at %u\n", xpost_memory_table_get_addr(ctx->gl, XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK));
printf("elderberry ");
xpost_object_dump(xpost_name_cons(ctx, "elderberry"));
printf("pop ");
xpost_object_dump(xpost_name_cons(ctx, "pop"));
//xpost_memory_file_dump(ctx->gl);
//dumpmtab(ctx->gl, 0);
puts("");
xpost_quit();
return 0;
}
