![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpgrep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / cpgrep|
Return to cpgrep.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / cpgrep |
1.1 root 1: /* cpgrep
2: *
3: * HISTORY:
4: * 23-Mar-87 danl exit(x) -> DOSEXIT(1, x)
5: *
6: */
7:
8: #include <stdio.h>
9: #include <fcntl.h>
10: #include <ctype.h>
11:
12: int far pascal DOSCREATETHREAD(void (far *)(),int far *,int far *);
13: int far pascal DOSGETMACHINEMODE(char far *);
14: int far pascal DOSQHANDTYPE(int,int far *,int far *);
15: int far pascal DOSREAD(int,char far *,int,int far *);
16: int far pascal DOSSEMCLEAR(long far *);
17: int far pascal DOSSEMREQUEST(long far *,long);
18: int far pascal DOSSEMSET(long far *);
19: int far pascal DOSSEMWAIT(long far *,long);
20: int far pascal DOSSLEEP(long);
21: int far pascal DOSWRITE(int,char far *,int,int far *);
22: int far pascal DOSEXIT(int, int);
23:
24: #define BEGLINE 0x40
25: #define DEBUG 0x08
26: #define ENDLINE 0x80
27: #define FILBUFLEN (SECTORLEN*30)
28: #define FILNAMLEN 80
29: #define INVERT 0x10
30: #define ISCOT 0x0002
31: #define LG2SECLEN 9
32: #define LINELEN 128
33: #define LINENOS 0x04
34: #define LNOLEN 8
35: #define MAXSTRLEN 128
36: #define NAMEONLY 0x02
37: #define OUTBUFLEN (SECTORLEN*4)
38: #define SECTORLEN (1 << LG2SECLEN)
39: #define SHOWNAME 0x01
40: #define STKLEN 256
41: #define TIMER 0x20
42: #define TRTABLEN 256
43: #define s_text(x) (((char *)(x)) - ((x)->s_must))
44:
45: typedef struct stringnode
46: {
47: struct stringnode *s_alt; /* List of alternates */
48: struct stringnode *s_suf; /* List of suffixes */
49: int s_must; /* Length of portion that must match */
50: }
51: STRINGNODE;
52:
53: char filbuf[(FILBUFLEN + 2)*2];
54: char *bufptr[] = { filbuf, filbuf + FILBUFLEN + 2 };
55: char outbuf[OUTBUFLEN*2];
56: char *obuf[] = { outbuf, outbuf + OUTBUFLEN };
57: char *optr[] = { outbuf, outbuf + OUTBUFLEN };
58: int ocnt[] = { OUTBUFLEN, OUTBUFLEN };
59: int oi = 0;
60: char transtab[TRTABLEN] = { 0 };
61: STRINGNODE *stringlist[TRTABLEN/2];
62: int arrc; /* I/O return code for DOSREAD */
63: int awrc; /* I/O return code for DOSWRITE */
64: int casesen = 1; /* Assume case-sensitivity */
65: int cbread; /* Bytes read by DOSREAD */
66: int cbwrite; /* Bytes written by DOSWRITE */
67: int clists = 1; /* One is first available index */
68: int flags; /* Flags */
69: int lineno; /* Current line number */
70: char pmode; /* Protected mode flag */
71: long readdone; /* Async read done semaphore */
72: long readpending; /* Async read pending semaphore */
73: int status = 1; /* Assume failure */
74: char *t2buf; /* Async read buffer */
75: int t2buflen; /* Async read buffer length */
76: int t2fd; /* Async read file */
77: char *t3buf; /* Async write buffer */
78: int t3buflen; /* Async write buffer length */
79: int t3fd; /* Async write file */
80: long writedone; /* Async write done semaphore */
81: long writepending; /* Async write pending semaphore */
82: char target[MAXSTRLEN];
83: /* Last string added */
84: int targetlen; /* Length of last string added */
85:
86: int countlines(); /* See CPGREPSB.ASM */
87: int countmatched(); /* See CPGREPSB.ASM */
88: char *findlist(); /* See CPGREPSB.ASM */
89: char *findone(); /* See CPGREPSB.ASM */
90: void flush1buf(); /* See below */
91: int grepbuffer(); /* See below */
92: int revfind(); /* See CPGREPSB.ASM */
93: void write1buf(); /* See below */
94: char *(*find)() = findlist;
95: void (*flush1)() = flush1buf;
96: int (*grep)() = grepbuffer;
97: void (*write1)() = write1buf;
98:
99: void freenode(x)
100: register STRINGNODE *x; /* Pointer to node to free */
101: {
102: register STRINGNODE *y; /* Pointer to next node in list */
103:
104: while(x != NULL) /* While not at end of list */
105: {
106: if(x->s_suf != NULL) freenode(x->s_suf);
107: /* Free suffix list */
108: y = x; /* Save pointer */
109: x = x->s_alt; /* Move down the list */
110: free(y); /* Free the node */
111: }
112: }
113:
114:
115: STRINGNODE *newnode(s,n)
116: char *s; /* String */
117: int n; /* Length of string */
118: {
119: register STRINGNODE *new; /* Pointer to new node */
120: char *t; /* String pointer */
121: char *malloc(); /* Storage allocator */
122:
123: if((t = malloc(sizeof(STRINGNODE) + n + (n & 1))) == NULL)
124: { /* If allocation fails */
125: fprintf(stderr,"Out of memory\n");
126: DOSEXIT(1, 2); /* Print error message and die */
127: }
128: if(n & 1) ++t; /* END of string word-aligned */
129: strncpy(t,s,n); /* Copy string text */
130: new = (STRINGNODE *)(t + n); /* Set pointer to node */
131: new->s_alt = NULL; /* No alternates yet */
132: new->s_suf = NULL; /* No suffixes yet */
133: new->s_must = n; /* Set string length */
134: return(new); /* Return pointer to new node */
135: }
136:
137:
138: void reallocnode(node,s,n)
139: register STRINGNODE *node; /* Pointer to node */
140: char *s; /* String */
141: register int n; /* Length of string */
142: {
143: if(n > node->s_must) /* If node must grow */
144: {
145: fprintf(stderr,"Internal error\n");
146: /* Error message */
147: DOSEXIT(1, 2); /* Error exit */
148: }
149: node->s_must = n; /* Set new length */
150: memcpy(s_text(node),s,n); /* Copy new text */
151: }
152:
153:
154: void addstring(s,n)
155: char *s; /* String to add */
156: int n; /* Length of string */
157: {
158: register STRINGNODE *cur; /* Current string */
159: register STRINGNODE **pprev; /* Pointer to previous link */
160: STRINGNODE *new; /* New string */
161: int i; /* Index */
162: int j; /* Count */
163: int k; /* Count */
164:
165: if(n <= 0 || n > 127) return; /* Should never happen */
166: i = transtab[*s]; /* Get current index */
167: if(i == 0) /* If no existing list */
168: {
169: /*
170: * We have to start a new list
171: */
172: if((i = clists++) >= TRTABLEN/2)
173: { /* If too many string lists */
174: fprintf(stderr,"Too many string lists\n");
175: /* Error message */
176: DOSEXIT(1, 2); /* Die */
177: }
178: stringlist[i] = NULL; /* Initialize */
179: transtab[*s] = i; /* Set pointer to new list */
180: if(!casesen && isalpha(*s)) transtab[*s ^ '\x20'] = i;
181: /* Set pointer for other case */
182: }
183: else if(stringlist[i] == NULL) return;
184: /* Check for existing 1-byte string */
185: if(--n == 0) /* If 1-byte string */
186: {
187: freenode(stringlist[i]); /* Free any existing stuff */
188: stringlist[i] = NULL; /* No record here */
189: return; /* Done */
190: }
191: ++s; /* Skip first char */
192: pprev = stringlist + i; /* Get pointer to link */
193: cur = *pprev; /* Get pointer to node */
194: while(cur != NULL) /* Loop to traverse match tree */
195: {
196: i = (n > cur->s_must)? cur->s_must: n;
197: /* Find minimum of string lengths */
198: matchstrings(s,s_text(cur),i,&j,&k);
199: /* Compare the strings */
200: if(j == 0) /* If complete mismatch */
201: {
202: if(k < 0) break; /* Break if insertion point found */
203: pprev = &(cur->s_alt); /* Get pointer to alternate link */
204: cur = *pprev; /* Follow the link */
205: }
206: else if(i == j) /* Else if strings matched */
207: {
208: if(i == n) /* If new is prefix of current */
209: {
210: reallocnode(cur,s_text(cur),n);
211: /* Shorten text of node */
212: if(cur->s_suf != NULL) /* If there are suffixes */
213: {
214: freenode(cur->s_suf);
215: /* Suffixes no longer needed */
216: cur->s_suf = NULL;
217: }
218: return; /* All done */
219: }
220: pprev = &(cur->s_suf); /* Get pointer to suffix link */
221: if((cur = *pprev) == NULL) return;
222: /* Done if current is prefix of new */
223: s += i; /* Skip matched portion */
224: n -= i;
225: }
226: else /* Else partial match */
227: {
228: /*
229: * We must split an existing node.
230: * This is the trickiest case.
231: */
232: new = newnode(s_text(cur) + j,cur->s_must - j);
233: /* Unmatched part of current string */
234: reallocnode(cur,s_text(cur),j);
235: /* Set length to matched portion */
236: new->s_suf = cur->s_suf; /* Current string's suffixes */
237: if(k < 0) /* If new preceded current */
238: {
239: cur->s_suf = newnode(s + j,n - j);
240: /* FIrst suffix is new string */
241: cur->s_suf->s_alt = new;/* Alternate is part of current */
242: }
243: else /* Else new followed current */
244: {
245: new->s_alt = newnode(s + j,n - j);
246: /* Unmatched new string is alternate */
247: cur->s_suf = new; /* New suffix list */
248: }
249: return;
250: }
251: }
252: *pprev = newnode(s,n); /* Set pointer to new node */
253: (*pprev)->s_alt = cur; /* Attach alternates */
254: }
255:
256:
257: int addfancy(buffer,buflen,seplist)
258: register char *buffer; /* Buffer */
259: int buflen; /* Length of buffer */
260: char *seplist; /* List of separators */
261: {
262: register char *bufend; /* Pointer to end of buffer */
263: int strcnt = 0; /* String count */
264: int len; /* String length */
265: char c; /* One char buffer */
266:
267: bufend = buffer + buflen; /* Set end pointer */
268: while(buffer < bufend) /* Loop through all strings */
269: {
270: len = strncspn(buffer,seplist,bufend - buffer);
271: /* Length of string */
272: if(flags & ENDLINE) /* If match must be at end of line */
273: {
274: c = buffer[len]; /* Save 1st character past string */
275: buffer[len++] = '\r'; /* Carriage return marks end of line */
276: }
277: if(findlist(buffer,buffer + len) == NULL)
278: { /* If no match within string */
279: addstring(buffer,len); /* Add string to list */
280: if(strcnt++ == 0) /* If first string */
281: {
282: memcpy(target,buffer,len);
283: /* Save first string in buffer */
284: targetlen = len; /* Remember length */
285: }
286: }
287: buffer += len; /* Skip over string */
288: if(flags & ENDLINE) (--buffer)[0] = c;
289: /* Restore saved character */
290: buffer += strnspn(buffer,seplist,bufend - buffer);
291: /* Skip over trailing separators */
292: }
293: return(strcnt); /* Return string count */
294: }
295:
296:
297: int addplain(buffer,buflen,seplist)
298: register char *buffer; /* String list buffer */
299: int buflen; /* Buffer length */
300: char *seplist; /* List of separators */
301: {
302: int strcnt; /* String count */
303: register int len; /* String length */
304: char c; /* One char buffer */
305:
306: strcnt = 0;
307: while((len = strncspn(buffer,seplist,buflen)) > 0)
308: { /* While not at end of input list */
309: if(flags & ENDLINE) /* If match must be at end of line */
310: {
311: c = buffer[len]; /* Save 1st character past string */
312: buffer[len++] = '\r'; /* Carriage return marks end of line */
313: }
314: if(strcnt == 0) /* Save first string */
315: {
316: strncpy(target,buffer,len); /* Save string in buffer */
317: targetlen = len; /* Save string length */
318: }
319: addstring(buffer,len); /* Add the string to the table */
320: if(flags & ENDLINE) buffer[--len] = c;
321: /* Restore saved character */
322: buffer += len; /* Skip the string */
323: buflen -= len;
324: len = strnspn(buffer,seplist,buflen);
325: /* Skip separators */
326: buffer += len;
327: buflen -= len;
328: ++strcnt; /* Increment string count */
329: }
330: return(strcnt); /* Return string count */
331: }
332:
333:
334: void dumplist(node,indent)
335: register STRINGNODE *node; /* Pointer to list to dump */
336: int indent; /* Current length of buffer */
337: {
338: int i; /* Counter */
339:
340: while(node != NULL) /* While not at end of list */
341: {
342: for(i = 0; i < indent; ++i) fputc(' ',stderr);
343: fwrite(s_text(node),sizeof(char),node->s_must,stderr);
344: fprintf(stderr,"\n");
345: if(node->s_suf != NULL)
346: dumplist(node->s_suf,indent + node->s_must);
347: /* Recurse to do suffixes */
348: node = node->s_alt; /* Do next alternate in list */
349: }
350: }
351:
352:
353: void dumpstrings()
354: {
355: int i; /* Index */
356:
357: for(i = 0; i < TRTABLEN; ++i) /* Loop through translation table */
358: {
359: if(transtab[i] == 0) continue; /* Skip null entries */
360: fprintf(stderr,"%c\n",i); /* Print the first byte */
361: dumplist(stringlist[transtab[i]],1);
362: /* Dump the list */
363: }
364: }
365:
366:
367: int openfile(name)
368: char *name; /* File name */
369: {
370: int fd; /* File descriptor */
371:
372: if((fd = open(name,0)) == -1) /* If error opening file */
373: {
374: fprintf(stderr,"Cannot open %s\r\n",name);
375: /* Print error message */
376: }
377: return(fd); /* Return file descriptor */
378: }
379:
380:
381: void far thread2() /* Read thread */
382: {
383: while(DOSSEMREQUEST((long far *) &readpending,-1L) == 0)
384: { /* While there is work to do */
385: arrc = DOSREAD(t2fd,(char far *) t2buf,t2buflen,(int far *) &cbread);
386: /* Do the read */
387: DOSSEMCLEAR((long far *) &readdone);
388: /* Signal read completed */
389: }
390: fprintf(stderr,"Thread 2: DOSSEMREQUEST failed\n");
391: /* Print error message */
392: DOSEXIT(1, 2); /* Die */
393: }
394:
395:
396: void far thread3() /* Write thread */
397: {
398: while(DOSSEMREQUEST((long far *) &writepending,-1L) == 0)
399: { /* While there is work to do */
400: awrc = DOSWRITE(t3fd,(char far *) t3buf,t3buflen,(int far *) &cbwrite);
401: /* Do the write */
402: DOSSEMCLEAR((long far *) &writedone);
403: /* Signal write completed */
404: }
405: fprintf(stderr,"Thread 3: DOSSEMREQUEST failed\n");
406: /* Print error message */
407: DOSEXIT(1, 2); /* Die */
408: }
409:
410:
411: void startread(fd,buffer,buflen)
412: int fd; /* File handle */
413: char *buffer; /* Buffer */
414: int buflen; /* Buffer length */
415: {
416: if(pmode) /* If protected mode */
417: {
418: if(DOSSEMREQUEST((long far *) &readdone,-1L) != 0)
419: { /* If we fail to get the semaphore */
420: fprintf(stderr,"DOSSEMREQUEST failed\n");
421: /* Error message */
422: DOSEXIT(1, 2); /* Die */
423: }
424: t2fd = fd; /* Set parameters for read */
425: t2buf = buffer;
426: t2buflen = buflen;
427: DOSSEMCLEAR((long far *) &readpending);
428: /* Wake thread 2 for read */
429: DOSSLEEP(0L); /* Yield the CPU */
430: }
431: else arrc = DOSREAD(fd,(char far *) buffer,buflen,(int far *) &cbread);
432: }
433:
434:
435: int finishread()
436: {
437: if(pmode && DOSSEMWAIT((long far *) &readdone,-1L) != 0)
438: { /* If protected mode and wait fails */
439: fprintf(stderr,"DOSSEMWAIT failed\n");
440: /* Print error message */
441: DOSEXIT(1, 2); /* Die */
442: }
443: return((arrc == 0)? cbread: -1); /* Return number of bytes read */
444: }
445:
446:
447: void startwrite(fd,buffer,buflen)
448: int fd; /* File handle */
449: char *buffer; /* Buffer */
450: int buflen; /* Buffer length */
451: {
452: if(pmode) /* If protected mode */
453: {
454: if(DOSSEMREQUEST((long far *) &writedone,-1L) != 0)
455: { /* If we fail to get the semaphore */
456: fprintf(stderr,"DOSSEMREQUEST failed\n");
457: /* Error message */
458: DOSEXIT(1, 2); /* Die */
459: }
460: t3fd = fd; /* Set parameters for write */
461: t3buf = buffer;
462: t3buflen = buflen;
463: DOSSEMCLEAR((long far *) &writepending);
464: /* Wake thread 3 for read */
465: DOSSLEEP(0L); /* Yield the CPU */
466: }
467: else awrc = DOSWRITE(fd,(char far *) buffer,buflen,(int far *) &cbwrite);
468: }
469:
470:
471: int finishwrite()
472: {
473: if(pmode && DOSSEMWAIT((long far *) &writedone,-1L) != 0)
474: { /* If protected mode and wait fails */
475: fprintf(stderr,"DOSSEMWAIT failed\n");
476: /* Print error message */
477: DOSEXIT(1, 2); /* Die */
478: }
479: return((awrc == 0)? cbwrite: -1); /* Return number of bytes written */
480: }
481:
482:
483: void write1nobuf(buffer,buflen)
484: char *buffer; /* Buffer */
485: register int buflen; /* Buffer length */
486: {
487: int cb; /* Count of bytes written */
488:
489: if(DOSWRITE(1,(char far *) buffer,buflen,(int far *) &cb) != 0 ||
490: cb != buflen) /* If write fails */
491: {
492: fprintf(stderr,"write error %d\n",awrc);
493: /* Print error message */
494: DOSEXIT(1, 2); /* Die */
495: }
496: }
497:
498:
499: void write1buf(buffer,buflen)
500: char *buffer; /* Buffer */
501: register int buflen; /* Buffer length */
502: {
503: register int cb; /* Byte count */
504:
505: while(buflen > 0) /* While bytes remain */
506: {
507: if(awrc != 0) /* If previous write failed */
508: {
509: fprintf(stderr,"write error %d\n",awrc);
510: /* Print error message */
511: DOSEXIT(1, 2); /* Die */
512: }
513: if((cb = ocnt[oi]) == 0) /* If buffer full */
514: {
515: startwrite(1,obuf[oi],OUTBUFLEN);
516: /* Write the buffer */
517: ocnt[oi] = OUTBUFLEN; /* Reset count and pointer */
518: optr[oi] = obuf[oi];
519: oi ^= 1; /* Switch buffers */
520: cb = ocnt[oi]; /* Get space remaining */
521: }
522: if(cb > buflen) cb = buflen; /* Get minimum */
523: memcpy(optr[oi],buffer,cb); /* Copy bytes to buffer */
524: ocnt[oi] -= cb; /* Update buffer length and pointers */
525: optr[oi] += cb;
526: buflen -= cb;
527: buffer += cb;
528: }
529: }
530:
531:
532: void flush1nobuf()
533: {
534: }
535:
536:
537: void flush1buf()
538: {
539: int cb; /* Byte count */
540:
541: if((cb = OUTBUFLEN - ocnt[oi]) > 0) /* If buffer not empty */
542: {
543: startwrite(1,obuf[oi],cb); /* Start write */
544: if(finishwrite() != cb) /* If write failed */
545: {
546: fprintf(stderr,"write error %d\n",awrc);
547: /* Print error message */
548: DOSEXIT(1, 2); /* Die */
549: }
550: }
551: }
552:
553:
554: int grepnull(cp,endbuf,name)
555: register char *cp; /* Buffer pointer */
556: char *endbuf; /* End of buffer */
557: char *name; /* File name */
558: {
559: return(0); /* Do nothing */
560: }
561:
562:
563: int grepbuffer(startbuf,endbuf,name)
564: char *startbuf; /* Start of buffer */
565: char *endbuf; /* End of buffer */
566: char *name; /* File name */
567: {
568: register char *cp; /* Buffer pointer */
569: char *lastmatch; /* Last matching line */
570: int linelen; /* Line length */
571: int namlen = 0; /* Length of name */
572: char lnobuf[LNOLEN]; /* Line number buffer */
573: char nambuf[LINELEN];/* Name buffer */
574:
575: cp = startbuf; /* Initialize to start of buffer */
576: lastmatch = cp; /* No previous match yet */
577: while((cp = (*find)(cp,endbuf)) != NULL)
578: { /* While matches are found */
579: if((flags & BEGLINE) && cp[-1] != '\n' && cp > startbuf)
580: { /* If begin line conditions not met */
581: ++cp; /* Skip first char of match */
582: continue; /* Keep looking */
583: }
584: status = 0; /* Match found */
585: if(flags & NAMEONLY) /* If filename only wanted */
586: {
587: (*write1)(nambuf,sprintf(nambuf,"%s\r\n",name));
588: /* Print the name */
589: return(1); /* Punt remainder of buffer */
590: }
591: cp -= revfind(cp,'\n',cp - startbuf);
592: /* Point at last linefeed */
593: if(*cp == '\n') ++cp; /* Point at start of line */
594: if(flags & SHOWNAME) /* If name wanted */
595: {
596: if(namlen == 0) namlen = sprintf(nambuf,"%s:",name);
597: /* Format name if not done already */
598: (*write1)(nambuf,namlen); /* Show name */
599: }
600: if(flags & LINENOS) /* If line number wanted */
601: {
602: lineno += countlines(lastmatch,cp);
603: /* Count lines since last match */
604: (*write1)(lnobuf,sprintf(lnobuf,"%d:",lineno));
605: /* Print line number */
606: lastmatch = cp; /* New last match */
607: }
608: linelen = strncspn(cp,"\n",endbuf - cp) + 1;
609: /* Calculate line length */
610: (*write1)(cp,linelen); /* Print the line */
611: cp += linelen; /* Skip the line */
612: }
613: if(flags & LINENOS) lineno += countlines(lastmatch,endbuf);
614: /* Count remaining lines in buffer */
615: return(0); /* Keep searching */
616: }
617:
618:
619: void showv(name,lastmatch,thismatch)
620: char *name;
621: register char *lastmatch;
622: char *thismatch;
623: {
624: register int linelen;
625: int namlen = 0; /* Length of name */
626: char lnobuf[LNOLEN]; /* Line number buffer */
627: char nambuf[LINELEN];/* Name buffer */
628:
629: if(flags & (SHOWNAME | LINENOS))
630: {
631: while(lastmatch < thismatch)
632: {
633: if(flags & SHOWNAME) /* If name wanted */
634: {
635: if(namlen == 0) namlen = sprintf(nambuf,"%s:",name);
636: /* Format name if not done already */
637: (*write1)(nambuf,namlen);
638: /* Write the name */
639: }
640: if(flags & LINENOS)
641: {
642: (*write1)(lnobuf,sprintf(lnobuf,"%d:",lineno++));
643: }
644: linelen = strncspn(lastmatch,"\n",thismatch - lastmatch) + 1;
645: (*write1)(lastmatch,linelen);
646: lastmatch += linelen;
647: }
648: }
649: else (*write1)(lastmatch,thismatch - lastmatch);
650: }
651:
652:
653: int grepvbuffer(startbuf,endbuf,name)
654: char *startbuf; /* Start of buffer */
655: char *endbuf; /* End of buffer */
656: char *name; /* File name */
657: {
658: register char *cp; /* Buffer pointer */
659: register char *lastmatch; /* Pointer to line after last match */
660:
661: cp = startbuf; /* Initialize to start of buffer */
662: lastmatch = cp;
663: while((cp = (*find)(cp,endbuf)) != NULL)
664: {
665: if((flags & BEGLINE) && cp[-1] != '\n' && cp > startbuf)
666: { /* If begin line conditions not met */
667: ++cp; /* Skip first char of match */
668: continue; /* Keep looking */
669: }
670: status = 1; /* Match found */
671: if(flags & NAMEONLY) return(1); /* Skip rest of file if NAMEONLY */
672: cp -= revfind(cp,'\n',cp - startbuf);
673: /* Point at last linefeed */
674: if(*cp == '\n') ++cp; /* Point at start of line */
675: showv(name,lastmatch,cp); /* Show from last match to this */
676: cp += strncspn(cp,"\n",endbuf - cp) + 1;
677: /* Skip over line with match */
678: lastmatch = cp; /* New "last" match */
679: ++lineno; /* Increment line count */
680: }
681: if(!(flags & NAMEONLY)) showv(name,lastmatch,endbuf);
682: /* Show buffer tail if not NAMEONLY */
683: return(0); /* Keep searching file */
684: }
685:
686:
687: void qgrep(name,fd)
688: char *name; /* File name */
689: int fd; /* File descriptor */
690: {
691: register int cb; /* Byte count */
692: register char *cp; /* Buffer pointer */
693: char *endbuf; /* End of buffer */
694: int taillen; /* Length of buffer tail */
695: int bufi; /* Buffer index */
696: char line[LINELEN]; /* Line buffer */
697:
698: lineno = 1; /* File starts on line 1 */
699: taillen = 0; /* No buffer tail yet */
700: bufi = 0; /* Initialize buffer index */
701: cp = bufptr[0]; /* Initialize to start of buffer */
702: finishread(); /* Make sure no I/O activity */
703: arrc = DOSREAD(fd,(char far *) cp,FILBUFLEN,(int far *) &cbread);
704: /* Do first read synchronously */
705: while((cb = finishread()) + taillen > 0)
706: { /* While search incomplete */
707: if(cb == 0) /* If buffer tail is all that's left */
708: {
709: taillen = 0; /* Set tail length to zero */
710: *cp++ = '\r'; /* Add end of line sequence */
711: *cp++ = '\n';
712: endbuf = cp; /* Note end of buffer */
713: }
714: else /* Else start next read */
715: {
716: taillen = revfind(cp + cb - 1,'\n',cb);
717: /* Find length of partial line */
718: endbuf = cp + cb - taillen; /* Get pointer to end of buffer */
719: cp = bufptr[bufi ^ 1]; /* Pointer to other buffer */
720: memcpy(cp,endbuf,taillen); /* Copy tail to head of other buffer */
721: cp += taillen; /* Skip over tail */
722: startread(fd,cp,(FILBUFLEN - taillen) & (~0 << LG2SECLEN));
723: /* Start next read */
724: }
725: if((*grep)(bufptr[bufi],endbuf,name)) return;
726: /* Done if NAMEONLY and match found */
727: bufi ^= 1; /* Switch buffers */
728: }
729: if((flags & (NAMEONLY | INVERT)) == (NAMEONLY | INVERT))
730: (*write1)(line,sprintf(line,"%s\r\n",name));
731: /* Write name if -lv */
732: }
733:
734:
735: void usage(verbose)
736: int verbose; /* Verbose message flag */
737: {
738: static char *opts[] =
739: {
740: "-? - print this message",
741: "-B - match pattern if at beginning of line",
742: "-E - match pattern if at end of line",
743: "-l - print only file name if file contains match",
744: "-n - print line number before each matching line",
745: "-v - print only lines not containing a match",
746: "-x - print lines that match exactly (-BE)",
747: "-y - treat upper and lower case as equivalent",
748: "-e - treat next argument as the search string",
749: "-f - read search strings from file named by next argument",
750: "-i - read file list from file named by next argument",
751: 0
752: };
753: register char **opt = opts; /* Option list */
754:
755: fprintf(stderr,"usage: CPGREP [-?BElnvxy][-e][-f <file>][-i <file>][<strings>][<files>]\n");
756: if(verbose) /* If verbose message wanted */
757: {
758: while(*opt != 0) fprintf(stderr,"%s\n",*opt++);
759: /* Print option list */
760: }
761: DOSEXIT(1, 2); /* Error exit */
762: }
763:
764:
765: void main(argc,argv)
766: int argc;
767: char **argv;
768: {
769: register char *cp;
770: int fd;
771: FILE *fi;
772: char filnam[FILNAMLEN];
773: int i;
774: char *inpfile = NULL;
775: int j;
776: char *seplist = " \t";
777: int strcnt;
778: char *strfile = NULL;
779: long start; /* Start time */
780: int (*add)();
781: int t2stk[STKLEN]; /* Read thread stack */
782: int t3stk[STKLEN]; /* Write thread stack */
783: long time(); /* Time and date in seconds */
784:
785: DOSGETMACHINEMODE((char far *) &pmode);
786: flags = 0;
787: for(i = 1; i < argc && argv[i][0] == '-'; ++i)
788: {
789: switch(argv[i][1])
790: {
791: case 'f':
792: case 'i':
793: if(i == argc - 1)
794: {
795: fprintf(stderr,"File name missing after -%c\n",argv[i][1]);
796: DOSEXIT(1, 2);
797: }
798: if(argv[i++][1] == 'i') inpfile = argv[i];
799: else strfile = argv[i];
800: break;
801:
802: case '?':
803: case 'B':
804: case 'E':
805: case 'N':
806: case 'S':
807: case 'd':
808: case 'l':
809: case 'n':
810: case 't':
811: case 'v':
812: case 'x':
813: case 'y':
814: for(cp = &argv[i][1]; *cp != '\0'; ++cp)
815: {
816: switch(*cp)
817: {
818: case '?':
819: usage(1); /* Verbose usage message */
820:
821: case 'B':
822: flags |= BEGLINE;
823: break;
824:
825: case 'E':
826: flags |= ENDLINE;
827: break;
828:
829: case 'N':
830: grep = grepnull;
831: break;
832:
833: case 'S':
834: pmode = 0; /* Force synchronous I/O */
835: break;
836:
837: case 'd':
838: flags |= DEBUG;
839: break;
840:
841: case 'l':
842: flags |= NAMEONLY;
843: break;
844:
845: case 'n':
846: flags |= LINENOS;
847: break;
848:
849: case 't':
850: flags |= TIMER;
851: break;
852:
853: case 'v':
854: status = 0; /* Assume success */
855: flags |= INVERT;
856: grep = grepvbuffer;
857: break;
858:
859: case 'x':
860: flags |= BEGLINE | ENDLINE;
861: break;
862:
863: case 'y':
864: casesen = 0;
865: break;
866:
867: default:
868: fprintf(stderr,"-%c ignored\n",*cp);
869: break;
870: }
871: }
872: break;
873:
874: case 'e':
875: if(strfile == NULL)
876: {
877: ++i;
878: seplist = ""; /* Allow anything in string */
879: goto endfor0;
880: }
881: /* Drop through to "default" */
882:
883: default:
884: fprintf(stderr,"%s ignored\n",argv[i]);
885: break;
886: }
887: }
888: endfor0:
889:
890: if(i == argc && strfile == NULL) usage(0);
891: /* Simple usage message if arg error */
892: if(flags & TIMER) start = time(NULL);
893: /* Get start time if timer on */
894: if(pmode) /* Initialize semaphores and threads */
895: {
896: DOSSEMCLEAR((long far *) &readdone);
897: DOSSEMCLEAR((long far *) &writedone);
898: DOSSEMSET((long far *) &readpending);
899: DOSSEMSET((long far *) &writepending);
900: if(DOSCREATETHREAD(thread2,(int far *) &fd,
901: (int far *) t2stk + STKLEN) != 0 ||
902: DOSCREATETHREAD(thread3,(int far *) &fd,
903: (int far *) t3stk + STKLEN) != 0)
904: { /* If thread creation fails */
905: fprintf(stderr,"Failed to create child threads\n");
906: /* Print error message */
907: DOSEXIT(1, 2); /* Die */
908: }
909: }
910: setmode(fileno(stdout),O_BINARY);
911: add = addplain; /* Assume plain string adds */
912: if(strfile != NULL) /* If strings from file */
913: {
914: if(!(flags & BEGLINE)) add = addfancy;
915: /* Try to add intelligently */
916: if((fd = open(strfile,0)) == -1)
917: { /* If open fails */
918: fprintf(stderr,"Cannot read strings from %s\n",strfile);
919: DOSEXIT(1, 2); /* Print message and die */
920: }
921: for(cp = filbuf, j = 0; (j = read(fd,cp,FILBUFLEN*2 - j)) > 0; cp += j);
922: /* Read strings file into buffer */
923: j = cp - filbuf; /* Get total length of buffer */
924: close(fd); /* Close strings file */
925: filbuf[j] = '\0'; /* Null-terminate the buffer */
926: cp = filbuf; /* Set pointer to string list */
927: seplist = "\r\n"; /* Only '\r' and '\n' are separators */
928: }
929: else /* Else strings on command line */
930: {
931: cp = argv[i++]; /* Set pointer to strings */
932: j = strlen(cp); /* Get length of strings */
933: }
934: if((strcnt = (*add)(cp,j,seplist)) == 0)
935: { /* If no strings */
936: fprintf(stderr,"No search strings\n");
937: DOSEXIT(1, 2); /* Print error message and die */
938: }
939:
940: /*
941: * Check type of handle for std. out.
942: */
943: if(DOSQHANDTYPE(fileno(stdout),(int far *) &j,(int far *) &fd) != 0)
944: { /* If error */
945: fprintf(stderr,"Standard output bad handle\n");
946: /* Print error message */
947: DOSEXIT(1, 2); /* Die */
948: }
949: if(j != 0 && (fd & ISCOT)) /* If handle is console output */
950: {
951: write1 = write1nobuf; /* Use unbuffered output */
952: flush1 = flush1nobuf;
953: }
954:
955: if(strcnt > 1) /* If more than one string */
956: {
957: if(flags & DEBUG) /* Print debug info maybe */
958: {
959: fprintf(stderr,"Here are the strings:\n");
960: dumpstrings();
961: }
962: }
963: else if(casesen) find = findone; /* Else use findone() */
964: if(inpfile != NULL) /* If file list from file */
965: {
966: flags |= SHOWNAME; /* Always show name of file */
967: if((fi = fopen(inpfile,"r")) == NULL)
968: { /* If open fails */
969: fprintf(stderr,"Cannot read file list from %s\r\n",inpfile);
970: /* Error message */
971: DOSEXIT(1, 2); /* Error exit */
972: }
973: while(fgets(filnam,FILNAMLEN,fi) != NULL)
974: { /* While there are names */
975: filnam[strcspn(filnam,"\r\n")] = '\0';
976: /* Null-terminate the name */
977: if((fd = openfile(filnam)) == -1) continue;
978: /* Skip file if it cannot be opened */
979: qgrep(filnam,fd); /* Do the work */
980: close(fd); /* Close the file */
981: }
982: fclose(fi); /* Close the list file */
983: }
984: else if(i == argc)
985: {
986: flags &= ~(NAMEONLY | SHOWNAME);
987: setmode(fileno(stdin),O_BINARY);
988: qgrep(NULL,fileno(stdin));
989: }
990: if(argc > i + 1) flags |= SHOWNAME;
991: for(; i < argc; ++i)
992: {
993: if((fd = openfile(argv[i])) == -1) continue;
994: qgrep(argv[i],fd);
995: close(fd);
996: }
997: (*flush1)();
998: if(flags & TIMER) fprintf(stderr,"%ld seconds\n",time(NULL) - start);
999: /* Print elapsed time if timer on */
1000: DOSEXIT(1, status);
1001: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.