[unix-history] / usr / src / usr.bin / ptx / ptx.c

static char *sccsid = "@(#)ptx.c	4.2 (Berkeley) %G%";
#

/*	permuted title index
	ptx [-t] [-i ignore] [-o only] [-w num] [-f] [input] [output]
	Ptx reads the input file and permutes on words in it.
	It excludes all words in the ignore file.
	Alternately it includes words in the only file.
	if neither is given it excludes the words in /usr/lib/eign.

	The width of the output line can be changed to num
	characters.  If omitted 72 is default unless troff than 100.
	the -f flag tells the program to fold the output
	the -t flag says the output is for troff and the
	output is then wider.

\e	make: cc ptx.c -lS
	*/

#include <stdio.h>
#include <ctype.h>
#include <signal.h>
#define DEFLTX "/usr/lib/eign"
#define TILDE 0177
#define SORT "/usr/bin/sort"
#define	N 30
#define	MAX	N*BUFSIZ
#define LMAX	200
#define MAXT	2048
#define MASK	03777
#define SET	1

#define isabreak(c) (btable[c])

extern char *calloc(), *mktemp();
extern char *getline();
int status;


char *hasht[MAXT];
char line[LMAX];
char btable[128];
int ignore;
int only;
int llen = 72;
int gap = 3;
int gutter = 3;
int mlen = LMAX;
int wlen;
int rflag;
int halflen;
char *strtbufp, *endbufp;
char *empty = "";

char *infile;
FILE *inptr = stdin;

char *outfile;
FILE *outptr = stdout;

char *sortfile;	/* output of sort program */
char nofold[] = {'-', 'd', 't', TILDE, 0};
char fold[] = {'-', 'd', 'f', 't', TILDE, 0};
char *sortopt = nofold;
FILE *sortptr;

char *bfile;	/*contains user supplied break chars */
FILE *bptr;

main(argc,argv)
int argc;
char **argv;
{
	register int c;
	register char *bufp;
	int pid;
	char *pend;
	extern onintr();

	char *xfile;
	FILE *xptr;

	if(signal(SIGHUP,onintr)==SIG_IGN)
		signal(SIGHUP,SIG_IGN);
	if(signal(SIGINT,onintr)==SIG_IGN)
		signal(SIGINT,SIG_IGN);
	signal(SIGPIPE,onintr);
	signal(SIGTERM,onintr);

/*	argument decoding	*/

	xfile = DEFLTX;
	argv++;
	while(argc>1 && **argv == '-') {
		switch (*++*argv){

		case 'r':
			rflag++;
			break;
		case 'f':
			sortopt = fold;
			break;

		case 'w':
			if(argc >= 2) {
				argc--;
				wlen++;
				llen = atoi(*++argv);
				if(llen == 0)
					diag("Wrong width:",*argv);
				if(llen > LMAX) {
					llen = LMAX;
					msg("Lines truncated to 200 chars.",empty);
				}
				break;
			}

		case 't':
			if(wlen == 0)
				llen = 100;
			break;
		case 'g':
			if(argc >=2) {
				argc--;
				gap = gutter = atoi(*++argv);
			}
			break;

		case 'i':
			if(only) 
				diag("Only file already given.",empty);
			if (argc>=2){
				argc--;
				ignore++;
				xfile = *++argv;
			}
			break;

		case 'o':
			if(ignore)
				diag("Ignore file already given",empty);
			if (argc>=2){
				only++;
				argc--;
				xfile = *++argv;
			}
			break;

		case 'b':
			if(argc>=2) {
				argc--;
				bfile = *++argv;
			}
			break;

		default:
			msg("Illegal argument:",*argv);
		}
		argc--;
		argv++;
	}

	if(argc>3)
		diag("Too many filenames",empty);
	else if(argc==3){
		infile = *argv++;
		outfile = *argv;
		if((outptr = fopen(outfile,"w")) == NULL)
			diag("Cannot open output file:",outfile);
	} else if(argc==2) {
		infile = *argv;
		outfile = 0;
	}


	/* Default breaks of blank, tab and newline */
	btable[' '] = SET;
	btable['\t'] = SET;
	btable['\n'] = SET;
	if(bfile) {
		if((bptr = fopen(bfile,"r")) == NULL)
			diag("Cannot open break char file",bfile);

		while((c = getc(bptr)) != EOF)
			btable[c] = SET;
	}

/*	Allocate space for a buffer.  If only or ignore file present
	read it into buffer. Else read in default ignore file
	and put resulting words in buffer.
	*/


	if((strtbufp = calloc(N,BUFSIZ)) == NULL)
		diag("Out of memory space",empty);
	bufp = strtbufp;
	endbufp = strtbufp+MAX;

	if((xptr = fopen(xfile,"r")) == NULL)
		diag("Cannot open  file",xfile);

	while(bufp < endbufp && (c = getc(xptr)) != EOF) {
		if(isabreak(c)) {
			if(storeh(hash(strtbufp,bufp),strtbufp))
				diag("Too many words",xfile);
			*bufp++ = '\0';
			strtbufp = bufp;
		}
		else {
			*bufp++ = (isupper(c)?tolower(c):c);
		}
	}
	if (bufp >= endbufp)
		diag("Too many words in file",xfile);
	endbufp = --bufp;

	/* open output file for sorting */

	sortfile = mktemp("/tmp/ptxsXXXXX");
	if((sortptr = fopen(sortfile, "w")) == NULL)
		diag("Cannot open output for sorting:",sortfile);

/*	get a line of data and compare each word for
	inclusion or exclusion in the sort phase
*/

	if (infile!=0 && (inptr = fopen(infile,"r")) == NULL)
		diag("Cannot open data: ",infile);
	while(pend=getline())
		cmpline(pend);
	fclose(sortptr);

	switch (pid = fork()){

	case -1:	/* cannot fork */
		diag("Cannot fork",empty);

	case 0:		/* child */
		execl(SORT, SORT, sortopt, "+0", "-1", "+1",
			sortfile, "-o", sortfile, 0);

	default:	/* parent */
		while(wait(&status) != pid);
	}


	getsort();
	if(*sortfile)
		unlink(sortfile);
	exit(0);
}

msg(s,arg)
char *s;
char *arg;
{
	fprintf(stderr,"%s %s\n",s,arg);
	return;
}
diag(s,arg)
char *s, *arg;
{

	msg(s,arg);
	exit(1);
}


char *getline()
{

	register c;
	register char *linep;
	char *endlinep;


	endlinep= line + mlen;
	linep = line;
	/* Throw away leading white space */

	while(isspace(c=getc(inptr)))
		;
	if(c==EOF)
		return(0);
	ungetc(c,inptr);
	while(( c=getc(inptr)) != EOF) {
		switch (c) {

			case '\t':
				if(linep<endlinep)
					*linep++ = ' ';
				break;
			case '\n':
				while(isspace(*--linep));
				*++linep = '\n';
				return(linep);
			default:
				if(linep < endlinep)
					*linep++ = c;
		}
	}
	return(0);
}

cmpline(pend)
char *pend;
{

	char *pstrt, *pchar, *cp;
	char **hp;
	int flag;

	pchar = line;
	if(rflag)
		while(pchar<pend&&!isspace(*pchar))
			pchar++;
	while(pchar<pend){
	/* eliminate white space */
		if(isabreak(*pchar++))
			continue;
		pstrt = --pchar;

		flag = 1;
		while(flag){
			if(isabreak(*pchar)) {
				hp = &hasht[hash(pstrt,pchar)];
				pchar--;
				while(cp = *hp++){
					if(hp == &hasht[MAXT])
						hp = hasht;
	/* possible match */
					if(cmpword(pstrt,pchar,cp)){
	/* exact match */
						if(!ignore && only)
							putline(pstrt,pend);
						flag = 0;
						break;
					}
				}
	/* no match */
				if(flag){
					if(ignore || !only)
						putline(pstrt,pend);
					flag = 0;
				}
			}
		pchar++;
		}
	}
}

cmpword(cpp,pend,hpp)
char *cpp, *pend, *hpp;
{
	char c;

	while(*hpp != '\0'){
		c = *cpp++;
		if((isupper(c)?tolower(c):c) != *hpp++)
			return(0);
	}
	if(--cpp == pend) return(1);
	return(0);
}

putline(strt, end)
char *strt, *end;
{
	char *cp;

	for(cp=strt; cp<end; cp++)
		putc(*cp, sortptr);
	/* Add extra blank before TILDE to sort correctly
	   with -fd option */
	putc(' ',sortptr);
	putc(TILDE,sortptr);
	for (cp=line; cp<strt; cp++)
		putc(*cp,sortptr);
	putc('\n',sortptr);
}

getsort()
{
	register c;
	register char *tilde, *linep, *ref;
	char *p1a,*p1b,*p2a,*p2b,*p3a,*p3b,*p4a,*p4b;
	int w;
	char *rtrim(), *ltrim();

	if((sortptr = fopen(sortfile,"r")) == NULL)
		diag("Cannot open sorted data:",sortfile);

	halflen = (llen-gutter)/2;
	linep = line;
	while((c = getc(sortptr)) != EOF) {
		switch(c) {

		case TILDE:
			tilde = linep;
			break;

		case '\n':
			while(isspace(linep[-1]))
				linep--;
			ref = tilde;
			if(rflag) {
				while(ref<linep&&!isspace(*ref))
					ref++;
				*ref++ = 0;
			}
		/* the -1 is an overly conservative test to leave
		   space for the / that signifies truncation*/
			p3b = rtrim(p3a=line,tilde,halflen-1);
			if(p3b-p3a>halflen-1)
				p3b = p3a+halflen-1;
			p2a = ltrim(ref,p2b=linep,halflen-1);
			if(p2b-p2a>halflen-1)
				p2a = p2b-halflen-1;
			p1b = rtrim(p1a=p3b+(isspace(p3b[0])!=0),tilde,
				w=halflen-(p2b-p2a)-gap);
			if(p1b-p1a>w)
				p1b = p1a;
			p4a = ltrim(ref,p4b=p2a-(isspace(p2a[-1])!=0),
				w=halflen-(p3b-p3a)-gap);
			if(p4b-p4a>w)
				p4a = p4b;
			fprintf(outptr,".xx \"");
			putout(p1a,p1b);
	/* tilde-1 to account for extra space before TILDE */
			if(p1b!=(tilde-1) && p1a!=p1b)
				fprintf(outptr,"/");
			fprintf(outptr,"\" \"");
			if(p4a==p4b && p2a!=ref && p2a!=p2b)
				fprintf(outptr,"/");
			putout(p2a,p2b);
			fprintf(outptr,"\" \"");
			putout(p3a,p3b);
	/* ++p3b to account for extra blank after TILDE */
	/* ++p3b to account for extra space before TILDE */
			if(p1a==p1b && ++p3b!=tilde)
				fprintf(outptr,"/");
			fprintf(outptr,"\" \"");
			if(p1a==p1b && p4a!=ref && p4a!=p4b)
				fprintf(outptr,"/");
			putout(p4a,p4b);
			if(rflag)
				fprintf(outptr,"\" %s\n",tilde);
			else
				fprintf(outptr,"\"\n");
			linep = line;
			break;

		case '"':
	/* put double " for "  */
			*linep++ = c;
		default:
			*linep++ = c;
		}
	}
}

char *rtrim(a,c,d)
char *a,*c;
{
	char *b,*x;
	b = c;
	for(x=a+1; x<=c&&x-a<=d; x++)
		if((x==c||isspace(x[0]))&&!isspace(x[-1]))
			b = x;
	if(b<c&&!isspace(b[0]))
		b++;
	return(b);
}

char *ltrim(c,b,d)
char *c,*b;
{
	char *a,*x;
	a = c;
	for(x=b-1; x>=c&&b-x<=d; x--)
		if(!isspace(x[0])&&(x==c||isspace(x[-1])))
			a = x;
	if(a>c&&!isspace(a[-1]))
		a--;
	return(a);
}

putout(strt,end)
char *strt, *end;
{
	char *cp;

	cp = strt;

	for(cp=strt; cp<end; cp++) {
		putc(*cp,outptr);
	}
}

onintr()
{

	if(*sortfile)
		unlink(sortfile);
	exit(1);
}

hash(strtp,endp)
char *strtp, *endp;
{
	char *cp, c;
	int i, j, k;

	/* Return zero hash number for single letter words */
	if((endp - strtp) == 1)
		return(0);

	cp = strtp;
	c = *cp++;
	i = (isupper(c)?tolower(c):c);
	c = *cp;
	j = (isupper(c)?tolower(c):c);
	i = i*j;
	cp = --endp;
	c = *cp--;
	k = (isupper(c)?tolower(c):c);
	c = *cp;
	j = (isupper(c)?tolower(c):c);
	j = k*j;

	k = (i ^ (j>>2)) & MASK;
	return(k);
}

storeh(num,strtp)
int num;
char *strtp;
{
	int i;

	for(i=num; i<MAXT; i++) {
		if(hasht[i] == 0) {
			hasht[i] = strtp;
			return(0);
		}
	}
	for(i=0; i<num; i++) {
		if(hasht[i] == 0) {
			hasht[i] = strtp;
			return(0);
		}
	}
	return(1);
}
Commit	Line	Data
62939760	1	static char *sccsid = "@(#)ptx.c 4.2 (Berkeley) %G%";
f125e2b0 BJ	2	#
	3
	4	/* permuted title index
	5	ptx [-t] [-i ignore] [-o only] [-w num] [-f] [input] [output]
	6	Ptx reads the input file and permutes on words in it.
	7	It excludes all words in the ignore file.
	8	Alternately it includes words in the only file.
	9	if neither is given it excludes the words in /usr/lib/eign.
	10
	11	The width of the output line can be changed to num
	12	characters. If omitted 72 is default unless troff than 100.
	13	the -f flag tells the program to fold the output
	14	the -t flag says the output is for troff and the
	15	output is then wider.
	16
	17	\e make: cc ptx.c -lS
	18	*/
	19
	20	#include <stdio.h>
	21	#include <ctype.h>
	22	#include <signal.h>
	23	#define DEFLTX "/usr/lib/eign"
	24	#define TILDE 0177
	25	#define SORT "/usr/bin/sort"
	26	#define N 30
	27	#define MAX N*BUFSIZ
	28	#define LMAX 200
	29	#define MAXT 2048
	30	#define MASK 03777
	31	#define SET 1
	32
	33	#define isabreak(c) (btable[c])
	34
	35	extern char calloc(), mktemp();
	36	extern char *getline();
	37	int status;
	38
	39
	40	char *hasht[MAXT];
	41	char line[LMAX];
	42	char btable[128];
	43	int ignore;
	44	int only;
	45	int llen = 72;
	46	int gap = 3;
	47	int gutter = 3;
	48	int mlen = LMAX;
	49	int wlen;
	50	int rflag;
	51	int halflen;
	52	char strtbufp, endbufp;
	53	char *empty = "";
	54
	55	char *infile;
	56	FILE *inptr = stdin;
	57
	58	char *outfile;
	59	FILE *outptr = stdout;
	60
	61	char sortfile; / output of sort program */
	62	char nofold[] = {'-', 'd', 't', TILDE, 0};
	63	char fold[] = {'-', 'd', 'f', 't', TILDE, 0};
	64	char *sortopt = nofold;
	65	FILE *sortptr;
66
67	char bfile; /contains user supplied break chars */
68	FILE *bptr;
69
70	main(argc,argv)
71	int argc;
72	char **argv;
73	{
74	register int c;
75	register char *bufp;
76	int pid;
77	char *pend;
78	extern onintr();
79
80	char *xfile;
81	FILE *xptr;
82
83	if(signal(SIGHUP,onintr)==SIG_IGN)
84	signal(SIGHUP,SIG_IGN);
85	if(signal(SIGINT,onintr)==SIG_IGN)
86	signal(SIGINT,SIG_IGN);
87	signal(SIGPIPE,onintr);
88	signal(SIGTERM,onintr);
89
90	/* argument decoding */
91
92	xfile = DEFLTX;
93	argv++;
94	while(argc>1 && **argv == '-') {
95	switch (++argv){
96
97	case 'r':
98	rflag++;
99	break;
100	case 'f':
101	sortopt = fold;
102	break;
103
104	case 'w':
105	if(argc >= 2) {
106	argc--;
107	wlen++;
108	llen = atoi(*++argv);
109	if(llen == 0)
110	diag("Wrong width:",*argv);
111	if(llen > LMAX) {
112	llen = LMAX;
113	msg("Lines truncated to 200 chars.",empty);
114	}
115	break;
116	}
117
118	case 't':
119	if(wlen == 0)
120	llen = 100;
121	break;
122	case 'g':
123	if(argc >=2) {
124	argc--;
125	gap = gutter = atoi(*++argv);
126	}
127	break;
128
129	case 'i':
130	if(only)
131	diag("Only file already given.",empty);
132	if (argc>=2){
133	argc--;
134	ignore++;
135	xfile = *++argv;
136	}
137	break;
138
139	case 'o':
140	if(ignore)
141	diag("Ignore file already given",empty);
142	if (argc>=2){
143	only++;
144	argc--;
145	xfile = *++argv;
146	}
147	break;
148
149	case 'b':
150	if(argc>=2) {
151	argc--;
152	bfile = *++argv;
153	}
154	break;
155
156	default:
157	msg("Illegal argument:",*argv);
158	}
159	argc--;
160	argv++;
161	}
162
163	if(argc>3)
164	diag("Too many filenames",empty);
165	else if(argc==3){
166	infile = *argv++;
167	outfile = *argv;
168	if((outptr = fopen(outfile,"w")) == NULL)
169	diag("Cannot open output file:",outfile);
170	} else if(argc==2) {
171	infile = *argv;
172	outfile = 0;
173	}
174
175
176	/* Default breaks of blank, tab and newline */
177	btable[' '] = SET;
178	btable['\t'] = SET;
179	btable['\n'] = SET;
180	if(bfile) {
181	if((bptr = fopen(bfile,"r")) == NULL)
182	diag("Cannot open break char file",bfile);
183
184	while((c = getc(bptr)) != EOF)
185	btable[c] = SET;
186	}
187
188	/* Allocate space for a buffer. If only or ignore file present
189	read it into buffer. Else read in default ignore file
190	and put resulting words in buffer.
191	*/
192
193
194	if((strtbufp = calloc(N,BUFSIZ)) == NULL)
195	diag("Out of memory space",empty);
196	bufp = strtbufp;
197	endbufp = strtbufp+MAX;
198
199	if((xptr = fopen(xfile,"r")) == NULL)
200	diag("Cannot open file",xfile);
201
202	while(bufp < endbufp && (c = getc(xptr)) != EOF) {
203	if(isabreak(c)) {
204	if(storeh(hash(strtbufp,bufp),strtbufp))
205	diag("Too many words",xfile);
206	*bufp++ = '\0';
207	strtbufp = bufp;
208	}
209	else {
210	*bufp++ = (isupper(c)?tolower(c):c);
211	}
212	}
213	if (bufp >= endbufp)
214	diag("Too many words in file",xfile);
215	endbufp = --bufp;
216
217	/* open output file for sorting */
218
219	sortfile = mktemp("/tmp/ptxsXXXXX");
220	if((sortptr = fopen(sortfile, "w")) == NULL)
221	diag("Cannot open output for sorting:",sortfile);
222
223	/* get a line of data and compare each word for
224	inclusion or exclusion in the sort phase
225	*/
226
227	if (infile!=0 && (inptr = fopen(infile,"r")) == NULL)
228	diag("Cannot open data: ",infile);
229	while(pend=getline())
230	cmpline(pend);
231	fclose(sortptr);
232
233	switch (pid = fork()){
234
235	case -1: /* cannot fork */
236	diag("Cannot fork",empty);
237
238	case 0: /* child */
239	execl(SORT, SORT, sortopt, "+0", "-1", "+1",
240	sortfile, "-o", sortfile, 0);
241
242	default: /* parent */
243	while(wait(&status) != pid);
244	}
245
246
247	getsort();
62939760 JB	248	if(*sortfile)
	249	unlink(sortfile);
	250	exit(0);
f125e2b0 BJ	251	}
	252
	253	msg(s,arg)
	254	char *s;
	255	char *arg;
	256	{
	257	fprintf(stderr,"%s %s\n",s,arg);
	258	return;
	259	}
	260	diag(s,arg)
	261	char s, arg;
	262	{
	263
	264	msg(s,arg);
	265	exit(1);
	266	}
	267
	268
	269	char *getline()
	270	{
	271
	272	register c;
	273	register char *linep;
	274	char *endlinep;
	275
	276
	277	endlinep= line + mlen;
	278	linep = line;
	279	/* Throw away leading white space */
	280
	281	while(isspace(c=getc(inptr)))
	282	;
	283	if(c==EOF)
	284	return(0);
	285	ungetc(c,inptr);
	286	while(( c=getc(inptr)) != EOF) {
	287	switch (c) {
	288
	289	case '\t':
	290	if(linep<endlinep)
	291	*linep++ = ' ';
	292	break;
	293	case '\n':
	294	while(isspace(*--linep));
	295	*++linep = '\n';
	296	return(linep);
	297	default:
	298	if(linep < endlinep)
	299	*linep++ = c;
	300	}
	301	}
	302	return(0);
	303	}
	304
	305	cmpline(pend)
	306	char *pend;
	307	{
	308
	309	char pstrt, pchar, *cp;
	310	char **hp;
	311	int flag;
	312
	313	pchar = line;
	314	if(rflag)
315	while(pchar<pend&&!isspace(*pchar))
316	pchar++;
317	while(pchar<pend){
318	/* eliminate white space */
319	if(isabreak(*pchar++))
320	continue;
321	pstrt = --pchar;
322
323	flag = 1;
324	while(flag){
325	if(isabreak(*pchar)) {
326	hp = &hasht[hash(pstrt,pchar)];
327	pchar--;
328	while(cp = *hp++){
329	if(hp == &hasht[MAXT])
330	hp = hasht;
331	/* possible match */
332	if(cmpword(pstrt,pchar,cp)){
333	/* exact match */
334	if(!ignore && only)
335	putline(pstrt,pend);
336	flag = 0;
337	break;
338	}
339	}
340	/* no match */
341	if(flag){
342	if(ignore \|\| !only)
343	putline(pstrt,pend);
344	flag = 0;
345	}
346	}
347	pchar++;
348	}
349	}
350	}
351
352	cmpword(cpp,pend,hpp)
353	char cpp, pend, *hpp;
354	{
355	char c;
356
357	while(*hpp != '\0'){
358	c = *cpp++;
359	if((isupper(c)?tolower(c):c) != *hpp++)
360	return(0);
361	}
362	if(--cpp == pend) return(1);
363	return(0);
364	}
365
366	putline(strt, end)
367	char strt, end;
368	{
369	char *cp;
370
371	for(cp=strt; cp<end; cp++)
372	putc(*cp, sortptr);
373	/* Add extra blank before TILDE to sort correctly
374	with -fd option */
375	putc(' ',sortptr);
376	putc(TILDE,sortptr);
377	for (cp=line; cp<strt; cp++)
378	putc(*cp,sortptr);
379	putc('\n',sortptr);
380	}
381
382	getsort()
383	{
384	register c;
385	register char tilde, linep, *ref;
386	char p1a,p1b,p2a,p2b,p3a,p3b,p4a,p4b;
387	int w;
388	char rtrim(), ltrim();
389
390	if((sortptr = fopen(sortfile,"r")) == NULL)
391	diag("Cannot open sorted data:",sortfile);
392
393	halflen = (llen-gutter)/2;
394	linep = line;
395	while((c = getc(sortptr)) != EOF) {
396	switch(c) {
397
398	case TILDE:
399	tilde = linep;
400	break;
401
402	case '\n':
403	while(isspace(linep[-1]))
404	linep--;
405	ref = tilde;
406	if(rflag) {
407	while(ref<linep&&!isspace(*ref))
408	ref++;
409	*ref++ = 0;
410	}
411	/* the -1 is an overly conservative test to leave
412	space for the / that signifies truncation*/
413	p3b = rtrim(p3a=line,tilde,halflen-1);
414	if(p3b-p3a>halflen-1)
415	p3b = p3a+halflen-1;
416	p2a = ltrim(ref,p2b=linep,halflen-1);
417	if(p2b-p2a>halflen-1)
418	p2a = p2b-halflen-1;
419	p1b = rtrim(p1a=p3b+(isspace(p3b[0])!=0),tilde,
420	w=halflen-(p2b-p2a)-gap);
421	if(p1b-p1a>w)
422	p1b = p1a;
423	p4a = ltrim(ref,p4b=p2a-(isspace(p2a[-1])!=0),
424	w=halflen-(p3b-p3a)-gap);
425	if(p4b-p4a>w)
426	p4a = p4b;
427	fprintf(outptr,".xx \"");
428	putout(p1a,p1b);
429	/* tilde-1 to account for extra space before TILDE */
430	if(p1b!=(tilde-1) && p1a!=p1b)
431	fprintf(outptr,"/");
432	fprintf(outptr,"\" \"");
433	if(p4a==p4b && p2a!=ref && p2a!=p2b)
434	fprintf(outptr,"/");
435	putout(p2a,p2b);
436	fprintf(outptr,"\" \"");
437	putout(p3a,p3b);
438	/* ++p3b to account for extra blank after TILDE */
439	/* ++p3b to account for extra space before TILDE */
440	if(p1a==p1b && ++p3b!=tilde)
441	fprintf(outptr,"/");
442	fprintf(outptr,"\" \"");
443	if(p1a==p1b && p4a!=ref && p4a!=p4b)
444	fprintf(outptr,"/");
445	putout(p4a,p4b);
446	if(rflag)
447	fprintf(outptr,"\" %s\n",tilde);
448	else
449	fprintf(outptr,"\"\n");
450	linep = line;
451	break;
452
453	case '"':
454	/* put double " for " */
455	*linep++ = c;
456	default:
457	*linep++ = c;
458	}
459	}
460	}
461
462	char *rtrim(a,c,d)
463	char a,c;
464	{
465	char b,x;
466	b = c;
467	for(x=a+1; x<=c&&x-a<=d; x++)
468	if((x==c\|\|isspace(x[0]))&&!isspace(x[-1]))
469	b = x;
470	if(b<c&&!isspace(b[0]))
471	b++;
472	return(b);
473	}
474
475	char *ltrim(c,b,d)
476	char c,b;
477	{
478	char a,x;
479	a = c;
480	for(x=b-1; x>=c&&b-x<=d; x--)
481	if(!isspace(x[0])&&(x==c\|\|isspace(x[-1])))
482	a = x;
483	if(a>c&&!isspace(a[-1]))
484	a--;
485	return(a);
486	}
487
488	putout(strt,end)
489	char strt, end;
490	{
491	char *cp;
492
493	cp = strt;
494
495	for(cp=strt; cp<end; cp++) {
496	putc(*cp,outptr);
497	}
498	}
499
500	onintr()
501	{
502
503	if(*sortfile)
504	unlink(sortfile);
505	exit(1);
506	}
507
508	hash(strtp,endp)
509	char strtp, endp;
510	{
511	char *cp, c;
512	int i, j, k;
513
514	/* Return zero hash number for single letter words */
515	if((endp - strtp) == 1)
516	return(0);
517
518	cp = strtp;
519	c = *cp++;
520	i = (isupper(c)?tolower(c):c);
521	c = *cp;
522	j = (isupper(c)?tolower(c):c);
523	i = i*j;
524	cp = --endp;
525	c = *cp--;
526	k = (isupper(c)?tolower(c):c);
527	c = *cp;
528	j = (isupper(c)?tolower(c):c);
529	j = k*j;
530
531	k = (i ^ (j>>2)) & MASK;
532	return(k);
533	}
534
535	storeh(num,strtp)
536	int num;
537	char *strtp;
538	{
539	int i;
540
541	for(i=num; i<MAXT; i++) {
542	if(hasht[i] == 0) {
543	hasht[i] = strtp;
544	return(0);
545	}
546	}
547	for(i=0; i<num; i++) {
548	if(hasht[i] == 0) {
549	hasht[i] = strtp;
550	return(0);
551	}
552	}
553	return(1);
554	}