Return to tail.c CVS log

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

Annotation of 3BSD/cmd/tail.c, revision 1.1.1.1

1.1       root        1: /* tail command 
                      2:  *
                      3:  *     tail where [file]
                      4:  *     where is +_n[type]
                      5:  *     - means n lines before end
                      6:  *     + means nth line from beginning
                      7:  *     type 'b' means tail n blocks, not lines
                      8:  *     type 'c' means tail n characters
                      9: */
                     10: #include       <sys/types.h>
                     11: #include       <sys/stat.h>
                     12: #include       <errno.h>
                     13: #include       <pagsiz.h>
                     14: #define        BUFSIZ  BSIZE
                     15: #define LBIN 4097
                     16: struct stat    statb;
                     17: char bin[LBIN];
                     18: int errno;
                     19: 
                     20: main(argc,argv)
                     21: char **argv;
                     22: {
                     23:        long n,di;
                     24:        int fromend;
                     25:        register i,j,k;
                     26:        char *p;
                     27:        int partial,piped,bylines;
                     28:        char *arg;
                     29:        lseek(0,(long)0,1);
                     30:        piped = errno==ESPIPE;
                     31:        arg = argv[1];
                     32:        if(argc<=1 || *arg!='-'&&*arg!='+') {
                     33:                arg = "-10l";
                     34:                argc++;
                     35:                argv--;
                     36:        }
                     37:        fromend = *arg=='-';
                     38:        arg++;
                     39:        if(!digit(*arg))
                     40:                goto errcom;
                     41:        n = 0;
                     42:        while(digit(*arg))
                     43:                n = n*10 + *arg++ - '0';
                     44:        if(!fromend&&n>0)
                     45:                n--;
                     46:        if(argc>2) {
                     47:                close(0);
                     48:                if(open(argv[2],0)!=0) {
                     49:                        write(2,"tail: can't open ",17);
                     50:                        write(2,argv[2],strlen(argv[2]));
                     51:                        write(2,"\n",1);
                     52:                        exit(1);
                     53:                }
                     54:        }
                     55:        bylines = 0;
                     56:        switch(*arg) {
                     57:        case 'b':
                     58:                n <<= 9;
                     59:                break;
                     60:        case 'c':
                     61:                break;
                     62:        case '\0':
                     63:        case 'l':
                     64:                bylines = 1;
                     65:                break;
                     66:        default:
                     67:                goto errcom;
                     68:        }
                     69:        if(fromend)
                     70:                goto keep;
                     71: 
                     72:                        /*seek from beginning */
                     73: 
                     74:        if(bylines) {
                     75:                j = 0;
                     76:                while(n-->0) {
                     77:                        do {
                     78:                                if(j--<=0) {
                     79:                                        p = bin;
                     80:                                        j = read(0,p,BUFSIZ);
                     81:                                        if(j--<=0) exit(0);
                     82:                                }
                     83:                        } while(*p++ != '\n');
                     84:                }
                     85:                write(1,p,j);
                     86:        } else  if(n>0) {
                     87:                if(!piped)
                     88:                        fstat(0,&statb);
                     89:                if(piped||(statb.st_mode&S_IFMT)==S_IFCHR)
                     90:                        while(n>0) {
                     91:                                i = n>BUFSIZ?BUFSIZ:n;
                     92:                                i = read(0,bin,i);
                     93:                                if(i<=0) exit(0);
                     94:                                n -= i;
                     95:                        }
                     96:                else
                     97:                        lseek(0,n,0);
                     98:        }
                     99:        while((i=read(0,bin,BUFSIZ))>0)
                    100:                write(1,bin,i);
                    101:        exit(0);
                    102: 
                    103:                        /*seek from end*/
                    104: 
                    105: keep:
                    106:        if(n<=0) exit(0);
                    107:        if(!piped) {
                    108:                fstat(0,&statb);
                    109:                di = !bylines&&n<LBIN?n:LBIN-1;
                    110:                if(statb.st_size > di)
                    111:                        lseek(0,-di,2);
                    112:        }
                    113:        partial = 1;
                    114:        for(;;) {
                    115:                i = 0;
                    116:                do {
                    117:                        j = read(0,&bin[i],LBIN-i);
                    118:                        if(j<=0)
                    119:                                goto brka;
                    120:                        i += j;
                    121:                } while(i<LBIN);
                    122:                partial = 0;
                    123:        }
                    124: brka:
                    125:        if(!bylines) {
                    126:                k =
                    127:                    n<=i ? i-n:
                    128:                    partial ? 0:
                    129:                    n>=LBIN ? i+1:
                    130:                    i-n+LBIN;
                    131:                k--;
                    132:        } else {
                    133:                k = i;
                    134:                j = 0;
                    135:                do {
                    136:                        do {
                    137:                                if(--k<0) {
                    138:                                        if(partial)
                    139:                                                goto brkb;
                    140:                                        k = LBIN -1;
                    141:                                }
                    142:                        } while(bin[k]!='\n'&&k!=i);
                    143:                } while(j++<n&&k!=i);
                    144: brkb:
                    145:                if(k==i) do {
                    146:                        if(++k>=LBIN)
                    147:                                k = 0;
                    148:                } while(bin[k]!='\n'&&k!=i);
                    149:        }
                    150:        if(k<i)
                    151:                write(1,&bin[k+1],i-k-1);
                    152:        else {
                    153:                write(1,&bin[k+1],LBIN-k-1);
                    154:                write(1,bin,i);
                    155:        }
                    156:        exit(0);
                    157: errcom:
                    158:        write(2,"usage: tail +_n[lbc] [file]\n",29);
                    159:        exit(1);
                    160: }
                    161: 
                    162: digit(c)
                    163: {
                    164:        return(c>='0'&&c<='9');
                    165: }

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