![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ptx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd|
Return to ptx.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd |
1.1 root 1: static char *sccsid = "@(#)ptx.c 4.1 (Berkeley) 10/1/80";
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: 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();
248: onintr();
249: }
250:
251: msg(s,arg)
252: char *s;
253: char *arg;
254: {
255: fprintf(stderr,"%s %s\n",s,arg);
256: return;
257: }
258: diag(s,arg)
259: char *s, *arg;
260: {
261:
262: msg(s,arg);
263: exit(1);
264: }
265:
266:
267: char *getline()
268: {
269:
270: register c;
271: register char *linep;
272: char *endlinep;
273:
274:
275: endlinep= line + mlen;
276: linep = line;
277: /* Throw away leading white space */
278:
279: while(isspace(c=getc(inptr)))
280: ;
281: if(c==EOF)
282: return(0);
283: ungetc(c,inptr);
284: while(( c=getc(inptr)) != EOF) {
285: switch (c) {
286:
287: case '\t':
288: if(linep<endlinep)
289: *linep++ = ' ';
290: break;
291: case '\n':
292: while(isspace(*--linep));
293: *++linep = '\n';
294: return(linep);
295: default:
296: if(linep < endlinep)
297: *linep++ = c;
298: }
299: }
300: return(0);
301: }
302:
303: cmpline(pend)
304: char *pend;
305: {
306:
307: char *pstrt, *pchar, *cp;
308: char **hp;
309: int flag;
310:
311: pchar = line;
312: if(rflag)
313: while(pchar<pend&&!isspace(*pchar))
314: pchar++;
315: while(pchar<pend){
316: /* eliminate white space */
317: if(isabreak(*pchar++))
318: continue;
319: pstrt = --pchar;
320:
321: flag = 1;
322: while(flag){
323: if(isabreak(*pchar)) {
324: hp = &hasht[hash(pstrt,pchar)];
325: pchar--;
326: while(cp = *hp++){
327: if(hp == &hasht[MAXT])
328: hp = hasht;
329: /* possible match */
330: if(cmpword(pstrt,pchar,cp)){
331: /* exact match */
332: if(!ignore && only)
333: putline(pstrt,pend);
334: flag = 0;
335: break;
336: }
337: }
338: /* no match */
339: if(flag){
340: if(ignore || !only)
341: putline(pstrt,pend);
342: flag = 0;
343: }
344: }
345: pchar++;
346: }
347: }
348: }
349:
350: cmpword(cpp,pend,hpp)
351: char *cpp, *pend, *hpp;
352: {
353: char c;
354:
355: while(*hpp != '\0'){
356: c = *cpp++;
357: if((isupper(c)?tolower(c):c) != *hpp++)
358: return(0);
359: }
360: if(--cpp == pend) return(1);
361: return(0);
362: }
363:
364: putline(strt, end)
365: char *strt, *end;
366: {
367: char *cp;
368:
369: for(cp=strt; cp<end; cp++)
370: putc(*cp, sortptr);
371: /* Add extra blank before TILDE to sort correctly
372: with -fd option */
373: putc(' ',sortptr);
374: putc(TILDE,sortptr);
375: for (cp=line; cp<strt; cp++)
376: putc(*cp,sortptr);
377: putc('\n',sortptr);
378: }
379:
380: getsort()
381: {
382: register c;
383: register char *tilde, *linep, *ref;
384: char *p1a,*p1b,*p2a,*p2b,*p3a,*p3b,*p4a,*p4b;
385: int w;
386: char *rtrim(), *ltrim();
387:
388: if((sortptr = fopen(sortfile,"r")) == NULL)
389: diag("Cannot open sorted data:",sortfile);
390:
391: halflen = (llen-gutter)/2;
392: linep = line;
393: while((c = getc(sortptr)) != EOF) {
394: switch(c) {
395:
396: case TILDE:
397: tilde = linep;
398: break;
399:
400: case '\n':
401: while(isspace(linep[-1]))
402: linep--;
403: ref = tilde;
404: if(rflag) {
405: while(ref<linep&&!isspace(*ref))
406: ref++;
407: *ref++ = 0;
408: }
409: /* the -1 is an overly conservative test to leave
410: space for the / that signifies truncation*/
411: p3b = rtrim(p3a=line,tilde,halflen-1);
412: if(p3b-p3a>halflen-1)
413: p3b = p3a+halflen-1;
414: p2a = ltrim(ref,p2b=linep,halflen-1);
415: if(p2b-p2a>halflen-1)
416: p2a = p2b-halflen-1;
417: p1b = rtrim(p1a=p3b+(isspace(p3b[0])!=0),tilde,
418: w=halflen-(p2b-p2a)-gap);
419: if(p1b-p1a>w)
420: p1b = p1a;
421: p4a = ltrim(ref,p4b=p2a-(isspace(p2a[-1])!=0),
422: w=halflen-(p3b-p3a)-gap);
423: if(p4b-p4a>w)
424: p4a = p4b;
425: fprintf(outptr,".xx \"");
426: putout(p1a,p1b);
427: /* tilde-1 to account for extra space before TILDE */
428: if(p1b!=(tilde-1) && p1a!=p1b)
429: fprintf(outptr,"/");
430: fprintf(outptr,"\" \"");
431: if(p4a==p4b && p2a!=ref && p2a!=p2b)
432: fprintf(outptr,"/");
433: putout(p2a,p2b);
434: fprintf(outptr,"\" \"");
435: putout(p3a,p3b);
436: /* ++p3b to account for extra blank after TILDE */
437: /* ++p3b to account for extra space before TILDE */
438: if(p1a==p1b && ++p3b!=tilde)
439: fprintf(outptr,"/");
440: fprintf(outptr,"\" \"");
441: if(p1a==p1b && p4a!=ref && p4a!=p4b)
442: fprintf(outptr,"/");
443: putout(p4a,p4b);
444: if(rflag)
445: fprintf(outptr,"\" %s\n",tilde);
446: else
447: fprintf(outptr,"\"\n");
448: linep = line;
449: break;
450:
451: case '"':
452: /* put double " for " */
453: *linep++ = c;
454: default:
455: *linep++ = c;
456: }
457: }
458: }
459:
460: char *rtrim(a,c,d)
461: char *a,*c;
462: {
463: char *b,*x;
464: b = c;
465: for(x=a+1; x<=c&&x-a<=d; x++)
466: if((x==c||isspace(x[0]))&&!isspace(x[-1]))
467: b = x;
468: if(b<c&&!isspace(b[0]))
469: b++;
470: return(b);
471: }
472:
473: char *ltrim(c,b,d)
474: char *c,*b;
475: {
476: char *a,*x;
477: a = c;
478: for(x=b-1; x>=c&&b-x<=d; x--)
479: if(!isspace(x[0])&&(x==c||isspace(x[-1])))
480: a = x;
481: if(a>c&&!isspace(a[-1]))
482: a--;
483: return(a);
484: }
485:
486: putout(strt,end)
487: char *strt, *end;
488: {
489: char *cp;
490:
491: cp = strt;
492:
493: for(cp=strt; cp<end; cp++) {
494: putc(*cp,outptr);
495: }
496: }
497:
498: onintr()
499: {
500:
501: if(*sortfile)
502: unlink(sortfile);
503: exit(1);
504: }
505:
506: hash(strtp,endp)
507: char *strtp, *endp;
508: {
509: char *cp, c;
510: int i, j, k;
511:
512: /* Return zero hash number for single letter words */
513: if((endp - strtp) == 1)
514: return(0);
515:
516: cp = strtp;
517: c = *cp++;
518: i = (isupper(c)?tolower(c):c);
519: c = *cp;
520: j = (isupper(c)?tolower(c):c);
521: i = i*j;
522: cp = --endp;
523: c = *cp--;
524: k = (isupper(c)?tolower(c):c);
525: c = *cp;
526: j = (isupper(c)?tolower(c):c);
527: j = k*j;
528:
529: k = (i ^ (j>>2)) & MASK;
530: return(k);
531: }
532:
533: storeh(num,strtp)
534: int num;
535: char *strtp;
536: {
537: int i;
538:
539: for(i=num; i<MAXT; i++) {
540: if(hasht[i] == 0) {
541: hasht[i] = strtp;
542: return(0);
543: }
544: }
545: for(i=0; i<num; i++) {
546: if(hasht[i] == 0) {
547: hasht[i] = strtp;
548: return(0);
549: }
550: }
551: return(1);
552: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.