# 2.11BSD#431 - /usr/src/usr.bin/refer/glue5.c

##### Functions

    cfail             X
    cgotofn           X
    execute           X
    fgrep             X
    gch               X
    new               X
    overflo           X

##### Variables

    buf               X
    inct              X
    instr             X
    need              X
    nfound            X
    nsucc             X
    numwords          X
    q                 X
    rflag             X
    smax              X
    www               X
    xargc             X
    xargv             X

##### Macros

    MAXSIZ            X
    QSIZE             X

##### struct's

    words             X

       1: #if defined(DOSCCS) && !defined(lint)
       2: static char *sccsid = "@(#)glue5.c	4.2.1 (2.11BSD GTE) 1/1/94";
       3: #endif
       4:
       5: #include <stdio.h>
       6: #include <ctype.h>
       7: /*
       8:  * fgrep -- print all lines containing any of a set of keywords
       9:  *
      10:  *	status returns:
      11:  *		0 - ok, and some matches
      12:  *		1 - ok, but no matches
      13:  *		2 - some error
      14:  */
      15: #ifdef pdp11
      16: #define MAXSIZ 350
      17: #define QSIZE 200
      18: #else
      19: #define MAXSIZ 700
      20: #define QSIZE 400
      21: #endif
      22: struct words {
      23:     char    inp;
      24:     char    out;
      25:     struct  words *nst;
      26:     struct  words *link;
      27:     struct  words *fail;
      28: }
      29: *www, *smax, *q;
      30:
      31: char    buf[2*BUFSIZ];
      32: int nsucc;
      33: int need;
      34: char    *instr;
      35: int inct;
      36: int rflag;
      37: int xargc;
      38: char    **xargv;
      39: int numwords;
      40: int nfound;
      41: static int flag = 0;
      42:
      43: fgrep(argc, argv)
      44: char **argv;
      45: {
      46:     nsucc = need = inct = rflag = numwords = nfound = 0;
      47:     instr = 0;
      48:     flag = 0;
      49:     if (www==0)
      50:         www = (struct words *) zalloc(MAXSIZ, sizeof (*www));
      51:     if (www==NULL)
      52:         err("Can't get space for machines", 0);
      53:     for (q=www; q<www+MAXSIZ; q++) {
      54:         q->inp =0; q->out =0; q->nst =0; q->link =0; q->fail =0;
      55:     }
      56:     xargc = argc-1;
      57:     xargv = argv+1;
      58:     while (xargc>0 && xargv[0][0]=='-')
      59:         {
      60:         switch(xargv[0][1])
      61:             {
      62:             case 'r': /* return value only */
      63:                 rflag++;
      64:                 break;
      65:             case 'n': /* number of answers needed */
      66:                 need = (int) xargv[1];
      67:                 xargv++; xargc--;
      68:                 break;
      69:             case 'i':
      70:                 instr = xargv[1];
      71:                 inct = (int) xargv[2]+2;
      72: # if D2
      73: fprintf(stderr,"inct %d xargv.2. %o %d\n",inct, xargv[2],xargv[2]);
      74: # endif
      75:                 xargv += 2; xargc -= 2;
      76:                 break;
      77:             }
      78:         xargv++; xargc--;
      79:         }
      80:     if (xargc<=0)
      81:         {
      82:         write (2, "bad fgrep call\n", 15);
      83:         exit(2);
      84:         }
      85: # if D1
      86:     fprintf(stderr, "before cgoto\n");
      87: # endif
      88:     cgotofn();
      89: # if D1
      90:     fprintf(stderr, "before cfail\n");
      91: # endif
      92:     cfail();
      93: # if D1
      94:     fprintf(stderr, "before execute instr %.20s\n", instr? instr: "");
      95:     fprintf(stderr, "end of string %d %c %c %c\n", inct, instr[inct-3],
      96:         instr[inct-2], instr[inct-1]);
      97: # endif
      98:     execute();
      99: # if D1
     100:     fprintf(stderr, "returning nsucc %d\n", nsucc);
     101:     fprintf(stderr, "fgrep done www %o\n",www);
     102: # endif
     103:     return(nsucc == 0);
     104: }
     105:
     106: execute()
     107: {
     108:     register char *p;
     109:     register struct words *c;
     110:     register ch;
     111:     register ccount;
     112:     int f;
     113:     char *nlp;
     114:     f=0;
     115:     ccount = instr ? inct : 0;
     116:     nfound=0;
     117:     p = instr ? instr : buf;
     118:     if (need == 0) need = numwords;
     119:     nlp = p;
     120:     c = www;
     121: # if D2
     122: fprintf(stderr, "in execute ccount %d inct %d\n",ccount, inct );
     123: # endif
     124:     for (;;) {
     125: # if D3
     126: fprintf(stderr, "down ccount\n");
     127: # endif
     128:         if (--ccount <= 0) {
     129: # if D2
     130: fprintf(stderr, "ex loop ccount %d instr %o\n",ccount, instr);
     131: # endif
     132:             if (instr) break;
     133:             if (p == &buf[2*BUFSIZ]) p = buf;
     134:             if (p > &buf[BUFSIZ]) {
     135:                 if ((ccount = read(f, p, &buf[2*BUFSIZ] - p)) <= 0) break;
     136:             }
     137:             else if ((ccount = read(f, p, BUFSIZ)) <= 0) break;
     138: # if D2
     139: fprintf(stderr, " normal read %d bytres\n", ccount);
     140: {char xx[20]; sprintf(xx, "they are %%.%ds\n", ccount);
     141: fprintf(stderr, xx, p);
     142: }
     143: # endif
     144:         }
     145: nstate:
     146:         ch = *p;
     147: # if D2
     148: fprintf(stderr, "roaming along in ex ch %c c %o\n",ch,c);
     149: # endif
     150:         if (isupper(ch)) ch |= 040;
     151:         if (c->inp == ch) {
     152:             c = c->nst;
     153:         }
     154:         else if (c->link != 0) {
     155:             c = c->link;
     156:             goto nstate;
     157:         }
     158:         else {
     159:             c = c->fail;
     160:             if (c==0) {
     161:                 c = www;
     162: istate:
     163:                 if (c->inp == ch) {
     164:                     c = c->nst;
     165:                 }
     166:                 else if (c->link != 0) {
     167:                     c = c->link;
     168:                     goto istate;
     169:                 }
     170:             }
     171:             else goto nstate;
     172:         }
     173:         if (c->out && new (c)) {
     174: # if D2
     175: fprintf(stderr, " found: nfound %d need %d\n",nfound,need);
     176: # endif
     177:             if (++nfound >= need)
     178:             {
     179: # if D1
     180: fprintf(stderr, "found, p %o nlp %o ccount %d buf %o buf[2*BUFSIZ] %o\n",p,nlp,ccount,buf,buf+2*BUFSIZ);
     181: # endif
     182:                 if (instr==0)
     183:                 while (*p++ != '\n') {
     184: # if D3
     185: fprintf(stderr, "down ccount2\n");
     186: # endif
     187:                     if (--ccount <= 0) {
     188:                         if (p == &buf[2*BUFSIZ]) p = buf;
     189:                         if (p > &buf[BUFSIZ]) {
     190:                             if ((ccount = read(f, p, &buf[2*BUFSIZ] - p)) <= 0) break;
     191:                         }
     192:                         else if ((ccount = read(f, p, BUFSIZ)) <= 0) break;
     193: # if D2
     194: fprintf(stderr, " read %d bytes\n",ccount);
     195: { char xx[20]; sprintf(xx, "they are %%.%ds\n", ccount);
     196: fprintf(stderr, xx, p);
     197: }
     198: # endif
     199:                     }
     200:                 }
     201:                 nsucc = 1;
     202:                 if (rflag==0)
     203:                     {
     204: # if D2
     205: fprintf(stderr, "p %o nlp %o buf %o\n",p,nlp,buf);
     206: if (p>nlp)
     207: {write (2, "XX\n", 3); write (2, nlp, p-nlp); write (2, "XX\n", 3);}
     208: # endif
     209:                     if (p > nlp) write(1, nlp, p-nlp);
     210:                     else {
     211:                         write(1, nlp, &buf[2*BUFSIZ] - nlp);
     212:                         write(1, buf, p-&buf[0]);
     213:                         }
     214:                     if (p[-1]!= '\n') write (1, "\n", 1);
     215:                     }
     216:                 if (instr==0)
     217:                     {
     218:                     nlp = p;
     219:                     c = www;
     220:                     nfound=0;
     221:                     }
     222:             }
     223:             else
     224:                 ccount++;
     225:             continue;
     226:         }
     227: # if D2
     228: fprintf(stderr, "nr end loop p %o\n",p);
     229: # endif
     230:         if (instr)
     231:             p++;
     232:         else
     233:         if (*p++ == '\n')
     234:         {
     235:             nlp = p;
     236:             c = www;
     237:             nfound=0;
     238:         }
     239:     }
     240:     if (instr==0)
     241:         close(f);
     242: }
     243:
     244: cgotofn() {
     245:     register c;
     246:     register struct words *s;
     247:     s = smax = www;
     248: nword:
     249:     for(;;) {
     250: # if D1
     251:     fprintf(stderr, " in for loop c now %o %c\n",c, c>' ' ? c : ' ');
     252: # endif
     253:         if ((c = gch())==0) return;
     254:         else if (c == '\n') {
     255:             s->out = 1;
     256:             s = www;
     257:         }
     258:         else {
     259: loop:
     260:             if (s->inp == c) {
     261:                 s = s->nst;
     262:                 continue;
     263:             }
     264:             if (s->inp == 0) goto enter;
     265:             if (s->link == 0) {
     266:                 if (smax >= &www[MAXSIZ - 1]) overflo();
     267:                 s->link = ++smax;
     268:                 s = smax;
     269:                 goto enter;
     270:             }
     271:             s = s->link;
     272:             goto loop;
     273:         }
     274:     }
     275:
     276: enter:
     277:     do {
     278:         s->inp = c;
     279:         if (smax >= &www[MAXSIZ - 1]) overflo();
     280:         s->nst = ++smax;
     281:         s = smax;
     282:     }
     283:     while ((c = gch()) != '\n');
     284:     smax->out = 1;
     285:     s = www;
     286:     numwords++;
     287:     goto nword;
     288:
     289: }
     290:
     291: gch()
     292: {
     293:     static char *s;
     294:     if (flag==0)
     295:     {
     296:         flag=1;
     297:         s = *xargv++;
     298: # if D1
     299:     fprintf(stderr, "next arg is %s xargc %d\n",s,xargc);
     300: # endif
     301:         if (xargc-- <=0) return(0);
     302:     }
     303:     if (*s) return(*s++);
     304:     for(flag=0; flag<2*BUFSIZ; flag++)
     305:         buf[flag]=0;
     306:     flag=0;
     307:     return('\n');
     308: }
     309:
     310: overflo() {
     311:     write(2,"wordlist too large\n", 19);
     312:     exit(2);
     313: }
     314: cfail() {
     315:     struct words *queue[QSIZE];
     316:     struct words **front, **rear;
     317:     struct words *state;
     318:     register char c;
     319:     register struct words *s;
     320:     s = www;
     321:     front = rear = queue;
     322: init:
     323:     if ((s->inp) != 0) {
     324:         *rear++ = s->nst;
     325:         if (rear >= &queue[QSIZE - 1]) overflo();
     326:     }
     327:     if ((s = s->link) != 0) {
     328:         goto init;
     329:     }
     330:
     331:     while (rear!=front) {
     332:         s = *front;
     333:         if (front == &queue[QSIZE-1])
     334:             front = queue;
     335:         else front++;
     336: cloop:
     337:         if ((c = s->inp) != 0) {
     338:             *rear = (q = s->nst);
     339:             if (front < rear)
     340:                 if (rear >= &queue[QSIZE-1])
     341:                     if (front == queue) overflo();
     342:                     else rear = queue;
     343:             else rear++;
     344:             else
     345:                 if (++rear == front) overflo();
     346:             state = s->fail;
     347: floop:
     348:             if (state == 0) state = www;
     349:             if (state->inp == c) {
     350:                 q->fail = state->nst;
     351:                 if ((state->nst)->out == 1) q->out = 1;
     352:                 continue;
     353:             }
     354:             else if ((state = state->link) != 0)
     355:                 goto floop;
     356:         }
     357:         if ((s = s->link) != 0)
     358:             goto cloop;
     359:     }
     360: }
     361:
     362: static int seen[50];
     363: new (x)
     364: {
     365:     int i;
     366:     for(i=0; i<nfound; i++)
     367:         if (seen[i]==x)
     368:             return(0);
     369:     seen[i]=x;
     370:     return(1);
     371: }

#### Defined functions

cfail defined in line 314; used 1 times

- in line 92

cgotofn defined in line 244; used 1 times

- in line 88

execute defined in line 106; used 1 times

- in line 98

fgrep defined in line 43; used 2 times

- in /usr/src/usr.bin/refer/glue4.c line 50
- in /usr/src/usr.bin/refer/hunt6.c line 92

gch defined in line 291; used 2 times

- in line 253, 283

new defined in line 363; used 1 times

- in line 173

overflo defined in line 310; used 5 times

- in line 266, 279, 325, 341-345(2)

#### Defined variables

buf defined in line 31; used 16 times

- in line 117, 133-135(4), 180(2), 188-190(4), 205, 211-212(3), 305

flag defined in line 41; used 8 times

- in line 48, 294-296(2), 304-306(5)

inct defined in line 35; used 9 times

- in line 46, 71-73(2), 95-96(4), 115, 122

instr defined in line 34; used 16 times

- in line 47, 70, 94-96(5), 115-117(3), 130-132(2), 182, 216, 230, 240

need defined in line 33; used 6 times

- in line 46, 66, 118(2), 175-177(2)

nfound defined in line 40; used 7 times

- in line 46, 116, 175-177(2), 220, 237, 366

nsucc defined in line 32; used 4 times

- in line 46, 100-103(2), 201

numwords defined in line 39; used 3 times

- in line 46, 118, 286

q defined in line 29; used 11 times

- in line 53-54(8), 338, 350-351(2)

rflag defined in line 36; used 3 times

- in line 46, 63, 202

sccsid defined in line 2; never used
seen defined in line 362; used 2 times

- in line 367-369(2)

smax defined in line 29; used 8 times

- in line 247, 266-268(3), 279-284(4)

www defined in line 29; used 18 times

- in line 49-53(6), 101, 120, 161, 219, 236, 247, 256, 266, 279, 285, 320, 348

xargc defined in line 37; used 8 times

- in line 56-58(2), 67, 75-80(3), 299-301(2)

xargv defined in line 38; used 12 times

- in line 57-60(3), 66-78(8), 297

#### Defined struct's

words defined in line 22; used 20 times

- in line 25-27(6), 50(2), 109(2), 246(2), 315-319(8)

#### Defined macros

MAXSIZ defined in line 19; used 4 times

- in line 50-53(2), 266, 279

QSIZE defined in line 20; used 4 times

- in line 315, 325, 333, 340

Last modified: 1994-01-11 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1474 |