Return to sp.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/sp.c, revision 1.1.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.