![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dread.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ap / apkeys|
Return to dread.c CVS log | Up to [Research Unix] / researchv10no / cmd / ap / apkeys |
1.1 root 1: # include "stdio.h"
2: # include "assert.h"
3: # include "key..c"
4: # include "sys/types.h"
5: # include "sys/stat.h"
6: int nseq =0;
7: int nsent=0;
8: int nstory=0;
9: int ndest= -1;
10: struct wordstr *wds;
11: int nwds = 0;
12: struct matchstr *seqs;
13: int *ok, *len, *wseen;
14: struct matchstr *sents;
15: struct matchstr *stories;
16: struct deststr *dests;
17: FILE * zfopen();
18: extern FILE *yyin;
19: extern char today[];
20: stread()
21: {
22: char line[400], *calloc(), buff[400];
23: int i, a, b, c, d, e;
24: gets(line);
25: nwds= atoi(line);
26: wds = (struct wordstr *)calloc(nwds+1, sizeof (*wds));
27: assert(wds!=0);
28: for(i=0; i<nwds; i++)
29: {
30: gets(line);
31: sscanf(line, "%s %d %d %d %d", buff, &a, &b, &c, &d);
32: wds[i].wch = svc(buff);
33: wds[i].seq = a;
34: wds[i].ifneg = b;
35: wds[i].which = c;
36: wds[i].mask = d;
37: }
38: gets(line);
39: nseq=atoi(line);
40: seqs = (struct matchstr *)calloc(nseq+1, sizeof(*seqs));
41: ok = (int *)calloc(nseq+1, sizeof(*ok));
42: len = (int *)calloc(nseq+1, sizeof(*len));
43: wseen = (int *)calloc(nseq+1, sizeof(*wseen));
44: assert(seqs!=0);
45: for(i=0; i<nseq; i++)
46: {
47: gets(line);
48: sscanf(line, "%d %d %d %d %d", &a, &b, &c, &d, &e);
49: seqs[i].next = a;
50: seqs[i].ntype = b;
51: seqs[i].lim = c;
52: seqs[i].smask = d;
53: len[i]=e;
54: }
55: gets(line);
56: nsent=atoi(line);
57: sents = (struct matchstr *)calloc(nsent+1, sizeof(*sents));
58: assert(sents!=0);
59: for(i=0; i<nsent; i++)
60: {
61: gets(line);
62: sscanf(line, "%d %d %d %d", &a, &b, &c, &d);
63: sents[i].next = a;
64: sents[i].ntype = b;
65: sents[i].lim =c;
66: sents[i].smask=d;
67: }
68: gets(line);
69: nstory=atoi(line);
70: stories = (struct matchstr *)calloc(nstory+1, sizeof(*stories));
71: assert(stories!=0);
72: for(i=0; i<nstory; i++)
73: {
74: gets(line);
75: sscanf(line, "%d %d %d", &a, &b, &c);
76: stories[i].next = a;
77: stories[i].ntype = b;
78: stories[i].lim = c;
79: }
80: gets(line);
81: ndest=atoi(line);
82: dests = (struct deststr *)calloc(ndest+1, sizeof(*dests));
83: assert(dests!=0);
84: for(i=0; i<ndest; i++)
85: {
86: gets(line);
87: dests[i].sndflg = atoi(line);
88: assert(strlen(line+2)<400);
89: dests[i].dstr = svc(line+2);
90: }
91: fprintf(stderr, "nwds %d nseq %d nsent %d sents %o\n",nwds,nseq,nsent, sents);
92: fprintf(stderr, "nstory %d ndests %d dests %o\n",nstory, ndest, dests);
93: fprintf(stderr, "about to exit stread\n");
94: }
95: char *yylval;
96: # define WORD 1
97: # define DOT 2
98: extern char *fname;
99: process()
100: {
101: int k, i, j;
102: yylval= (char *) calloc(10,1); /* get it set up */
103: for(i=0; i<nseq; i++)
104: seqs[i].ct=ok[i]=wseen[i]=0;
105: for(i=0; i<nsent; i++)
106: sents[i].ct=0;
107: for(i=0; i<nstory; i++)
108: stories[i].ct=0;
109: yyunput('#');
110: while (k = yylex())
111: {
112: switch(k)
113: {
114: case WORD:
115: i = search(yylval);
116: while (i<nwds && strcmp(wds[i].wch, yylval)==0)
117: hit(i++);
118: break;
119: case DOT:
120: senthits();
121: for(i=0; i<nsent; i++)
122: sents[i].ct=0;
123: break;
124: }
125: for(i=0; i<nseq; i++)
126: {
127: if (wseen[i] ==len[i] && seqs[i].ct==seqs[i].lim)
128: seqhit(i);
129: if (wseen[i]>0 && missing(i, wseen[i])) wseen[i]++;
130: else
131: if (ok[i]==0 || (seqs[i].ct==0) || (wseen[i]>len[i]))
132: seqs[i].ct=wseen[i]=0;
133: ok[i]=0;
134: }
135: }
136: storyhits();
137: }
138: hit(i)
139: {
140: int j, m, n, ms;
141: j = wds[i].seq;
142: ms = wds[i].mask;
143: switch(wds[i].which)
144: {
145: case SEQ:
146: ok[j]=1;
147: while (missing(j, wseen[j])) wseen[j]++; /* anything we didn't see */
148: wseen[j]++;
149: seqs[j].ct |= ms;
150: if (wseen[j]==len[j] && seqs[j].ct== seqs[j].lim)
151: {
152: seqhit(j);
153: wseen[j]=0;
154: }
155: return;
156: case SENT:
157: sents[j].ct |= ms;
158: return;
159: case STORY:
160: stories[j].ct |= ms;
161: return;
162: case DEST:
163: if (wds[i].ifneg==0)
164: found(j);
165: return;
166: }
167: }
168: seqhit(j)
169: {
170: int m, ms;
171: m = seqs[j].next;
172: ms = seqs[j].smask;
173: switch(seqs[j].ntype)
174: {
175: case SENT:
176: sents[m].ct |= ms;
177: break;
178: case STORY:
179: stories[m].ct |= ms;
180: break;
181: case DEST:
182: found(m);
183: break;
184: }
185: }
186: senthits()
187: {
188: int m,n;
189: for(m=0; m<nsent; m++)
190: if (sents[m].ct==sents[m].lim)
191: {
192: n = sents[m].next;
193: switch(sents[m].ntype)
194: {
195: case STORY:
196: stories[n].ct |= sents[m].smask;
197: continue;
198: case DEST:
199: found(n);
200: continue;
201: }
202: }
203: }
204: storyhits()
205: {
206: int n;
207: for(n=0; n<nstory; n++)
208: if (stories[n].ct==stories[n].lim)
209: found(stories[n].next);
210: }
211: int tosend[400];
212: int nts=0;
213: found(nx)
214: {
215: int i;
216: for(i=0; i<nts; i++)
217: if (tosend[i]==nx)
218: return;
219: tosend[nts++]=nx;
220: assert(nts<400);
221: }
222: extern int debug;
223: deliver()
224: {
225: char *d, sline[300];
226: int nx, para, i, sendf;
227: int gate;
228: FILE *fi, *fo;
229: for(i=0; i<nts; i++)
230: {
231: nx = tosend[i];
232: d = dests[nx].dstr;
233: if (debug) printf("Send %s to %s\n", fname, d);
234: if (d[0]=='*')
235: {
236: printf("deliver %d to :%s:\n",nx,d+1);
237: continue;
238: }
239: if (d[0]=='|')
240: {
241: pipeto(d+1, fname, dests[nx].sndflg);
242: continue;
243: }
244: if (d[0]=='>' && d[1]=='>')
245: fo = zfopen(d+2, "a");
246: else if (d[0]=='>')
247: fo = zfopen(d+1, "w");
248: if (fo==NULL) /* may be a directory */
249: {
250: char temp[400];
251: while (*d=='>' || *d==' ') d++;
252: sprintf(temp, "%s/%s.%s", d, today, fname);
253: fo = zfopen(temp, "a");
254: }
255: if (fo==NULL) continue;
256: sendf = dests[nx].sndflg;
257: fi = fopen(fname, "r");
258: para=0;
259: gate = debug ? 1 : 0; /* pass on first line */
260: while (fgets(sline, 300, fi))
261: {
262: if (strncmp(sline, "\t ", 4)==0) para++;
263: if (para==2 && sendf==2) break;
264: fputs(sline, fo);
265: if (gate>0)
266: {
267: printf("%s", sline);
268: gate=0;
269: }
270: if (sendf==1) break;
271: }
272: fclose(fo); fclose(fi);
273: }
274: nts=0;
275: }
276: pipeto( command, file, sendf)
277: char *command, *file;
278: {
279: int fp[2], fr, fw, para, gate;
280: char sline[300];
281: FILE *fi, *fo;
282: assert(pipe(fp)!= -1);
283: fr = fp[0]; fw = fp[1];
284: if (fork()==0)
285: {
286: close(fw);
287: close(0);
288: assert(dup(fr)==0);
289: system(command);
290: exit(0);
291: }
292: close(fr);
293: fi = fopen(file, "r");
294: fo = fopen("/dev/null", "w");
295: assert(fi!=NULL);
296: assert(fo!=NULL);
297: close(fo->_file);
298: fo->_file = fw;
299: para=0;
300: gate = debug ? 1 : 0;
301: fprintf(fo, "(%s) ", file);
302: while (fgets(sline, 300, fi))
303: {
304: if (strncmp(sline, "\t ", 4)==0) para++;
305: if (para==2 && sendf == 2) break;
306: fputs(sline, fo);
307: if (gate>0)
308: {
309: printf("%s", sline);
310: gate=0;
311: }
312: if (sendf==1) break;
313: }
314: fclose(fo);
315: fclose(fi);
316: wait(0);
317: return;
318: }
319: search(s)
320: char *s;
321: {
322: /* binarysearch from 1 to nwds thru wds[].wch */
323: /* find x such that [x-1]is <s and x big as possible */
324: int i, j, low, hi, lv, hv;
325: low=0; hi=nwds-1; i= -10;
326: while (low+1 < hi)
327: {
328: i = (low+hi)/2;
329: j = strcmp (wds[i].wch, s);
330: if (j>=0)
331: {
332: hi=i;
333: continue;
334: }
335: low=i;
336: }
337: if (i==hi)
338: {
339: hv = j;
340: lv = strcmp(wds[low].wch, s);
341: }
342: else if (i==low)
343: {
344: lv = j;
345: hv = strcmp(wds[hi].wch, s);
346: }
347: else
348: {
349: lv = strcmp(wds[low].wch, s);
350: hv = strcmp(wds[hi].wch, s);
351: }
352: if (lv==0) return(low);
353: if (hv==0) return(hi);
354: return(low);
355: }
356: missing( i, lni )
357: {
358: /* checks whether the next item in a sequence is deliberately missing */
359: if (lni<0) return(0);
360: if ((seqs[i].lim & (1<<lni))==0) return(1);
361: return(0);
362: }
363: FILE *
364: zfopen( fnam, w)
365: char *fnam, *w;
366: {
367: /* this opens file fnam and if successful, tries to donate
368: to the user who owns the including directory */
369: char td[100];
370: FILE *f;
371: struct stat buf;
372: char *x;
373: while (*fnam==' ') fnam++;
374: f = fopen(fnam, w);
375: if (f==NULL) return(NULL);
376: strcpy(td, fnam);
377: for (x=td; *x; x++);
378: while (x>td && *x!='/') x--;
379: *x=0;
380: if (x<=td) return(f);
381: stat (td, &buf);
382: chown (fnam, buf.st_uid, buf.st_gid);
383: return(f);
384: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.