212 lines
3.1 KiB
C
212 lines
3.1 KiB
C
#include <u.h>
|
|
#include <libc.h>
|
|
#include <draw.h>
|
|
#include <event.h>
|
|
#include <bio.h>
|
|
#include "proof.h"
|
|
|
|
Rectangle rpage = { 0, 0, 850, 1150 };
|
|
char devname[64];
|
|
double mag = DEFMAG;
|
|
int dbg = 0;
|
|
char *track = 0;
|
|
Biobuf bin;
|
|
char libfont[256] = "/lib/font/bit";
|
|
char mapfile[256] = "MAP";
|
|
char *mapname = "MAP";
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
fprint(2, "usage: proof [-m mag] [-/ nview] [-x xoff] [-y yoff] "
|
|
"[-M mapfile] [-F fontdir] [-dt] file...\n");
|
|
exits("usage");
|
|
}
|
|
|
|
void
|
|
main(int argc, char *argv[])
|
|
{
|
|
char c;
|
|
int dotrack = 0;
|
|
|
|
ARGBEGIN{
|
|
case 'M': /* change MAP file */
|
|
mapname = EARGF(usage());
|
|
break;
|
|
case 'F': /* change /lib/font/bit directory */
|
|
strncpy(libfont, EARGF(usage()), sizeof libfont);
|
|
break;
|
|
case 'd':
|
|
dbg = 1;
|
|
break;
|
|
case 'm': /* magnification */
|
|
mag = atof(EARGF(usage()));
|
|
if (mag < 0.1 || mag > 10){
|
|
fprint(2, "ridiculous mag argument ignored\n");
|
|
mag = DEFMAG;
|
|
}
|
|
break;
|
|
case 't':
|
|
dotrack = 1;
|
|
break;
|
|
case 'x':
|
|
xyoffset.x += atof(EARGF(usage())) * 100;
|
|
break;
|
|
case 'y':
|
|
xyoffset.y += atof(EARGF(usage())) * 100;
|
|
break;
|
|
case '/':
|
|
nview = atof(EARGF(usage()));
|
|
if (nview < 1 || nview > MAXVIEW)
|
|
nview = 1;
|
|
break;
|
|
default:
|
|
usage();
|
|
}ARGEND
|
|
|
|
if (argc > 0) {
|
|
close(0);
|
|
if (open(argv[0], 0) != 0) {
|
|
sysfatal("can't open %s: %r", argv[0]);
|
|
exits("open failure");
|
|
}
|
|
if(dotrack)
|
|
track = argv[0];
|
|
}
|
|
Binit(&bin, 0, OREAD);
|
|
snprint(mapfile, sizeof mapfile, "%s/%s", libfont, mapname);
|
|
readmapfile(mapfile);
|
|
for (c = 0; c < NFONT; c++)
|
|
loadfontname(c, "??");
|
|
mapscreen();
|
|
clearscreen();
|
|
readpage();
|
|
exits(0);
|
|
}
|
|
|
|
/*
|
|
* Input buffer to allow us to back up
|
|
*/
|
|
#define SIZE 100000 /* 8-10 pages, typically */
|
|
|
|
char bufc[SIZE];
|
|
char *inc = bufc; /* where next input character goes */
|
|
char *outc = bufc; /* next character to be read from buffer */
|
|
int off; /* position of outc in total input stream */
|
|
|
|
void
|
|
addc(int c)
|
|
{
|
|
*inc++ = c;
|
|
if(inc == &bufc[SIZE])
|
|
inc = &bufc[0];
|
|
}
|
|
|
|
int
|
|
getc(void)
|
|
{
|
|
int c;
|
|
|
|
if(outc == inc){
|
|
c = Bgetc(&bin);
|
|
if(c == Beof)
|
|
return Beof;
|
|
addc(c);
|
|
}
|
|
off++;
|
|
c = *outc++;
|
|
if(outc == &bufc[SIZE])
|
|
outc = &bufc[0];
|
|
return c;
|
|
}
|
|
|
|
int
|
|
getrune(void)
|
|
{
|
|
int c, n;
|
|
Rune r;
|
|
char buf[UTFmax];
|
|
|
|
for(n=0; !fullrune(buf, n); n++){
|
|
c = getc();
|
|
if(c == Beof)
|
|
return Beof;
|
|
buf[n] = c;
|
|
}
|
|
chartorune(&r, buf);
|
|
return r;
|
|
}
|
|
|
|
int
|
|
nbuf(void) /* return number of buffered characters */
|
|
{
|
|
int ini, outi;
|
|
|
|
ini = inc-bufc;
|
|
outi = outc-bufc;
|
|
if(ini < outi)
|
|
ini += SIZE;
|
|
return ini-outi;
|
|
}
|
|
|
|
ulong
|
|
seekc(ulong o)
|
|
{
|
|
ulong avail;
|
|
long delta;
|
|
|
|
delta = off-o;
|
|
if(delta < 0)
|
|
return Beof;
|
|
avail = SIZE-nbuf();
|
|
if(delta < avail){
|
|
off = o;
|
|
outc -= delta;
|
|
if(outc < &bufc[0])
|
|
outc += SIZE;
|
|
return off;
|
|
}
|
|
return Beof;
|
|
}
|
|
|
|
void
|
|
ungetc(void)
|
|
{
|
|
if(off == 0)
|
|
return;
|
|
if(nbuf() == SIZE){
|
|
fprint(2, "backup buffer overflow\n");
|
|
return;
|
|
}
|
|
if(outc == &bufc[0])
|
|
outc = &bufc[SIZE];
|
|
--outc;
|
|
--off;
|
|
}
|
|
|
|
ulong
|
|
offsetc(void)
|
|
{
|
|
return off;
|
|
}
|
|
|
|
char*
|
|
rdlinec(void)
|
|
{
|
|
static char buf[2048];
|
|
int c, i;
|
|
|
|
for(i=0; i<sizeof buf; ){
|
|
c = getc();
|
|
if(c == Beof)
|
|
break;
|
|
buf[i++] = c;
|
|
if(c == '\n')
|
|
break;
|
|
}
|
|
|
|
if(i == 0)
|
|
return nil;
|
|
return buf;
|
|
}
|