开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 搜索引擎 > 查看源码
index.c
资源名称：swish-efiles.1.3.2.tar.gz　[点击查看]
上传用户：qin5330
上传日期：2007-01-05
资源大小：114k
文件大小：29k
源码类别：

搜索引擎

开发平台：

Perl

index.c：源码内容
  1. /*
  2. ** Copyright (C) 1995, 1996, 1997, 1998 Hewlett-Packard Company
  3. ** Originally by Kevin Hughes, kev@kevcom.com, 3/11/94
  4. **
  5. ** This program and library is free software; you can redistribute it and/or
  6. ** modify it under the terms of the GNU (Library) General Public License
  7. ** as published by the Free Software Foundation; either version 2
  8. ** of the License, or any later version.
  9. **
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. ** GNU (Library) General Public License for more details.
  14. **
  15. ** You should have received a copy of the GNU (Library) General Public License
  16. **  long with this program; if not, write to the Free Software
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18. **--------------------------------------------------------------------
  19. ** ** ** PATCHED 5/13/96, CJC
  20. **
  21. ** Added code to countwords and countwordstr to disreguard the last char
  22. ** if requiered by the config.h
  23. ** G. Hill  3/12/97  ghill@library.berkeley.edu
  24. **
  25. ** Changed addentry, countwords, countwordstr, parsecomment, printindex
  26. ** added createMetaEntryList, getMeta, parseMetaData
  27. ** to support METADATA
  28. ** G. Hill 3/18/97 ghill@library.berkeley.edu
  29. **
  30. ** Changed removestops to support printing of stop words
  31. ** G. Hill 4/7/97
  32. **
  33. ** Changed countwords, countwrdstr, and parseMetaData to disreguard the
  34. ** first char if required by the config.h
  35. ** G.Hill 10/16/97  ghill@library.berkeley.edu
  36. **
  37. ** Added stripIgnoreLastChars and isIgnoreLastChar routines which iteratively
  38. ** remove all ignore characters from the end of each word.
  39. ** P. Bergner  10/5/97  bergner@lcse.umn.edu
  40. **
  41. ** Added stripIgnoreFirstChars and isIgnoreFirstChar to make stripping of
  42. ** the ignore first chars iterative.
  43. ** G. Hill 11/19/97 ghill@library.berkeley.edu
  44. **
  45. ** Added possibility of use of quotes and brackets in meta CONTENT countwords, parsemetadata
  46. ** G. Hill 1/14/98
  47. **
  48. ** Added regex for replace rule G.Hill 1/98
  49. */
  52. #include "swish.h"
  53. #include "index.h"
  54. #include "hash.h"
  55. #include "mem.h"
  56. #include "string.h"
  57. #include "check.h"
  58. #include "search.h"
  59. #include "docprop.h"
  60. #include "stemmer.h"
  62. /* Stores file names in alphabetical order so they can be
  63. ** indexed alphabetically. No big whoop.
  64. */
  66. struct sortentry *addsortentry(e, filename, title)
  67. struct sortentry *e;
  68. char *filename;
  69. char *title;
  70. {
  71. if (e == NULL) {
  72. e = (struct sortentry *) emalloc(sizeof(struct sortentry));
  73. e->filename = (char *) mystrdup(filename);
  74. e->title = (char *) mystrdup(title);
  75. e->left = e->right = NULL;
  76. }
  77. else {
  78. if (strcmp(e->filename, filename) > 0)
  79. e->left = (struct sortentry *)
  80. addsortentry(e->left, filename, title);
  81. else
  82. e->right = (struct sortentry *)
  83. addsortentry(e->right, filename, title);
  84. }
  86. return e;
  87. }
  89. /* Adds a word to the master index tree.
  90. */
  92. struct entry *addentry(e, word, filenum, emphasized, structure, metaName)
  93. struct entry *e;
  94. char *word;
  95. int filenum;
  96. int emphasized;
  97. int structure;
  98. int metaName;
  99. {
  100. int isbigger;
  101. struct location *tp, *oldtp;
  103. if (e == NULL) {
  104. e = (struct entry *) emalloc(sizeof(struct entry));
  105. e->word = (char *) mystrdup(word);
  106. e->tfrequency = 1;
  107. e->locationlist = (struct location *)
  108. emalloc(sizeof(struct location));
  109. e->locationlist->filenum = filenum;
  110. e->locationlist->frequency = 1;
  111. e->locationlist->emphasized = emphasized;
  112. e->locationlist->structure = structure;
  113. e->locationlist->metaName = metaName;
  114. e->locationlist->next = NULL;
  115. e->left = e->right = NULL;
  116. totalwords++;
  117. }
  118. else {
  119. isbigger = wordcompare(e->word, word);
  120. if (isbigger == 0) {
  121. tp = e->locationlist;
  122. while (tp != NULL) {
  123. if (tp->filenum == filenum && tp->metaName == metaName) 
  124. break;
  125. oldtp = tp;
  126. tp = tp->next;
  127. }
  128. if (tp == NULL) {
  129. tp = (struct location *) emalloc(sizeof(struct
  130. location));
  131. tp->filenum = filenum;
  132. tp->frequency = 1;
  133. tp->emphasized = emphasized;
  134. tp->structure = structure;
  135. tp->metaName = metaName;
  136. tp->next = NULL;
  137. oldtp->next = tp;
  138. if (!emphasized)
  139. e->tfrequency = e->tfrequency + 1;
  140. }
  141. else {
  142. if ((tp->filenum == filenum) && (tp->metaName == metaName)) 
  143. {
  144. tp->frequency++;
  145. if (emphasized)
  146. tp->emphasized++;
  147. tp->structure |= structure;
  148. }
  149. }
  150. }
  151. else if (isbigger > 0)
  152. {
  153. e->left = (struct entry *)
  154. addentry(e->left, word, filenum, emphasized, structure, metaName);
  155. }
  156. else
  157. {
  158. e->right = (struct entry *)
  159. addentry(e->right, word, filenum, emphasized, structure, metaName);
  160. }
  161. }
  163. return e;
  164. }
  166. /* Adds a file to the master list of files and file numbers.
  167. */
  169. struct file *addtofilelist(filep, filename, title, size, newFileEntry)
  170. struct file *filep;
  171. char *filename;
  172. char *title;
  173. int size;
  174. struct file ** newFileEntry;
  175. {
  176. struct file *newnode;
  177. static struct file *filelistp = NULL;
  179. newnode = (struct file *) emalloc(sizeof(struct file));
  180. if (newFileEntry != NULL)
  181. {
  182. *newFileEntry = newnode; /* pass object pointer up to caller */
  183. }
  184. newnode->filename = (char *) mystrdup(filename);
  185. newnode->title = (char *) mystrdup(title);
  186. newnode->size = size;
  187. newnode->next = NULL;
  189. #ifdef SUPPORT_DOC_PROPERTIES
  190. newnode->docProperties = NULL;
  191. #endif
  193. if (filep == NULL)
  194. filep = newnode;
  195. else if (filelistp != NULL)
  196. filelistp->next = newnode;
  198. filelistp = newnode;
  200. return filep;
  201. }
  203. /* Just goes through the master list of files and
  204. ** counts 'em.
  205. */
  207. int getfilecount(filep)
  208. struct file *filep;
  209. {
  210. int i;
  212. for (i = 0; filep != NULL; filep = filep->next)
  213. i++;
  215. return i;
  216. }
  218. /* Returns the nicely formatted date.
  219. */
  221. char *getthedate()
  222. {
  223. static char date[MAXSTRLEN];
  224. time_t time;
  226. time = (time_t) getthetime();
  227. /* strftime(date, MAXSTRLEN, "%x %X", (struct tm *) localtime(&time));*/
  228. strftime(date, MAXSTRLEN, "%d/%m/%y %H:%M:%S %Z",
  229. (struct tm *) localtime(&time)); 
  231. return date;
  232. }
  234. /* Indexes all the words in a file and adds the appropriate information
  235. ** to the appropriate structures.
  236. */
  238. int countwords(vp, filename, title, indextitleonly)
  239. void *vp;
  240. char *filename;
  241. char *title;
  242. int indextitleonly;
  243. {
  244. int c, i, j, inword, ftotalwords, emphasized, structure;
  245. int metaName;
  246. static int filenum;
  247. char word[MAXWORDLEN], tag[MAXSTRLEN];
  248. struct file *thisFileEntry = NULL;
  250. ftotalwords = 0;
  251. if (indextitleonly) {
  252. filelist = addtofilelist(filelist, filename, title, vsize(vp), NULL);
  253. filenum++;
  254. if (!(filenum % 128))
  255. filenum++;
  256. addtofwordtotals(filenum, 100);
  257. return (countwordstr(title, filenum, 0));
  258. }
  260. filelist = addtofilelist(filelist, filename, title, vsize(vp), &thisFileEntry);
  261. filenum++;
  262. if (!(filenum % 128))
  263. filenum++;
  265. c = 1;
  266. i = j = 0;
  267. inword = 0;
  268. emphasized = 0;
  269. structure = 1;
  270. metaName = 1;
  272. while (c != EOF && (c = vgetc(vp)) != EOF) 
  273. {
  274. if (!inword) {
  275. if (iswordchar((char)c)) {
  276. i = 0;
  277. word[i++] = c;
  278. if (i == MAXWORDLEN)
  279. i--;
  280. inword = 1;
  281. }
  282. }
  283. else if (inword) 
  284. {
  285. if (!iswordchar((char)c)) 
  286. {
  287. word[i++] = '';
  288. if (i == MAXWORDLEN)
  289. word[--i] = '';
  291. /* Move this stuff after entities are converted
  292. for (i = 0; word[i]; i++)
  293. word[i] = tolower(word[i]);
  294. i = 0;
  295. */
  296. if (isokword(word))
  297. {
  298. strcpy(word, (char *) convertentities(word));
  299. }
  301. /* Ok, can now go to lowercase, the whole problem
  302. was with entities Á would become á
  303. */
  304. for (i = 0; word[i]; i++)
  305. word[i] = tolower(word[i]);
  306. i = 0;
  308. /* Get rid of the last char's */
  309. stripIgnoreLastChars(word);
  311. /* Get rid of the first char */
  312. stripIgnoreFirstChars(word);
  314. if (applyStemmingRules)
  315. {
  316. /* apply stemming algorithm to the word to index */
  317. Stem(word);
  318. }
  320. /* Sorry, have to do isokword() twice to filter out converted strings! */
  322. if (hasokchars(word) && isokword(word)) 
  323. {
  324. #ifdef DEBUG
  325. printf(" %s %dn", word, structure);
  326. #endif
  327. entrylist = (struct entry *)
  328. addentry(entrylist, word, filenum, emphasized,  structure, metaName);
  329. ftotalwords++;
  330. }
  331. inword = 0;
  332. }
  333. else {
  334. word[i++] = c;
  335. if (i == MAXWORDLEN)
  336. i--;
  337. }
  338. }
  339. if (c == '<' && !INDEXTAGS) {
  340. j = 0;
  341. while ((c = vgetc(vp)) != EOF) {
  342. tag[j++] = c;
  343. if (j == MAXSTRLEN)
  344. j--;
  345. if (c == '>' && notEscaped(tag,j) ) {
  346. if (j)
  347. tag[--j] = '';
  348. else
  349. tag[j] = '';
  350. #ifdef DEBUG
  351. printf("t: %sn", tag);
  352. #endif
  353. structure = getstructure(tag,
  354. structure);
  355. #ifdef DEBUG
  356. printf("s: %dn", structure);
  357. #endif
  358. if ((tag[0]=='!') && 
  359. lstrstr(tag,"META") && 
  360. (lstrstr(tag,"START") ||
  361. lstrstr(tag,"END") ) ) 
  362. {
  363. if (lstrstr(tag, "START")) 
  364. {
  365. metaName=getMeta(tag, NULL);
  366. /* If there is not a legal metaName
  367. ** the program quits into getMeta
  368. */
  369. }
  370. else if (lstrstr(tag, "END") ) 
  371. {
  372. metaName = 1;
  373. }
  374. }
  375. else if ( (tag[0] != '!') &&
  376. (lstrstr(tag, "META")) &&
  377. (lstrstr(tag,"NAME")) &&
  378. (lstrstr(tag,"CONTENT")) )
  379. {
  380. ftotalwords += parseMetaData(tag, filenum, structure, thisFileEntry);
  381. }
  382. else if ( (tag[0] == '!') && indexComments)
  383. {
  384. ftotalwords += parsecomment(tag, filenum, structure,1);
  385. }
  387. if ((structure & IN_HEADER) ||
  388. (structure & IN_TITLE))
  389. emphasized = 5;
  390. else
  391. emphasized = 0;
  393. break;
  394. }
  395. }
  396. }
  397. }
  399. addtofwordtotals(filenum, ftotalwords);
  400. return ftotalwords;
  401. }
  403. /* Indexes the words in a string, such as a file name or an
  404. ** HTML title.
  405. */
  407. int countwordstr(s, filenum, emphasized)
  408. char *s;
  409. int filenum;
  410. int emphasized;
  411. {
  412. int i, j, inword, wordcount;
  413. char c, word[MAXWORDLEN], tmpstr[MAXFILELEN];
  415. sprintf(tmpstr, "%s ", s);
  416. for (j = inword = wordcount = 0; (c = tmpstr[j]) != ''; j++) {
  417. if (!inword) {
  418. if (iswordchar(c)) {
  419. i = 0;
  420. word[i++] = c;
  421. if (i == MAXWORDLEN)
  422. i--;
  423. inword = 1;
  424. }
  425. }
  426. else {
  427. if (!iswordchar(c)) {
  428. wordcount++;
  429. word[i] = '';
  431. /* Same as above, move after convertentities
  432. for (i = 0; word[i]; i++)
  433. word[i] = tolower(word[i]);
  434. */
  436. if (isokword(word))
  437. strcpy(word, (char *)
  438. convertentities(word));
  440. /* Ok to go lower now */
  441. for (i = 0; word[i]; i++)
  442. word[i] = tolower(word[i]);
  444. /* Get rid of specified last char's */
  445. stripIgnoreLastChars (word);
  447. /* Get rid of the first char */
  448. stripIgnoreFirstChars(word);
  450. if (hasokchars(word) && isokword(word))
  451. entrylist = (struct entry *)
  452. addentry(entrylist, word,
  453. filenum, emphasized, IN_FILE, 1);
  454. inword = 0;
  455. }
  456. else {
  457. word[i++] = c;
  458. if (i == MAXWORDLEN)
  459. i--;
  460. }
  461. }
  462. }
  464. return wordcount;
  465. }
  467. /* This returns the value corresponding to the HTML structures
  468. ** a word is in.
  469. */
  471. int getstructure(tag, structure)
  472. char *tag;
  473. int structure;
  474. {
  476.         int len;
  477.         char oldChar = 0;
  478.         char* endOfTag = NULL;
  479.         char* pos;
  481. pos = tag;
  482.         while (*pos)
  483.   {
  484.                 if (isspace(*pos))
  485.   {
  486.                         endOfTag = pos; /* remember where we are... */
  487.                         oldChar = *pos; /* ...and what we saw */
  488.                         *pos = '';    /* truncate string, for now */
  489.       }
  490. else 
  491.   pos++;
  492.       }
  494.         if (ourstricmp(tag, "/title") == 0)
  495.                 structure &= ~IN_TITLE;
  496.         else if (ourstricmp(tag, "title") == 0)
  497.                 structure |= IN_TITLE;
  498.         else if (ourstricmp(tag, "/head") == 0)
  499.                 structure &= ~IN_HEAD;
  500.         else if (ourstricmp(tag, "head") == 0)
  501.                 structure |= IN_HEAD;
  502.         else if (ourstricmp(tag, "/body") == 0)
  503.                 structure &= ~IN_BODY;
  504.         else if (ourstricmp(tag, "body") == 0)
  505.                 structure |= IN_BODY;
  506.         else if (tag[0] == '/' && tolower(tag[1]) == 'h' && isdigit(tag[2]))
  507.                 structure &= ~IN_HEADER;
  508.         else if (tolower(tag[0]) == 'h' && isdigit(tag[1]))
  509.                 structure |= IN_HEADER;
  510.         else if ((ourstricmp(tag, "/em") == 0) || 
  511.  (ourstricmp(tag, "/strong") == 0))
  512.                 structure &= ~IN_EMPHASIZED;
  514.         else if ((ourstricmp(tag, "em") == 0) ||
  515.  (ourstricmp(tag, "strong") == 0))
  516.                 structure |= IN_EMPHASIZED;
  517.         else if ((ourstricmp(tag, "b") == 0) || (ourstricmp(tag, "i") == 0))
  518.                 structure |= IN_EMPHASIZED;
  519.         else if ((ourstricmp(tag, "/b") == 0) || 
  520.  (ourstricmp(tag, "/i") == 0))
  521.                 structure &= ~IN_EMPHASIZED;
  523.         if (endOfTag != NULL)
  524.   {
  525.                 *endOfTag = oldChar;
  526.       }
  527.         return structure;
  528. }
  530. /* Parses the words in a comment.
  531. */
  533. int parsecomment(tag, filenum, structure, metaName)
  534. char *tag;
  535. int filenum;
  536. int structure;
  537. int metaName;
  538. {
  539. int i, j, inword, wordcount, emphasized;
  540. char c, word[MAXWORDLEN];
  542. if (EMPHASIZECOMMENTS)
  543. emphasized = 5;
  544. else
  545. emphasized = 0;
  546. structure |= IN_COMMENTS;
  547. for (j = 1, inword = wordcount = 0; (c = tag[j]) != ''; j++) {
  548. if (!inword) {
  549. if (iswordchar(c)) {
  550. i = 0;
  551. word[i++] = c;
  552. if (i == MAXWORDLEN)
  553. i--;
  554. inword = 1;
  555. }
  556. }
  557. else {
  558. if (!iswordchar(c)) {
  559. wordcount++;
  560. word[i] = '';
  561. for (i = 0; word[i]; i++)
  562. word[i] = tolower(word[i]);
  563. if (isokword(word))
  564. strcpy(word, (char *)
  565. convertentities(word));
  566. if (hasokchars(word) && isokword(word))
  567. {
  568. if (applyStemmingRules)
  569. {
  570. /* apply stemming algorithm to the word to index */
  571. Stem(word);
  572. }
  573. entrylist = (struct entry *)
  574. addentry(entrylist, word, filenum, emphasized, structure, metaName);
  575. }
  576. inword = 0;
  577. }
  578. else {
  579. word[i++] = c;
  580. if (i == MAXWORDLEN)
  581. i--;
  582. }
  583. }
  584. }
  586. return wordcount;
  587. }
  589. /* Removes words that occur in over _plimit_ percent of the files and
  590. ** that occur in over _flimit_ files (marks them as stopwords, that is).
  591. */
  593. int removestops(ep, totalfiles, plimit, flimit)
  594. struct entry *ep;
  595. int totalfiles;
  596. int plimit;
  597. int flimit;
  598. {
  599. int percent, wordfilecount, stopwords;
  600. struct location *lp;
  602. stopwords = 0;
  603. if (ep != NULL) {
  604. stopwords += removestops(ep->left, totalfiles, plimit, flimit);
  605. lp = ep->locationlist;
  606. wordfilecount = 0;
  607. while (lp != NULL) {
  608. wordfilecount++;
  609. lp = lp->next;
  610. }
  611. percent = (int) (((float) wordfilecount / (float) totalfiles) * 100.0f);
  612. if (percent >= plimit && wordfilecount >= flimit) {
  613. addStopList(ep->word);
  614. addstophash(ep->word);
  615. stopwords++;
  616. }
  617. stopwords += removestops(ep->right,totalfiles, plimit, flimit);
  618. }
  619. return stopwords;
  620. }
  622. /* This is somewhat similar to the rank calculation algorithm
  623. ** from WAIS (I think). Any suggestions for improvements?
  624. ** Note that ranks can't be smaller than 1, emphasized words
  625. ** (words in titles, headers) have ranks multiplied by at least 5
  626. ** (just a guess), and ranks divisible by 128 are bumped up by one
  627. ** (to make the compression scheme with with '' as a line delimiter
  628. ** work). Fudging with the ranks doesn't seem to make much difference.
  629. */
  631. int getrank(freq, tfreq, words, emphasized)
  632. int freq;
  633. int tfreq;
  634. int words;
  635. int emphasized;
  636. {
  637. double d, e, f;
  638. int tmprank;
  640. if (freq < 5)
  641. freq = 5;
  642. d = 1.0 / (double) tfreq;
  643. e = (log((double) freq) + 10.0) * d;
  644. if (!ignoreTotalWordCountWhenRanking)
  645. {
  646. e /= words;
  647. }
  648. else
  649. {
  650. /* scale the rank down a bit. a larger has the effect of
  651.    making small differences in work frequency wash out */ 
  652. e /= 100;
  653. }
  654. f = e * 10000.0;
  656. /*sprintf(rankstr, "%f", f);
  657. tmprank = atoi(rankstr);*/
  658. tmprank = (int) f;
  659. if (tmprank <= 0)
  660. tmprank = 1;
  661. if (emphasized)
  662. tmprank *= emphasized;
  663. if (!(tmprank % 128))
  664. tmprank++;
  666. return tmprank;
  667. }
  669. /* Prints the index information at the head of index files.
  670. */
  672. void printheader(fp, filename, totalwords, totalfiles, merged)
  673. FILE *fp;
  674. char *filename;
  675. int totalwords;
  676. int totalfiles;
  677. int merged;
  678. {
  679. char *c;
  681. c = (char *) strrchr(filename, '/');
  683. fprintf(fp, "%sn", INDEXHEADER);
  684. fprintf(fp, "%sn", INDEXVERSION);
  685. fprintf(fp, "# %sn", (merged) ? "MERGED INDEX" : "");
  686. fprintf(fp, "# Name: %sn", (indexn[0] == '') ? "(no name)" :
  687. indexn);
  688. fprintf(fp, "# Saved as: %sn", 
  689. (c == NULL && c + 1 != '') ? filename : c + 1);
  690. fprintf(fp, "# Counts: ");
  691. if (totalwords)
  692. fprintf(fp, "%d words%s", totalwords, (totalfiles) ? ", " : "");
  693. if (totalfiles)
  694. fprintf(fp, "%d files", totalfiles);
  695. fprintf(fp, "n");
  696. fprintf(fp, "# Indexed on: %sn", getthedate());
  697. fprintf(fp, "# Description: %sn", (indexd[0] == '') ?
  698. "(no description)" : indexd);
  699. fprintf(fp, "# Pointer: %sn", (indexp[0] == '') ?
  700. "(no pointer)" : indexp);
  701. fprintf(fp, "# Maintained by: %sn", (indexa[0] == '') ?
  702. "(no maintainer)" : indexa);
  703. #ifdef SUPPORT_DOC_PROPERTIES
  704. fprintf(fp, "# DocumentProperties: %sn", "Enabled");
  705. #endif
  706. fprintf(fp, "%s %dn", STEMMINGHEADER, applyStemmingRules);
  707. }
  709. char* getFileNameByFileNum(int filenum)
  710. {
  711. /* for diagnostics only */
  712. struct file *filep = filelist;
  713. while ((filep != NULL) && --filenum)
  714. {
  715. filep = filep->next;
  716. }
  718. if (filep != NULL)
  719. return filep->filename;
  720. else
  721. return "";
  722. }
  724. /* Print the index entries that hold the word, rank, and other information.
  725. */
  727. void printindex(ep, fp)
  728. struct entry *ep;
  729. FILE *fp;
  730. {
  731. int i, rank;
  732. struct location *lp;
  734. if (ep != NULL) {
  735. printindex(ep->left, fp);
  736. if (!isstopword(ep->word)) {
  738. for (i = 0; indexchars[i] != ''; i++)
  739. if ((ep->word)[0] == indexchars[i] &&
  740. !offsets[i])
  741. offsets[i] = ftell(fp);
  743. fprintf(fp, "%s:", ep->word);
  744. lp = ep->locationlist;
  745. while (lp != NULL) {
  746. int totalWords;
  747. totalWords = gettotalwords(lp->filenum);
  748. rank = getrank(lp->frequency, ep->tfrequency,
  749. totalWords, lp->emphasized);
  750. if (verbose == 4)
  751. {
  752. printf("%st%st%dt%dt%dt%dt%dt%dt%dn",
  753. getFileNameByFileNum(lp->filenum), 
  754. ep->word, 
  755. lp->emphasized, 
  756. rank, 
  757. lp->frequency, 
  758. ep->tfrequency, 
  759. totalWords,
  760. lp->structure,
  761. lp->metaName);
  762. }
  763. compress(lp->filenum, fp);
  764. compress(rank, fp);
  765. compress(lp->structure, fp);
  766. compress(lp->metaName, fp);
  767. lp = lp->next;
  768. }
  769. fputc(0, fp);
  771. }
  772. printindex(ep->right, fp);
  773. }
  774. }
  776. /* Prints the list of stopwords into the index file.
  777. */
  779. void printstopwords(fp)
  780. FILE *fp;
  781. {
  782. int hashval;
  783. struct swline *sp;
  785. offsets[STOPWORDPOS] = ftell(fp);
  786. for (hashval = 0; hashval < HASHSIZE; hashval++) {
  787. sp = hashstoplist[hashval];
  788. while (sp != NULL) {
  789. fprintf(fp, "%s ", sp->line);
  790. sp = sp->next;
  791. }
  792. }
  793. fprintf(fp, "n");
  794. }
  796. void writeFileEntry(filep, fp)
  797.      struct file *filep;
  798.      FILE *fp;
  799. {
  800. fprintf(fp, "%s "%s" %dn", 
  801. ruleparse(filep->filename),
  802. filep->title, filep->size);
  804. #ifdef SUPPORT_DOC_PROPERTIES
  805. storeDocProperties(filep->docProperties, fp);
  806. freeDocProperties(&filep->docProperties);
  807. #endif
  808. }
  810. void readFileEntry(fp, line, docProperties)
  811.      FILE* fp;
  812.      char* line;
  813.      struct docPropertyEntry **docProperties;
  814. {
  815. fgets(line, MAXSTRLEN, fp);
  817. if (docProperties != NULL)
  818. *docProperties = NULL;
  820. #ifdef SUPPORT_DOC_PROPERTIES
  821. /* read (or skip over) the document properties section  */
  822. fetchDocProperties(docProperties, fp);
  823. #endif
  824. }
  826. /* Prints the list of files, titles, and sizes into the index file.
  827. */
  829. void printfilelist(filep, fp)
  830. struct file *filep;
  831. FILE *fp;
  832. {
  833. int i;
  835. i = 0;
  836. offsets[FILELISTPOS] = ftell(fp);
  837. while (filep != NULL) 
  838. {
  839. int filenum = i++;
  840. addtofilehashlist(filenum, ftell(fp));
  842. writeFileEntry(filep, fp);
  844. filep = filep->next;
  845. }
  846. }
  848. /* Prints the list of metaNames into the file index
  849. */
  851. void printMetaNames(fp)
  852. FILE *fp;
  853. {
  854. struct metaEntry* entry;
  855. char docPropStyle[20];
  857. offsets[METANAMEPOS] = ftell(fp);
  858. for (entry = metaEntryList; entry; entry = entry->next)
  859.     {
  860. docPropStyle[0] = '';
  861. #ifdef SUPPORT_DOC_PROPERTIES
  862. if (entry->isDocProperty)
  863. {
  864. /* write the meta name style:
  865.  * <name>"0   -> normal meta name [default, so does not have to be written]
  866.  * <name>"1   -> doc property name
  867.  * <name>"2   -> both
  868.  */
  869. sprintf(docPropStyle, ""%d", (entry->isOnlyDocProperty) ? 1 : 2);
  870. }
  871. #endif
  873. fprintf(fp, "%s%s ", entry->metaName, docPropStyle);
  874.     }
  875. fprintf(fp, "n");
  876. }
  878. /* Prints the list of file offsets into the index file.
  879.  */
  881. void printfileoffsets(fp)
  882. FILE *fp;
  883. {
  884. int i;
  886. offsets[FILEOFFSETPOS] = ftell(fp);
  887. for (i = 0; getfilenum(i) != 0; i++)
  888. fprintf(fp, "%016li", getfilenum(i));
  889. fprintf(fp,"n");
  890. }
  892. /* Takes a number and prints it to a file using the simple
  893. ** accordion scheme of storing numbers.
  894. */
  896. void compress(num, fp)
  897. int num;
  898. FILE *fp;
  899. {
  900. int i, r;
  901. static char s[8];
  903. i = 0;
  904. while (num) {
  905. r = num % 128;
  906. num /= 128;
  907. s[i++] = r;
  908. }
  909. while (i-- >= 0)
  910. fputc(s[i] | (i ? 128 : 0), fp);
  911. }
  913. /* Prints out the decompressed values in an index file.*/
  915. void decompress(fp)
  916. FILE *fp;
  917. {
  918. int c, x, inword, fieldnum;
  919. long pos;
  920. char line[MAXSTRLEN], header[MAXHEADCHARS + 1];
  922. readoffsets(fp);
  924. if (verbose == 4)
  925. {
  926. readfileoffsets(fp);
  927. }
  929. fseek(fp, 0, 0);
  930. inword = 1;
  931. fieldnum = 0;
  933. while (1) {
  934. c = fgetc(fp);
  935. ungetc(c, fp);
  936. if (c == '#') {
  937. fgets(line, MAXSTRLEN, fp);
  938. printf("%s", line);
  939. continue;
  940. }
  941. else {
  942. fgets(header, MAXHEADCHARS + 1, fp);
  943. printf("%s", header);
  944. break;
  945. }
  946. }
  948. while ((c = fgetc(fp)) != EOF) 
  949. {
  950. if (c == ':' && inword) {
  951. inword = 0;
  952. putchar(c);
  953. }
  954. if (inword)
  955. putchar(c);
  956. else {
  957. x = 0;
  958. do {
  959. c = fgetc(fp);
  960. pos = ftell(fp);
  961. if (pos == offsets[STOPWORDPOS]) {
  962. putchar('n');
  963. while (fgets(line, MAXSTRLEN, fp) != NULL)
  964. {
  965. printf("%s", line);
  966. }
  967. return;
  968. }
  969. if (c == 0) {
  970. putchar('n');
  971. inword = 1;
  972. break;
  973. }
  974. x *= 128;
  975. x += c & 127;
  976. } while (c & 128);
  977. if (x)
  978. {
  979. if (verbose == 4)
  980.   {
  981.     if (fieldnum == 0)
  982.       {
  983. char* filename;
  984. char* junk;
  986. pos = ftell(fp);
  987. filename = lookupfile(x, fp, NULL);
  988. junk = strchr(filename, '"');
  989. *(junk-1) = '';
  990. printf(" %s", filename);
  991. fseek(fp, pos, 0);
  992.       }
  993.     else if (fieldnum == 1)
  994.       {
  996. printf(" %d", x);
  997.       }
  998.     else if (fieldnum == 2)
  999.       {
  1000.       }
  1001.     else if (fieldnum == 3)
  1002.       {
  1003.       }
  1004.   }
  1005. else
  1006.   {
  1007. printf(" %d", x);
  1008.   }
  1010. fieldnum++;
  1011. if (fieldnum == 4)
  1012.   fieldnum = 0;
  1013. }
  1014. }
  1015. }
  1016. }
  1018. /* Parses lines according to the ReplaceRules directives.
  1019. */
  1021. char *ruleparse(line)
  1022. char *line;
  1023. {
  1024. char rule[MAXSTRLEN];
  1025. static char tmpline[MAXSTRLEN], newtmpline[MAXSTRLEN];
  1026. static char line1[MAXSTRLEN], line2[MAXSTRLEN];
  1027. struct swline *tmplist;
  1029. if (replacelist == NULL)
  1030. return line;
  1032. tmplist = replacelist;
  1033. strcpy(tmpline, line);
  1034. while (1) 
  1035. {
  1036. if (tmplist == NULL)
  1037. return tmpline;
  1038. strcpy(rule, tmplist->line);
  1039. tmplist = tmplist->next;
  1040. if (tmplist == NULL)
  1041. return tmpline;
  1042. if (rule == NULL) {
  1043. replacelist = tmplist;
  1044. return tmpline;
  1045. }
  1046. else {
  1047. if (lstrstr(rule, "replace")) {
  1048. strcpy(line1, tmplist->line);
  1049. tmplist = tmplist->next;
  1050. if (tmplist)
  1051. {
  1052. strcpy(line2, tmplist->line);
  1053. tmplist = tmplist->next;
  1054. }
  1055. else
  1056. {
  1057. /* Handle case where 2nd part of replace rule
  1058. ** is an empty string. Config-file parsing
  1059. ** idiosyncrasies cause a replace of "x" to ""
  1060. ** to incompletely represent the rule.
  1061. */
  1062. line2[0] = '';
  1063. }
  1064. strcpy(newtmpline, (char *) matchAndChange(tmpline,
  1065. line1, line2));
  1066. }
  1067. else if (lstrstr(rule, "append")) {
  1068. sprintf(newtmpline, "%s%s", tmpline,
  1069. tmplist->line);
  1070. tmplist = tmplist->next;
  1071. }
  1072. else if (lstrstr(rule, "prepend")) {
  1073. sprintf(newtmpline, "%s%s", tmplist->line,
  1074. tmpline);
  1075. tmplist = tmplist->next;
  1076. }
  1077. else if (lstrstr(rule,"remove")) {
  1078. strcpy(newtmpline, (char *)matchAndChange(tmpline,tmplist->line,""));
  1079. }
  1080. strcpy(tmpline, newtmpline);
  1081. }
  1082. }
  1083. }
  1087. /* Get the MetaData index when the whole tag is passed */
  1089. int getMeta(tag, docPropName)
  1090. char* tag;
  1091. int* docPropName;
  1092. {
  1093. char* temp;
  1094. char word[MAXWORDLEN];
  1095. int i;
  1096. struct metaEntry* list;
  1098. if (docPropName != NULL)
  1099. {
  1100. *docPropName = 0;
  1101. }
  1103. i = 0;
  1104. temp = (char*) lstrstr((char*)tag,(char*) "NAME");
  1105. if (temp == NULL)
  1106. return 1;
  1108. temp += strlen("NAME");
  1110. /* Get to the '=' sign disreguarding blanks */
  1111. while (temp != NULL) {
  1112. if (strncmp(temp, "=",1))
  1113. temp++;
  1114. else {
  1115. temp++;
  1116. break;
  1117. }
  1118. }
  1120. /* Get to the beginning of the word disreguarding blanks and quotes */
  1121. while (temp != NULL) {
  1122. if (!strncmp(temp," ",1) || !strncmp(temp,""",1) )
  1123. temp++;
  1124. else
  1125. break;
  1126. }
  1128. /* Copy the word and convert to lowercase */
  1129. while (temp !=NULL && strncmp(temp," ",1) 
  1130. && strncmp(temp,""",1) && i<= MAXWORDLEN ) {
  1131. word[i] = *temp++;
  1132. word[i] = tolower(word[i]);
  1133. i++;
  1134. }
  1136. if (i == MAXWORDLEN)
  1137. word[--i] = '';
  1138. else
  1139. word[i] = '';
  1141. for (list = metaEntryList; list != NULL; list = list->next)
  1142. {
  1143. if (!strcmp(list->metaName, word) )
  1144. {
  1145. #ifdef SUPPORT_DOC_PROPERTIES
  1146. if ((docPropName != NULL) && (list->isDocProperty))
  1147. {
  1148. *docPropName = list->index;
  1149. }
  1150. if (list->isOnlyDocProperty)
  1151. {
  1152. /* property is not for indexing, so return generic metaName value */
  1153. return 1;
  1154. }
  1155. #endif
  1156. return list->index;
  1157. }
  1158. }
  1160. /* If it is ok not to have the name listed, just index as no-name */
  1161. if (OKNOMETA) {
  1162. /*    printf ("nwarning: metaName %s does not exiest in the user config file", word); */
  1163. return 1;
  1164. }
  1165. else {
  1166. printf ("nerr: INDEXING FAILUREn");
  1167. printf ("err: The metaName %s does not exist in the user config filen", word);
  1168. exit(0);
  1169. }
  1171. }
  1173. /* Parses the Meta tag */
  1174. int parseMetaData(tag, filenum, structure, thisFileEntry)
  1175. char* tag;
  1176. int filenum;
  1177. int structure;
  1178. struct file* thisFileEntry;
  1179. {
  1180. int metaName, j, i, inword, wordcount, emphasized, jstart;
  1181. char* temp;
  1182. char c, word[MAXWORDLEN];
  1183. int docPropName = 0;
  1185. wordcount = 0;
  1186. temp = NULL;
  1187. metaName= getMeta(tag, &docPropName);
  1188. temp = (char*) lstrstr((char*) tag,(char*) "CONTENT");
  1190. /* if there is no  CONTENT is another tag so just ignore the whole thing
  1191. * the check is done here istead of before because META tags do not have
  1192. * a fixed length that can be checked
  1193. */
  1194. if (temp != NULL)
  1195.     {
  1196. temp += strlen("CONTENT");
  1198. /* Get to the " sign disreguarding blanks */
  1199. while (temp != NULL) {
  1200. if (strncmp(temp, """,1))
  1201. temp++;
  1202. else {
  1203. temp++;
  1204. break;
  1205. }
  1206. }
  1208. jstart = strlen(tag) - strlen(temp);
  1210. if (EMPHASIZECOMMENTS)
  1211. emphasized = 5;
  1212. else
  1213. emphasized = 0;
  1215. #ifdef SUPPORT_DOC_PROPERTIES
  1216. if (docPropName)
  1217. {
  1218. temp = strchr(tag + jstart, '"'); /* first quote after start of CONTENT */
  1219. if (temp != NULL)
  1220. {
  1221. *temp = ''; /* terminate CONTENT, temporarily */
  1222. addDocProperty(&thisFileEntry->docProperties, docPropName, tag+jstart);
  1223. *temp = '"'; /* restore string */
  1224. }
  1225. }
  1226. #endif
  1228. for (j = jstart, inword = wordcount = 0;(c = tag[j]) != ''; j++) {
  1229. if (!inword) {
  1230. if (iswordchar(c)) {
  1231. i = 0;
  1232. word[i++] = c;
  1233. if (i == MAXWORDLEN)
  1234. i--;
  1235. inword = 1;
  1236. }
  1237. }
  1238. else {
  1239. if (!iswordchar(c)) {
  1240. wordcount++;
  1241. word[i] = '';
  1242. for (i = 0; word[i]; i++)
  1243. word[i] = tolower(word[i]);
  1244. if (isokword(word))
  1245. strcpy(word, (char *)
  1246. convertentities(word));
  1247. /* Get rid of the last specified char's */
  1248. stripIgnoreLastChars(word);
  1250. /* Get rid of the first char */
  1251. stripIgnoreFirstChars(word);
  1253. if (applyStemmingRules)
  1254. {
  1255. /* apply stemming algorithm to the word to index */
  1256. Stem(word);
  1257. }
  1259. if (hasokchars(word) && isokword(word))
  1260. entrylist = (struct entry *)
  1261. addentry(entrylist, word,
  1262. filenum, emphasized, 
  1263. structure, metaName);
  1264. inword = 0;
  1265. if (c == '"' && tag[j-1] != '\')
  1266. break;
  1267. }
  1268. else {
  1269. word[i++] = c;
  1270. if (i == MAXWORDLEN)
  1271. i--;
  1272. }
  1273. }
  1274. }
  1275.     }
  1276. return wordcount;
  1277. }
  1279. /*  These 2 routines fix the problem when a word ends with mutiple
  1280. **  IGNORELASTCHAR's (eg, qwerty'. ).  The old code correctly deleted
  1281. **  the ".", but didn't check if the new last character ("'") is also
  1282. **  an ignore character.
  1283. */
  1285. void stripIgnoreLastChars(char *word)
  1286. {
  1287. int i;
  1289. /* Get rid of specified last char's */
  1290. for (i=0; word[i] != ''; i++)
  1291. ;
  1292. /* Iteratively strip off the last character if it's an ignore character */
  1293. while ( isIgnoreLastChar(word[--i]) )
  1294. word[i] = '';
  1295. }
  1297. int isIgnoreLastChar(char c)
  1299. {
  1300. int i;
  1302. /*  Returns TRUE if the character is a member of ignorelastchar,
  1303. **  FALSE otherwise.
  1304. */
  1305. for (i=0; ignorelastchar[i] != ''; i++)
  1306. {
  1307. if (c == ignorelastchar[i])
  1308. return 1;
  1309. }
  1312. return 0;
  1313. }
  1315. void stripIgnoreFirstChars(char *word)
  1316. {
  1317. int j, k;
  1318. int i = 0;
  1320. /* Keep going until a char not to ignore is found */
  1321. while ( isIgnoreFirstChar(word[i]) )
  1322. i++;
  1324. /* If all the char's are valid, just return */
  1325. if (0 == i)
  1326. return;
  1327. else
  1328.     {
  1329. for ( k=i, j=0; word[k] != ''; j++,k++)
  1330. {
  1331. word[j] = word[k];
  1332. }
  1333. /* Add the NULL */
  1334. word[j] = '';
  1335.     }
  1336. }
  1338. int isIgnoreFirstChar(char c)
  1339. {
  1340. int i;
  1342. for (i=0; ignorefirstchar[i] != ''; i++)
  1343. if (c == ignorefirstchar[i])
  1344. return 1;
  1346. return 0;
  1347. }
  1349. int notEscaped( char *tag, int j)
  1350. {
  1351. if ( j > 1)
  1352.     { 
  1353. if ( tag[j - 2] !=  '\')
  1354. { return 1;}
  1355. else
  1356. { return 0; }
  1357.     }
  1358. else
  1359.     { return 1; }
  1360. }