![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hunt1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / refer|
Return to hunt1.c CVS log | Up to [Research Unix] / researchv10no / cmd / refer |
1.1 root 1: # include "stdio.h"
2: # include "assert.h"
3: extern char refdir[];
4: extern int keepold;
5: extern char *fgnames[];
6: extern char **fgnamp;
7: FILE *fd =NULL;
8: int lmaster =500;
9: int *hfreq, hfrflg;
10: int colevel =0;
11: int measure=0;
12: int soutlen =1000;
13: int reached =0;
14: int iflong =0;
15: int prfreqs =0;
16: char usedir[100];
17: char * calloc(); char * todir();
18: char gfile[50];
19: static int full =1000;
20: static int tags =0;
21: char *sinput, *soutput, *tagout;
22: long indexdate =0, gdate();
23:
24: main(argc,argv)
25: char *argv[];
26: {
27: /* read query from stdin, expect name of indexes in argv[1] */
28: static FILE *fa, *fb, *fc;
29: char nma[100], nmb[100], nmc[100], *qitem[100], *rprog = NULL;
30: char nmd[100], grepquery[256];
31: static char oldname[30] ;
32: static int was =0;
33: /* these pointers are unions of pointer to int and pointer to long */
34: long *hpt;
35: unsigned *master =0;
36: int falseflg, nhash, nitem, nfound, frtbl, kk;
37:
38: /* special wart for refpart: default is tags only */
39:
40: while (argv[1][0] == '-')
41: {
42: switch(argv[1][1])
43: {
44: case 'a': /* all output, incl. false drops */
45: falseflg = 1; break;
46: case 'r':
47: argc--; argv++;
48: rprog = argv[1];
49: break;
50: case 'F': /* put out full text */
51: full = setfrom(argv[1][2]);
52: break;
53: case 'T': /* put out tags */
54: tags = setfrom(argv[1][2]);
55: break;
56: case 'i': /* input in argument string */
57: argc--; argv++;
58: sinput = argv[1];
59: break;
60: case 's': /*text output to string */
61: case 'o':
62: argc--; argv++;
63: soutput = argv[1];
64: if (argv[2]<(char *)16000) /* this is a crazy kludge and only left to show what not to do */
65: {
66: soutlen = (int)argv[2];
67: argc--; argv++;
68: }
69: break;
70: case 't': /*tag output to string */
71: argc--; argv++;
72: tagout = argv[1];
73: break;
74: case 'l': /* length of internal lists */
75: argc--; argv++;
76: lmaster = atoi(argv[1]);
77: break;
78: case 'g': /* suppress fgrep search on old files */
79: keepold = 0;
80: break;
81: case 'C': /* coordination level */
82: colevel = atoi(argv[1]+2);
83: # if D1
84: fprintf(stderr, "colevel set to %d\n",colevel);
85: # endif
86: break;
87: case 'P': /* print term freqs */
88: prfreqs=1; break;
89: case 'm':
90: measure=1; break;
91: }
92: argc--; argv++;
93: }
94: strcpy (nma, todir(argv[1]));
95: if (was == 0 || strcmp (oldname, nma) !=0)
96: {
97: strcpy (oldname,nma);
98: strcpy (nmb, nma); strcpy (nmc, nmb); strcpy(nmd,nma);
99: strcat (nma, ".ia");
100: strcat (nmb, ".ib");
101: strcat (nmc, ".ic");
102: strcat (nmd, ".id");
103: if (was)
104: {fclose(fa); fclose(fb); fclose(fc);}
105:
106: fa = fopen(nma, "r");
107: if (fa==NULL)
108: {
109: strcpy(*fgnamp++ = calloc(strlen(oldname)+2,1), oldname);
110: fb=NULL;
111: goto search;
112: }
113: fb = fopen(nmb, "r");
114: fc = fopen(nmc, "r");
115: was =1;
116: if (fb== NULL || fc ==NULL)
117: {
118: err("Index incomplete %s", nmb);
119: exit(1);
120: }
121: indexdate = gdate(fb);
122: fd = fopen(nmd, "r");
123: }
124: fseek (fa, 0L, 0);
125: fread (&nhash, sizeof(nhash), 1, fa);
126: fread (&iflong, sizeof(iflong), 1, fa);
127: if(master==0)
128: master = (unsigned *) calloc (lmaster, iflong? sizeof(long): sizeof(int));
129: hpt = (long *) calloc(nhash, sizeof(*hpt));
130: kk=fread( hpt, sizeof(*hpt), nhash, fa);
131: # if D1
132: fprintf(stderr,"read %d hashes, iflong %d, nhash %d\n", kk, iflong, nhash);
133: # endif
134: assert (kk==nhash);
135: hfreq = (int *) calloc(nhash, sizeof(*hfreq));
136: assert (hfreq != NULL);
137: frtbl = fread(hfreq, sizeof(*hfreq), nhash, fa);
138: hfrflg = (frtbl == nhash);
139: # if D1
140: fprintf(stderr, "read freqs %d\n", frtbl);
141: # endif
142:
143: search:
144: while (1)
145: {
146: nitem = getq(qitem);
147: if (measure) tick();
148: if (nitem==0) continue;
149: if (nitem < 0) break;
150: if (tagout) tagout[0]=0;
151: if (fb!=NULL)
152: {
153: nfound = doquery(hpt, nhash, fb, nitem, qitem, master);
154: # if D1
155: fprintf(stderr,"after doquery nfound %d\n", nfound);
156: # endif
157: fgnamp=fgnames;
158: if (falseflg == 0)
159: nfound = baddrop(master, nfound, fc, nitem, qitem, rprog, full);
160: # if D1
161: fprintf(stderr,"after baddrop nfound %d\n", nfound);
162: # endif
163: }
164: if (fgnamp>fgnames)
165: {
166: char **fgp, tgbuff[100];
167: int k;
168: # if D1
169: fprintf(stderr, "were %d bad files\n", fgnamp-fgnames);
170: # endif
171: grepquery[0]=0;
172: for(k=0; k<nitem; k++)
173: {
174: strcat(grepquery, " ");
175: strcat(grepquery, qitem[k]);
176: }
177: # if D1
178: fprintf(stderr, "grepquery %s\n",grepquery);
179: # endif
180: for(fgp=fgnames; fgp<fgnamp; fgp++)
181: {
182: # if D1
183: fprintf(stderr, "Now on %s query /%s/\n", *fgp, grepquery);
184: # endif
185: makefgrep(*fgp);
186: # if D1
187: fprintf(stderr, "grepmade\n");
188: # endif
189: if (tagout==0)
190: tagout=tgbuff;
191: grepcall(grepquery, tagout, *fgp);
192: # if D1
193: fprintf(stderr, "tagout now /%s/\n", tagout);
194: # endif
195: if (full)
196: {
197: char bout[1000];
198: findline(tagout, bout, 1000);
199: fputs(bout,stdout);
200: }
201: }
202: }
203: if (tags)
204: result (master, nfound >tags ? tags: nfound, fc);
205: if (measure) tock();
206: }
207: }
208:
209: char *
210: todir(t)
211: char *t;
212: {
213: char *s;
214: s=t;
215: while (*s) s++;
216: while (s>=t && *s != '/') s--;
217: if (s<t) return(t);
218: *s++ = 0;
219: t = (*t ? t : "/");
220: chdir (t);
221: strcpy (usedir,t);
222: return(s);
223: }
224: setfrom(c)
225: {
226: switch(c)
227: {
228: case 'y': case '\0':
229: default:
230: return(1000);
231: case '1':
232: case '2': case '3': case '4': case '5':
233: case '6': case '7': case '8': case '9':
234: return(c-'0');
235: case 'n': case '0':
236: return(0);
237: }
238: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.