UNIX 6th Ed. - /usr/source/s1/grep.c

   1: #
   2: /*
   3:  * grep -- print lines matching (or not matching) a pattern
   4:  *
   5:  */
   6: 
   7: #define CCHR    2
   8: #define CDOT    4
   9: #define CCL 6
  10: #define NCCL    8
  11: #define CDOL    10
  12: #define CEOF    11
  13: 
  14: #define STAR    01
  15: 
  16: #define LBSIZE  256
  17: #define ESIZE   256
  18: 
  19: char    ibuf[512];
  20: char    expbuf[ESIZE];
  21: int lnum[2];
  22: char    linebuf[LBSIZE+1];
  23: int bflag;
  24: int nflag;
  25: int cflag;
  26: int vflag;
  27: int nfile;
  28: int circf;
  29: int blkno;
  30: int tln[2];
  31: 
  32: main(argc, argv)
  33: char **argv;
  34: {
  35:     extern fout;
  36: 
  37:     fout = dup(1);
  38:     flush();
  39:     while (--argc > 0 && (++argv)[0][0]=='-')
  40:         switch (argv[0][1]) {
  41: 
  42:         case 'v':
  43:             vflag++;
  44:             continue;
  45: 
  46:         case 'b':
  47:             bflag++;
  48:             continue;
  49: 
  50:         case 'c':
  51:             cflag++;
  52:             continue;
  53: 
  54:         case 'n':
  55:             nflag++;
  56:             continue;
  57: 
  58:         default:
  59:             printf2("Unknown flag\n");
  60:             continue;
  61:         }
  62:     if (argc<=0)
  63:         exit(2);
  64:     compile(*argv);
  65:     nfile = --argc;
  66:     if (argc<=0)
  67:         execute(0);
  68:     else while (--argc >= 0) {
  69:         argv++;
  70:         execute(*argv);
  71:     }
  72:     flush();
  73:     exit(0);
  74: }
  75: 
  76: compile(astr)
  77: char *astr;
  78: {
  79:     register c;
  80:     register char *ep, *sp;
  81:     char *lastep;
  82:     int cclcnt;
  83: 
  84:     ep = expbuf;
  85:     sp = astr;
  86:     if (*sp == '^') {
  87:         circf++;
  88:         sp++;
  89:     }
  90:     for (;;) {
  91:         if (ep >= &expbuf[ESIZE])
  92:             goto cerror;
  93:         if ((c = *sp++) != '*')
  94:             lastep = ep;
  95:         switch (c) {
  96: 
  97:         case '\0':
  98:             *ep++ = CEOF;
  99:             return;
 100: 
 101:         case '.':
 102:             *ep++ = CDOT;
 103:             continue;
 104: 
 105:         case '*':
 106:             if (lastep==0)
 107:                 goto defchar;
 108:             *lastep =| STAR;
 109:             continue;
 110: 
 111:         case '$':
 112:             if (*sp != '\0')
 113:                 goto defchar;
 114:             *ep++ = CDOL;
 115:             continue;
 116: 
 117:         case '[':
 118:             *ep++ = CCL;
 119:             *ep++ = 0;
 120:             cclcnt = 1;
 121:             if ((c = *sp++) == '^') {
 122:                 c = *sp++;
 123:                 ep[-2] = NCCL;
 124:             }
 125:             do {
 126:                 *ep++ = c;
 127:                 cclcnt++;
 128:                 if (c=='\0' || ep >= &expbuf[ESIZE])
 129:                     goto cerror;
 130:             } while ((c = *sp++) != ']');
 131:             lastep[1] = cclcnt;
 132:             continue;
 133: 
 134:         case '\\':
 135:             if ((c = *sp++) == '\0')
 136:                 goto cerror;
 137:         defchar:
 138:         default:
 139:             *ep++ = CCHR;
 140:             *ep++ = c;
 141:         }
 142:     }
 143:     cerror:
 144:     printf2("RE error\n");
 145: }
 146: 
 147: execute(file)
 148: {
 149:     register char *p1, *p2;
 150:     register c;
 151:     int f;
 152:     char *ebp, *cbp;
 153: 
 154:     if (file) {
 155:         if ((f = open(file, 0)) < 0) {
 156:             printf2("Can't open %s\n", file);
 157:         }
 158:     } else
 159:         f = 0;
 160:     ebp = ibuf;
 161:     cbp = ibuf;
 162:     lnum[0] = 0;
 163:     lnum[1] = 0;
 164:     tln[0] = 0;
 165:     tln[1] = 0;
 166:     blkno = -1;
 167:     for (;;) {
 168:         if ((++lnum[1])==0)
 169:             lnum[1]++;
 170:         if((lnum[1]&0377) == 0)
 171:             flush();
 172:         p1 = linebuf;
 173:         p2 = cbp;
 174:         for (;;) {
 175:             if (p2 >= ebp) {
 176:                 if ((c = read(f, ibuf, 512)) <= 0) {
 177:                     close(f);
 178:                     if (cflag) {
 179:                         if (nfile > 1)
 180:                             printf("%s:", file);
 181:                         p1 = locv(tln[0],tln[1]);
 182:                         printf("%s\n", p1);
 183:                     }
 184:                     return;
 185:                 }
 186:                 blkno++;
 187:                 p2 = ibuf;
 188:                 ebp = ibuf+c;
 189:             }
 190:             if ((c = *p2++) == '\n')
 191:                 break;
 192:             if(c)
 193:             if (p1 < &linebuf[LBSIZE-1])
 194:                 *p1++ = c;
 195:         }
 196:         *p1++ = 0;
 197:         cbp = p2;
 198:         p1 = linebuf;
 199:         p2 = expbuf;
 200:         if (circf) {
 201:             if (advance(p1, p2))
 202:                 goto found;
 203:             goto nfound;
 204:         }
 205:         /* fast check for first character */
 206:         if (*p2==CCHR) {
 207:             c = p2[1];
 208:             do {
 209:                 if (*p1!=c)
 210:                     continue;
 211:                 if (advance(p1, p2))
 212:                     goto found;
 213:             } while (*p1++);
 214:             goto nfound;
 215:         }
 216:         /* regular algorithm */
 217:         do {
 218:             if (advance(p1, p2))
 219:                 goto found;
 220:         } while (*p1++);
 221:     nfound:
 222:         if (vflag)
 223:             succeed(file);
 224:         continue;
 225:     found:
 226:         if (vflag==0)
 227:             succeed(file);
 228:     }
 229: }
 230: 
 231: advance(alp, aep)
 232: {
 233:     register char *lp, *ep, *curlp;
 234:     char *nextep;
 235: 
 236:     lp = alp;
 237:     ep = aep;
 238:     for (;;) switch (*ep++) {
 239: 
 240:     case CCHR:
 241:         if (*ep++ == *lp++)
 242:             continue;
 243:         return(0);
 244: 
 245:     case CDOT:
 246:         if (*lp++)
 247:             continue;
 248:         return(0);
 249: 
 250:     case CDOL:
 251:         if (*lp==0)
 252:             continue;
 253:         return(0);
 254: 
 255:     case CEOF:
 256:         return(1);
 257: 
 258:     case CCL:
 259:         if (cclass(ep, *lp++, 1)) {
 260:             ep =+ *ep;
 261:             continue;
 262:         }
 263:         return(0);
 264: 
 265:     case NCCL:
 266:         if (cclass(ep, *lp++, 0)) {
 267:             ep =+ *ep;
 268:             continue;
 269:         }
 270:         return(0);
 271: 
 272:     case CDOT|STAR:
 273:         curlp = lp;
 274:         while (*lp++);
 275:         goto star;
 276: 
 277:     case CCHR|STAR:
 278:         curlp = lp;
 279:         while (*lp++ == *ep);
 280:         ep++;
 281:         goto star;
 282: 
 283:     case CCL|STAR:
 284:     case NCCL|STAR:
 285:         curlp = lp;
 286:         while (cclass(ep, *lp++, ep[-1]==(CCL|STAR)));
 287:         ep =+ *ep;
 288:         goto star;
 289: 
 290:     star:
 291:         do {
 292:             lp--;
 293:             if (advance(lp, ep))
 294:                 return(1);
 295:         } while (lp > curlp);
 296:         return(0);
 297: 
 298:     default:
 299:         printf2("RE botch\n");
 300:     }
 301: }
 302: 
 303: cclass(aset, ac, af)
 304: {
 305:     register char *set, c;
 306:     register n;
 307: 
 308:     set = aset;
 309:     if ((c = ac) == 0)
 310:         return(0);
 311:     n = *set++;
 312:     while (--n)
 313:         if (*set++ == c)
 314:             return(af);
 315:     return(!af);
 316: }
 317: 
 318: printf2(s, a)
 319: {
 320:     extern fout;
 321:     flush();
 322:     fout = 2;
 323:     printf(s, a);
 324:     flush();
 325:     exit(2);
 326: }
 327: 
 328: succeed(f)
 329: {
 330:     if (cflag) {
 331:         if (++tln[1]==0)
 332:             tln[0]++;
 333:         return;
 334:     }
 335:     if (nfile > 1)
 336:         printf("%s:", f);
 337:     if (bflag)
 338:         printf("%l:", blkno);
 339:     if (nflag)
 340:         printf("%s:", locv(lnum[0], lnum[1]));
 341:     printf("%s\n", linebuf);
 342: }

Defined functions

Defined variables

Defined macros