![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to look.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin|
Return to look.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /* look.c - look for matching lines of text in a sorted file.
2: */
3: #include <stdio.h>
4: #include <ctype.h>
5:
6: #define TRUE 1
7: #define FALSE 0
8: #define EQ 1
9: #define LESS 0
10: #define GREATER 2
11: #define TAB ' '
12: #define BSIZ 512
13:
14: extern long ftell() ;
15:
16: /* Globals
17: */
18:
19: int d_mode, f_mode ;
20: long top, bottom ;
21: long fsiz ;
22: FILE *fildes ;
23: char stbuf[BSIZ], rbuf[BSIZ] ;
24: char *rbufp ;
25:
26: /* getx - Get the nex character from the character buffer.
27: * If the buffer is empty get the next block.
28: */
29:
30: /* getx()
31: * {
32: * if (rbufp < &rbuf[BSIZ])
33: * return(*rbufp++) ;
34: * else {
35: * gnb() ;
36: * return(getx()) ;
37: * }
38: * }
39: */
40:
41: #ifdef FIXED /* Bug in 8086 compiler */
42: #define getx() ((rbuf < &rbuf[BSIZ]) ? *rbufp++ : (gnb(), *rbufp++))
43: #else
44: getx()
45: {
46: if (rbufp >= &rbuf[BSIZ])
47: gnb();
48: return (*rbufp++);
49: }
50: #endif
51:
52: /* order - Order relation for characters. Returns GREATER, LESS or EQ.
53: */
54:
55: /* order(a, b)
56: * {
57: * if (a > b)
58: * return(GREATER) ;
59: * else if (a < b)
60: * return(LESS) ;
61: * return(EQ) ;
62: * }
63: */
64:
65: #define order(a, b) ((a > b) ? GREATER : ((a < b) ? LESS : EQ))
66:
67: /* isdict - Test for a dictionary character. From the class :
68: * [a-zA-Z0-9 ].
69: */
70:
71: /* isdict(ch)
72: * {
73: * if (isalnum(ch) || (ch == ' '))
74: * return(1) ;
75: * return(0) ;
76: * }
77: */
78:
79: #define isdict(ch) ((isalnum(ch) || (ch == ' ')) ? 1 : 0)
80:
81: /* main - Get args, set flags and get the ball rolling.
82: */
83:
84: main(argc, argv)
85: register char *argv[] ;
86: {
87: ++argv ;
88: switch (argc) {
89:
90: case 4 :
91: case 3 :
92: if (setop(argv[0])) {
93: ++argv ;
94: --argc ;
95: } else
96: if (argc == 4) {
97: form() ;
98: break ;
99: }
100: case 2 :
101: if (argc == 3)
102: gfile(argv[1]) ;
103: else
104: gfile(NULL) ;
105: if (gstring(argv[0])) {
106: look() ;
107: exit(0) ;
108: break ;
109: }
110: default :
111: form() ;
112: }
113: exit(1) ;
114: }
115:
116: /* setop - set option flags d_mode and f_mode. d_mode marks an occurance
117: * of -d[f] or -[f]d and f_mode marks an occurance of -f[d] or
118: * -[d]f.
119: */
120:
121: setop(fp)
122: register char *fp ;
123: {
124: register int i ;
125:
126: d_mode = FALSE ;
127: f_mode = FALSE ;
128:
129: if (*fp++ != '-')
130: return(0) ;
131: else {
132: for (i = 0; i < 2; i++) {
133: switch (*fp++) {
134:
135: case 'd' :
136: d_mode = TRUE ;
137: break ;
138: case 'f' :
139: f_mode = TRUE ;
140: break ;
141: case '\0' :
142: --fp ;
143: return(1) ;
144: default :
145: return(0) ;
146: }
147: }
148: if (*fp != '\0')
149: return(0) ;
150: return(1) ;
151: }
152: }
153:
154: /* gstring - gets the match string <string> and places it in the
155: * stbuf buffer after conforming it to the d_mode and
156: * f_mode options (That will make the compare routine
157: * faster). Returns the number of characters in stbuf.
158: */
159:
160: gstring(fp)
161: register char *fp ;
162: {
163: register int nc ;
164: register char *st ;
165:
166: nc = 0 ;
167: st = stbuf ;
168: while ((nc++ < BSIZ) && (*fp != '\0')) {
169: if (d_mode && !isdict(*fp)) {
170: fp++ ;
171: nc-- ;
172: continue ;
173: }
174: if (f_mode && islower(*fp)) {
175: *st++ = toupper(*fp++) ;
176: continue ;
177: }
178: *st++ = *fp++ ;
179: }
180: if (nc >= BSIZ)
181: return(0) ;
182: return(nc) ;
183: }
184:
185:
186: /* gfile - Gets the specified file and opens it for reading.
187: * If no file is specified /usr/dict/words is opened.
188: */
189:
190: gfile(fp)
191: register char *fp ;
192: {
193: register char *file ;
194:
195: if (fp == NULL) {
196: file = "/usr/dict/words" ;
197: d_mode = TRUE ;
198: f_mode = TRUE ;
199: } else
200: file = fp ;
201:
202: if ((fildes = fopen(file, "r")) == NULL) {
203: aww("look : Cannot open file") ;
204: exit(1) ;
205: }
206:
207: bottom = 0 ;
208: if (fseek(fildes, 0L, 2) == -1) {
209: aww("look : Cannot seek on file") ;
210: exit(1) ;
211: }
212:
213: top = ftell(fildes) ;
214: top -= 2 ;
215: fsiz = top ;
216:
217:
218: return(1) ;
219: }
220:
221: /* aww - Error condition. Prints out the passed string.
222: */
223:
224: aww(sp)
225: char *sp ;
226: {
227: fprintf(stderr, "%s\n", sp) ;
228: }
229:
230: /* form - Prints out a Usage message.
231: */
232:
233: form()
234: {
235: fprintf(stderr, "Usage : look [-df] string [file]\n") ;
236: }
237:
238: /* look - Binary search looking for a string match. If a match
239: * is found (the EQ case) all the strings that match
240: * are printed and then we quit else the window is
241: * decreased and the test goes on.
242: */
243:
244: look()
245: {
246: register int nmove ;
247: long mid1, mid2 ;
248: long gll() ;
249: long gteol() ;
250:
251: while (top != bottom) {
252: mid1 = (top - bottom)/2 + bottom ;
253: mid2 = gll(mid1) ;
254: nmove = comstr() ;
255: switch (nmove) {
256:
257: case EQ :
258: wstr(mid2) ;
259: return(1) ;
260: case GREATER :
261: bottom = gteol(mid1) ;
262: break ;
263: case LESS :
264: top = mid2 - 2 ;
265: break ;
266: }
267: if (top < bottom)
268: top = bottom ;
269: }
270: }
271:
272:
273: /* wstr - We found a string that matches but we are not sure that
274: * this is the only occurance of a matched string and hence
275: * we must back up until we find a non match and print
276: * forward till we find a non match in the other direction.
277: */
278:
279: wstr(seek)
280: long seek ;
281: {
282: long temp1, temp2 ;
283: long gll() ;
284:
285: if (seek != 0) {
286: temp2 = seek ;
287: temp1 = gll(seek - 2) ;
288: while (comstr() == EQ) {
289: temp2 = temp1 ;
290: if (temp1 == 0)
291: break ;
292: else
293: temp1 = gll(temp1 - 2) ;
294: }
295: } else
296: temp2 = 0 ;
297: fseek(fildes, temp2, 0) ;
298: while (ftell(fildes) <= seek) {
299: fgets(rbuf, BSIZ, fildes) ;
300: fputs(rbuf, stdout) ;
301: }
302: fgets(rbuf, BSIZ, fildes) ;
303: rbufp = rbuf ;
304: while (comstr() == EQ) {
305: fputs(rbuf, stdout) ;
306: fgets(rbuf, BSIZ, fildes) ;
307: rbufp = rbuf ;
308: }
309: return(1) ;
310: }
311:
312: /* comstr - Compare the base string to the input line.
313: * Returns a stat telling what the difference between the
314: * two strings is. EQ is equal, GREATER implies the base string
315: * is greater then the input string and LESS is vice versa.
316: */
317:
318: comstr()
319: {
320: register int state ;
321: register int ch ;
322: register char *sp ;
323:
324: sp = stbuf ;
325: while (*sp != '\0') {
326: ch = getx() ;
327: if (ch == '\n')
328: return(GREATER) ;
329: if (d_mode && !isdict(ch)) {
330: continue ;
331: }
332: if (f_mode && islower(ch))
333: ch = toupper(ch) ;
334: if ((state = order(*sp, ch)) != EQ) {
335: return(state) ;
336: }
337: ++sp ;
338: }
339: return(EQ) ;
340: }
341:
342: /* gll - Get last line. Using the seek variable, returns a pointer to
343: * the beginning of the last line of text. If neccesary
344: * gll will wind back seek a block at a time looking for
345: * the last line.
346: */
347:
348: long
349: gll(seek)
350: long seek ;
351: {
352: register char *cp ;
353: register int tmp ;
354:
355: if (seek == 0) {
356: rbufp = rbuf ;
357: return(0) ;
358: }
359:
360: if (seek < BSIZ) {
361: cp = &rbuf[(int) seek] ;
362: seek = 0 ;
363: fseek(fildes, 0L, 0) ;
364: } else {
365: cp = &rbuf[BSIZ - 1] ;
366: seek -= BSIZ ;
367: fseek(fildes, seek, 0) ;
368: }
369: fread(rbuf, sizeof(*cp), BSIZ, fildes) ;
370:
371: while (cp >= rbuf) {
372: if (*cp == '\n')
373: break ;
374: --cp ;
375: }
376:
377: if (*cp == '\n') {
378: rbufp = ++cp ;
379: tmp = cp - rbuf ;
380: seek += (long) tmp ;
381: if (seek > fsiz)
382: return(-1) ;
383: fseek(fildes, seek, 0) ;
384: fread(rbuf, sizeof(*rbufp), BSIZ, fildes) ;
385: rbufp = rbuf ;
386: return(seek) ;
387: } else
388: return(gll(seek)) ;
389: }
390:
391: /* gnb - Get the next block from the file and adjust the
392: * character buffer pointer.
393: */
394:
395: gnb()
396: {
397: fseek(fildes, 512L, 1) ;
398: fread(rbuf, sizeof(*rbufp), BSIZ, fildes) ;
399: rbufp = rbuf ;
400: return(1) ;
401: }
402:
403: /* gteol - Go to end of line. Returns the seek adress of the end of line.
404: */
405:
406: long
407: gteol(seek)
408: long seek ;
409: {
410: if (seek >= fsiz)
411: return(fsiz) ;
412: fseek(fildes, seek, 0) ;
413: while (fgetc(fildes) != '\n')
414: ;
415: return(ftell(fildes)) ;
416: }
417:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.