/* 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;
}
static
int init_test_garbage(int (*xpost_interpreter_cid_init)(unsigned int *cid),
Xpost_Context *(*xpost_interpreter_cid_get_context)(unsigned int cid),
int (*xpost_interpreter_get_initializing)(void),
void (*xpost_interpreter_set_initializing)(int),
Xpost_Memory_File *(*xpost_interpreter_alloc_global_memory)(void),
Xpost_Memory_File *(*xpost_interpreter_alloc_local_memory)(void))
{
int fd;
unsigned int cid;
char fname[] = "xmemXXXXXX";
unsigned int tadr;
int ret;
unsigned int ent;
/* create interpreter and context */
itpdata = malloc(sizeof*itpdata);
if (!itpdata) return 0;
memset(itpdata, 0, sizeof*itpdata);
ret = xpost_interpreter_cid_init(&cid);
if (!ret)
return 0;
ctx = xpost_interpreter_cid_get_context(cid);
ctx->id = cid;
/* create global memory file */
ctx->gl = xpost_interpreter_alloc_global_memory();
if (ctx->gl == NULL)
{
return 0;
}
fd = mkstemp(fname);
ret = xpost_memory_file_init(ctx->gl, fname, fd, xpost_interpreter_cid_get_context,
xpost_interpreter_get_initializing, xpost_interpreter_set_initializing);
if (!ret)
{
close(fd);
return 0;
}
ret = xpost_memory_table_init(ctx->gl, &tadr);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
return 0;
}
ret = xpost_free_init(ctx->gl);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
return 0;
}
ret = xpost_save_init(ctx->gl);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
return 0;
}
ret = xpost_context_init_ctxlist(ctx->gl);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
return 0;
}
xpost_context_append_ctxlist(ctx->gl, ctx->id);
ctx->gl->start = XPOST_MEMORY_TABLE_SPECIAL_OPERATOR_TABLE + 1;
/* create local memory file */
ctx->lo = xpost_interpreter_alloc_local_memory();
if (ctx->lo == NULL)
{
xpost_memory_file_exit(ctx->gl);
return 0;
}
strcpy(fname, "xmemXXXXXX");
fd = mkstemp(fname);
ret = xpost_memory_file_init(ctx->lo, fname, fd, xpost_interpreter_cid_get_context,
xpost_interpreter_get_initializing, xpost_interpreter_set_initializing);
if (!ret)
{
close(fd);
xpost_memory_file_exit(ctx->gl);
return 0;
}
ret = xpost_memory_table_init(ctx->lo, &tadr);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
xpost_memory_file_exit(ctx->lo);
return 0;
}
ret = xpost_free_init(ctx->lo);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
xpost_memory_file_exit(ctx->lo);
return 0;
}
ret = xpost_save_init(ctx->lo);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
xpost_memory_file_exit(ctx->lo);
return 0;
}
ret = xpost_context_init_ctxlist(ctx->lo);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
xpost_memory_file_exit(ctx->lo);
return 0;
}
xpost_context_append_ctxlist(ctx->lo, ctx->id);
ctx->lo->start = XPOST_MEMORY_TABLE_SPECIAL_BOGUS_NAME + 1;
/* create names in both mfiles */
ret = xpost_name_init(ctx);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
xpost_memory_file_exit(ctx->lo);
return 0;
}
/* create global OPTAB */
ctx->vmmode = GLOBAL;
/*ret = initoptab(ctx);*/ /* NO! only need to allocate something in the table slot */
ret = xpost_memory_table_alloc(ctx->gl, 1024, 0, &ent);
if (!ret)
{
xpost_memory_file_exit(ctx->gl);
xpost_memory_file_exit(ctx->lo);
return 0;
}
/* ... no initop(). don't need operators for this. */
/* only need one stack */
ctx->vmmode = LOCAL;
xpost_stack_init(ctx->lo, &ctx->hold);
ctx->os = ctx->ds = ctx->es = ctx->hold;
ctx->gl->interpreter_set_initializing(0); /* garbage collector won't run otherwise */
return 1;
}
