Return to ptx.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/ptx.c, revision 1.1

1.1     ! root        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:       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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.