/* file string readstring substring true
false
read from file into string */
static
int xpost_op_file_readstring (Xpost_Context *ctx,
Xpost_Object F,
Xpost_Object S)
{
int n;
Xpost_File *f;
char *s;
if (!xpost_file_get_status(ctx->lo, F))
return ioerror;
if (!xpost_object_is_readable(ctx,F))
return invalidaccess;
f = xpost_file_get_file_pointer(ctx->lo, F);
s = xpost_string_get_pointer(ctx, S);
n = xpost_file_read(s, 1, S.comp_.sz, f);
if (n == S.comp_.sz)
{
xpost_stack_push(ctx->lo, ctx->os, S);
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(1));
}
else
{
S.comp_.sz = n;
xpost_stack_push(ctx->lo, ctx->os, S);
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(0));
}
return 0;
}
/* file status bool
return bool indicating whether file object is active or closed */
static
int xpost_op_file_status (Xpost_Context *ctx,
Xpost_Object F)
{
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(xpost_file_get_status(ctx->lo, F)));
return 0;
}
/* file string readline substring true
false
read a line of text from file */
static
int xpost_op_file_readline (Xpost_Context *ctx,
Xpost_Object F,
Xpost_Object S)
{
Xpost_File *f;
char *s;
int n, c = ' ';
if (!xpost_file_get_status(ctx->lo, F))
return ioerror;
if (!xpost_object_is_readable(ctx,F))
return invalidaccess;
f = xpost_file_get_file_pointer(ctx->lo, F);
s = xpost_string_get_pointer(ctx, S);
for (n = 0; n < S.comp_.sz; n++)
{
c = xpost_file_getc(f);
if (c == EOF || c == '\n')
break;
s[n] = c;
}
if (n == S.comp_.sz && c != '\n')
return rangecheck;
S.comp_.sz = n;
xpost_stack_push(ctx->lo, ctx->os, S);
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(c != EOF));
return 0;
}
/* obj xcheck bool
test executable attribute in obj */
static
int Axcheck(Xpost_Context *ctx,
Xpost_Object o)
{
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(xpost_object_is_exe(o)));
return 0;
}
/* any gcheck bool
check whether value is a legal element of a global compound object */
static
int Agcheck (Xpost_Context *ctx,
Xpost_Object A)
{
Xpost_Object r;
switch(xpost_object_get_type(A)) {
default:
r = xpost_bool_cons(0); break;
case stringtype:
case nametype:
case dicttype:
case arraytype:
r = xpost_bool_cons((A.tag&XPOST_OBJECT_TAG_DATA_FLAG_BANK)!=0);
}
xpost_stack_push(ctx->lo, ctx->os, r);
return 0;
}
/* obj wcheck bool
test obj for write-access */
static
int Awcheck(Xpost_Context *ctx,
Xpost_Object o)
{
//xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons( (o.tag & XPOST_OBJECT_TAG_DATA_FLAG_ACCESS_MASK) >> XPOST_OBJECT_TAG_DATA_FLAG_ACCESS_OFFSET == XPOST_OBJECT_TAG_ACCESS_UNLIMITED ));
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons( xpost_object_get_access(ctx, o) == XPOST_OBJECT_TAG_ACCESS_UNLIMITED));
return 0;
}
/* file read int true
false
read a byte from file */
static
int xpost_op_file_read(Xpost_Context *ctx,
Xpost_Object f)
{
Xpost_Object b;
if (!xpost_object_is_readable(ctx,f))
return invalidaccess;
b = xpost_file_read_byte(ctx->lo, f);
if (xpost_object_get_type(b) == invalidtype)
return ioerror;
if (b.int_.val != EOF)
{
xpost_stack_push(ctx->lo, ctx->os, b);
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(1));
}
else
{
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(0));
}
return 0;
}
/* file string readhexstring substring true
false
read hex-encoded data from file into string */
static
int xpost_op_file_readhexstring (Xpost_Context *ctx,
Xpost_Object F,
Xpost_Object S)
{
int n;
int c[2];
int eof = 0;
Xpost_File *f;
char *s;
if (!xpost_file_get_status(ctx->lo, F))
return ioerror;
if (!xpost_object_is_readable(ctx,F))
return invalidaccess;
f = xpost_file_get_file_pointer(ctx->lo, F);
s = xpost_string_get_pointer(ctx, S);
for (n = 0; !eof && n < S.comp_.sz; n++)
{
do
{
c[0] = xpost_file_getc(f);
if (c[0] == EOF) ++eof;
} while(!eof && strchr(hex, c[0]) != NULL);
if (!eof)
{
do
{
c[1] = xpost_file_getc(f);
if (c[1] == EOF) ++eof;
} while(!eof && strchr(hex, c[1]) != NULL);
}
else
{
c[1] = '0';
}
s[n] = ((strchr(hex, toupper(c[0])) - hex) << 4)
| (strchr(hex, toupper(c[1])) - hex);
}
S.comp_.sz = n;
xpost_stack_push(ctx->lo, ctx->os, S);
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(!eof));
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;
}
/* - currentglobal bool
return vm allocation mode for current context */
static
int Zcurrentglobal (Xpost_Context *ctx)
{
xpost_stack_push(ctx->lo, ctx->os, xpost_bool_cons(ctx->vmmode==GLOBAL));
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);
}