Return to sp.c CVS log

Up to [Research Unix] / researchv10dc / cmd

Annotation of researchv10dc/cmd/sp.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Print horizontally as possible, thus saving paper
        !             3:  */
        !             4: #include <stdio.h>
        !             5: int tab[8] = {8,7,6,5,4,3,2,1};
        !             6: int next;      /*next output position on line*/
        !             7: int slen;      /*length at start of line*/
        !             8: int alen;      /*actual length*/
        !             9: int elen;      /*length on current line*/
        !            10: char buf[256];
        !            11: getit()
        !            12: {      register int i;
        !            13:        register c;
        !            14:        slen=alen=elen=0;
        !            15:        for(i=0;;i++)
        !            16:        {       buf[i]=c=getchar();
        !            17:                switch(c)
        !            18:                {
        !            19:                case '\n':      if(i==0) continue;
        !            20:                case EOF:
        !            21:                        alen=i;
        !            22:                        return(i);
        !            23:                case '\t':
        !            24:                        elen+= tab[(next+elen)%8];
        !            25:                        slen += tab[slen%8];
        !            26:                        continue;
        !            27:                default:
        !            28:                        elen++;
        !            29:                        slen++;
        !            30:                        continue;
        !            31:                }
        !            32:        }
        !            33: }
        !            34: putit(ntab)
        !            35: {      register int i;
        !            36:        for(i=0;i<ntab;i++) putchar('\t');
        !            37:        for(i=0;i<alen;i++) putchar(buf[i]);
        !            38: }
        !            39: clean()
        !            40: {
        !            41:        putchar('\n');
        !            42: }
        !            43: main(argc,argv) char *argv[];
        !            44: {      int len,ntab;
        !            45:        int i;
        !            46:        len=80;
        !            47:        for( ; argc>1; argv++,argc--) {
        !            48:                if(access(argv[1],04)==0) {
        !            49:                        freopen(argv[1],"r",stdin);
        !            50:                        continue;
        !            51:                }
        !            52:                i=atoi(argv[1]);
        !            53:                if(i<0) i= -i;
        !            54:                len=(i<1?1:i);
        !            55:        }
        !            56:        for(;;)
        !            57:        {       if(next==0) ntab=0;
        !            58:                else if(tab[next%8]<1)
        !            59:                        {       ntab=2;
        !            60:                                next+= tab[next%8];
        !            61:                                next += tab[next%8];
        !            62:                        }
        !            63:                        else
        !            64:                        {       ntab=1;
        !            65:                                next += tab[next%8];
        !            66:                        }
        !            67:                if(getit()<=0) {clean(); exit(0);}
        !            68:                if(elen+next>=len)
        !            69:                {       clean();
        !            70:                        next=slen;
        !            71:                        putit(0);
        !            72:                }
        !            73:                else
        !            74:                {       next += elen;
        !            75:                        putit(ntab);
        !            76:                }
        !            77:        }
        !            78: }

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