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