![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to egrep.bundle CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / egrep|
Return to egrep.bundle CVS log | Up to [Research Unix] / researchv10dc / cmd / egrep |
1.1 ! root 1: # To unbundle, sh this file ! 2: echo mkfile 1>&2 ! 3: sed 's/.//' >mkfile <<'//GO.SYSIN DD mkfile' ! 4: -CFLAGS=-O ! 5: -YFLAGS=-d ! 6: -NPROC=2 ! 7: - ! 8: -egrep: gram.o main.o egrep.o bm.o anal.o ! 9: - $CC $CFLAGS -o $target $prereq ! 10: - ! 11: -install: egrep ! 12: - cp egrep /usr/bin/egrep ! 13: - strip /usr/bin/egrep ! 14: - chmod 775 /usr/bin/egrep ! 15: - chown bin,bin /usr/bin/egrep ! 16: - ! 17: -clean:V: ! 18: - rm -f *.o egrep ! 19: - ! 20: -y.tab.h: gram.o ! 21: -egrep.o anal.o: y.tab.h ! 22: -anal.o bm.o egrep.o main.o gram.o: hdr.h ! 23: - ! 24: -pp: ! 25: - smallpr mkfile hdr.h anal.c bm.c egrep.c gram.y main.c ! 26: - ! 27: -egrep.bundle:V: ! 28: - bundle mkfile *.h *.c *.y > $target ! 29: //GO.SYSIN DD mkfile ! 30: echo hdr.h 1>&2 ! 31: sed 's/.//' >hdr.h <<'//GO.SYSIN DD hdr.h' ! 32: -#include <fio.h> ! 33: -#include <ctype.h> ! 34: -#include <libc.h> ! 35: - ! 36: -#define BLKSIZE 1024 /* size of reported disk blocks */ ! 37: -#define MAXLIN 10000 ! 38: -#define MAXPOS 20000 ! 39: -#define NCHARS 256 ! 40: -#define NSTATES 128 ! 41: -#define FINAL -1 ! 42: -#define LEFT '\177' /* serves as ^ */ ! 43: -#define RIGHT '\n' /* serves as record separator and as $ */ ! 44: - ! 45: -typedef struct State ! 46: -{ ! 47: - struct State *gotofn[NCHARS]; ! 48: - int out; ! 49: -} State; ! 50: -extern State states[]; ! 51: -State *nxtst(); ! 52: -extern int state[]; ! 53: -extern int line; ! 54: -extern int name[]; ! 55: -extern int left[]; ! 56: -extern int right[]; ! 57: -extern int parent[]; ! 58: -extern int foll[]; ! 59: -extern int positions[]; ! 60: -extern char chars[]; ! 61: -extern int nxtpos; ! 62: -extern int nxtfoll; ! 63: -extern int inxtpos; ! 64: -extern int nxtfoll; ! 65: -extern int nxtchar; ! 66: -extern int tmpstat[]; ! 67: -extern State *istat; ! 68: -extern int nstate; ! 69: -extern int xstate; ! 70: -extern int count; ! 71: -extern char *input; ! 72: -extern char *progname; ! 73: - ! 74: -extern char reinit; ! 75: - ! 76: -extern int begout; ! 77: -extern int begcnt; ! 78: -extern int begstat[]; ! 79: - ! 80: -extern int colpos[]; ! 81: -extern int cntpos; ! 82: - ! 83: -extern long lnum; ! 84: -extern int bflag; ! 85: -extern int cflag; ! 86: -extern int fflag; ! 87: -extern int hflag; ! 88: -extern int iflag; ! 89: -extern int lflag; ! 90: -extern int nflag; ! 91: -extern int sflag; ! 92: -extern int vflag; ! 93: -extern int nfile; ! 94: -extern long tln; ! 95: -extern int nsucc; ! 96: -extern int badbotch; ! 97: - ! 98: -extern int expfile; ! 99: - ! 100: -extern int bmegrep; ! 101: -extern int scanexit; ! 102: //GO.SYSIN DD hdr.h ! 103: echo y.tab.h 1>&2 ! 104: sed 's/.//' >y.tab.h <<'//GO.SYSIN DD y.tab.h' ! 105: -# define CHAR 257 ! 106: -# define DOT 258 ! 107: -# define CCL 259 ! 108: -# define NCCL 260 ! 109: -# define OR 261 ! 110: -# define CAT 262 ! 111: -# define STAR 263 ! 112: -# define PLUS 264 ! 113: -# define QUEST 265 ! 114: //GO.SYSIN DD y.tab.h ! 115: echo anal.c 1>&2 ! 116: sed 's/.//' >anal.c <<'//GO.SYSIN DD anal.c' ! 117: -#include "hdr.h" ! 118: -#include "y.tab.h" ! 119: - ! 120: -#define NLIT 256 ! 121: -#define LSTART litp = litb ! 122: -#define LEND {*litp = 0; if(strlen(litb) > strlen(blit))strcpy(blit,litb);} ! 123: - ! 124: -static char *litp, litb[NLIT], *blit; ! 125: - ! 126: - ! 127: -/* ! 128: - islit has to return 1 if we are to use boyer-moore. ! 129: - in this case, set buf to the literal string and ! 130: - set bmegrep to 1 if there is a regular expression ! 131: - beside the literal (literal can be anywhere). ! 132: -*/ ! 133: -islit(buf) ! 134: - char *buf; ! 135: -{ ! 136: - bmegrep = 0; ! 137: - blit = buf; ! 138: - *blit = 0; ! 139: - LSTART; ! 140: - ! 141: -/* pr(line-2, ""); */ ! 142: - ! 143: - lit(line-2); ! 144: - LEND; ! 145: - if(strlen(blit) > 1){ ! 146: - /* bmegrep set by lit */ ! 147: - return(1); ! 148: - } ! 149: - return(0); ! 150: -} ! 151: - ! 152: -/* ! 153: - lit builds literal strings in litb. we ensure these are compulsory ! 154: - literal string by only descending the right nodes. ! 155: -*/ ! 156: -lit(n) ! 157: -{ ! 158: - if(name[n] == CAT){ ! 159: - lit(left[n]); ! 160: - lit(right[n]); ! 161: - } else if(name[n] == PLUS){ ! 162: - lit(left[n]); ! 163: - LEND; /* can't go on past a + */ ! 164: - LSTART; ! 165: - bmegrep = 1; ! 166: - lit(left[n]); /* but we can start with one! */ ! 167: - } else if((name[n] == CCL) && (chars[right[n]] == 1)){ ! 168: - *litp++ = chars[right[n]+1]; ! 169: - if(litp == &litb[NLIT]) ! 170: - litp--; ! 171: - } else if(left[n] == 0 && name[n] < 256 ! 172: - && name[n] != LEFT && name[n] != RIGHT){ ! 173: - *litp++ = name[n]; ! 174: - if(litp == &litb[NLIT]) ! 175: - litp--; ! 176: - } else { ! 177: - LEND; ! 178: - LSTART; ! 179: - bmegrep = 1; ! 180: - } ! 181: -} ! 182: - ! 183: -/*#ifdef DEBUG*/ ! 184: - ! 185: -pr(n, s) ! 186: - char *s; ! 187: -{ ! 188: - char buf[256]; ! 189: - int i, cnt; ! 190: - ! 191: - print("%s", s); ! 192: - sprint(buf, "%s ", s); ! 193: - switch(name[n]) ! 194: - { ! 195: - case FINAL: print("expr=\n"); pr(left[n], buf); break; ! 196: - case DOT: print("%d: .\n",n); break; ! 197: - case STAR: print("%d: *\n",n); pr(left[n], buf); break; ! 198: - case PLUS: print("%d: +\n",n); pr(left[n], buf); break; ! 199: - case QUEST: print("%d: ?\n",n); pr(left[n], buf); break; ! 200: - case CAT: print("%d: cat\n", n); pr(left[n], buf); pr(right[n], buf); break; ! 201: - case OR: print("%d: or\n", n); pr(left[n], buf); pr(right[n], buf); break; ! 202: - case NCCL: ! 203: - case CCL: print("%d: [%s", n, name[n]==NCCL? "^":""); ! 204: - for(i = right[n], cnt = chars[i++]; cnt > 0; cnt--) ! 205: - print("%c", chars[i++]); ! 206: - print("]\n"); ! 207: - break; ! 208: - default: ! 209: - if(name[n] < 256) ! 210: - print("%d: '%c'\n", n, name[n]); ! 211: - else ! 212: - print("URK %d\n", name[n]); ! 213: - break; ! 214: - } ! 215: -} ! 216: -/*#endif*/ ! 217: //GO.SYSIN DD anal.c ! 218: echo bm.c 1>&2 ! 219: sed 's/.//' >bm.c <<'//GO.SYSIN DD bm.c' ! 220: -#include "hdr.h" ! 221: - ! 222: -#define LARGE 100000 ! 223: - ! 224: -static int delta0[256]; ! 225: -static char cmap[256]; ! 226: -static char *bmpat; ! 227: - ! 228: -bmprep(pattern) ! 229: - char *pattern; ! 230: -{ ! 231: - register int j, patlen; ! 232: - ! 233: - patlen = strlen(bmpat = pattern); ! 234: - for(j = 0; j < 256; j++){ ! 235: - delta0[j] = patlen; ! 236: - cmap[j] = j; ! 237: - } ! 238: - for(j = 0; j < patlen-1; j++) ! 239: - delta0[pattern[j]] = patlen-j-1; ! 240: - delta0[pattern[patlen-1]] = LARGE; ! 241: - if(iflag){ ! 242: - for(j = 0; j < patlen-1; j++) ! 243: - if(islower(pattern[j])) ! 244: - delta0[toupper(pattern[j])] = patlen-j-1; ! 245: - if(islower(pattern[patlen-1])) ! 246: - delta0[toupper(pattern[patlen-1])] = LARGE; ! 247: - for(j = 'A'; j <= 'Z'; j++) ! 248: - cmap[j] = tolower(j); ! 249: - } ! 250: -} ! 251: - ! 252: -bmexecute(file) ! 253: -char *file; ! 254: -{ ! 255: - register char *p; ! 256: - register char *endpt; ! 257: - register char *s; ! 258: - register int j; ! 259: - int len, patlen = strlen(bmpat); ! 260: - char *rdpt; ! 261: - int fd, eof, n; ! 262: - long seek; ! 263: - char *nlp, *proc, *np, *op; ! 264: - char buf[8*8192]; ! 265: - ! 266: - if(file){ ! 267: - if((fd = open(file, 0)) < 0){ ! 268: - fprint(2, "%s: can't open %s\n", progname, file); ! 269: - badbotch=1; ! 270: - return; ! 271: - } ! 272: - } else ! 273: - fd = 0; ! 274: - lnum = 1; ! 275: - tln = 0; ! 276: - rdpt = buf; ! 277: - seek = 0; ! 278: - for(eof = 0; eof == 0;){ ! 279: - Fflush(1); ! 280: - if((n = read(fd, rdpt, &buf[sizeof buf]-rdpt)) <= 0){ ! 281: - if(rdpt == buf) ! 282: - break; /* eof, nothing left to process */ ! 283: - *rdpt = '\n'; /* terminate */ ! 284: - endpt = rdpt+1; ! 285: - eof = 1; ! 286: - } else { ! 287: - for(p = &rdpt[n]; p >= rdpt;) ! 288: - if(*--p == '\n') ! 289: - break; ! 290: - if(p < rdpt){ /* line bigger than buf!! */ ! 291: - rdpt = &buf[sizeof buf/2]; /* chop in half */ ! 292: - continue; /* reading */ ! 293: - } ! 294: - endpt = p+1; ! 295: - } ! 296: - /* ! 297: - invariants: ! 298: - no newline between buf and rdpt[-1] ! 299: - lnum = nlines before buf ! 300: - seek = char offset of buf[0] ! 301: - last char read is rdpt[n-1] ! 302: - first char after last \n is endpt ! 303: - ! 304: - following is exited to three places: ! 305: - succeed: match ! 306: - refresh: !match (readjust ptrs and loop) ! 307: - ! 308: - */ ! 309: - p = buf+patlen-1; ! 310: - proc = buf-1; ! 311: - scan: ! 312: - for(;;){ ! 313: - while((p += delta0[*(unsigned char *)p]) < endpt) ! 314: - ; ! 315: - if(p < (buf+LARGE)){ /* no match */ ! 316: - goto refresh; ! 317: - } ! 318: - p -= LARGE; ! 319: - for(j = patlen-2, s = p-1; j >= 0; j--) ! 320: - if(cmap[*s--] != bmpat[j]) ! 321: - break; ! 322: - if(j < 0) /* match!! */ ! 323: - goto succeed; ! 324: - fail: ! 325: - p++; ! 326: - } ! 327: - succeed: ! 328: - if(bmegrep || !cflag || !sflag){ /* lflag doesn't matter */ ! 329: - nlp = memchr(p, '\n', (endpt+1)-p); ! 330: - op = p; ! 331: - p -= patlen-1; ! 332: - while(*p != '\n') ! 333: - if(--p < buf) break; ! 334: - p++; ! 335: - if(bmegrep) ! 336: - if(legrep(p) == 0){ ! 337: - p = op; ! 338: - goto fail; ! 339: - } ! 340: - } ! 341: - nsucc = 1; ! 342: - if (cflag){ ! 343: - tln++; ! 344: - p = nlp+1; ! 345: - goto scan; ! 346: - } else if(sflag){ ! 347: - if(scanexit) exit(0); ! 348: - } else if(lflag){ ! 349: - Fprint(1, "%s\n", file); ! 350: - close(fd); ! 351: - return; ! 352: - } else { ! 353: - if (nfile > 1 && hflag) ! 354: - Fprint(1, "%s:", file); ! 355: - if (bflag) ! 356: - Fprint(1, "%ld:", (seek+(p-buf))/BLKSIZE); ! 357: - if (nflag){ ! 358: - while(np = memchr(proc+1, '\n', p-proc)){ ! 359: - lnum++; ! 360: - proc = np; ! 361: - } ! 362: - Fprint(1, "%ld:", lnum); ! 363: - } ! 364: - Fwrite(1, p, nlp-p+1); ! 365: - p = nlp+1; ! 366: - if(p < endpt) ! 367: - goto scan; ! 368: - } ! 369: - refresh: ! 370: - if(nflag){ /* count newlines that we haven't proc */ ! 371: - while(proc = memchr(proc+1, '\n', endpt-proc)) ! 372: - lnum++; ! 373: - } ! 374: - memcpy(buf, endpt, j = &rdpt[n]-endpt); ! 375: - rdpt = &buf[j]; ! 376: - seek += n; ! 377: - } ! 378: -done: close(fd); ! 379: - if (cflag) { ! 380: - if (nfile > 1) ! 381: - Fprint(1, "%s:", file); ! 382: - Fprint(1, "%ld\n", tln); ! 383: - } ! 384: -} ! 385: - ! 386: -/* ! 387: - isn't egrep pretty when it just has to mtach or not? ! 388: -*/ ! 389: - ! 390: -legrep(p) ! 391: - register char *p; ! 392: -{ ! 393: - register State *cstat, *t; ! 394: - ! 395: - if(reinit == 1) ! 396: - clearg(); ! 397: - cstat = istat; ! 398: - if(cstat->out) ! 399: - return(1); ! 400: - for(;;){ ! 401: - if((t = cstat->gotofn[*(unsigned char *)p]) == 0) ! 402: - cstat = nxtst(cstat, *(unsigned char *)p); ! 403: - else ! 404: - cstat = t; ! 405: - if(cstat->out){ ! 406: - return(1); ! 407: - } ! 408: - if(*p++ == RIGHT){ ! 409: - return(0); ! 410: - } ! 411: - } ! 412: -} ! 413: //GO.SYSIN DD bm.c ! 414: echo egrep.c 1>&2 ! 415: sed 's/.//' >egrep.c <<'//GO.SYSIN DD egrep.c' ! 416: -#include "hdr.h" ! 417: -#include "y.tab.h" ! 418: - ! 419: -cgotofn() { ! 420: - register i; ! 421: - count = cntpos = 0; ! 422: - nxtpos = 0; ! 423: - nxtfoll = MAXPOS-1; ! 424: - begout = 0; ! 425: - for (i=1; i<=line; i++) colpos[i] = 0; ! 426: - if (first(line-1)==0) { ! 427: - colpos[line] = 1; ! 428: - cntpos++; ! 429: - begout = 1; ! 430: - } ! 431: - for (i=1; i<=line; i++) tmpstat[i] = begstat[i] = colpos[i]; ! 432: - count = begcnt = cntpos-1; /* leave out position 1 */ ! 433: - tmpstat[1] = begstat[1] = 0; ! 434: - addstate(1); ! 435: - inxtpos = nxtpos; ! 436: - istat = nxtst(states+1,LEFT); ! 437: -} ! 438: - ! 439: -State * ! 440: -nxtst(ss,c) ! 441: -State *ss; ! 442: -char c; ! 443: -{ ! 444: - register i, num, k; ! 445: - int pos, curpos, number, newpos; ! 446: - int s = ss-states; ! 447: - num = positions[state[s]]; ! 448: - count = begcnt; ! 449: - for (i=3; i<=line; i++) tmpstat[i] = begstat[i]; ! 450: - pos = state[s] + 1; ! 451: - for (i=0; i<num; i++) { ! 452: - curpos = positions[pos]; ! 453: - if ((k = name[curpos]) >= 0) { ! 454: - if ( ! 455: - (k == c) ! 456: - | (k == DOT && c != LEFT && c != RIGHT) ! 457: - | (k == CCL && member(c, right[curpos], 1)) ! 458: - | (k == NCCL && member(c, right[curpos], 0) && c != LEFT && c != RIGHT) ! 459: - ) { ! 460: - if (foll[curpos] == 0) { ! 461: - cntpos = 0; ! 462: - for (k=1; k<=line; k++) colpos[k] = 0; ! 463: - follow(curpos); ! 464: - addfoll(curpos); ! 465: - } ! 466: - number = positions[foll[curpos]]; ! 467: - newpos = foll[curpos] - 1; ! 468: - for (k=0; k<number; k++) { ! 469: - if (tmpstat[positions[newpos]] != 1) { ! 470: - tmpstat[positions[newpos]] = 1; ! 471: - count++; ! 472: - } ! 473: - newpos--; ! 474: - } ! 475: - } ! 476: - } ! 477: - pos++; ! 478: - } ! 479: - if (notin(nstate)) { ! 480: - if (++nstate >= NSTATES) { ! 481: - nxtpos = inxtpos; ! 482: - reinit = 1; ! 483: - nstate = 1; ! 484: - addstate(1); ! 485: - return states+1; ! 486: - } ! 487: - addstate(nstate); ! 488: - return(states[s].gotofn[c] = states+nstate); ! 489: - } ! 490: - else { ! 491: - return(states[s].gotofn[c] = states+xstate); ! 492: - } ! 493: -} ! 494: - ! 495: -first(v) { ! 496: - register b; ! 497: - if (left[v] == 0) { ! 498: - if (colpos[v] != 1) { ! 499: - colpos[v] = 1; ! 500: - cntpos++; ! 501: - } ! 502: - return(1); ! 503: - } ! 504: - else if (right[v] == 0) { ! 505: - if (first(left[v]) == 0) return (0); ! 506: - else if (name[v] == PLUS) return (1); ! 507: - else return (0); ! 508: - } ! 509: - else if (name[v] == CAT) { ! 510: - if (first(left[v]) == 0 && first(right[v]) == 0) return (0); ! 511: - else return (1); ! 512: - } ! 513: - else { /* name[v] == OR */ ! 514: - b = first(right[v]); ! 515: - if (first(left[v]) == 0 || b == 0) return (0); ! 516: - else return (1); ! 517: - } ! 518: -} ! 519: - ! 520: -member(symb, set, torf) { ! 521: - register i, num, pos; ! 522: - num = chars[set]; ! 523: - pos = set + 1; ! 524: - for (i=0; i<num; i++) ! 525: - if (symb == chars[pos++]) return (torf); ! 526: - return (!torf); ! 527: -} ! 528: - ! 529: -notin(n) { ! 530: - register i, j, pos; ! 531: - for (i=1; i<=n; i++) { ! 532: - if (positions[state[i]] == count) { ! 533: - pos = state[i] + 1; ! 534: - for (j=0; j < count; j++) { ! 535: - if (tmpstat[positions[pos++]] != 1) goto nxt; } ! 536: - xstate = i; ! 537: - return (0); ! 538: - } ! 539: - nxt: ; ! 540: - } ! 541: - return (1); ! 542: -} ! 543: - ! 544: -addstate(n) { ! 545: - register i; ! 546: - if (nxtpos + count >= nxtfoll) { ! 547: - overflo(); } ! 548: - for (i=0; i<NCHARS; i++) ! 549: - states[n].gotofn[i] = 0; ! 550: - state[n] = nxtpos; ! 551: - positions[nxtpos++] = count; ! 552: - for (i=3; i <= line; i++) { ! 553: - if (tmpstat[i] == 1) { ! 554: - positions[nxtpos++] = i; ! 555: - } ! 556: - } ! 557: - if (tmpstat[line] == 1) ! 558: - states[n].out = 1; ! 559: - else ! 560: - states[n].out = 0; ! 561: -} ! 562: - ! 563: -addfoll(n) { ! 564: - register i; ! 565: - if (nxtfoll - cntpos <= nxtpos) { ! 566: - overflo(); } ! 567: - foll[n] = nxtfoll; ! 568: - positions[nxtfoll--] = cntpos; ! 569: - for (i=3; i <= line; i++) { ! 570: - if (colpos[i] == 1) { ! 571: - positions[nxtfoll--] = i; ! 572: - } ! 573: - } ! 574: -} ! 575: - ! 576: -follow(v) int v; { ! 577: - int p; ! 578: - if (v == line) return; ! 579: - p = parent[v]; ! 580: - switch(name[p]) { ! 581: - case STAR: ! 582: - case PLUS: first(v); ! 583: - follow(p); ! 584: - return; ! 585: - ! 586: - case OR: ! 587: - case QUEST: follow(p); ! 588: - return; ! 589: - ! 590: - case CAT: if (v == left[p]) { ! 591: - if (first(right[p]) == 0) { ! 592: - follow(p); ! 593: - return; ! 594: - } ! 595: - } ! 596: - else follow(p); ! 597: - return; ! 598: - case FINAL: if (colpos[line] != 1) { ! 599: - colpos[line] = 1; ! 600: - cntpos++; ! 601: - } ! 602: - return; ! 603: - } ! 604: -} ! 605: - ! 606: -clearg() { ! 607: - register i; ! 608: - reinit = 0; ! 609: - states[1].out = begout; ! 610: - for (i=0; i<NCHARS; i++) ! 611: - states[1].gotofn[i] = 0; ! 612: - nstate = 1; ! 613: - state[1] = 0; ! 614: - istat = nxtst(states+1,LEFT); ! 615: -} ! 616: - ! 617: -execute(file) ! 618: -char *file; ! 619: -{ ! 620: - register char *p; ! 621: - register State *cstat, *t; ! 622: - int len; ! 623: - char *nlp; ! 624: - int f; ! 625: - ! 626: -#define READLINE if((p = nlp = Frdline(f)) == 0)\ ! 627: - goto done;\ ! 628: - else /* Frdline nulls the \n, put it back */\ ! 629: - len = FIOLINELEN(f), nlp[len++] = RIGHT ! 630: - ! 631: - if (file) { ! 632: - if ((f = open(file, 0)) < 0) { ! 633: - fprint(2, "%s: can't open %s\n", progname, file); ! 634: - badbotch=1; ! 635: - return; ! 636: - } ! 637: - } ! 638: - else f = 0; ! 639: - Finit(f, (char *)0); ! 640: - Ftie(f, 1); /* link input f with stdout */ ! 641: - lnum = 1; ! 642: - tln = 0; ! 643: - READLINE; ! 644: - cstat = istat; ! 645: - if (cstat->out) goto found; ! 646: - for (;;) { ! 647: - if ((t = cstat->gotofn[*p]) == 0) ! 648: - cstat = nxtst(cstat, *p); ! 649: - else ! 650: - cstat = t; ! 651: - if (cstat->out) { ! 652: - found: ! 653: - if (vflag == 0) { ! 654: - succeed: nsucc = 1; ! 655: - if (cflag) tln++; ! 656: - else if (sflag){ ! 657: - if(scanexit) exit(0); ! 658: - } else if (lflag) { ! 659: - Fprint(1, "%s\n", file); ! 660: - close(f); ! 661: - return; ! 662: - } ! 663: - else { ! 664: - if (nfile > 1 && hflag) ! 665: - Fprint(1, "%s:", file); ! 666: - if (bflag) ! 667: - Fprint(1, "%ld:", (FIOSEEK(f)-len)/BLKSIZE); ! 668: - if (nflag) ! 669: - Fprint(1, "%ld:", lnum); ! 670: - Fwrite(1, nlp, len); ! 671: - } ! 672: - } ! 673: - lnum++; ! 674: - READLINE; ! 675: - if (reinit == 1) clearg(); ! 676: - if ((cstat = istat)->out) ! 677: - goto found; /* we are a match already */ ! 678: - else ! 679: - continue; /* normal pattern matching loop */ ! 680: - } ! 681: - if (*p++ == RIGHT) { ! 682: - if (vflag) goto succeed; ! 683: - else { ! 684: - lnum++; ! 685: - READLINE; ! 686: - if (reinit == 1) clearg(); ! 687: - if ((cstat = istat)->out) ! 688: - goto found; /* we are a match already */ ! 689: - } ! 690: - } ! 691: - } ! 692: -done: close(f); ! 693: - if (cflag) { ! 694: - if (nfile > 1) ! 695: - Fprint(1, "%s:", file); ! 696: - Fprint(1, "%ld\n", tln); ! 697: - } ! 698: -} ! 699: //GO.SYSIN DD egrep.c ! 700: echo main.c 1>&2 ! 701: sed 's/.//' >main.c <<'//GO.SYSIN DD main.c' ! 702: -#include "hdr.h" ! 703: - ! 704: -State states[NSTATES]; ! 705: -State *nxtst(); ! 706: -int state[NSTATES]; ! 707: -int line = 1; ! 708: -int name[MAXLIN]; ! 709: -int left[MAXLIN]; ! 710: -int right[MAXLIN]; ! 711: -int parent[MAXLIN]; ! 712: -int foll[MAXLIN]; ! 713: -int positions[MAXPOS]; ! 714: -char chars[MAXLIN]; ! 715: -int nxtpos = 0; ! 716: -int inxtpos; ! 717: -int nxtchar = 0; ! 718: -int tmpstat[MAXLIN]; ! 719: -int begstat[MAXLIN]; ! 720: -int colpos[MAXLIN]; ! 721: -State *istat; ! 722: -int nstate = 1; ! 723: -int xstate; ! 724: -int count; ! 725: -int icount; ! 726: -char *input; ! 727: -char *progname; ! 728: -int begout; ! 729: -int begcnt; ! 730: -int cntpos; ! 731: -int nxtfoll; ! 732: - ! 733: -char reinit = 0; ! 734: - ! 735: -long lnum; ! 736: -int bflag; ! 737: -int cflag; ! 738: -int fflag; ! 739: -int hflag = 1; ! 740: -int iflag; ! 741: -int lflag; ! 742: -int nflag; ! 743: -int sflag; ! 744: -int vflag; ! 745: -int nfile; ! 746: -long tln; ! 747: -int nsucc; ! 748: -int badbotch; ! 749: - ! 750: -int expfile; ! 751: -int bmegrep = 0; ! 752: -int scanexit = 0; ! 753: - ! 754: -extern char *optarg; ! 755: -extern int optind, getopt(); ! 756: - ! 757: -usage() ! 758: -{ ! 759: - fprint(2, "usage: %s [ -bchilnsv ] [ -e pattern ] [ -f file ] [ pattern ] [ file ] ...\n", progname); ! 760: - exit(2); ! 761: -} ! 762: - ! 763: -main(argc, argv) ! 764: -char **argv; ! 765: -{ ! 766: - register c; ! 767: - int errflg = 0; ! 768: - int (*fn)(), execute(), bmexecute(); ! 769: - int etext(); ! 770: - char *ffile; ! 771: - char buf[2048]; ! 772: - ! 773: - if(progname = strrchr(argv[0], '/')) ! 774: - progname++; ! 775: - else ! 776: - progname = argv[0]; ! 777: - ! 778: -#ifdef forfutureuse ! 779: - switch (progname[0]) { ! 780: - case 'f': fgrep++; break; ! 781: - case 'e': egrep++; break; ! 782: - case 'g': grep++; break; ! 783: - } ! 784: -#endif ! 785: - ! 786: - while(( c = getopt(argc, argv, "bchie:f:lnsv?")) != -1) ! 787: - switch(c) { ! 788: - ! 789: - case 'b': ! 790: - bflag++; ! 791: - continue; ! 792: - ! 793: - case 'c': ! 794: - cflag++; ! 795: - continue; ! 796: - ! 797: - case 'e': ! 798: - input = optarg; ! 799: - continue; ! 800: - ! 801: - case 'f': ! 802: - fflag++; ! 803: - ffile = optarg; ! 804: - continue; ! 805: - ! 806: - case 'h': ! 807: - hflag = 0; ! 808: - continue; ! 809: - ! 810: - case 'i': ! 811: - iflag++; ! 812: - continue; ! 813: - ! 814: - case 'l': ! 815: - lflag++; ! 816: - continue; ! 817: - ! 818: - case 'n': ! 819: - nflag++; ! 820: - continue; ! 821: - ! 822: - case 's': ! 823: - sflag++; ! 824: - continue; ! 825: - ! 826: - case 'v': ! 827: - vflag++; ! 828: - continue; ! 829: - ! 830: - case '?': ! 831: - errflg++; ! 832: - continue; ! 833: - } ! 834: - ! 835: - if (errflg) ! 836: - usage(); ! 837: - ! 838: - argc -= optind; ! 839: - argv += optind; ! 840: - if (fflag) { ! 841: - if ((expfile = open(ffile, 0)) < 0) { ! 842: - fprint(2, "%s: can't open %s\n", progname, ffile); ! 843: - exit(2); ! 844: - } ! 845: - } else if (input == 0) { ! 846: - if ((input = *argv++) == 0) ! 847: - usage(); ! 848: - argc--; ! 849: - } ! 850: - Finit(1, (char *)0); ! 851: - ! 852: -#ifdef MAILPREP ! 853: - mailprep(); ! 854: -#endif /* MAILPREP */ ! 855: - ! 856: - yyparse(); ! 857: - ! 858: -#ifdef MAILPREP ! 859: - maildone(); ! 860: -#endif /* MAILPREP */ ! 861: - ! 862: - if(!vflag && islit(buf)){ ! 863: - bmprep(buf); ! 864: - fn = bmexecute; ! 865: - } else ! 866: - fn = execute; ! 867: - ! 868: - cgotofn(); ! 869: - nfile = argc; ! 870: - if (argc<=0) { ! 871: - if (lflag) exit(1); ! 872: - scanexit = 1; ! 873: - (*fn)((char *)0); ! 874: - } ! 875: - else while (--argc >= 0) { ! 876: - if (reinit == 1) clearg(); ! 877: - scanexit = argc == 0; ! 878: - (*fn)(*argv++); ! 879: - } ! 880: - exit(badbotch ? 2 : nsucc==0); ! 881: -} ! 882: //GO.SYSIN DD main.c ! 883: echo y.tab.c 1>&2 ! 884: sed 's/.//' >y.tab.c <<'//GO.SYSIN DD y.tab.c' ! 885: -# define CHAR 257 ! 886: -# define DOT 258 ! 887: -# define CCL 259 ! 888: -# define NCCL 260 ! 889: -# define OR 261 ! 890: -# define CAT 262 ! 891: -# define STAR 263 ! 892: -# define PLUS 264 ! 893: -# define QUEST 265 ! 894: - ! 895: -# line 16 "gram.y" ! 896: -#include "hdr.h" ! 897: -#define yyclearin yychar = -1 ! 898: -#define yyerrok yyerrflag = 0 ! 899: -extern int yychar; ! 900: -extern short yyerrflag; ! 901: -#ifndef YYMAXDEPTH ! 902: -#define YYMAXDEPTH 150 ! 903: -#endif ! 904: -#ifndef YYSTYPE ! 905: -#define YYSTYPE int ! 906: -#endif ! 907: -YYSTYPE yylval, yyval; ! 908: -# define YYERRCODE 256 ! 909: - ! 910: -# line 63 "gram.y" ! 911: - ! 912: -yyerror(s) { ! 913: - fprint(2, "egrep: %s\n", s); ! 914: - exit(2); ! 915: -} ! 916: - ! 917: -yylex() { ! 918: - extern int yylval; ! 919: - int cclcnt, x; ! 920: - register char c, d; ! 921: - switch(c = nextch()) { ! 922: - case '^': c = LEFT; ! 923: - goto defchar; ! 924: - case '$': c = RIGHT; ! 925: - goto defchar; ! 926: - case '|': return (OR); ! 927: - case '*': return (STAR); ! 928: - case '+': return (PLUS); ! 929: - case '?': return (QUEST); ! 930: - case '(': return (c); ! 931: - case ')': return (c); ! 932: - case '.': return (DOT); ! 933: - case '\0': return (0); ! 934: - case RIGHT: return (OR); ! 935: - case '[': ! 936: - x = CCL; ! 937: - cclcnt = 0; ! 938: - count = nxtchar++; ! 939: - if ((c = nextch()) == '^') { ! 940: - x = NCCL; ! 941: - c = nextch(); ! 942: - } ! 943: - do { ! 944: - if (c == '\0') synerror(); ! 945: - if (c == '-' && cclcnt > 0 && chars[nxtchar-1] != 0) { ! 946: - if ((d = nextch()) != 0) { ! 947: - c = chars[nxtchar-1]; ! 948: - while (c < d) { ! 949: - if (iflag && isalpha(c)) { ! 950: - if (nxtchar >= MAXLIN-1) overflo(); ! 951: - chars[nxtchar++] = isupper(++c)?tolower(c):toupper(c); ! 952: - chars[nxtchar++] = c; ! 953: - cclcnt += 2; ! 954: - } ! 955: - else { ! 956: - if (nxtchar >= MAXLIN) overflo(); ! 957: - chars[nxtchar++] = ++c; ! 958: - cclcnt++; ! 959: - } ! 960: - } ! 961: - continue; ! 962: - } ! 963: - } ! 964: - if (iflag&&isalpha(c)) { ! 965: - if (nxtchar >= MAXLIN-1) overflo(); ! 966: - chars[nxtchar++] = isupper(c)?tolower(c):toupper(c); ! 967: - chars[nxtchar++] = c; ! 968: - cclcnt += 2; ! 969: - } ! 970: - else { ! 971: - if (nxtchar >= MAXLIN) overflo(); ! 972: - chars[nxtchar++] = c; ! 973: - cclcnt++; ! 974: - } ! 975: - } while ((c = nextch()) != ']'); ! 976: - chars[count] = cclcnt; ! 977: - return (x); ! 978: - case '\\': ! 979: - if ((c = nextch()) == '\0') synerror(); ! 980: - else if (c == '\n') c = nextch(); ! 981: - defchar: ! 982: - default: yylval = c; return (CHAR); ! 983: - } ! 984: -} ! 985: - ! 986: -static int mailfd = -1; ! 987: - ! 988: -nextch() { ! 989: - register c; ! 990: - if (fflag) { ! 991: - if ((c = Fgetc(expfile)) < 0) ! 992: - c = 0; ! 993: - } ! 994: - else c = *input++; ! 995: -if(mailfd >= 0) Fputc(mailfd, c? c : '\n'); ! 996: - return(c); ! 997: -} ! 998: - ! 999: -synerror() { ! 1000: - fprint(2, "egrep: syntax error\n"); ! 1001: - exit(2); ! 1002: -} ! 1003: - ! 1004: -enter(x) int x; { ! 1005: - if(line >= MAXLIN) overflo(); ! 1006: - name[line] = x; ! 1007: - left[line] = 0; ! 1008: - right[line] = 0; ! 1009: - return(line++); ! 1010: -} ! 1011: - ! 1012: -cclenter(x) int x; { ! 1013: - register linno; ! 1014: - linno = enter(x); ! 1015: - right[linno] = count; ! 1016: - return (linno); ! 1017: -} ! 1018: - ! 1019: -node(x, l, r) { ! 1020: - if(line >= MAXLIN) overflo(); ! 1021: - name[line] = x; ! 1022: - left[line] = l; ! 1023: - right[line] = r; ! 1024: - parent[l] = line; ! 1025: - parent[r] = line; ! 1026: - return(line++); ! 1027: -} ! 1028: - ! 1029: -unary(x, d) { ! 1030: - if(line >= MAXLIN) overflo(); ! 1031: - name[line] = x; ! 1032: - left[line] = d; ! 1033: - right[line] = 0; ! 1034: - parent[d] = line; ! 1035: - return(line++); ! 1036: -} ! 1037: -overflo() { ! 1038: - fprint(2, "egrep: regular expression too long\n"); ! 1039: - exit(2); ! 1040: -} ! 1041: -#include <errno.h> ! 1042: -#define NAME "/tmp/grepdata" ! 1043: -mailprep() ! 1044: -{ ! 1045: - umask(0); ! 1046: - mailfd = open(NAME, 1); ! 1047: - if((mailfd < 0) && (errno != ECONC)) ! 1048: - mailfd = creat(NAME, 03666); ! 1049: - if(mailfd >= 0){ ! 1050: - Finit(mailfd, (char *)0); ! 1051: - Fseek(mailfd, 0L, 2); ! 1052: - Fprint(mailfd, "\321egrep: "); ! 1053: - } ! 1054: -} ! 1055: - ! 1056: -maildone() ! 1057: -{ ! 1058: - if(mailfd >= 0){ ! 1059: - Fflush(mailfd); ! 1060: - close(mailfd); ! 1061: - } ! 1062: -} ! 1063: -short yyexca[] ={ ! 1064: --1, 1, ! 1065: - 0, -1, ! 1066: - -2, 0, ! 1067: --1, 5, ! 1068: - 0, 2, ! 1069: - -2, 0, ! 1070: --1, 13, ! 1071: - 0, 5, ! 1072: - -2, 0, ! 1073: --1, 14, ! 1074: - 0, 12, ! 1075: - 257, 12, ! 1076: - 258, 12, ! 1077: - 259, 12, ! 1078: - 260, 12, ! 1079: - 261, 12, ! 1080: - 40, 12, ! 1081: - 41, 12, ! 1082: - -2, 0, ! 1083: --1, 19, ! 1084: - 0, 4, ! 1085: - -2, 0, ! 1086: --1, 20, ! 1087: - 0, 11, ! 1088: - 261, 11, ! 1089: - 41, 11, ! 1090: - -2, 0, ! 1091: --1, 23, ! 1092: - 0, 3, ! 1093: - -2, 0, ! 1094: - }; ! 1095: -# define YYNPROD 18 ! 1096: -# define YYLAST 261 ! 1097: -short yyact[]={ ! 1098: - ! 1099: - 10, 22, 4, 14, 11, 2, 1, 5, 0, 0, ! 1100: - 10, 15, 16, 17, 18, 0, 19, 20, 3, 0, ! 1101: - 10, 0, 0, 12, 0, 20, 0, 20, 0, 0, ! 1102: - 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1103: - 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1104: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1105: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1106: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1107: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1108: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1109: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1110: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1111: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1112: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1113: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1114: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1115: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1116: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1117: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1118: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1119: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1120: - 0, 0, 0, 0, 0, 0, 11, 6, 7, 8, ! 1121: - 9, 21, 0, 15, 16, 17, 11, 6, 7, 8, ! 1122: - 9, 23, 0, 15, 16, 17, 11, 6, 7, 8, ! 1123: - 9, 13, 0, 15, 16, 17, 11, 6, 7, 8, ! 1124: - 9, 0, 0, 15, 16, 17, 11, 6, 7, 8, ! 1125: - 9 }; ! 1126: -short yypact[]={ ! 1127: - ! 1128: --259,-1000,-1000, 0,-1000, -20,-1000,-1000,-1000,-1000, ! 1129: - 0,-1000, 0, 0,-252,-1000,-1000,-1000, -40, -30, ! 1130: - -10, 0,-1000, 0 }; ! 1131: -short yypgo[]={ ! 1132: - ! 1133: - 0, 6, 5, 18, 3 }; ! 1134: -short yyr1[]={ ! 1135: - ! 1136: - 0, 1, 2, 2, 2, 2, 3, 4, 4, 4, ! 1137: - 4, 4, 4, 4, 4, 4, 4, 4 }; ! 1138: -short yyr2[]={ ! 1139: - ! 1140: - 0, 1, 2, 4, 3, 3, 0, 1, 1, 1, ! 1141: - 1, 3, 2, 2, 2, 2, 3, 1 }; ! 1142: -short yychk[]={ ! 1143: - ! 1144: --1000, -1, -2, -3, 261, -4, 257, 258, 259, 260, ! 1145: - 40, 256, -3, 261, -4, 263, 264, 265, -4, -4, ! 1146: - -4, 261, 41, 261 }; ! 1147: -short yydef[]={ ! 1148: - ! 1149: - 6, -2, 1, 0, 6, -2, 7, 8, 9, 10, ! 1150: - 0, 17, 0, -2, -2, 13, 14, 15, 0, -2, ! 1151: - -2, 0, 16, -2 }; ! 1152: -# ifdef YYDEBUG ! 1153: -# include "y.debug" ! 1154: -# endif ! 1155: - ! 1156: -# define YYFLAG -1000 ! 1157: -# define YYERROR goto yyerrlab ! 1158: -# define YYACCEPT return(0) ! 1159: -# define YYABORT return(1) ! 1160: - ! 1161: -/* parser for yacc output */ ! 1162: - ! 1163: -#ifdef YYDEBUG ! 1164: -int yydebug = 0; /* 1 for debugging */ ! 1165: -#endif ! 1166: -YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */ ! 1167: -int yychar = -1; /* current input token number */ ! 1168: -int yynerrs = 0; /* number of errors */ ! 1169: -short yyerrflag = 0; /* error recovery flag */ ! 1170: - ! 1171: -yyparse() ! 1172: -{ short yys[YYMAXDEPTH]; ! 1173: - int yyj, yym; ! 1174: - register YYSTYPE *yypvt; ! 1175: - register int yystate, yyn; ! 1176: - register short *yyps; ! 1177: - register YYSTYPE *yypv; ! 1178: - register short *yyxi; ! 1179: - ! 1180: - yystate = 0; ! 1181: - yychar = -1; ! 1182: - yynerrs = 0; ! 1183: - yyerrflag = 0; ! 1184: - yyps= &yys[-1]; ! 1185: - yypv= &yyv[-1]; ! 1186: - ! 1187: -yystack: /* put a state and value onto the stack */ ! 1188: -#ifdef YYDEBUG ! 1189: - if(yydebug >= 3) ! 1190: - if(yychar < 0 || yytoknames[yychar] == 0) ! 1191: - printf("char %d in %s", yychar, yystates[yystate]); ! 1192: - else ! 1193: - printf("%s in %s", yytoknames[yychar], yystates[yystate]); ! 1194: -#endif ! 1195: - if( ++yyps >= &yys[YYMAXDEPTH] ) { ! 1196: - yyerror( "yacc stack overflow" ); ! 1197: - return(1); ! 1198: - } ! 1199: - *yyps = yystate; ! 1200: - ++yypv; ! 1201: - *yypv = yyval; ! 1202: -yynewstate: ! 1203: - yyn = yypact[yystate]; ! 1204: - if(yyn <= YYFLAG) goto yydefault; /* simple state */ ! 1205: - if(yychar<0) { ! 1206: - yychar = yylex(); ! 1207: -#ifdef YYDEBUG ! 1208: - if(yydebug >= 2) { ! 1209: - if(yychar <= 0) ! 1210: - printf("lex EOF\n"); ! 1211: - else if(yytoknames[yychar]) ! 1212: - printf("lex %s\n", yytoknames[yychar]); ! 1213: - else ! 1214: - printf("lex (%c)\n", yychar); ! 1215: - } ! 1216: -#endif ! 1217: - if(yychar < 0) ! 1218: - yychar = 0; ! 1219: - } ! 1220: - if((yyn += yychar) < 0 || yyn >= YYLAST) ! 1221: - goto yydefault; ! 1222: - if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */ ! 1223: - yychar = -1; ! 1224: - yyval = yylval; ! 1225: - yystate = yyn; ! 1226: - if( yyerrflag > 0 ) --yyerrflag; ! 1227: - goto yystack; ! 1228: - } ! 1229: -yydefault: ! 1230: - /* default state action */ ! 1231: - if( (yyn=yydef[yystate]) == -2 ) { ! 1232: - if(yychar < 0) { ! 1233: - yychar = yylex(); ! 1234: -#ifdef YYDEBUG ! 1235: - if(yydebug >= 2) ! 1236: - if(yychar < 0) ! 1237: - printf("lex EOF\n"); ! 1238: - else ! 1239: - printf("lex %s\n", yytoknames[yychar]); ! 1240: -#endif ! 1241: - if(yychar < 0) ! 1242: - yychar = 0; ! 1243: - } ! 1244: - /* look through exception table */ ! 1245: - for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate); ! 1246: - yyxi += 2 ) ; /* VOID */ ! 1247: - while( *(yyxi+=2) >= 0 ){ ! 1248: - if( *yyxi == yychar ) break; ! 1249: - } ! 1250: - if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */ ! 1251: - } ! 1252: - if( yyn == 0 ){ /* error */ ! 1253: - /* error ... attempt to resume parsing */ ! 1254: - switch( yyerrflag ){ ! 1255: - case 0: /* brand new error */ ! 1256: -#ifdef YYDEBUG ! 1257: - yyerror("syntax error\n%s", yystates[yystate]); ! 1258: - if(yytoknames[yychar]) ! 1259: - yyerror("saw %s\n", yytoknames[yychar]); ! 1260: - else if(yychar >= ' ' && yychar < '\177') ! 1261: - yyerror("saw `%c'\n", yychar); ! 1262: - else if(yychar == 0) ! 1263: - yyerror("saw EOF\n"); ! 1264: - else ! 1265: - yyerror("saw char 0%o\n", yychar); ! 1266: -#else ! 1267: - yyerror( "syntax error" ); ! 1268: -#endif ! 1269: -yyerrlab: ! 1270: - ++yynerrs; ! 1271: - case 1: ! 1272: - case 2: /* incompletely recovered error ... try again */ ! 1273: - yyerrflag = 3; ! 1274: - /* find a state where "error" is a legal shift action */ ! 1275: - while ( yyps >= yys ) { ! 1276: - yyn = yypact[*yyps] + YYERRCODE; ! 1277: - if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){ ! 1278: - yystate = yyact[yyn]; /* simulate a shift of "error" */ ! 1279: - goto yystack; ! 1280: - } ! 1281: - yyn = yypact[*yyps]; ! 1282: - /* the current yyps has no shift onn "error", pop stack */ ! 1283: -#ifdef YYDEBUG ! 1284: - if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] ); ! 1285: -#endif ! 1286: - --yyps; ! 1287: - --yypv; ! 1288: - } ! 1289: - /* there is no state on the stack with an error shift ... abort */ ! 1290: -yyabort: ! 1291: - return(1); ! 1292: - case 3: /* no shift yet; clobber input char */ ! 1293: -#ifdef YYDEBUG ! 1294: - if( yydebug ) { ! 1295: - printf("error recovery discards "); ! 1296: - if(yytoknames[yychar]) ! 1297: - printf("%s\n", yytoknames[yychar]); ! 1298: - else if(yychar >= ' ' && yychar < '\177') ! 1299: - printf("`%c'\n", yychar); ! 1300: - else if(yychar == 0) ! 1301: - printf("EOF\n"); ! 1302: - else ! 1303: - printf("char 0%o\n", yychar); ! 1304: - } ! 1305: -#endif ! 1306: - if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */ ! 1307: - yychar = -1; ! 1308: - goto yynewstate; /* try again in the same state */ ! 1309: - } ! 1310: - } ! 1311: - /* reduction by production yyn */ ! 1312: -#ifdef YYDEBUG ! 1313: - if(yydebug) { char *s; ! 1314: - printf("reduce %d in:\n\t", yyn); ! 1315: - for(s = yystates[yystate]; *s; s++) { ! 1316: - putchar(*s); ! 1317: - if(*s == '\n' && *(s+1)) ! 1318: - putchar('\t'); ! 1319: - } ! 1320: - } ! 1321: -#endif ! 1322: - yyps -= yyr2[yyn]; ! 1323: - yypvt = yypv; ! 1324: - yypv -= yyr2[yyn]; ! 1325: - yyval = yypv[1]; ! 1326: - yym=yyn; ! 1327: - /* consult goto table to find next state */ ! 1328: - yyn = yyr1[yyn]; ! 1329: - yyj = yypgo[yyn] + *yyps + 1; ! 1330: - if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]]; ! 1331: - switch(yym){ ! 1332: - ! 1333: -case 1: ! 1334: -# line 21 "gram.y" ! 1335: -{ unary(FINAL, yypvt[-0]); ! 1336: - line--; ! 1337: - } break; ! 1338: -case 2: ! 1339: -# line 26 "gram.y" ! 1340: -{ yyval = node(CAT, yypvt[-1], yypvt[-0]); } break; ! 1341: -case 3: ! 1342: -# line 28 "gram.y" ! 1343: -{ yyval = node(CAT, yypvt[-2], yypvt[-1]); } break; ! 1344: -case 4: ! 1345: -# line 30 "gram.y" ! 1346: -{ yyval = node(CAT, yypvt[-1], yypvt[-0]); } break; ! 1347: -case 5: ! 1348: -# line 32 "gram.y" ! 1349: -{ yyval = node(CAT, yypvt[-2], yypvt[-1]); } break; ! 1350: -case 6: ! 1351: -# line 35 "gram.y" ! 1352: -{ yyval = enter(DOT); ! 1353: - yyval = unary(STAR, yyval); } break; ! 1354: -case 7: ! 1355: -# line 39 "gram.y" ! 1356: -{ yyval = iflag?node(OR, enter(tolower(yypvt[-0])), enter(toupper(yypvt[-0]))):enter(yypvt[-0]); } break; ! 1357: -case 8: ! 1358: -# line 41 "gram.y" ! 1359: -{ yyval = enter(DOT); } break; ! 1360: -case 9: ! 1361: -# line 43 "gram.y" ! 1362: -{ yyval = cclenter(CCL); } break; ! 1363: -case 10: ! 1364: -# line 45 "gram.y" ! 1365: -{ yyval = cclenter(NCCL); } break; ! 1366: -case 11: ! 1367: -# line 49 "gram.y" ! 1368: -{ yyval = node(OR, yypvt[-2], yypvt[-0]); } break; ! 1369: -case 12: ! 1370: -# line 51 "gram.y" ! 1371: -{ yyval = node(CAT, yypvt[-1], yypvt[-0]); } break; ! 1372: -case 13: ! 1373: -# line 53 "gram.y" ! 1374: -{ yyval = unary(STAR, yypvt[-1]); } break; ! 1375: -case 14: ! 1376: -# line 55 "gram.y" ! 1377: -{ yyval = unary(PLUS, yypvt[-1]); } break; ! 1378: -case 15: ! 1379: -# line 57 "gram.y" ! 1380: -{ yyval = unary(QUEST, yypvt[-1]); } break; ! 1381: -case 16: ! 1382: -# line 59 "gram.y" ! 1383: -{ yyval = yypvt[-1]; } break; ! 1384: - } ! 1385: - goto yystack; /* stack new state and value */ ! 1386: -} ! 1387: //GO.SYSIN DD y.tab.c ! 1388: echo gram.y 1>&2 ! 1389: sed 's/.//' >gram.y <<'//GO.SYSIN DD gram.y' ! 1390: -/* ! 1391: - * egrep -- print lines containing (or not containing) a regular expression ! 1392: - * ! 1393: - * status returns: ! 1394: - * 0 - ok, and some matches ! 1395: - * 1 - ok, but no matches ! 1396: - * 2 - some error; matches irrelevant ! 1397: - */ ! 1398: -%token CHAR DOT CCL NCCL OR CAT STAR PLUS QUEST ! 1399: -%left OR ! 1400: -%left CHAR DOT CCL NCCL '(' ! 1401: -%left CAT ! 1402: -%left STAR PLUS QUEST ! 1403: - ! 1404: -%{ ! 1405: -#include "hdr.h" ! 1406: -%} ! 1407: - ! 1408: -%% ! 1409: -s: t ! 1410: - { unary(FINAL, $1); ! 1411: - line--; ! 1412: - } ! 1413: - ; ! 1414: -t: b r ! 1415: - { $$ = node(CAT, $1, $2); } ! 1416: - | OR b r OR ! 1417: - { $$ = node(CAT, $2, $3); } ! 1418: - | OR b r ! 1419: - { $$ = node(CAT, $2, $3); } ! 1420: - | b r OR ! 1421: - { $$ = node(CAT, $1, $2); } ! 1422: - ; ! 1423: -b: ! 1424: - { $$ = enter(DOT); ! 1425: - $$ = unary(STAR, $$); } ! 1426: - ; ! 1427: -r: CHAR ! 1428: - { $$ = iflag?node(OR, enter(tolower($1)), enter(toupper($1))):enter($1); } ! 1429: - | DOT ! 1430: - { $$ = enter(DOT); } ! 1431: - | CCL ! 1432: - { $$ = cclenter(CCL); } ! 1433: - | NCCL ! 1434: - { $$ = cclenter(NCCL); } ! 1435: - ; ! 1436: - ! 1437: -r: r OR r ! 1438: - { $$ = node(OR, $1, $3); } ! 1439: - | r r %prec CAT ! 1440: - { $$ = node(CAT, $1, $2); } ! 1441: - | r STAR ! 1442: - { $$ = unary(STAR, $1); } ! 1443: - | r PLUS ! 1444: - { $$ = unary(PLUS, $1); } ! 1445: - | r QUEST ! 1446: - { $$ = unary(QUEST, $1); } ! 1447: - | '(' r ')' ! 1448: - { $$ = $2; } ! 1449: - | error ! 1450: - ; ! 1451: - ! 1452: -%% ! 1453: -yyerror(s) { ! 1454: - fprint(2, "%s: %s\n", progname, s); ! 1455: - exit(2); ! 1456: -} ! 1457: - ! 1458: -yylex() { ! 1459: - extern int yylval; ! 1460: - int cclcnt, x; ! 1461: - register char c, d; ! 1462: - switch(c = nextch()) { ! 1463: - case '^': c = LEFT; ! 1464: - goto defchar; ! 1465: - case '$': c = RIGHT; ! 1466: - goto defchar; ! 1467: - case '|': return (OR); ! 1468: - case '*': return (STAR); ! 1469: - case '+': return (PLUS); ! 1470: - case '?': return (QUEST); ! 1471: - case '(': return (c); ! 1472: - case ')': return (c); ! 1473: - case '.': return (DOT); ! 1474: - case '\0': return (0); ! 1475: - case RIGHT: return (OR); ! 1476: - case '[': ! 1477: - x = CCL; ! 1478: - cclcnt = 0; ! 1479: - count = nxtchar++; ! 1480: - if ((c = nextch()) == '^') { ! 1481: - x = NCCL; ! 1482: - c = nextch(); ! 1483: - } ! 1484: - do { ! 1485: - if (c == '\0') synerror(); ! 1486: - if (c == '-' && cclcnt > 0 && chars[nxtchar-1] != 0) { ! 1487: - if ((d = nextch()) != 0) { ! 1488: - c = chars[nxtchar-1]; ! 1489: - while (c < d) { ! 1490: - if (iflag && isalpha(c)) { ! 1491: - if (nxtchar >= MAXLIN-1) overflo(); ! 1492: - chars[nxtchar++] = isupper(++c)?tolower(c):toupper(c); ! 1493: - chars[nxtchar++] = c; ! 1494: - cclcnt += 2; ! 1495: - } ! 1496: - else { ! 1497: - if (nxtchar >= MAXLIN) overflo(); ! 1498: - chars[nxtchar++] = ++c; ! 1499: - cclcnt++; ! 1500: - } ! 1501: - } ! 1502: - continue; ! 1503: - } ! 1504: - } ! 1505: - if (iflag&&isalpha(c)) { ! 1506: - if (nxtchar >= MAXLIN-1) overflo(); ! 1507: - chars[nxtchar++] = isupper(c)?tolower(c):toupper(c); ! 1508: - chars[nxtchar++] = c; ! 1509: - cclcnt += 2; ! 1510: - } ! 1511: - else { ! 1512: - if (nxtchar >= MAXLIN) overflo(); ! 1513: - chars[nxtchar++] = c; ! 1514: - cclcnt++; ! 1515: - } ! 1516: - } while ((c = nextch()) != ']'); ! 1517: - chars[count] = cclcnt; ! 1518: - return (x); ! 1519: - case '\\': ! 1520: - if ((c = nextch()) == '\0') synerror(); ! 1521: - else if (c == '\n') c = nextch(); ! 1522: - defchar: ! 1523: - default: yylval = c; return (CHAR); ! 1524: - } ! 1525: -} ! 1526: - ! 1527: -#ifdef MAILPREP ! 1528: -static int mailfd = -1; ! 1529: -#endif /* MAILPREP */ ! 1530: - ! 1531: -nextch() { ! 1532: - register c; ! 1533: - if (fflag) { ! 1534: - if ((c = Fgetc(expfile)) < 0) ! 1535: - c = 0; ! 1536: - } ! 1537: - else c = *input++; ! 1538: -#ifdef MAILPREP ! 1539: -if(mailfd >= 0) Fputc(mailfd, c? c : '\n'); ! 1540: -#endif /* MAILPREP */ ! 1541: - return(c); ! 1542: -} ! 1543: - ! 1544: -synerror() { ! 1545: - fprint(2, "%s: syntax error\n", progname); ! 1546: - exit(2); ! 1547: -} ! 1548: - ! 1549: -enter(x) int x; { ! 1550: - if(line >= MAXLIN) overflo(); ! 1551: - name[line] = x; ! 1552: - left[line] = 0; ! 1553: - right[line] = 0; ! 1554: - return(line++); ! 1555: -} ! 1556: - ! 1557: -cclenter(x) int x; { ! 1558: - register linno; ! 1559: - linno = enter(x); ! 1560: - right[linno] = count; ! 1561: - return (linno); ! 1562: -} ! 1563: - ! 1564: -node(x, l, r) { ! 1565: - if(line >= MAXLIN) overflo(); ! 1566: - name[line] = x; ! 1567: - left[line] = l; ! 1568: - right[line] = r; ! 1569: - parent[l] = line; ! 1570: - parent[r] = line; ! 1571: - return(line++); ! 1572: -} ! 1573: - ! 1574: -unary(x, d) { ! 1575: - if(line >= MAXLIN) overflo(); ! 1576: - name[line] = x; ! 1577: - left[line] = d; ! 1578: - right[line] = 0; ! 1579: - parent[d] = line; ! 1580: - return(line++); ! 1581: -} ! 1582: -overflo() { ! 1583: - fprint(2, "%s: regular expression too long\n", progname); ! 1584: - exit(2); ! 1585: -} ! 1586: - ! 1587: -#ifdef MAILPREP ! 1588: -#include <errno.h> ! 1589: -#define NAME "/tmp/grepdata" ! 1590: -mailprep() ! 1591: -{ ! 1592: - umask(0); ! 1593: - mailfd = open(NAME, 1); ! 1594: - if((mailfd < 0) && (errno != ECONC)) ! 1595: - mailfd = creat(NAME, 03666); ! 1596: - if(mailfd >= 0){ ! 1597: - Finit(mailfd, (char *)0); ! 1598: - Fseek(mailfd, 0L, 2); ! 1599: - Fprint(mailfd, "\321egrep: "); ! 1600: - } ! 1601: -} ! 1602: - ! 1603: -maildone() ! 1604: -{ ! 1605: - if(mailfd >= 0){ ! 1606: - Fflush(mailfd); ! 1607: - close(mailfd); ! 1608: - } ! 1609: -} ! 1610: -#endif /* MAILPREP */ ! 1611: //GO.SYSIN DD gram.y
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.