/*  This program, SEARCH, is used to search a "database" for
*  matches to a user supplied set of strings.  The match function implemented
*  is the OR case.  Others may be added later if it does not too severly
*  detract from the usefulness of the program.
*
*  SEARCH functions similart to the excellent public domain utility FIND. The
*  major difference is that SEARCH will display multiple lines (a record) when
*  a pattern match is made.  SEARCH is valuable for accessing information
*  entered in a random database.
*
*  The term "database" is used very loosely. Database, here, refers to a
*  loose collection of information.  The program expects to see
*  a "database" bound together in the form of records.  Records, here is
*  also defined very loosely.  For our purposes a record is a collection
*  of ASCII text separated from other ASCII text by a record delimiter.  The
*  record delimiter, itself, is a predefined sequence of ASCII text or a blank
*  line.
*  The main reason we keep everything in ASCII is so that the database can be
*  created, modified, and searched using very primitive tools.  The tools we
*  will need are a simple editor to create and modify the database, and the
*  program SEARCH for searching and extracting information from the database.
*
* ENVIRONMENT:
*  The program was written and compiled using Aztec C on a CP/M 80 system.
*
* Copyright notice:
* This program is Copyrighted by Don Finley (May 1985)
* It is released into the public domain for all to freely use.
* It may be freely given away, but must not be sold for commercial gain
* without the author's permission.
* I ask only that should you find bugs in the program or add enhancements
* please let me know. In the case of enhancements, I would appreciate getting
* a copy.  RBBS 615-229-4488  300/1200 bps, 24 hrs.
*
* Don L. Finley
* 310 Willow St.
* MT. Carmel, TN 37642  (615) 357-3355
*
*/

#include "fcntl.h"
#include "stdio.h"
#include "ctype.h"
#include "sgtty.h"

#define MAXCHR 2048	/* maximum size of record */
#define MAXLINE 50	/* maximum number of lines in a record */
#define RECMARK "--"	/* delimiter between records */
#define MAXWIDE 256	/* maximum width of a line */
#define TRUE 1
#define FALSE 0
#define PHANTOM '_'		/* phantom space */

char *string[MAXLINE];	/* pointers to strings */
char *tl;		/* pointer to cat'ed string shifted to lower case */
int chrcnt;
char *frag[MAXLINE];	/* fragments to search for */
int no_frags;				/* number of fragments */
int incname;				/* flag to include file names */
int recno;
struct sgttyb stty;

FILE *fopen(),*fd;

main(argc,argv)
int argc;
char **argv;
{
int rec_len;
int i,hit,j,k,kf;
int forhit;
char *p,*strlow();

	no_frags=0;
	recno=1;
	forhit=FALSE;
	incname=FALSE;
	chrcnt=MAXCHR;

	if(argc < 2) error(1);		/* not enough arguments */

	for(j=1;j<argc;j++){
		for(p=argv[j];*p;p++)*p=tolower(*p);
		if(left(argv[j],"for")){	/* pick up words to search for */
			forhit=TRUE;	/* say we got one, perhaps */
			kf=j;
			for(j++;j<argc;j++){
				if(*argv[j]=='-'){	/* look for - options */
					argv[j]++;
					switch(tolower(*argv[j])){
						case 'n' :	incname = TRUE;
										break;
						default	:	error(6);
					}
					continue;
				}
				if(!(frag[no_frags]=malloc(strlen(argv[j])+2))) error(3);

/* keep everything in lower case and substitute space for phantom */
				strlow(frag[no_frags],argv[j]);
				no_frags++;		/* keep up with number of words entered */
			}
		}
	}

	/* allocate room for saving cat'ed tolower() string */
			if( ! (tl=malloc(MAXCHR) ) ) error(3);

	if(!forhit)error(4);		/* if no FOR given, crap out */
	if(!no_frags)error(5);	/* or if no words follow FOR also crap out */

/* off and running */

	for(j=1;j<kf;j++){
		fd=fopen(argv[j],"r");	/* open for read only */
		if(fd == 0){
				printf("Error. File %s does not exist.\n",argv[j]);
				exit();
		}
		while((rec_len=read_rec()) != -1){
			if(rec_len){		/* got a non-blank record, look at it */
				for(k=0, hit=FALSE ; k<no_frags ; k++){
					if(hit = mids(tl,frag[k])) break;
				}
				/* if found a match, print record */
				if(hit) pri_rec(string,rec_len,argv[j],incname);
				free_up(rec_len);	/* release memory for next record */
			}
		recno++;
		}
		close(fd);
	}
}


/************************** free_up() ***********************/
/* release memory used by malloc function */
free_up(n)
int n;
{
register int i;
	for(i=0;i<n;i++){
		free(string[i]);
	}
}


/************************** read_rec() ****************************/
/* read in a record from stdin. Use the malloc() function to */
/* allocate memory space for records. Read in up to MAXLINE  */
/* lines.  Return number of lines read, or -1 if error */
/* read until record delimiter found or until MAXCHR is equaled */
/* recall that fgets() function includes newline character in string */

read_rec()
{
char line[256];
int lcount;
int l;
char *s,*strlow();

	chrcnt=MAXCHR;
	lcount=0;
	s=tl;
	if(feof(fd))return -1;
	while(fgets(line,256,fd) != NULL){
		if( ((l=strlen(line)) == 1) || left(line,RECMARK)){
			return lcount;
		}
		l++;
		if(!(string[lcount]=malloc(l))){
			exit(3);
		}
		strcpy(string[lcount],line);
		if(!(s=strlow(s,line))) error(8);
		lcount++;
		if(lcount > MAXLINE)error(2);
	}
	if(lcount)return lcount;
	if(feof(fd))return -1;
	return 0;
}

/*************************** strlow(() **********************/
/* copy string p to string s while shifting s to lower case */
/* remove excess spaces */
/* replace phantom character with space */
/* replace punctuation with space */
/* strip starting spaces */
/* add trailing space */

char *strlow(s,p)
char *s,*p;
{
char c,flag;
	flag=FALSE;

	if(!*p)return (s);

	while(*p == ' ' || isspace(*p) || isperiod(*p) )p++;
	while(*p && chrcnt){
		c=tolower(*p);
		if( isperiod(c) || isspace(c)) c=' ';
		if(!((c==' ') && (flag == ' '))){
			*s++=c;
			chrcnt--;
		}
		flag=c;
		p++;
	}
	if(!chrcnt) return (0);		/* about to overflow buffer */
	if(c != ' ')*s++=' ';
	*s=0;
	return s;
}

isperiod(c)
char c;
{
	if(c == '.' ||
		c == ',' ||
		c == ';' ||
		c == '?' ||
		c == PHANTOM ||
		c == ':' ) return TRUE;
		return FALSE;
}

force_con()
{
if(!isatty(stdout))freopen("con:","w",stdout);
}

/*************************** usage () ***************************/
usage()
{

force_con();	/* force output to console */

puts("");
puts("--- Program to look for string matches in files ---");
puts("  Copyright Don L. Finley   May, 1985   Mt. Carmel, TN");
puts("  Released into the public domain for non commerial distribution.");
puts("");
puts("The files should contain freeform ASCII text grouped as records.");
printf("A record is defined as up to %d lines separated by a\n",MAXLINE);
printf("record delimiter. The record delimiter is a line beginning\n");
printf("with the special sequence    %s    or a blank line.\n\n",RECMARK);
puts("USAGE:  SEARCH file.ext FOR word1 word2 word3 etc ");
puts("        file.ext can be one or more valid file name(s). NO wildcards.");
puts("        FOR separates the file names from the word fragments to match.");
puts("        word(s) can be any valid ASCII strings. Spaces separate words.");
puts("        The underline character '_' can be used as a phantom space.");
puts("        i.e. to search for 4 mhz, enter the string as: 4_mhz");
puts("OPTIONS:");
puts("        -N  include file name in output.");
puts("        to send output to a file, specify output file name as >file.");
exit();
}

/*************************** left() *************************/
/* determine if two strings start the same */
left(s,p)
char *s,*p;
{
	for( ; *p; p++, s++){
		if(*s != *p)break;
	}
	if(*p)return FALSE;
	return TRUE;
}

/*************************** error() *************************/
/* Error function */
error(n)
int n;
{
	fprintf(stderr,"Error. ");
	switch(n){
		case 1	:	usage();
						abort();
		case 2	:	fprintf(stderr,"\nToo many lines in record.");
						fprintf(stderr," Maximum of %d allowed\n",MAXLINE);
						abort();
		case 3	:	fprintf(stderr,"Unable to allocate required memory.\n");
						abort();
		case 4	:	fprintf(stderr,"No FOR directive encountered.\n");
						abort();
		case 5	:	fprintf(stderr,"No string fragments to search for.\n");
						abort();
		case 6	:	fprintf(stderr,"Unknown OPTION.\n");
						abort();
		case 8	:	fprintf(stderr,"Too many characters in record #%d.\n",recno);
						fprintf(stderr,"Maximum of ( %d) permitted.\n",MAXCHR);
						abort();
		default	:
						puts("Unrecognized error number ");
						abort();
	}
}

abort()
{
	exit(1);
}

/************************** pri_rec() *****************************/
/* Print record.  Most always 'cause we got a match */
pri_rec(s,n,fname,flg)
char **s,*fname;
int n;
{
int i;
	if(flg){
		printf("----  File -->  %s ---------\n",fname);
	}
	else{
		puts("");
	}
	for(i=0;i<n;i++){
		printf("%s",s[i]);
	}
}

/*************************** mids() **************************/
/* function to see if string s1 is contained within string s */
/* if  s contains s1 then return TRUE, otherwise return FALSE */
/* Further, if s1 is a null string, return FALSE */

mids(s,s1)
char *s,*s1;
{
char *p,*p1;
	if(!*s1)return FALSE;
	while(*s){
		if(*s == *s1){
			for(p1=s1+1,p=s+1;*p && *p == *p1;p1++,p++);
			if(!*p1)return TRUE;
		}
		s++;
	}
	return FALSE;
}