/* initialize */
extern Sinstack *
s_allocinstack(char *file)
{
Sinstack *sp;
Biobuf *fp;
fp = Bopen(file, OREAD);
if(fp == nil)
return nil;
sp = malloc(sizeof *sp);
sp->depth = 0;
sp->fp[0] = fp;
return sp;
}
static Biobuf*
openPW(char *id, int mode)
{
int nfn = strlen(SECSTORE_DIR)+strlen(id)+20;
char *fn;
Biobuf *b;
if(validatefile(id) == nil || strcmp(id,".") == 0)
return nil;
fn = emalloc(nfn);
snprint(fn, nfn, "%s/who/%s", SECSTORE_DIR, id);
b = Bopen(fn, mode);
free(fn);
return b;
}
void
readlife(char *filename)
{
int c, i, j;
char name[256];
Biobuf *bp;
if ((bp = Bopen(filename, OREAD)) == nil) {
snprint(name, sizeof name, "/sys/games/lib/life/%s", filename);
if ((bp = Bopen(name, OREAD)) == nil)
sysfatal("can't read %s: %r", name);
}
draw(screen, screen->r, display->white, nil, ZP);
for (i = 0; i != NLIFE; i++) {
row[i] = col[i] = 0;
for (j = 0; j != NLIFE; j++)
life[i][j] = 0;
}
c = 0;
for (i = 1; i != NLIFE - 1 && c >= 0; i++) {
j = 1;
while ((c = Bgetc(bp)) >= 0 && c != '\n')
if (j != NLIFE - 1)
switch (c) {
case '.':
j++;
break;
case 'x':
birth(i, j);
j++;
break;
}
}
Bterm(bp);
centerlife();
}
/*
* parse user's cron file
* other lines: minute hour monthday month weekday host command
*/
Job *
readjobs(char *file, User *user)
{
Biobuf *b;
Job *j, *jobs;
Dir *d;
int line;
d = dirstat(file);
if(!d)
return nil;
b = Bopen(file, OREAD);
if(!b){
free(d);
return nil;
}
jobs = nil;
user->lastqid = d->qid;
free(d);
for(line = 1; savec = Brdline(b, '\n'); line++){
savec[Blinelen(b) - 1] = '\0';
while(*savec == ' ' || *savec == '\t')
savec++;
if(*savec == '#' || *savec == '\0')
continue;
if(strlen(savec) > 1024){
clog("%s: line %d: line too long", user->name, line);
continue;
}
j = emalloc(sizeof *j);
j->time.min = gettime(0, 59);
if(j->time.min && (j->time.hour = gettime(0, 23))
&& (j->time.mday = gettime(1, 31))
&& (j->time.mon = gettime(1, 12))
&& (j->time.wday = gettime(0, 6))
&& getname(&j->host)){
j->cmd = emalloc(strlen(savec) + 1);
strcpy(j->cmd, savec);
j->next = jobs;
jobs = j;
}else{
clog("%s: line %d: syntax error", user->name, line);
free(j);
}
}
Bterm(b);
return jobs;
}
void
http(Ticketreq *tr)
{
Ticket t;
char tbuf[TICKETLEN+1];
char key[DESKEYLEN];
char *p;
Biobuf *b;
int n;
n = strlen(tr->uid);
b = Bopen("/sys/lib/httppasswords", OREAD);
if(b == nil){
replyerror("no password file", raddr);
return;
}
/* find key */
for(;;){
p = Brdline(b, '\n');
if(p == nil)
break;
p[Blinelen(b)-1] = 0;
if(strncmp(p, tr->uid, n) == 0)
if(p[n] == ' ' || p[n] == '\t'){
p += n;
break;
}
}
Bterm(b);
if(p == nil) {
randombytes((uchar*)key, DESKEYLEN);
} else {
while(*p == ' ' || *p == '\t')
p++;
passtokey(key, p);
}
/* send back a ticket encrypted with the key */
randombytes((uchar*)t.chal, CHALLEN);
mkkey(t.key);
tbuf[0] = AuthOK;
t.num = AuthHr;
safecpy(t.cuid, tr->uid, sizeof(t.cuid));
safecpy(t.suid, tr->uid, sizeof(t.suid));
convT2M(&t, tbuf+1, key);
write(1, tbuf, sizeof(tbuf));
}
void
buildre(Dreprog *re[3])
{
Biobuf *b;
if((b = Bopen(refile, OREAD)) == nil)
sysfatal("open %s: %r", refile);
re[0] = Breaddfa(b);
re[1] = Breaddfa(b);
re[2] = Breaddfa(b);
if(re[0]==nil || re[1]==nil || re[2]==nil)
sysfatal("Breaddfa: %r");
Bterm(b);
}
Biobuf*
opn(char *p)
{
Biobuf *fd;
while ((fd = Bopen(p, OREAD)) == 0) {
if(msflag || p == devnull)
fatal("Cannot open file %s - quitting\n", p);
else {
fprint(2, "Deroff: Cannot open file %s - continuing\n", p);
p = devnull;
}
}
linect = 0;
return(fd);
}
void
main(int argc, char *argv[])
{
Biobuf stdin, stdout;
while (--argc > 0 && (*++argv)[0] == '-'){
switch ((*argv)[1]){
case 's':
strict = 1;
continue;
case 'j':
join = 1;
continue;
case 'l':
if((*argv)[2] != '\0'){
maxleng = atoi( &((*argv)[2]) );
}
else{
maxleng = atoi(*++argv);
argc--;
}
maxtabs = maxleng/TABLENG - 2;
maxleng -= (maxleng + 5)/10;
continue;
default:
fprint(2, "cb: illegal option %c\n", *argv[1]);
exits("boom");
}
}
Binit(&stdout, 1, OWRITE);
output = &stdout;
if (argc <= 0){
Binit(&stdin, 0, OREAD);
input = &stdin;
work();
} else {
while (argc-- > 0){
if ((input = Bopen( *argv, OREAD)) == 0){
fprint(2, "cb: cannot open input file %s\n", *argv);
exits("boom");
}
work();
argv++;
}
}
exits(0);
}
Biobuf *
prepare(int i, char *arg)
{
struct line *p;
int j, h;
Biobuf *bp;
char *cp, buf[MAXLINELEN];
int nbytes;
Rune r;
bp = Bopen(arg, OREAD);
if (!bp) {
panic(mflag ? 0: 2, "cannot open %s: %r\n", arg);
return 0;
}
if (binary)
return bp;
nbytes = Bread(bp, buf, MIN(1024, MAXLINELEN));
if (nbytes > 0) {
cp = buf;
while (cp < buf+nbytes-UTFmax) {
/*
* heuristic for a binary file in the
* brave new UNICODE world
*/
cp += chartorune(&r, cp);
if (r == 0 || (r > 0x7f && r <= 0xa0)) {
binary++;
return bp;
}
}
Bseek(bp, 0, 0);
}
p = MALLOC(struct line, 3);
for (j = 0; h = readhash(bp, buf); p[j].value = h)
p = REALLOC(p, struct line, (++j+3));
len[i] = j;
file[i] = p;
input[i] = bp; /*fix*/
if (i == 0) { /*fix*/
file1 = arg;
firstchange = 0;
}
else
file2 = arg;
return bp;
}
static void
mapinit(char *mapfile)
{
int nf;
char *ln;
char *fields[2];
Biobuf *bp;
Map *map;
if (mapfile == nil)
return;
bp = Bopen(mapfile, OREAD);
if (bp == nil)
sysfatal("can't read %s", mapfile);
devmap = nil;
while ((ln = Brdline(bp, '\n')) != nil) {
ln[Blinelen(bp)-1] = '\0';
if (*ln == '\0' || *ln == '#')
continue;
nf = tokenize(ln, fields, nelem(fields));
if (nf != 2)
continue;
if(testconfig(fields[0]) != 0) {
print("bad `from' device %s in %s\n",
fields[0], mapfile);
continue;
}
map = malloc(sizeof *map);
map->from = strdup(fields[0]);
map->to = strdup(fields[1]);
map->fdev = iconfig(fields[0]);
map->tdev = nil;
if (access(map->to, AEXIST) < 0) {
/*
* map->to isn't an existing file, so it had better be
* a config string for a device.
*/
if(testconfig(fields[1]) == 0)
map->tdev = iconfig(fields[1]);
}
/* else map->to is the replacement file name */
map->next = devmap;
devmap = map;
}
Bterm(bp);
}
static int
topcmd(char *arg)
{
int done, i, lines, n;
char buf[40], *p;
Biobuf *b;
if(*arg == 0)
return senderr("TOP requires a message number");
n = atoi(arg)-1;
if(n < 0 || n >= nmsg || msg[n].deleted)
return senderr("no such message");
arg = nextarg(arg);
if(*arg == 0)
return senderr("TOP requires a line count");
lines = atoi(arg);
if(lines < 0)
return senderr("bad args to TOP");
snprint(buf, sizeof buf, "%d/raw", msg[n].upasnum);
if((b = Bopen(buf, OREAD)) == nil)
return senderr("message disappeared");
sendok("");
while(p = Brdstr(b, '\n', 1)){
if(p[0]=='.')
Bputc(&out, '.');
Bwrite(&out, p, strlen(p));
Bwrite(&out, "\r\n", 2);
done = p[0]=='\0';
free(p);
if(done)
break;
}
for(i=0; i<lines; i++){
p = Brdstr(b, '\n', 1);
if(p == nil)
break;
if(p[0]=='.')
Bwrite(&out, ".", 1);
Bwrite(&out, p, strlen(p));
Bwrite(&out, "\r\n", 2);
free(p);
}
sendcrnl(".");
Bterm(b);
return 0;
}
void
main(int argc, char **argv)
{
int i;
long a, ae;
char *p;
Entry e;
Binit(&boutbuf, 1, OWRITE);
dict = &dicts[0];
ARGBEGIN {
case 'd':
p = ARGF();
dict = 0;
if(p) {
for(i=0; dicts[i].name; i++)
if(strcmp(p, dicts[i].name)==0) {
dict = &dicts[i];
break;
}
}
if(!dict) {
err("unknown dictionary: %s", p);
exits("nodict");
}
break;
case 'D':
debug++;
break;
ARGEND }
USED(argc,argv);
bdict = Bopen(dict->path, OREAD);
ae = Bseek(bdict, 0, 2);
if(!bdict) {
err("can't open dictionary %s", dict->path);
exits("nodict");
}
for(a = 0; a < ae; a = (*dict->nextoff)(a+1)) {
linelen = 0;
e = getentry(a);
Bprint(bout, "%ld\t", a);
linelen = 4; /* only has to be approx right */
(*dict->printentry)(e, 'h');
}
exits(0);
}
Img*
dssread(char *file)
{
int nx, ny, scale, sumall;
Pix *p, *pend;
uint8_t buf[21];
Biobuf *bp;
Img *ip;
if(debug)
Bprint(&bout, "reading %s\n", file);
bp = Bopen(file, OREAD);
if(bp == 0)
return 0;
if(Bread(bp, buf, sizeof(buf)) != sizeof(buf) ||
buf[0] != 0xdd || buf[1] != 0x99){
werrstr("bad format");
return 0;
}
nx = getlong(buf+2);
ny = getlong(buf+6);
scale = getlong(buf+10);
sumall = getlong(buf+14);
if(debug)
fprint(2, "%s: nx=%d, ny=%d, scale=%d, sumall=%d, nbitplanes=%d,%d,%d\n",
file, nx, ny, scale, sumall, buf[18], buf[19], buf[20]);
ip = malloc(sizeof(Img) + (nx*ny-1)*sizeof(int));
if(ip == 0){
Bterm(bp);
werrstr("no memory");
return 0;
}
ip->nx = nx;
ip->ny = ny;
dodecode(bp, ip->a, nx, ny, buf+18);
ip->a[0] = sumall; /* sum of all pixels */
Bterm(bp);
if(scale > 1){
p = ip->a;
pend = &ip->a[nx*ny];
while(p < pend)
*p++ *= scale;
}
hinv(ip->a, nx, ny);
return ip;
}
static int
listkeys(Key **kp)
{
Biobuf *b;
Key *k;
int nk;
char *p, *f[20];
int nf;
mpint *mod, *ek;
*kp = nil;
if((b = Bopen("/mnt/factotum/ctl", OREAD)) == nil)
return -1;
k = nil;
nk = 0;
while((p = Brdline(b, '\n')) != nil){
p[Blinelen(b)-1] = '\0';
nf = tokenize(p, f, nelem(f));
if(nf == 0 || strcmp(f[0], "key") != 0)
continue;
p = find(f, nf, "proto");
if(p == nil || strcmp(p, "rsa") != 0)
continue;
p = find(f, nf, "n");
if(p == nil || (mod = strtomp(p, nil, 16, nil)) == nil)
continue;
p = find(f, nf, "ek");
if(p == nil || (ek = strtomp(p, nil, 16, nil)) == nil){
mpfree(mod);
continue;
}
p = find(f, nf, "comment");
if(p == nil)
p = "";
k = erealloc(k, (nk+1)*sizeof(k[0]));
k[nk].mod = mod;
k[nk].ek = ek;
k[nk].comment = emalloc(strlen(p)+1);
strcpy(k[nk].comment, p);
nk++;
}
Bterm(b);
*kp = k;
return nk;
}
int
main(int argc, char *argv[])
{
int i;
Biobuf in, *inp;
Rune r;
for(i=0; i<nelem(htmlchars); i++){
chartorune(&r, htmlchars[i].utf);
htmlchars[i].value = r;
}
qsort(htmlchars, nelem(htmlchars), sizeof(htmlchars[0]), hccmp);
ARGBEGIN{
case 't':
title = ARGF();
if(title == nil)
usage();
break;
case 'd':
debug++;
break;
default:
usage();
}ARGEND
Binit(&bout, 1, OWRITE);
if(argc == 0){
header(title);
Binit(&in, 0, OREAD);
process(&in, "<stdin>");
}else{
header(title);
for(i=0; i<argc; i++){
inp = Bopen(argv[i], OREAD);
if(inp == nil)
sysfatal("can't open %s: %r", argv[i]);
process(inp, argv[i]);
Bterm(&(inp->Biobufhdr));
}
}
flush();
trailer();
exits(nil);
}
int
_inputstdin(void (*push)(Istack*))
{
Biobuf *b;
Istack *is;
if((b = Bopen("/dev/null", OREAD)) == nil){
fprint(2, "%s: open /dev/null: %r\n", argv0);
return -1;
}
dup(0, b->fid);
is = emalloc(sizeof *is);
is->b = b;
is->name = erunestrdup(L("stdin"));
is->lineno = 1;
push(is);
return 0;
}
void
populate(char *name)
{
char *p;
Fileinf f;
ZipHead zh;
int ok, entries;
crctab = mkcrctab(ZCrcPoly);
ok = inflateinit();
if(ok != FlateOk)
sysfatal("inflateinit failed: %s", flateerr(ok));
bin = Bopen(name, OREAD);
if (bin == nil)
error("Can't open argument file");
entries = findCDir(bin);
if(entries < 0)
sysfatal("empty file");
while(entries-- > 0){
memset(&zh, 0, sizeof(zh));
if(!cheader(bin, &zh))
break;
f.addr = zh.off;
if(zh.iattr & IS_TEXT)
f.addr |= High64;
f.mode = (zh.madevers == IS_MSDOS && zh.eattr & IS_RDONLY)? 0444: 0644;
if (zh.meth == 0 && zh.uncsize == 0){
p = strchr(zh.file, '\0');
if(p > zh.file && p[-1] == '/')
f.mode |= (DMDIR | 0111);
}
f.uid = 0;
f.gid = 0;
f.size = zh.uncsize;
f.mdate = msdos2time(zh.modtime, zh.moddate);
f.name = zh.file + ((zh.file[0] == '/')? 1: 0);
poppath(f, 1);
free(zh.file);
}
return ;
}
void
redirectinit(void)
{
static Biobuf *b = nil;
static Qid qid;
char *file, *line, *s, *host, *field[3];
static char pfx[] = "http://";
file = "/sys/lib/httpd.rewrite";
if(b != nil){
if(updateQid(Bfildes(b), &qid) == 0)
return;
Bterm(b);
}
b = Bopen(file, OREAD);
if(b == nil)
sysfatal("can't read from %s", file);
updateQid(Bfildes(b), &qid);
cleartab(redirtab);
cleartab(vhosttab);
while((line = Brdline(b, '\n')) != nil){
line[Blinelen(b)-1] = 0;
s = strchr(line, '#');
if(s != nil && (s == line || s[-1] == ' ' || s[-1] == '\t'))
*s = '\0'; /* chop comment iff after whitespace */
if(tokenize(line, field, nelem(field)) == 2){
if(strncmp(field[0], pfx, STRLEN(pfx)) == 0 &&
strncmp(undecorated(field[1]), pfx, STRLEN(pfx)) != 0){
/* url -> filename */
host = field[0] + STRLEN(pfx);
s = strrchr(host, '/');
if(s)
*s = 0; /* chop trailing slash */
insert(vhosttab, estrdup(host), estrdup(field[1]));
}else{
insert(redirtab, estrdup(field[0]), estrdup(field[1]));
}
}
}
syslog(0, HTTPLOG, "redirectinit pid=%d", getpid());
}
void
stringit(char *str)
{
long posn, start;
int cnt = 0;
long c;
Rune buf[BUFSIZE];
if ((fin = Bopen(str, OREAD)) == 0) {
perror("open");
return;
}
start = 0;
posn = Boffset(fin);
while((c = Bgetrune(fin)) >= 0) {
if(isprint(c)) {
if(start == 0)
start = posn;
buf[cnt++] = c;
if(cnt == BUFSIZE-1) {
buf[cnt] = 0;
Bprint(&fout, "%8ld: %S ...\n", start, buf);
start = 0;
cnt = 0;
}
} else {
if(cnt >= minspan) {
buf[cnt] = 0;
Bprint(&fout, "%8ld: %S\n", start, buf);
}
start = 0;
cnt = 0;
}
posn = Boffset(fin);
}
if(cnt >= minspan){
buf[cnt] = 0;
Bprint(&fout, "%8ld: %S\n", start, buf);
}
Bterm(fin);
}
void
qcmd(char *arname, int count, char **files)
{
int fd, i;
Armember *bp;
Biobuf *bfile;
if(aflag || bflag) {
fprint(2, "ar: abi not allowed with q\n");
exits("error");
}
fd = openar(arname, ORDWR, 1);
if (fd < 0) {
if(!cflag)
fprint(2, "ar: creating %s\n", arname);
fd = arcreate(arname);
}
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
/* leave note group behind when writing archive; i.e. sidestep interrupts */
rfork(RFNOTEG);
Bseek(&bar, 0, 2);
bp = newmember();
for(i=0; i<count && files[i]; i++) {
file = files[i];
files[i] = 0;
bfile = Bopen(file, OREAD);
if(!bfile)
fprint(2, "ar: %s cannot open\n", file);
else {
mesg('q', file);
armove(bfile, 0, bp);
if (!arwrite(fd, bp))
wrerr();
free(bp->member);
bp->member = 0;
Bterm(bfile);
}
}
free(bp);
close(fd);
}
void
patchopen(void)
{
Biobuf *b;
int32_t l, m;
char buf[100];
if(patchdb == 0) {
patchdb = eopen("patch");
sprint(buf, "%s/patchindex.scat", dir);
b = Bopen(buf, OREAD);
if(b == 0) {
fprint(2, "can't open %s\n", buf);
exits("open");
}
for(m=0,l=0; l<=Npatch; l++)
patchaddr[l] = m += Bgetc(b)*4;
Bterm(b);
}
}
void
hostobjs(void)
{
int i;
Biobuf *f;
Hostobj *h;
for(i=0; i<nhostobj; i++) {
h = &hostobj[i];
f = Bopen(h->file, OREAD);
if(f == nil) {
ctxt->cursym = S;
diag("cannot reopen %s: %r", h->pn);
errorexit();
}
Bseek(f, h->off, 0);
h->ld(f, h->pkg, h->len, h->pn);
Bterm(f);
}
}
void
main(int argc, char *argv[])
{
int i;
Biobuf *bin;
Binit(&bout, 1, OWRITE);
argv0 = argv[0];
ARGBEGIN {
default: usage();
case 'a': aflag = 1; break;
case 'g': gflag = 1; break;
case 'h': hflag = 1; break;
case 'n': nflag = 1; break;
case 's': sflag = 1; break;
case 'S': nflag = Sflag = 1; break;
case 'u': uflag = 1; break;
case 't': tflag = 1; break;
case 'T': Tflag = 1; break;
} ARGEND
if (argc == 0)
usage();
if (argc > 1)
multifile++;
for(i=0; i<argc; i++){
filename = argv[i];
bin = Bopen(filename, OREAD);
if(bin == 0){
error("cannot open %s", filename);
continue;
}
if (isar(bin))
doar(bin);
else{
Bseek(bin, 0, 0);
dofile(bin);
}
Bterm(bin);
}
exits(errs);
}
int
swapin(void)
{
char *name;
while (sargc > 0 && **sargv == '-') {
if (match("-ms", *sargv)) {
*sargv = MACROS;
break;
}
if (match("-mm", *sargv)) {
*sargv = PYMACS;
break;
}
if (match("-TX", *sargv))
pr1403 = 1;
if (match("-", *sargv))
break;
sargc--;
sargv++;
}
if (sargc <= 0)
return(0);
/* file closing is done by GCOS troff preprocessor */
if(tabin)
Bterm(tabin);
ifile = *sargv;
name = ifile;
if (match(ifile, "-")) {
tabin = (Biobuf*)getcore(sizeof(Biobuf), 1);
Binit(tabin, 0, OREAD);
} else
tabin = Bopen(ifile, OREAD);
iline = 1;
Bprint(&tabout, ".ds f. %s\n", ifile);
Bprint(&tabout, ".lf %d %s\n", iline, name);
if (tabin == 0)
error("Can't open file");
sargc--;
sargv++;
return(1);
}
void
loadexcludefile(char *file)
{
Biobuf *b;
char *p, *q;
int n, inc;
Reprog *re;
if((b = Bopen(file, OREAD)) == nil)
sysfatal("open %s: %r", file);
for(n=1; (p=Brdstr(b, '\n', 1)) != nil; free(p), n++){
q = p+strlen(p);
while(q > p && isspace((uint8_t)*(q-1)))
*--q = 0;
switch(p[0]){
case '\0':
case '#':
continue;
}
inc = 0;
if(strncmp(p, "include ", 8) == 0){
inc = 1;
}else if(strncmp(p, "exclude ", 8) == 0){
inc = 0;
}else
sysfatal("%s:%d: line does not begin with include or exclude", file, n);
if(strchr(p+8, ' '))
fprint(2, "%s:%d: warning: space in pattern\n", file, n);
if((re = glob2regexp(p+8)) == nil)
sysfatal("%s:%d: bad glob pattern", file, n);
pattern = vtrealloc(pattern, (npattern+1)*sizeof pattern[0]);
pattern[npattern].re = re;
pattern[npattern].include = inc;
npattern++;
}
Bterm(b);
}
/* read address file */
void
readaddrs(char *file)
{
Biobuf *b;
char *p;
b = Bopen(file, OREAD);
if(b == nil)
return;
while((p = Brdline(b, '\n')) != nil){
p[Blinelen(b)-1] = 0;
if(*p == '#')
continue;
if(*p == '!')
remaddr(p+1);
else
addaddr(p);
}
Bterm(b);
}
int
_inputfile(Rune *s, void (*push)(Istack*))
{
Istack *is;
Biobuf *b;
char *t;
t = esmprint("%S", s);
if((b = Bopen(t, OREAD)) == nil){
free(t);
fprint(2, "%s: open %S: %r\n", argv0, s);
return -1;
}
free(t);
is = emalloc(sizeof *is);
is->b = b;
is->name = erunestrdup(s);
is->lineno = 1;
push(is);
return 0;
}
static int
isobjfile(char *f)
{
int n, v;
Biobuf *b;
char buf1[5], buf2[SARMAG];
b = Bopen(f, OREAD);
if(b == nil)
return 0;
n = Bread(b, buf1, 5);
if(n == 5 && (buf1[2] == 1 && buf1[3] == '<' || buf1[3] == 1 && buf1[4] == '<'))
v = 1; /* good enough for our purposes */
else{
Bseek(b, 0, 0);
n = Bread(b, buf2, SARMAG);
v = n == SARMAG && strncmp(buf2, ARMAG, SARMAG) == 0;
}
Bterm(b);
return v;
}
static void
mconfinit(void)
{
int nf, pgsize = 0;
uint32_t size, userpgs = 0, userused = 0;
char *ln, *sl;
char *fields[2];
Biobuf *bp;
Mbank *mbp;
size = 64*MB;
bp = Bopen("#c/swap", OREAD);
if (bp != nil) {
while ((ln = Brdline(bp, '\n')) != nil) {
ln[Blinelen(bp)-1] = '\0';
nf = tokenize(ln, fields, nelem(fields));
if (nf != 2)
continue;
if (strcmp(fields[1], "pagesize") == 0)
pgsize = atoi(fields[0]);
else if (strcmp(fields[1], "user") == 0) {
sl = strchr(fields[0], '/');
if (sl == nil)
continue;
userpgs = atol(sl+1);
userused = atol(fields[0]);
}
}
Bterm(bp);
if (pgsize > 0 && userpgs > 0)
size = (((userpgs - userused)*3LL)/4)*pgsize;
}
mconf.memsize = size;
mbp = mconf.bank;
mbp->base = 0x10000000; /* fake addresses */
mbp->limit = mbp->base + size;
mbp++;
mconf.nbank = mbp - mconf.bank;
}
Rune
troff2rune(Rune *rs)
{
char *file, *f[10], *p, s[3];
int i, nf;
Biobuf *b;
if(rs[0] >= Runeself || rs[1] >= Runeself)
return Runeerror;
s[0] = rs[0];
s[1] = rs[1];
s[2] = 0;
if(ntrtab == 0){
for(i=0; i<nelem(trinit) && ntrtab < nelem(trtab); i++){
trtab[ntrtab] = trinit[i];
ntrtab++;
}
file = FONTDIR "/devutf/utfmap";
if((b = Bopen(file, OREAD)) == nil)
sysfatal("open %s: %r", file);
while((p = Brdline(&(b->Biobufhdr), '\n')) != nil){
p[Blinelen(&(b->Biobufhdr))-1] = 0;
nf = getfields(p, f, nelem(f), 0, "\t");
for(i=0; i+2<=nf && ntrtab<nelem(trtab); i+=2){
chartorune(&trtab[ntrtab].r, f[i]);
memmove(trtab[ntrtab].t, f[i+1], 2);
ntrtab++;
}
}
Bterm(&(b->Biobufhdr));
if(ntrtab >= nelem(trtab))
fprint(2, "%s: trtab too small\n", argv0);
}
for(i=0; i<ntrtab; i++)
if(strcmp(s, trtab[i].t) == 0)
return trtab[i].r;
return Runeerror;
}
