4.3BSD - /usr/src/new/tac/tac.c

   1: #ifndef lint
   2: static char sccsid[] = "@(#)tac.c	1.4 6/5/86";
   3: #endif
   4: 
   5: /*
   6:  * tac.c - Print file segments in reverse order
   7:  *
   8:  * Original line-only version by unknown author off the net.
   9:  * Rewritten in 1985 by Jay Lepreau, Univ of Utah, to allocate memory
  10:  * dynamically, handle string bounded segments (suggested by Rob Pike),
  11:  * and handle pipes.
  12:  */
  13: 
  14: #include <sys/types.h>
  15: #include <sys/stat.h>
  16: #include <stdio.h>
  17: #include <signal.h>
  18: 
  19: /*
  20:  * This should be defined for BSD releases later than 4.2 and for Sys V.2,
  21:  * at least.  fwrite is faster than putc only if you have a new speedy fwrite.
  22:  */
  23: #define FAST_FWRITE
  24: 
  25: #ifdef DEBUG                /* dbx can't handle registers */
  26: #include <ctype.h>
  27: # define register
  28: #endif
  29: 
  30: /* Default target string and bound */
  31: int right = 1;              /* right or left bounded segments? */
  32: char *targ = "\n";
  33: 
  34: char *tfile;
  35: char *buf;
  36: 
  37: int readsize = 4096;            /* significantly faster than 1024 */
  38: int bufsize;
  39: int targlen;
  40: int numerr;
  41: 
  42: int cleanup();
  43: extern off_t lseek();
  44: extern char *strcpy(), *malloc(), *realloc(), *mktemp();
  45: 
  46: main(argc, argv)
  47:     int argc;
  48:     char **argv;
  49: {
  50: 
  51: #ifdef DEBUG
  52:     if (argc > 1 && isdigit(*argv[1])) {
  53:     readsize = atoi(argv[1]);
  54:     argc--, argv++;
  55:     }
  56: #endif
  57: 
  58:     if (argc > 1 && (argv[1][0] == '+' || argv[1][0] == '-') && argv[1][1]) {
  59:     targ = &argv[1][1];
  60:     right = (argv[1][0] == '+');
  61:     argc--; argv++;
  62:     }
  63:     targlen = strlen(targ);
  64: 
  65:     bufsize = (readsize << 1) + targlen + 2;
  66:     if ((buf = malloc((unsigned) bufsize)) == NULL) {
  67:     perror("tac: initial malloc");
  68:     exit(1);
  69:     }
  70: 
  71:     (void) strcpy(buf, targ);       /* stop string at beginning */
  72:     buf += targlen;
  73: 
  74:     if (argc == 1)
  75:     tacstdin();
  76:     while (--argc) {
  77:     if (strcmp(*++argv, "-") == 0)
  78:         tacstdin();
  79:     else
  80:         tacit(*argv);
  81:     }
  82:     exit(numerr > 0 ? 1 : 0);
  83: }
  84: 
  85: tacstdin()
  86: {
  87: 
  88:     int (*sigint)(), (*sighup)(), (*sigterm)();
  89: 
  90:     if ((sigint = signal(SIGINT, SIG_IGN)) != SIG_IGN)
  91:     (void) signal(SIGINT, cleanup);
  92:     if ((sighup = signal(SIGHUP, SIG_IGN)) != SIG_IGN)
  93:     (void) signal(SIGHUP, cleanup);
  94:     if ((sigterm = signal(SIGTERM, SIG_IGN)) != SIG_IGN)
  95:     (void) signal(SIGTERM, cleanup);
  96: 
  97:     savestdin();
  98:     tacit(tfile);
  99:     (void) unlink(tfile);
 100: 
 101:     (void) signal(SIGINT, sigint);
 102:     (void) signal(SIGHUP, sighup);
 103:     (void) signal(SIGTERM, sigterm);
 104: }
 105: 
 106: char template[] = "/tmp/tacXXXXXX";
 107: char workplate[sizeof template];
 108: 
 109: savestdin()
 110: {
 111:     int fd;
 112:     register int n;
 113: 
 114:     (void) strcpy(workplate, template);
 115:     tfile = mktemp(workplate);
 116:     if ((fd = creat(tfile, 0600)) < 0) {
 117:     prterr(tfile);
 118:     cleanup();
 119:     }
 120:     while ((n = read(0, buf, readsize)) > 0)
 121:     if (write(fd, buf, n) != n) {
 122:         prterr(tfile);
 123:         cleanup();
 124:     }
 125:     (void) close(fd);
 126:     if (n < 0) {
 127:     prterr("stdin read");
 128:     cleanup();
 129:     }
 130: }
 131: 
 132: tacit(name)
 133:     char *name;
 134: {
 135:     register char *p, *pastend;
 136:     register int firstchar, targm1len;  /* target length minus 1 */
 137:     struct stat st;
 138:     off_t off;
 139:     int fd, i;
 140: 
 141:     firstchar = *targ;
 142:     targm1len = targlen - 1;
 143: 
 144:     if (stat(name, &st) < 0) {
 145:     prterr(name);
 146:     numerr++;
 147:     return;
 148:     }
 149:     if ((off = st.st_size) == 0)
 150:     return;
 151:     if ((fd = open(name, 0)) < 0) {
 152:     prterr(name);
 153:     numerr++;
 154:     return;
 155:     }
 156: 
 157:     /*
 158:      * Arrange for the first read to lop off enough to
 159:      * leave the rest of the file a multiple of readsize.
 160:      * Since readsize can change, this may not always hold during
 161:      * the pgm run, but since it usually will, leave it here
 162:      * for i/o efficiency (page/sector boundaries and all that).
 163:      * Note: the efficiency gain has not been verified.
 164:      */
 165:     if ((i = off % readsize) == 0)
 166:     i = readsize;
 167:     off -= i;
 168: 
 169:     (void) lseek(fd, off, 0);
 170:     if (read(fd, buf, i) != i) {
 171:     prterr(name);
 172:     (void) close(fd);
 173:     numerr++;
 174:     return;
 175:     }
 176:     p = pastend = buf + i;      /* pastend always points to end+1 */
 177:     p -= targm1len;
 178: 
 179:     for (;;) {
 180:     while ( *--p != firstchar ||
 181:       (targm1len && strncmp(p+1, targ+1, targm1len)) )
 182:         continue;
 183:     if (p < buf) {      /* backed off front of buffer */
 184:         if (off == 0) {
 185:         /* beginning of file: dump last segment */
 186:         output(p + targlen, pastend);
 187:         (void) close(fd);
 188:         break;
 189:         }
 190:         if ((i = pastend - buf) > readsize) {
 191:         char *tbuf;
 192:         int newbufsize = (readsize << 2) + targlen + 2;
 193: 
 194:         if ((tbuf = realloc(buf-targlen, (unsigned) newbufsize)) == NULL) {
 195:             /* If realloc fails, old buf contents may be lost. */
 196:             perror("tac: segment too long; may have garbage here");
 197:             numerr++;
 198:             i = readsize;
 199:         }
 200:         else {
 201:             tbuf += targlen;    /* skip over the stop string */
 202:             p += tbuf - buf;
 203:             pastend += tbuf - buf;
 204:             buf = tbuf;
 205:             bufsize = newbufsize;
 206:             readsize = readsize << 1;
 207:             /* guaranteed to fit now (I think!) */
 208:         }
 209:         }
 210:         if (off - readsize < 0) {
 211:         readsize = off;
 212:         off = 0;
 213:         }
 214:         else
 215:         off -= readsize;
 216:         (void) lseek(fd, off, 0);   /* back up */
 217:         /* Shift pending old data right to make room for new */
 218:         bcopy(buf, p = buf + readsize, i);
 219:         pastend = p + i;
 220:         if (read(fd, buf, readsize) != readsize) {
 221:         prterr(name);
 222:         numerr++;
 223:         (void) close(fd);
 224:         break;
 225:         }
 226:         continue;
 227:     }
 228:     /* Found a real instance of the target string */
 229:     output(right ? p + targlen : p, pastend);
 230:     pastend = p;
 231:     p -= targm1len;
 232:     }
 233: }
 234: 
 235: /*
 236:  * Dump chars from p to pastend-1.  If right-bounded by target
 237:  * and not the first time through, append the target string.
 238:  */
 239: output(p, pastend)
 240:     register char *p;
 241:     char *pastend;
 242: {
 243:     static short first = 1;
 244: 
 245: #ifdef FAST_FWRITE
 246:     (void) fwrite(p, 1, pastend - p, stdout);
 247: #else
 248:     while (p < pastend)
 249:     (void) putc(*p++, stdout);
 250: #endif
 251:     if (right && !first)
 252:     (void) fwrite(targ, 1, targlen, stdout);
 253:     first = 0;
 254:     if ferror(stdout) {
 255:     perror("tac: fwrite/putc");
 256:     exit(++numerr > 1 ? numerr : 1);
 257:     }
 258: }
 259: 
 260: prterr(s)
 261:     char *s;
 262: {
 263: 
 264:     fprintf(stderr, "tac: ");
 265:     perror(s);
 266: }
 267: 
 268: cleanup()
 269: {
 270: 
 271:     (void) unlink(tfile);
 272:     exit(1);
 273: }

Defined functions

Defined variables

Defined macros