void
tokeytab (const char *t, int nref)
{
n_strcpy(labtab[nref]=lbp, t, sizeof(bflab) - (lbp - bflab));
while (*lbp++)
;
}
void
output(const char *s)
{
if (gate)
fputs(buff,ftemp);
else
gate = 1;
if (strlen(s) > sizeof buff)
err("one buff too big (%d)!", sizeof buff);
n_strcpy(buff, s, sizeof(buff));
}
strid_t startup_findfile(void)
{
static DIR *dir = NULL;
static char *pathstart = NULL;
static char *path = NULL;
strid_t stream;
struct dirent *d;
char *name = NULL;
if(!pathstart) {
char *p = search_path;
if(!p)
return 0;
pathstart = n_strdup(p);
if(!(path = n_strtok(pathstart, ":"))) {
n_free(pathstart);
pathstart = 0;
return 0;
}
}
do {
if(!dir) {
dir = opendir(path);
if(!dir) {
n_free(pathstart);
pathstart = 0;
return 0;
}
}
d = readdir(dir);
if(!d) {
closedir(dir);
dir = NULL;
if(!(path = n_strtok(NULL, ":"))) {
n_free(pathstart);
pathstart = 0;
return 0;
}
}
} while(!dir);
name = (char *) n_malloc(n_strlen(path) + n_strlen(d->d_name) + 2);
n_strcpy(name, path);
n_strcat(name, "/");
n_strcat(name, d->d_name);
stream = glkunix_stream_open_pathname(name, fileusage_Data |
fileusage_BinaryMode, 0);
if(stream)
set_game_filename(name);
n_free(name);
return stream;
}
char *
strsave(char *s)
{
register char *q;
size_t l;
l = strlen(s)+1;
q = malloc(l);
if (q == NULL)
error(FATAL, "out of space in strsave on %s", s);
n_strcpy(q, s, l);
return(q);
}
char *
todir(char *t)
{
char *s;
usedir[0] = 0;
s=t;
while (*s) s++;
while (s>=t && *s != '/') s--;
if (s<t) return(t);
*s++ = 0;
t = (*t ? t : "/");
chdir (t);
n_strcpy (usedir,t,sizeof(usedir));
return(s);
}
int
chkdup(const char *tag)
{
int i;
for(i = 1; i <= refnum; i++) {
if (reftable[i] && strcmp(reftable[i], tag)==0)
return(i);
}
reftable[refnum+1] = rtp;
if (refnum >= NRFTBL)
err("too many references (%d) for table", refnum);
n_strcpy(rtp, tag, NRFTXT - (rtp - reftext));
while (*rtp++);
if (rtp > reftext + NRFTXT)
err("reference pointers too long (%d)", rtp-reftext);
return(0);
}
strid_t startup_open(const char *name)
{
strid_t str;
char *s;
str = glkunix_stream_open_pathname((char *) name, fileusage_Data | fileusage_BinaryMode, 0);
if(str) {
set_game_filename(name);
#ifdef USE_GARGLK_FEATURES
s = strrchr(name, '\\');
if (!s) s = strrchr(name, '/');
garglk_set_story_name(s ? s + 1 : name);
#endif
} else {
char *path = search_path;
if(path) {
char *p;
char *newname = (char *) n_malloc(strlen(path) + strlen(name) + 2);
path = n_strdup(path);
for(p = n_strtok(path, ":"); p; p = n_strtok(NULL, ":")) {
n_strcpy(newname, p);
n_strcat(newname, "/");
n_strcat(newname, name);
str = glkunix_stream_open_pathname((char *) newname, fileusage_Data |
fileusage_BinaryMode, 0);
if(str) {
set_game_filename(newname);
#ifdef USE_GARGLK_FEATURES
s = strrchr(newname, '\\');
if (!s) s = strrchr(newname, '/');
garglk_set_story_name(s ? s + 1 : newname);
#endif
break;
}
}
n_free(path);
}
}
if(!str)
fprintf(stderr, "Cannot open '%s'\n", name);
return str;
}
char *
fpar (int nf, char **flds, char *out, size_t outsiz __unused, int c, int seq,
int prepend)
{
char *p, *s;
int i, fnd = 0;
for(i = 0; i < nf; i++)
if (flds[i][1] == c && ++fnd >= seq) {
/* for titles use first word otherwise last */
if (c == 'T' || c == 'J') {
p = flds[i]+3;
if (prefix(p, "A "))
p += 2;
if (prefix(p, "An "))
p += 3;
if (prefix(p, "The "))
p += 4;
mycpy2(out, p, 20);
return(out);
}
/* if its not 'L' then use just the last word */
s = p = flds[i]+2;
if (c != 'L') {
for(; *p; p++);
while (p > s && *p != ' ')
p--;
}
/* special wart for authors */
if (c == 'A' && (p[-1] == ',' || p[1] =='(')) {
p--;
while (p > s && *p != ' ')
p--;
mycpy(out, p+1);
}
else
n_strcpy(out, p+1, outsiz);
if (c == 'A' && prepend)
initadd(out, flds[i]+2, p);
return(out);
}
return(0);
}
void
huntmain(int argc,char **argv)
{
/* read query from stdin, expect name of indexes in argv[1] */
static FILE *fa, *fb, *fc;
char indexname[PATH_MAX], *qitem[100], *rprog = 0;
char grepquery[200];
static char oldname[30] ;
static int nhash = 0;
static int maxhash = 0;
int falseflg = 0, nitem, nfound, frtbl;
static long *hpt = 0;
unsigned *masterp;
# if D1
fprintf(stderr, "in glue1 argc %d argv %o %o\n", argc, argv[0],argv[1]);
# endif
savedir();
while (argv[1][0] == '-')
{
# if D1
fprintf(stderr, "argv.1 is %s\n",argv[1]);
# endif
switch(argv[1][1])
{
case 'a': /* all output, incl. false drops */
falseflg = 1;
break;
case 'r':
argc--;
argv++;
rprog = argv[1];
break;
case 'F': /* put out full text */
full = setfrom(argv[1][2]);
break;
case 'T': /* put out tags */
tags = setfrom(argv[1][2]);
break;
case 'i': /* input in argument string */
argc--;
argv++;
sinput = argv[1];
break;
case 's': /*text output to string */
case 'o':
argc--;
argv++;
soutput = argv[1];
if ((intptr_t) argv[2]<16000)
{
soutlen = (intptr_t) argv[2];
argc--;
argv++;
}
break;
case 't': /*tag output to string */
argc--;
argv++;
tagout = argv[1];
if ((intptr_t)argv[2]<16000)
{
taglen = (intptr_t)argv[2];
argc--;
argv++;
}
break;
case 'l': /* specify length of lists */
argc--;
argv++;
lmaster = atoi(argv[1]);
# if D1
fprintf(stderr, "lmaster now %d\n",lmaster);
# endif
break;
case 'C':
argc--;
argv++;
colevel = atoi(argv[1]);
break;
}
argc--;
argv++;
}
n_strcpy (indexname, todir(argv[1]), sizeof(indexname));
# if D1
fprintf(stderr, "in huntmain indexname %s typeindex %d\n", indexname, typeindex);
# endif
if (typeindex == 0 || strcmp (oldname, indexname) !=0)
{
n_strcpy (oldname, indexname, sizeof(oldname));
unopen(fa);
unopen(fb);
unopen(fc);
if (ckexist(indexname, ".ib"))
{
# if D1
fprintf(stderr, "found old index\n");
# endif
fa = iopen(indexname, ".ia");
fb = iopen(indexname, ".ib");
fc = iopen(indexname, ".ic");
typeindex =1;
# if D1
fprintf(stderr, "opened f's as %o %o %o\n",fa,fb,fc);
# endif
indexdate = gdate(fb);
fread (&nhash, sizeof(nhash), 1, fa);
fread (&iflong, sizeof(iflong), 1, fa);
if (nhash > maxhash)
{
if (hpt)
free (hpt);
hpt=0;
if (hfreq)
free(hfreq);
hfreq=0;
maxhash=nhash;
# if D1
fprintf(stderr, "Freed if needed maxhash %d\n",maxhash);
# endif
}
if (hpt==0)
hpt = zalloc(nhash, sizeof(*hpt));
# if D1
fprintf(stderr, "hpt now %o\n",hpt);
# endif
if (hpt == NULL)
err("No space for hash list (%d)", nhash);
fread( hpt, sizeof(*hpt), nhash, fa);
if (hfreq==0)
hfreq=zalloc(nhash, sizeof(*hfreq));
if (hfreq==NULL)
err("No space for hash frequencies (%d)",
nhash);
frtbl = fread(hfreq, sizeof(*hfreq), nhash, fa);
hfrflg = (frtbl == nhash);
# if D1
fprintf(stderr,"Read pointer files\n");
# endif
if (master.a == NULL)
{
if (iflong)
master.b = zalloc(lmaster, sizeof(long));
else
master.a = zalloc(lmaster, sizeof(int));
}
if (master.a == NULL)
err("no space for answer list", 0);
}
else
if (makefgrep(indexname))
typeindex=2;
else
{
err("No files %s\n", indexname);
exit(1);
}
}
if (iflong)
masterp = (unsigned *) master.b;
else
masterp = master.a;
# if D1
fprintf(stderr, "typeindex now %d\n",typeindex);
# endif
tagout[0]=0;
if (typeindex==2)
{
grepcall(sinput, tagout, indexname);
# if D1
fprintf(stderr, " back from grepcall\n");
# endif
restodir();
return;
}
nitem = getq(qitem);
# if D1
fprintf(stderr, "approaching doquery fb %o\n", fb);
# endif
nfound = doquery(hpt, nhash, fb, nitem, qitem, masterp);
# ifdef D1
fprintf(stderr, "return from doquery with nfound %d\n", nfound);
# endif
if (falseflg == 0)
nfound = baddrop(masterp, nfound, fc, nitem, qitem, rprog, full);
# ifdef D1
fprintf(stderr, "after baddrop with nfound %d\n",nfound);
fprintf(stderr, "tagout is /%s/, sout /%s/\n",tagout, soutput);
# endif
if (tags)
result (masterp, nfound >tags ? tags : nfound, fc);
# if D1
fprintf(stderr, "done with huntmain\n");
fprintf(stderr, "tagout is /%s/\n", tagout);
fprintf(stderr, "string out is /%s/\n", soutput);
# endif
if (fgnamp>fgnames)
{
char **fgp;
int k;
# if D1
fprintf(stderr, "were %d bad files\n", fgnamp-fgnames);
# endif
grepquery[0]=0;
for(k=0; k<nitem; k++)
{
n_strcat(grepquery, " ", sizeof(grepquery));
n_strcat(grepquery, qitem[k], sizeof(grepquery));
}
for(fgp=fgnames; fgp<fgnamp; fgp++)
{
# if D1
fprintf(stderr, "Now on %s query /%s/\n", *fgp, grepquery);
# endif
makefgrep(*fgp);
grepcall(grepquery, tagout, *fgp);
# if D1
fprintf(stderr, "tagout now /%s/\n", tagout);
# endif
}
}
restodir();
}
int
newkeys (FILE *outf, FILE *inf, FILE *recf, int nhash, FILE *_fd, int *_iflong)
{
/* reads key lines from inf; hashes and writes on outf;
* writes orig key on recf, records pointer on outf too.
* format of outf is : hash code space record pointer
*/
long lp;
long ld = 0;
int ll = 0, lt = 0;
char line[LINESIZ];
char key[30], bkeys[40];
char *p, *s;
char *keyv[500];
int i, nk, ndoc = 0, more = 0, c;
lp = ftell (recf);
while (fgets(line, LINESIZ, inf))
{
p = line;
while (*p != '\t') p++;
*p++ =0;
fputs(line, recf);
if (_fd)
{
snprintf(bkeys, sizeof(bkeys), ";%ld", ld);
ll = strlen(p);
lt = strlen(bkeys);
fputs(bkeys, recf);
snprintf(bkeys, sizeof(bkeys), ",%d", ll);
lt += strlen(bkeys);
fputs(bkeys, recf);
ld += ll;
fputs(p, _fd);
}
putc('\n',recf);
for(s=p; *s; s++);
if (*--s == '\n')
{
more=0;
*s=0;
}
else
more=1;
assert (_fd==0 || more==0);
nk = getargs(p, keyv);
if (more)
nk--;
for(i=0; i<nk; i++)
fprintf(outf,"%04d %06ld\n",hash(keyv[i])%nhash, lp);
# if D1
for(i=0; i<nk; i++)
printf("key %s hash %d\n",keyv[i],hash(keyv[i])%nhash);
# endif
if (more) /* allow more than LINESIZ keys */
{
n_strcpy(key, keyv[nk], sizeof(key));
for(s=key; *s; s++);
while ( (c=getc(inf)) != '\n')
{
if (c != ' ')
{
*s++ = c;
continue;
}
*s=0;
if (s>key)
fprintf(outf, "%04d %06ld\n",hash(key)%nhash, lp);
s = key;
}
}
lp += (strlen(line)+lt+1);
ndoc++;
}
*_iflong = (lp>=65536L);
if (sizeof(int)>2) *_iflong=1; /* force long on VAX */
fclose(recf);
return(ndoc);
}
void
putsig (int nf, char **flds, int nref, char *nstline,
char *endline, int toindex) /* choose signal style */
{
char t[100], t1[MXSIG], t2[100], format[10], *sd, *stline;
int addon = 0, another = 0;
static FILE *fhide = 0;
if (labels) {
if (nf == 0) /* old */
snprintf(t, sizeof(t), "%s%c", labtab[nref],
labc[nref]);
else {
*t = 0;
if (keywant)
fpar(nf, flds, t, sizeof(t), keywant, 1, 0);
if (science && t[0] == 0) {
if (fpar(nf, flds, t, sizeof(t), 'A', 1, 0)
!= 0) {
if (fpar(nf, flds, t2, sizeof(t2),
'D', 1, 0) != 0) {
n_strcat(t, ", ", sizeof(t));
n_strcat(t, t2, sizeof(t));
}
}
} else if (t[0] == 0) {
if (nmlen > 0) {
snprintf(format, sizeof(format),
"%%.%ds%%s", nmlen);
} else {
snprintf(format, sizeof(format),
"%%s%%s");
}
/* format is %s%s for default labels */
/* or %.3s%s eg if wanted */
if (fpar(nf, flds, t2, sizeof(t2), 'D', 1, 0)) {
sd = t2;
if (dtlen > 0) {
int n = strlen(sd) - dtlen;
if (n > 0)
sd += n;
}
} else {
sd = "";
}
t1[0] = 0;
fpar(nf, flds, t1, sizeof(t1), 'A', 1, 0);
snprintf(t, sizeof(t), format, t1, sd);
}
if (keywant) {
addon = 0;
for (sd = t; *sd; sd++)
;
if (*--sd == '-') {
addon = 1;
*sd = 0;
}
}
if ((!keywant || addon) && !science) {
addch(t, keylet(t, nref));
}
else {
tokeytab (t,nref);
}
}
}
else {
if (sort)
snprintf(t, sizeof(t), "%c%d%c", FLAG, nref, FLAG);
else
snprintf(t, sizeof(t), "%d", nref);
}
another = (sd = lookat()) ? prefix(sd, ".[") : 0;
if (another && (strcmp(".[\n", sd) != SAME))
fprintf(stderr, "File %s line %d: punctuation ignored from: %s",
Ifile, Iline, sd);
if ((strlen(sig) + strlen(t)) > MXSIG)
err("sig overflow (%d)", MXSIG);
n_strcat(sig, t, sizeof(sig));
#if EBUG
fprintf(stderr, "sig is now %s leng %d\n",sig,strlen(sig));
#endif
trimnl(nstline);
trimnl(endline);
stline = stbuff;
if (prevsig == 0) {
n_strcpy (stline, nstline, sizeof(stbuff));
prevsig=1;
}
if (stline[2] || endline[2]) {
stline += 2;
endline += 2;
}
else {
stline = "\\*([.";
endline = "\\*(.]";
}
if (science) {
stline = " (";
endline = ")";
}
if (bare == 0) {
if (!another) {
snprintf(t1, sizeof(t1), "%s%s%s\n", stline, sig,
endline);
if (strlen(t1) > MXSIG)
err("t1 overflow (%d)", MXSIG);
append(t1);
flout();
sig[0] = 0;
prevsig = 0;
if (fo == fhide) {
int ch;
fclose(fhide);
fhide = fopen(hidenam, "r");
fo = ftemp;
while ((ch = getc(fhide)) != EOF)
putc(ch, fo);
fclose(fhide);
unlink(hidenam);
}
}
else {
if (labels) {
n_strcat(sig, ",\\|", sizeof(sig));
} else {
/*
* Seperate reference numbers with AFLAG
* for later sorting and condensing.
*/
t1[0] = AFLAG;
t1[1] = '\0';
n_strcat(sig, t1, sizeof(sig));
}
if (fo == ftemp) { /* hide if need be */
snprintf(hidenam, NTFILE,
"/tmp/rj%dc", (int)getpid());
#if EBUG
fprintf(stderr, "hiding in %s\n", hidenam);
#endif
fhide = fopen(hidenam, "w");
if (fhide == NULL)
err("Can't get scratch file %s",
hidenam);
fo = fhide;
}
}
}
if (bare < 2)
if (nf > 0 && toindex)
fprintf(fo,".ds [F %s%c",t,sep);
if (bare > 0)
flout();
#if EBUG
fprintf(stderr, "sig is now %s\n",sig);
#endif
}
int
main(int argc, char **argv)
{
FILE *f;
int i;
char *cp, *cq, c;
stk = calloc(sizeof *stk, maxstk = 100);
/* Figure out how many known commands there are */
while (knowncmds[ncmds])
ncmds++;
while (argc > 1 && argv[1][0] == '-') {
switch (argv[1][1]) {
/* -a: add pairs of macros */
case 'a':
/* look for empty macro slots */
for (i = 0; br[i].opbr; i++)
;
cp = &argv[1][3];
while (*cp) {
size_t s;
if (i >= MAXBR - 3) {
printf("Only %d known pairs allowed\n",
MAXBR/2);
exit(1);
}
for (cq = cp; *cq && *cq != '.'; cq++);
if (*cq != '.')
usage();
*cq = 0;
s = cq - cp + 1;
br[i].opbr = malloc(s);
n_strcpy(br[i].opbr, cp, s);
*cq = '.';
cp = &cq[1];
for (cq = cp; *cq && *cq != '.'; cq++);
c = *cq;
*cq = 0;
s = cq - cp + 1;
br[i].clbr = malloc(s);
n_strcpy(br[i].clbr, cp, s);
*cq = c;
cp = c ? &cq[1] : cq;
/* knows pairs are also known cmds */
addmac(br[i].opbr);
addmac(br[i].clbr);
i++;
}
break;
/* -c: add known commands */
case 'c':
cp = &argv[1][3];
while (*cp) {
for (cq = cp; *cq && *cq != '.'; cq++);
c = *cq;
*cq = 0;
addmac(cp);
*cq = c;
cp = c ? &cq[1] : cq;
}
break;
/* -f: ignore font changes */
case 'f':
fflag = 1;
break;
/* -s: ignore size changes */
case 's':
sflag = 1;
break;
default:
usage();
}
argc--; argv++;
}
nfiles = argc - 1;
if (nfiles > 0) {
for (i = 1; i < argc; i++) {
cfilename = argv[i];
f = fopen(cfilename, "r");
if (f == NULL) {
perror(cfilename);
exit(1);
}
else {
process(f);
fclose(f);
}
}
} else {
cfilename = "stdin";
process(stdin);
}
return (0);
}
