Return to mc.c CVS log

Up to [Research Unix] / researchv8dc / cmd

Annotation of researchv8dc/cmd/mc.c, revision 1.1

1.1     ! root        1: #define        JERQ
        !             2: /*
        !             3:  * mc - columnate
        !             4:  *
        !             5:  * mc[-][-LINEWIDTH][-t][file...]
        !             6:  *     -suppresses break on colon
        !             7:  *     -LINEWIDTH sets width of line in which to columnate(default 80)
        !             8:  *     -t suppresses expanding multiple blanks into tabs
        !             9:  *
        !            10:  */
        !            11: #include       <stdio.h>
        !            12: #ifdef JERQ
        !            13: #include       <sgtty.h>
        !            14: #include       "/usr/jerq/include/jioctl.h"
        !            15: #endif
        !            16: #define WIDTH          80
        !            17: #define NWALLOC                1024
        !            18: #define NALLOC         4096
        !            19: int linewidth=WIDTH; 
        !            20: int colonflag=1; 
        !            21: int tabflag=1; 
        !            22: char *cbuf, *cbufp; 
        !            23: char **word; 
        !            24: FILE *file; 
        !            25: char *malloc(); 
        !            26: char *realloc(); 
        !            27: int maxwidth=0; 
        !            28: int nalloc=NALLOC; 
        !            29: int nwalloc=NWALLOC; 
        !            30: int nchars=0; 
        !            31: int nwords=0; 
        !            32: 
        !            33: main(argc, argv)
        !            34:        char *argv[]; 
        !            35: {
        !            36:        FILE *fopen(); 
        !            37:        register i; 
        !            38:        char buf[BUFSIZ]; 
        !            39: #ifdef JERQ
        !            40:        struct winsize wbuf;
        !            41: 
        !            42:        if(ioctl(1, JWINSIZE, &wbuf)==0){
        !            43:                linewidth=wbuf.bytesx;
        !            44:                if(linewidth<0)
        !            45:                        linewidth=WIDTH; 
        !            46:        }
        !            47: #endif
        !            48:        if(argc>1){
        !            49:                while(*argv[1]=='-'){
        !            50:                        --argc; argv++; 
        !            51:                        switch(argv[0][1]){
        !            52:                        case '\0':
        !            53:                                colonflag=0; 
        !            54:                                break; 
        !            55:                        case 't':
        !            56:                                tabflag=0; 
        !            57:                                break; 
        !            58:                        default:
        !            59:                                linewidth=atoi(&argv[0][1]); 
        !            60:                                if(linewidth<=1)
        !            61:                                        linewidth=WIDTH; 
        !            62:                                break; 
        !            63:                        }
        !            64:                }
        !            65:        }
        !            66:        setbuf(stdout, buf); 
        !            67:        cbuf=cbufp=malloc(NALLOC); 
        !            68:        word=(char **)malloc(NWALLOC *(sizeof *word)); 
        !            69:        if(word==0 || cbuf==0)
        !            70:                error("out of memory"); 
        !            71:        if(argc==1){
        !            72:                file=stdin; 
        !            73:                readbuf(); 
        !            74:        }else{
        !            75:                colonflag=0; 
        !            76:                for(i=1; i<argc; i++){
        !            77:                        file=freopen(*++argv, "r", stdin); 
        !            78:                        if(file==NULL)
        !            79:                                fprintf(stderr, "mc: can't open %s\n", *argv); 
        !            80:                        else
        !            81:                                readbuf(); 
        !            82:                }
        !            83:        }
        !            84:        columnate(); 
        !            85:        exit(0); 
        !            86: }
        !            87: error(s)
        !            88:        char *s; 
        !            89: {
        !            90:        fprintf(stderr, "mc: %s\n", s); 
        !            91:        exit(1); 
        !            92: }
        !            93: readbuf()
        !            94: {
        !            95:        register c, lastwascolon=0; 
        !            96:        do{
        !            97:                if(nchars++>=nalloc){
        !            98:                        if((cbuf=realloc(cbuf, nalloc+=NALLOC))==0)
        !            99:                                error("out of memory"); 
        !           100:                        cbufp=cbuf+nchars-1; 
        !           101:                }
        !           102:                *cbufp++=c=getc(file); 
        !           103:                if(colonflag && c==':')
        !           104:                        lastwascolon++; 
        !           105:                else if(lastwascolon){
        !           106:                        if(c=='\n'){
        !           107:                                register n=1; 
        !           108:                                --nchars;       /* skip newline */
        !           109:                                while(nchars>0 && cbuf[--nchars]!='\n')
        !           110:                                        n++; 
        !           111:                                if(cbuf[nchars]=='\n')
        !           112:                                        nchars++; 
        !           113:                                columnate(); 
        !           114:                                fwrite(cbuf+nchars, 1, n, stdout); 
        !           115:                                nchars=0; 
        !           116:                                cbufp=cbuf; 
        !           117:                        }
        !           118:                        lastwascolon=0; 
        !           119:                }
        !           120:        }while(c!=EOF); 
        !           121: }
        !           122: scanwords(){
        !           123:        register char *p, *q; 
        !           124:        register i; 
        !           125:        nwords=0; 
        !           126:        maxwidth=0; 
        !           127:        for(p=q=cbuf, i=0; i<nchars; i++){
        !           128:                if(*p++=='\n'){
        !           129:                        if(nwords>=nwalloc){
        !           130:                                if((word=(char **)realloc((char *)word, (nwalloc+=NWALLOC)*sizeof(*word)))==0)
        !           131:                                        error("out of memory"); 
        !           132:                        }
        !           133:                        word[nwords++]=q; 
        !           134:                        p[-1]=0; 
        !           135:                        if(p-q>maxwidth)
        !           136:                                maxwidth=p-q; 
        !           137:                        q=p; 
        !           138:                }
        !           139:        }
        !           140: }
        !           141: int words_per_line; 
        !           142: int nlines; 
        !           143: int col; 
        !           144: int tabcol; 
        !           145: int endcol; 
        !           146: int maxcol; 
        !           147: columnate(){
        !           148:        register char *p; 
        !           149:        register i, j; 
        !           150:        scanwords(); 
        !           151:        if(nwords==0)
        !           152:                return; 
        !           153:        words_per_line=linewidth/maxwidth; 
        !           154:        if(words_per_line<=0)
        !           155:                words_per_line=1; 
        !           156:        nlines=(nwords+words_per_line-1)/words_per_line; 
        !           157:        for(i=0; i<nlines; i++){
        !           158:                col=0; 
        !           159:                endcol=0; 
        !           160:                for(j=0; i+j<nwords; ){
        !           161:                        endcol+=maxwidth; 
        !           162:                        p=word[i+j]; 
        !           163:                        while(*p){
        !           164:                                putchar(*p++); 
        !           165:                                col++; 
        !           166:                        }
        !           167:                        if(i+(j+=nlines)<nwords){
        !           168:                                tabcol=(col|07)+1; 
        !           169:                                if(tabflag)
        !           170:                                        while(tabcol<=endcol){
        !           171:                                                putchar('\t'); 
        !           172:                                                col=tabcol; 
        !           173:                                                tabcol+=8; 
        !           174:                                        }
        !           175:                                while(col<endcol){
        !           176:                                        putchar(' '); 
        !           177:                                        col++; 
        !           178:                                }
        !           179:                        }
        !           180:                }
        !           181:                putchar('\n'); 
        !           182:        }
        !           183: }

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