Return to glue1.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / refer

Annotation of 43BSD/usr.bin/refer/glue1.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *sccsid = "@(#)glue1.c     4.3 (Berkeley) 3/4/86";
        !             3: #endif
        !             4: 
        !             5: #include <stdio.h>
        !             6: #define unopen(fil) {if (fil!=NULL) {fclose(fil); fil=NULL;}}
        !             7: 
        !             8: extern char refdir[];
        !             9: int lmaster = 1000;
        !            10: int reached = 0;
        !            11: FILE *fd = 0;
        !            12: int *hfreq, hfrflg;
        !            13: int colevel = 0;
        !            14: static union firetruck {
        !            15:        unsigned *a; 
        !            16:        long *b;
        !            17: } master;
        !            18: int iflong;
        !            19: extern char *fgnames[], **fgnamp;
        !            20: extern FILE *iopen();
        !            21: char *todir();
        !            22: int prfreqs = 0;
        !            23: int typeindex = 0;
        !            24: char usedir[100];
        !            25: static int full = 1000;
        !            26: static int tags = 0;
        !            27: char *sinput, *soutput, *tagout;
        !            28: long indexdate = 0, gdate();
        !            29: int soutlen = 1000;
        !            30: int taglen = 1000;
        !            31: 
        !            32: huntmain(argc,argv)
        !            33: char *argv[];
        !            34: {
        !            35:        /* read query from stdin, expect name of indexes in argv[1] */
        !            36:        static FILE *fa, *fb, *fc;
        !            37:        char indexname[100], *qitem[100], *rprog = 0;
        !            38:        char grepquery[200];
        !            39:        static char oldname[30] ;
        !            40:        static int nhash = 0;
        !            41:        static int maxhash = 0;
        !            42:        int falseflg = 0, nitem, nfound, frtbl;
        !            43:        static long *hpt = 0;
        !            44: # if D1
        !            45:        fprintf(stderr, "in glue1 argc %d argv %o %o\n", argc, argv[0],argv[1]);
        !            46: # endif
        !            47:        savedir();
        !            48:        while (argv[1][0] == '-')
        !            49:        {
        !            50: # if D1
        !            51:                fprintf(stderr, "argv.1 is %s\n",argv[1]);
        !            52: # endif
        !            53:                switch(argv[1][1])
        !            54:                {
        !            55:                case 'a': /* all output, incl. false drops */
        !            56:                        falseflg = 1; 
        !            57:                        break;
        !            58:                case 'r':
        !            59:                        argc--; 
        !            60:                        argv++;
        !            61:                        rprog = argv[1];
        !            62:                        break;
        !            63:                case 'F': /* put out full text */
        !            64:                        full = setfrom(argv[1][2]);
        !            65:                        break;
        !            66:                case 'T': /* put out tags */
        !            67:                        tags = setfrom(argv[1][2]);
        !            68:                        break;
        !            69:                case 'i': /* input in argument string */
        !            70:                        argc--; 
        !            71:                        argv++;
        !            72:                        sinput = argv[1];
        !            73:                        break;
        !            74:                case 's': /*text output to string */
        !            75:                case 'o':
        !            76:                        argc--; 
        !            77:                        argv++;
        !            78:                        soutput = argv[1];
        !            79:                        if ((int) argv[2]<16000)
        !            80:                        {
        !            81:                                soutlen = (int) argv[2];
        !            82:                                argc--; 
        !            83:                                argv++;
        !            84:                        }
        !            85:                        break;
        !            86:                case 't': /*tag output to string */
        !            87:                        argc--; 
        !            88:                        argv++;
        !            89:                        tagout = argv[1];
        !            90:                        if ((int)argv[2]<16000)
        !            91:                        {
        !            92:                                taglen = (int)argv[2];
        !            93:                                argc--; 
        !            94:                                argv++;
        !            95:                        }
        !            96:                        break;
        !            97:                case 'l': /* specify length of lists */
        !            98:                        argc--; 
        !            99:                        argv++;
        !           100:                        lmaster = atoi(argv[1]);
        !           101: # if D1
        !           102:                        fprintf(stderr, "lmaster now %d\n",lmaster);
        !           103: # endif
        !           104:                        break;
        !           105:                case 'C': 
        !           106:                        argc--; 
        !           107:                        argv++;
        !           108:                        colevel = atoi(argv[1]);
        !           109:                        break;
        !           110:                }
        !           111:                argc--; 
        !           112:                argv++;
        !           113:        }
        !           114:        strcpy (indexname, todir(argv[1]));
        !           115: # if D1
        !           116:        fprintf(stderr, "in huntmain indexname %s typeindex %d\n", indexname, typeindex);
        !           117: # endif
        !           118:        if (typeindex == 0 || strcmp (oldname, indexname) !=0)
        !           119:        {
        !           120:                strcpy (oldname, indexname);
        !           121:                unopen(fa); 
        !           122:                unopen(fb); 
        !           123:                unopen(fc);
        !           124: 
        !           125:                if (ckexist(indexname, ".ib"))
        !           126:                {
        !           127: # if D1
        !           128:                        fprintf(stderr, "found old index\n");
        !           129: # endif
        !           130:                        fa = iopen(indexname, ".ia");
        !           131:                        fb = iopen(indexname, ".ib");
        !           132:                        fc = iopen(indexname, ".ic");
        !           133:                        typeindex =1;
        !           134: # if D1
        !           135:                        fprintf(stderr, "opened f's as %o %o %o\n",fa,fb,fc);
        !           136: # endif
        !           137:                        indexdate = gdate(fb);
        !           138:                        fread (&nhash, sizeof(nhash), 1, fa);
        !           139:                        fread (&iflong, sizeof(iflong), 1, fa);
        !           140:                        if (nhash > maxhash)
        !           141:                        {
        !           142:                                if (hpt)
        !           143:                                        free (hpt, maxhash, sizeof(*hpt));
        !           144:                                hpt=0;
        !           145:                                if (hfreq)
        !           146:                                        free(hfreq, maxhash, sizeof(*hfreq));
        !           147:                                hfreq=0;
        !           148:                                maxhash=nhash;
        !           149: # if D1
        !           150:                                fprintf(stderr, "Freed if needed maxhash %d\n",maxhash);
        !           151: # endif
        !           152:                        }
        !           153:                        if (hpt==0)
        !           154:                                hpt = (long *) zalloc(nhash, sizeof(*hpt));
        !           155: # if D1
        !           156:                        fprintf(stderr, "hpt now %o\n",hpt);
        !           157: # endif
        !           158:                        if (hpt == NULL)
        !           159:                                err ("No space for hash list (%d)", nhash);
        !           160:                        fread( hpt, sizeof(*hpt), nhash, fa);
        !           161:                        if (hfreq==0)
        !           162:                                hfreq=(int *)zalloc(nhash, sizeof(*hfreq));
        !           163:                        if (hfreq==NULL)
        !           164:                                err ("No space for hash frequencies (%d)", nhash);
        !           165:                        frtbl = fread(hfreq, sizeof(*hfreq), nhash, fa);
        !           166:                        hfrflg = (frtbl == nhash);
        !           167: # if D1
        !           168:                        fprintf(stderr,"Read pointer files\n");
        !           169: # endif
        !           170:                        if (master.a == NULL)
        !           171:                                if (iflong)
        !           172:                                        master.b = (long *)zalloc(lmaster, sizeof(long));
        !           173:                                else
        !           174:                                        master.a = (unsigned *)zalloc(lmaster, sizeof(int));
        !           175:                        if (master.a == NULL)
        !           176:                                err ("no space for answer list",0);
        !           177:                }
        !           178:                else
        !           179:                        if (makefgrep(indexname))
        !           180:                                typeindex=2;
        !           181:                        else
        !           182:                        {
        !           183:                                err ("No files %s\n",indexname);
        !           184:                                exit(1);
        !           185:                        }
        !           186:        }
        !           187: 
        !           188: # if D1
        !           189:        fprintf(stderr, "typeindex now %d\n",typeindex);
        !           190: # endif
        !           191:        tagout[0]=0;
        !           192:        if (typeindex==2)
        !           193:        {
        !           194:                grepcall(sinput, tagout, indexname);
        !           195: # if D1
        !           196:                fprintf(stderr, " back from grepcall\n");
        !           197: # endif
        !           198:                restodir();
        !           199:                return;
        !           200:        }
        !           201:        nitem = getq(qitem);
        !           202: # if D1
        !           203:        fprintf(stderr, "approaching doquery fb %o\n", fb);
        !           204: # endif
        !           205:        nfound = doquery(hpt, nhash, fb, nitem, qitem, master);
        !           206: # ifdef D1
        !           207:        fprintf(stderr, "return from doquery with nfound %d\n", nfound);
        !           208: # endif
        !           209:        if (falseflg == 0)
        !           210:                nfound = baddrop(master, nfound, fc, nitem, qitem, rprog, full);
        !           211: # ifdef D1
        !           212:        fprintf(stderr, "after baddrop with nfound %d\n",nfound);
        !           213:        fprintf(stderr, "tagout is /%s/, sout /%s/\n",tagout, soutput);
        !           214: # endif
        !           215:        if (tags)
        !           216:                result (master, nfound >tags ? tags : nfound, fc);
        !           217: # if D1
        !           218:        fprintf(stderr, "done with huntmain\n");
        !           219:        fprintf(stderr, "tagout is /%s/\n", tagout);
        !           220:        fprintf(stderr, "string out is /%s/\n", soutput);
        !           221: # endif
        !           222:        if (fgnamp>fgnames)
        !           223:        {
        !           224:                char **fgp;
        !           225:                int k;
        !           226: # if D1
        !           227:                fprintf(stderr, "were %d bad files\n", fgnamp-fgnames);
        !           228: # endif
        !           229:                grepquery[0]=0;
        !           230:                for(k=0; k<nitem; k++)
        !           231:                {
        !           232:                        strcat(grepquery, " ");
        !           233:                        strcat(grepquery, qitem[k]);
        !           234:                }
        !           235:                for(fgp=fgnames; fgp<fgnamp; fgp++)
        !           236:                {
        !           237: # if D1
        !           238:                        fprintf(stderr, "Now on %s query /%s/\n", *fgp, grepquery);
        !           239: # endif
        !           240:                        makefgrep(*fgp);
        !           241:                        grepcall(grepquery, tagout, *fgp);
        !           242: # if D1
        !           243:                        fprintf(stderr, "tagout now /%s/\n", tagout);
        !           244: # endif
        !           245:                }
        !           246:        }
        !           247:        restodir();
        !           248: }
        !           249: 
        !           250: char *
        !           251: todir(t)
        !           252: char *t;
        !           253: {
        !           254:        char *s;
        !           255: 
        !           256:        usedir[0] = 0;
        !           257:        s=t;
        !           258:        while (*s) s++;
        !           259:        while (s>=t && *s != '/') s--;
        !           260:        if (s<t) return(t);
        !           261:        *s++ = 0;
        !           262:        t = (*t ? t : "/");
        !           263:        chdir (t);
        !           264:        strcpy (usedir,t);
        !           265:        return(s);
        !           266: }
        !           267: 
        !           268: setfrom(c)
        !           269: {
        !           270:        switch(c)
        !           271:        {
        !           272:        case 'y': 
        !           273:        case '\0':
        !           274:        default:
        !           275:                return(1000);
        !           276:        case '1':
        !           277:        case '2': 
        !           278:        case '3': 
        !           279:        case '4': 
        !           280:        case '5':
        !           281:        case '6': 
        !           282:        case '7': 
        !           283:        case '8': 
        !           284:        case '9':
        !           285:                return(c-'0');
        !           286:        case 'n': 
        !           287:        case '0':
        !           288:                return(0);
        !           289:        }
        !           290: }

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