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

#

/*	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();
	onintr();
}

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