/*		Find Pattern
 *
 *	This is a program which prints out all lines in a file with a
 * given pattern.  It can be conditionally compiled for either CP/M or
 * Unix.  In either case, it is invoked by:
 *
 *		fp <pattern> <file(s)>
 *
 *	The <file(s)> specification can use normal file widcards, as
 * defined by wildexp in CP/M and the shell in Unix.
 *	The <pattern> is a string of characters, some of which have special
 * meanings:
 *
 *		<char> - any character not listed below matches exactly that
 *			 character.
 *		? - matches any single character.
 *		* - matches zero or more of any character.
 *		[...] - matches one of any of the characters included between
 *			the brackets; character ranges can also be indicated
 *			by <char>-<char>.  E.g., [a-z0-9] will match any
 *			letter or digit.
 *		[-...] - matches one of any of the characters not included
 *			 between the brackets.
 *
 *	Also, backslash (\) can be used to quote characters (i.e., keep them
 * from being interpreted specially).
 *
 *	To compile and load the program, make sure that one of UNIX or CPM
 * is defined (not both!) in fp.c, and that you have pat.h and pat.c (and
 * wildexp.crl).  On CP/M, then do:
 *
 *		cc1 pat.c
 *		cc1 fp.c
 *		clink fp pat wildexp
 *
 *	On Unix, then do:
 *
 *		cc -O -o fp fp.c pat.c
 *
 *	Note: On Unix, fp runs about three times slower than grep, so it's
 * not clear why you'd want to use it.  This is probably because I use
 * recursion.  Maybe I'll do a non-recursive version later, but this way
 * is much simpler.
 *
 *
 *	Initial coding 8/18/82 by Harry R. Chesley.
 *
 *
 *	Copyright 1982 by Harry R. Chesley.
 *	Unlimited permission granted for non-profit use only.
 */

#include "pat.h"

/* UNIX - defined for use on Unix.
 * CPM - defined for use on CP/M (with BDS-C).
 *
 * MAXBSZ - max size of text buffer (big to minimize IO); should be a multiple
 *	    of 128 for CPM, but doesn't really have to be.  One more char is
 *	    allocated so that a zero byte can be appended when printing
 *	    strings.
 * MAXPSZ - max size of pattern string.
 */

#define UNIX
/*#define CPM*/

#define MAXBSZ 10240+1
#define MAXPSZ 100

/*	main()
 *
 *	Function: Invoked by "fp <pattern> <files>".  Prints every line in
 * each file containing the pattern.
 *
 *	Algorithm: Use srchpat() to locate each subsequent line to be output.
 *
 *	Comments: The only tricky things here are: (1) The search pattern is
 * surrounded with "*"s because srchpat() will only do exact matches;
 * inserting the "*"s makes it match the pattern anywhere on the line.  And
 * (2) when we find outselves at the end of a buffer, we read in a new buffer
 * of text, but keep any partial lines to concatenate with the next buffer
 * load.
 *	I use puts() in the CP/M version because BDS-C printf breaks on long
 * lines.  I don't use it in the Unix version because Unix puts() appends
 * newlines to the string.
 */

main(argc,argv)

int argc;
char *argv[];

{
	int fd;			/* File descriptor. */
	char tbuf[MAXBSZ];	/* Input buffer. */
	char pat[MAXPSZ];	/* Search pattern. */
	char *pptr;		/* Pattern string pointer. */
	char *aptr;		/* Argv pattern pointer. */
	char *nptr;		/* New pointer (in copying partials). */
	char *tptr;		/* Text pointer (while searching). */
	char *retstr;		/* Srchpat() return value. */
	char *eosret;		/* EOS pointer return from srchpat(). */
	char ctmp;		/* Temp storage. */
	int sz, osz;		/* Bytes remaining sizes. */

#ifdef CPM
	/* Fake command name. */
	argv[0] = "FP";
#endif

	/* Verify proper calling procedure: */
	if (argc < 3) {
		printf("Usage: %s <pattern> <file(s)>\n",argv[0]);
		exit(1);
	};

	/* Copy search pattern, prepend and postpend "*". */
	pptr = pat;
	*pptr++ = '*';
	for (aptr = argv[1]; *aptr != 0; *pptr++ = *aptr++);
	*pptr++ = '*';
	*pptr = 0;

	/* Compile search pattern; normal EOL, ignore case. */
	comppat(pat,'\n',TRUE);

#ifdef CPM
	/* Remove search pattern from argv, and expand file names. */
	argv[1] = "NOARG";
	wildexp(&argc, &argv);
#endif

	/* Go thru the files one by one. */
	argc--; argv++; argc--; argv++;	/* Skip command name and pattern. */
	while (argc-- > 0) {
		if ((fd = open(argv[0],0)) == -1) {
			printf("Bad file name: %s!\n",argv[0]);
			argv++;
			continue;
		};
		
		/* Read & write, read & write, ... */
		osz = 0;
#ifdef UNIX
		while ((sz = read(fd,tbuf+osz,(MAXBSZ-1)-osz)) > 0) {
#endif
#ifdef CPM
		while ((sz = 128*read(fd,tbuf+osz,((MAXBSZ-1)-osz)/128)) > 0){
#endif
			osz += sz;
			tptr = tbuf;

			/* While there's something worth printing. */
			while ((retstr = srchpat(tptr,osz,&eosret)) != 0) {
				ctmp = *eosret;
				*eosret = 0;
#ifdef UNIX
				printf("%s: %s",argv[0],retstr);
#endif
#ifdef CPM
				puts(argv[0]); puts(": "); puts(retstr);
#endif
				*eosret = ctmp;
				osz -= eosret - tptr;
				tptr = eosret;
			};

			/* Find partial line at end. */
			tptr += osz-1;
			for (sz = 0; sz != osz; sz++) {
				if (*tptr == '\n') break;
				tptr--;
			};

			/* Copy partial. */
			tptr++;
			osz = sz;
			for (nptr = tbuf; sz != 0; sz--) *nptr++ = *tptr++;
		};

		close(fd);
		argv++;
	};
}

.