![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to glue5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / refer|
Return to glue5.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / refer |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)glue5.c 4.2 (Berkeley) 1/9/85";
3: #endif
4:
5: #include <stdio.h>
6: #include <ctype.h>
7: /*
8: * fgrep -- print all lines containing any of a set of keywords
9: *
10: * status returns:
11: * 0 - ok, and some matches
12: * 1 - ok, but no matches
13: * 2 - some error
14: */
15: #define MAXSIZ 700
16: #define QSIZE 400
17: struct words {
18: char inp;
19: char out;
20: struct words *nst;
21: struct words *link;
22: struct words *fail;
23: }
24: *www, *smax, *q;
25:
26: char buf[2*BUFSIZ];
27: int nsucc;
28: int need;
29: char *instr;
30: int inct;
31: int rflag;
32: int xargc;
33: char **xargv;
34: int numwords;
35: int nfound;
36: static int flag = 0;
37:
38: fgrep(argc, argv)
39: char **argv;
40: {
41: nsucc = need = inct = rflag = numwords = nfound = 0;
42: instr = 0;
43: flag = 0;
44: if (www==0)
45: www = (struct words *) zalloc(MAXSIZ, sizeof (*www));
46: if (www==NULL)
47: err("Can't get space for machines", 0);
48: for (q=www; q<www+MAXSIZ; q++) {
49: q->inp =0; q->out =0; q->nst =0; q->link =0; q->fail =0;
50: }
51: xargc = argc-1;
52: xargv = argv+1;
53: while (xargc>0 && xargv[0][0]=='-')
54: {
55: switch(xargv[0][1])
56: {
57: case 'r': /* return value only */
58: rflag++;
59: break;
60: case 'n': /* number of answers needed */
61: need = (int) xargv[1];
62: xargv++; xargc--;
63: break;
64: case 'i':
65: instr = xargv[1];
66: inct = (int) xargv[2]+2;
67: # if D2
68: fprintf(stderr,"inct %d xargv.2. %o %d\n",inct, xargv[2],xargv[2]);
69: # endif
70: xargv += 2; xargc -= 2;
71: break;
72: }
73: xargv++; xargc--;
74: }
75: if (xargc<=0)
76: {
77: write (2, "bad fgrep call\n", 15);
78: exit(2);
79: }
80: # if D1
81: fprintf(stderr, "before cgoto\n");
82: # endif
83: cgotofn();
84: # if D1
85: fprintf(stderr, "before cfail\n");
86: # endif
87: cfail();
88: # if D1
89: fprintf(stderr, "before execute instr %.20s\n", instr? instr: "");
90: fprintf(stderr, "end of string %d %c %c %c\n", inct, instr[inct-3],
91: instr[inct-2], instr[inct-1]);
92: # endif
93: execute();
94: # if D1
95: fprintf(stderr, "returning nsucc %d\n", nsucc);
96: fprintf(stderr, "fgrep done www %o\n",www);
97: # endif
98: return(nsucc == 0);
99: }
100:
101: execute()
102: {
103: register char *p;
104: register struct words *c;
105: register ch;
106: register ccount;
107: int f;
108: char *nlp;
109: f=0;
110: ccount = instr ? inct : 0;
111: nfound=0;
112: p = instr ? instr : buf;
113: if (need == 0) need = numwords;
114: nlp = p;
115: c = www;
116: # if D2
117: fprintf(stderr, "in execute ccount %d inct %d\n",ccount, inct );
118: # endif
119: for (;;) {
120: # if D3
121: fprintf(stderr, "down ccount\n");
122: # endif
123: if (--ccount <= 0) {
124: # if D2
125: fprintf(stderr, "ex loop ccount %d instr %o\n",ccount, instr);
126: # endif
127: if (instr) break;
128: if (p == &buf[2*BUFSIZ]) p = buf;
129: if (p > &buf[BUFSIZ]) {
130: if ((ccount = read(f, p, &buf[2*BUFSIZ] - p)) <= 0) break;
131: }
132: else if ((ccount = read(f, p, BUFSIZ)) <= 0) break;
133: # if D2
134: fprintf(stderr, " normal read %d bytres\n", ccount);
135: {char xx[20]; sprintf(xx, "they are %%.%ds\n", ccount);
136: fprintf(stderr, xx, p);
137: }
138: # endif
139: }
140: nstate:
141: ch = *p;
142: # if D2
143: fprintf(stderr, "roaming along in ex ch %c c %o\n",ch,c);
144: # endif
145: if (isupper(ch)) ch |= 040;
146: if (c->inp == ch) {
147: c = c->nst;
148: }
149: else if (c->link != 0) {
150: c = c->link;
151: goto nstate;
152: }
153: else {
154: c = c->fail;
155: if (c==0) {
156: c = www;
157: istate:
158: if (c->inp == ch) {
159: c = c->nst;
160: }
161: else if (c->link != 0) {
162: c = c->link;
163: goto istate;
164: }
165: }
166: else goto nstate;
167: }
168: if (c->out && new (c)) {
169: # if D2
170: fprintf(stderr, " found: nfound %d need %d\n",nfound,need);
171: # endif
172: if (++nfound >= need)
173: {
174: # if D1
175: fprintf(stderr, "found, p %o nlp %o ccount %d buf %o buf[2*BUFSIZ] %o\n",p,nlp,ccount,buf,buf+2*BUFSIZ);
176: # endif
177: if (instr==0)
178: while (*p++ != '\n') {
179: # if D3
180: fprintf(stderr, "down ccount2\n");
181: # endif
182: if (--ccount <= 0) {
183: if (p == &buf[2*BUFSIZ]) p = buf;
184: if (p > &buf[BUFSIZ]) {
185: if ((ccount = read(f, p, &buf[2*BUFSIZ] - p)) <= 0) break;
186: }
187: else if ((ccount = read(f, p, BUFSIZ)) <= 0) break;
188: # if D2
189: fprintf(stderr, " read %d bytes\n",ccount);
190: { char xx[20]; sprintf(xx, "they are %%.%ds\n", ccount);
191: fprintf(stderr, xx, p);
192: }
193: # endif
194: }
195: }
196: nsucc = 1;
197: if (rflag==0)
198: {
199: # if D2
200: fprintf(stderr, "p %o nlp %o buf %o\n",p,nlp,buf);
201: if (p>nlp)
202: {write (2, "XX\n", 3); write (2, nlp, p-nlp); write (2, "XX\n", 3);}
203: # endif
204: if (p > nlp) write(1, nlp, p-nlp);
205: else {
206: write(1, nlp, &buf[2*BUFSIZ] - nlp);
207: write(1, buf, p-&buf[0]);
208: }
209: if (p[-1]!= '\n') write (1, "\n", 1);
210: }
211: if (instr==0)
212: {
213: nlp = p;
214: c = www;
215: nfound=0;
216: }
217: }
218: else
219: ccount++;
220: continue;
221: }
222: # if D2
223: fprintf(stderr, "nr end loop p %o\n",p);
224: # endif
225: if (instr)
226: p++;
227: else
228: if (*p++ == '\n')
229: {
230: nlp = p;
231: c = www;
232: nfound=0;
233: }
234: }
235: if (instr==0)
236: close(f);
237: }
238:
239: cgotofn() {
240: register c;
241: register struct words *s;
242: s = smax = www;
243: nword:
244: for(;;) {
245: # if D1
246: fprintf(stderr, " in for loop c now %o %c\n",c, c>' ' ? c : ' ');
247: # endif
248: if ((c = gch())==0) return;
249: else if (c == '\n') {
250: s->out = 1;
251: s = www;
252: }
253: else {
254: loop:
255: if (s->inp == c) {
256: s = s->nst;
257: continue;
258: }
259: if (s->inp == 0) goto enter;
260: if (s->link == 0) {
261: if (smax >= &www[MAXSIZ - 1]) overflo();
262: s->link = ++smax;
263: s = smax;
264: goto enter;
265: }
266: s = s->link;
267: goto loop;
268: }
269: }
270:
271: enter:
272: do {
273: s->inp = c;
274: if (smax >= &www[MAXSIZ - 1]) overflo();
275: s->nst = ++smax;
276: s = smax;
277: }
278: while ((c = gch()) != '\n');
279: smax->out = 1;
280: s = www;
281: numwords++;
282: goto nword;
283:
284: }
285:
286: gch()
287: {
288: static char *s;
289: if (flag==0)
290: {
291: flag=1;
292: s = *xargv++;
293: # if D1
294: fprintf(stderr, "next arg is %s xargc %d\n",s,xargc);
295: # endif
296: if (xargc-- <=0) return(0);
297: }
298: if (*s) return(*s++);
299: for(flag=0; flag<2*BUFSIZ; flag++)
300: buf[flag]=0;
301: flag=0;
302: return('\n');
303: }
304:
305: overflo() {
306: write(2,"wordlist too large\n", 19);
307: exit(2);
308: }
309: cfail() {
310: struct words *queue[QSIZE];
311: struct words **front, **rear;
312: struct words *state;
313: register char c;
314: register struct words *s;
315: s = www;
316: front = rear = queue;
317: init:
318: if ((s->inp) != 0) {
319: *rear++ = s->nst;
320: if (rear >= &queue[QSIZE - 1]) overflo();
321: }
322: if ((s = s->link) != 0) {
323: goto init;
324: }
325:
326: while (rear!=front) {
327: s = *front;
328: if (front == &queue[QSIZE-1])
329: front = queue;
330: else front++;
331: cloop:
332: if ((c = s->inp) != 0) {
333: *rear = (q = s->nst);
334: if (front < rear)
335: if (rear >= &queue[QSIZE-1])
336: if (front == queue) overflo();
337: else rear = queue;
338: else rear++;
339: else
340: if (++rear == front) overflo();
341: state = s->fail;
342: floop:
343: if (state == 0) state = www;
344: if (state->inp == c) {
345: q->fail = state->nst;
346: if ((state->nst)->out == 1) q->out = 1;
347: continue;
348: }
349: else if ((state = state->link) != 0)
350: goto floop;
351: }
352: if ((s = s->link) != 0)
353: goto cloop;
354: }
355: }
356:
357: static int seen[50];
358: new (x)
359: {
360: int i;
361: for(i=0; i<nfound; i++)
362: if (seen[i]==x)
363: return(0);
364: seen[i]=x;
365: return(1);
366: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.