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

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

搜索引擎

开发平台：

Perl

string.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. ** along 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. ** Added MatchAndChange for regex in replace rule G.Hill 2/10/98
  21. */
  23. #include "swish.h"
  24. #include "string.h"
  25. #include "mem.h"
  27. /* My own case-insensitive strstr().
  28. */
  30. char *lstrstr(s, t)
  31. char *s;
  32. char *t;
  33. {
  34. int i, j, k, l;
  36. for (i = 0; s[i]; i++) {
  37. for (j = 0, l = k = i; s[k] && t[j] &&
  38. tolower(s[k]) == tolower(t[j]); j++, k++)
  39. ;
  40. if (t[j] == '')
  41. return s + l;
  42. }
  43. return NULL;
  44. }
  46. /* Another case insensitive comparison by M.Gaulin*/
  47. int ourstricmp(const char* s1, const char* s2)
  48. {
  49.         while (*s1 && *s2)
  50.   {
  51.                 char c1 = *s1++;
  52.                 char c2 = *s2++;
  53.                 int diff = (tolower(c1) - tolower(c2));
  54.                 if (diff)
  55.                         return diff;
  56.       }
  57.         return (*s1 - *s2);
  58.       }
  60. /* Gets the next word in a line. If the word's in quotes,
  61. ** include blank spaces in the word or phrase.
  62. */
  64. char *getword(line, skiplen)
  65. char *line;
  66. int *skiplen;
  67. {
  68. int i, inquotes;
  69. char *start;
  70. static char word[MAXSTRLEN];
  72. start = line;
  73. if (!(*line))
  74. return "";
  75. while (isspace(*line))
  76. line++;
  77. if (!(*line))
  78. return "";
  79. if (*line == '"') {
  80. inquotes = 1;
  81. line++;
  82. }
  83. else
  84. inquotes = 0;
  85. for (i = 0; *line && i < MAXSTRLEN &&
  86.         ((inquotes) ? (*line != '"') : (!isspace(*line))); line++)
  87. word[i++] = *line;
  88. word[i] = '';
  89. if (!(*line))
  90. return "";
  91. if (*line == '"')
  92. line++;
  94. *skiplen = line - start;
  96. return word;
  97. }
  99. /* Gets the value of a variable in a line of the configuration file.
  100. ** Basically, anything in quotes or an argument to a variable.
  101. */
  103. char *getconfvalue(line, var, value)
  104. char *line;
  105. char *var;
  106. char *value;
  107. {
  108. int i;
  109. char *c;
  110. static char tmpvalue[MAXSTRLEN];
  112. if ((c = (char *) lstrstr(line, var)) != NULL) {
  113. if (c != line)
  114. return NULL;
  115. c += strlen(var);
  116. while (isspace(*c) || *c == '"')
  117. c++;
  118. if (*c == '')
  119. return NULL;
  120. for (i = 0; *c != '' && *c != '"' && *c != 'n' &&
  121. i < MAXSTRLEN; c++)
  122. tmpvalue[i++] = *c;
  123. tmpvalue[i] = '';
  124. strcpy(value, tmpvalue);
  125. return tmpvalue;
  126. }
  127. else
  128. return NULL;
  129. }
  131. /* Extracts anything in <title> tags from an HTML file and returns it.
  132. ** Otherwise, only the file name without its path is returned.
  133. */
  135. char *parsetitle(filename, alttitle)
  136. char *filename;
  137. char *alttitle;
  138. {
  139. register int c, d;
  140. register char *p;
  141. char *tag;
  142. static char title[MAXTITLELEN], shorttitle[MAXTITLELEN];
  143. int i, j, lines, status, tagbuflen, totaltaglen;
  144. FILE *fp;
  146. tag = (char *) emalloc(1);
  147. tag[0] = '';
  148. lines = status = 0;
  149. p = title;
  150. *p = '';
  152. if (strrchr(alttitle, '/'))
  153. strcpy(shorttitle, strrchr(alttitle, '/') + 1);
  154. else
  155. strcpy(shorttitle, alttitle);
  157. fp = fopen(filename, "r");
  158. if (fp == NULL) {
  159. free(tag);
  160. return shorttitle;
  161. }
  162. for (; lines < TITLETOPLINES ; ) {
  163. c = getc(fp);
  164. if (c == 'n')
  165. lines++;
  166. if (feof(fp)) {
  167. fclose(fp);
  168. free(tag);
  169. return shorttitle;
  170. }
  171. switch(c) {
  172. case '<':
  174. free(tag);
  175. tag = (char *) emalloc(MAXSTRLEN);
  176. tag[0] = '';
  177. tagbuflen = totaltaglen = 0;
  179. tag[totaltaglen++] = '<';
  180. tagbuflen++;
  181. status = TI_OPEN;
  183. while (1) {
  184. d = getc(fp);
  185. if (d == EOF) {
  186. fclose(fp);
  187. free(tag);
  188. return shorttitle;
  189. }
  190. else if (d == '>') {
  191. tag[totaltaglen] = '';
  192. tag = (char *) erealloc(tag,
  193. totaltaglen + MAXSTRLEN);
  194. sprintf(tag, "%s%c", tag, '>');
  195. break;
  196. }
  198. tag[totaltaglen++] = d;
  199. tagbuflen++;
  200. if (tagbuflen >= MAXSTRLEN) {
  201. tag = (char *) erealloc(tag,
  202. totaltaglen + MAXSTRLEN);
  203. tagbuflen = 0;
  204. }
  205. }
  207. if (lstrstr(tag, "</title>")) {
  208. status = TI_CLOSE;
  209. *p = '';
  210. fclose(fp);
  211. for (i = 0; title[i]; i++)
  212. if (title[i] == 'n')
  213. title[i] = ' ';
  214. for (i = 0; isspace(title[i]) ||
  215. title[i] == '"'; i++)
  216. ;
  217. for (j = 0; title[i]; j++)
  218. title[j] = title[i++];
  219. title[j] = '';
  220. for (j = strlen(title) - 1;
  221. (j && isspace(title[j]))
  222. || title[j] == '' || title[j] == '"'; j--)
  223. title[j] = '';
  224. for (j = 0; title[j]; j++)
  225. if (title[j] == '"')
  226. title[j] = ''';
  227. free(tag);
  228. return *title ? title : shorttitle;
  229. }
  230. else {
  231. if (lstrstr(tag, "<title>"))
  232. status = TI_FOUND;
  233. }
  234. break;
  235. default:
  236. if (status == TI_FOUND) {
  237. *p = c;
  238. p++;
  239. }
  240. else {
  241. if (status == TI_CLOSE) {
  242. fclose(fp);
  243. free(tag);
  244. return shorttitle;
  245. }
  246. }
  247. }
  248. }
  249. fclose(fp);
  250. free(tag);
  251. return shorttitle;
  252. }
  254. /* Malloc()'s a string, returns it.
  255. */
  257. char *mystrdup(s)
  258.      char *s;
  259. {
  260. char *p;
  262. p = (char *) emalloc(strlen(s) + 1);
  263. strcpy(p, s);
  264. return p;
  265. }
  267. /* Is a character a valid word character?
  268. */
  270. int iswordchar(char c)
  272. {
  273. int d, i;
  275. d = tolower(c);
  276. for (i = 0; wordchars[i] != ''; i++)
  277. {
  278. if ((char)d == wordchars[i])
  279. return 1;
  280. }
  281. return 0;
  282. }
  284. /* In a string, replaces all occurrences of "oldpiece" with "newpiece".
  285. ** This is not really bulletproof yet.
  286. */
  288. char *replace(string, oldpiece, newpiece)
  289.      char *string;
  290.      char *oldpiece;
  291.      char *newpiece;
  292. {
  293. int i, j, limit;
  294. char *c;
  295. char beforestring[MAXSTRLEN], afterstring[MAXSTRLEN];
  296. static char newstring[MAXSTRLEN];
  298. if ((c = (char *) strstr(string, oldpiece)) == NULL)
  299. return string;
  300. limit = c - string;
  302. for (i = 0; i < limit; i++)
  303. beforestring[i] = string[i];
  304. beforestring[i] = '';
  306. i += strlen(oldpiece);
  308. for (j = 0; string[i] != ''; i++)
  309. afterstring[j++] = string[i];
  310. afterstring[j] = '';
  312. sprintf(newstring, "%s%s%s", beforestring, newpiece, afterstring);
  314. while (strstr(newstring, oldpiece))
  315. strcpy(newstring, replace(newstring, oldpiece, newpiece));
  317. return newstring;
  318. }
  320. /* Just for A.P. and K.H. 2/5/98 by G.Hill - not really used now */
  321. char* replaceWild (char* fileName, char* pattern, char* subs)
  322. {
  323. int i;
  324. for (i = 0; pattern[i] != '*' && fileName[i] != ''; i++) 
  325.     {
  326. if (fileName[i] != pattern[i])
  327. return fileName;
  328.     }
  329. return subs;
  330. }
  332. /* Like strcmp(), but the order of sorting the first char is
  333. ** determined by the order of the characters in the wordchars array.
  334. */
  336. int wordcompare(s1, s2)
  337.      char *s1;
  338.      char *s2;
  339. {
  340. register int i, j;
  342. if (s1[0] != s2[0]) {
  343. for (i = 0; wordchars[i] != ''; i++)
  344. if (s1[0] == wordchars[i])
  345. break;
  346. for (j = 0; wordchars[j] != ''; j++)
  347. {
  348. if (s2[0] == wordchars[j])
  349. break;
  350. }
  351. if (i < j)
  352. return -1;
  353. else
  354. return 1;
  355. }
  356. else
  357. return strcmp(s1, s2);
  358. }
  360. /* This converts HTML numbered entities (such as &#169;)
  361. ** to strings (like &copy;). Much is this function is
  362. ** simply adding semicolons in the right places.
  363. ** This and the functions it calls are not very fast
  364. ** and could be made faster.
  365. */
  367. char *convertentities(s)
  368. char *s;
  369. {
  370. int i, skip;
  371. char ent[MAXENTLEN];
  372. static char newword[MAXWORDLEN];
  374. if ((char *) strchr(s, '&') == NULL)
  375. return s;
  376. if (strlen(s) > maxwordlimit)
  377. return s;
  379. for (i = 0; i < MAXWORDLEN; i++)
  380. newword[i] = '';
  381. for (; *s != ''; s++) {
  382. if (*s == '&') {
  383. strcpy(ent, getent(s, &skip));
  384. if (ent[0] == '') {
  385. sprintf(newword, "%s&", newword);
  386. continue;
  387. }
  388. s += skip;
  389. if (*s == ';')
  390. s++;
  391. sprintf(newword, "%s%s;", newword, ent);
  392. s--;
  393. }
  394. else
  395. sprintf(newword, "%s%c", newword, *s);
  396. }
  398. strcpy(newword, (char *) converttonamed(newword));
  399. if (ASCIIENTITIES)
  400. strcpy(newword, (char *) converttoascii(newword));
  402. return newword;
  403. }
  405. /* Returns a matching entity that matches the beginning of a string, if any.
  406. */
  408. char *getent(s, skip)
  409. char *s;
  410. int *skip;
  411. {
  412. int i;
  413. static char ent[MAXENTLEN], testent[MAXENTLEN];
  415. *skip = 0;
  416. strncpy(ent, s, MAXENTLEN);
  417. if (ent[1] == '#') {
  418. if (isdigit(ent[5]))
  419. return "";
  420. for (i = 2; ent[i] != '' && isdigit(ent[i]); i++)
  421. ;
  422. while (ent[i] != '' && !isdigit(ent[i]))
  423. ent[i++] = '';
  424. *skip = strlen(ent);
  425. return ent;
  426. }
  427. else {
  428. for (i = 0; entities[i] != NULL; i += 3) {
  429. strcpy(testent, entities[i]);
  430. if (testent[0] != '') {
  431. if (!strncmp(testent, ent, strlen(testent))) {
  432. strcpy(ent, testent);
  433. *skip = strlen(ent);
  434. return ent;
  435. }
  436. }
  437. }
  438. }
  440. return "";
  441. }
  443. /* This is the real function called by convertentities() that
  444. ** changes numbered to named entities.
  445. */
  447. char *converttonamed(s)
  448. char *s;
  449. {
  450. int i;
  451. char testent[MAXENTLEN], newent[MAXENTLEN];
  452. static char newword[MAXWORDLEN];
  454. strcpy(newword, s);
  455. for (i = 0; entities[i] != NULL; i += 3) {
  456. sprintf(testent, "%s;", entities[i + 1]);
  457. if (strstr(newword, testent) != NULL &&
  458. (entities[i])[0] != '') {
  459. sprintf(newent, "%s;", entities[i]);
  460. strcpy(newword, (char *) replace(newword,
  461. testent, newent));
  462. }
  463. }
  465. while (hasnumbered(newword))
  466. strcpy(newword, (char *) converttonamed(newword));
  468. return newword;
  469. }
  471. /* Does a string still contain numbered entities that can be converted?
  472. */
  474. int hasnumbered(s)
  475. char *s;
  476. {
  477. int i;
  478. char testent[MAXENTLEN];
  480. for (i = 0; entities[i] != NULL; i += 3) {
  481. sprintf(testent, "%s;", entities[i + 1]);
  482. if (strstr(s, testent) != NULL && (entities[i])[0] != '')
  483. return 1;
  484. }
  485. return 0;
  486. }
  488. /* This function converts all convertable named and numbered
  489. ** entities to their ASCII equivalents, if they exist.
  490. */
  492. char *converttoascii(s)
  493. char *s;
  494. {
  495. int i;
  496. char *c, *d, wrdent[MAXENTLEN], nument[MAXENTLEN];
  497. static char newword[MAXWORDLEN];
  499. strcpy(newword, s);
  500. for (i = 0; entities[i] != NULL; i += 3) {
  502. sprintf(wrdent, "%s;", entities[i]);
  503. sprintf(nument, "%s;", entities[i + 1]);
  505. c = d = NULL;
  506. if ((entities[i])[0] != '')
  507. c = (char *) strstr(newword, wrdent);
  508. if ((entities[i + 1])[0] != '')
  509. d = (char *) strstr(newword, nument);
  510. if ((entities[i + 2])[0] != '') {
  511. if (c != NULL)
  512. strcpy(newword, (char *) replace(newword,
  513. wrdent, entities[i + 2]));
  514. if (d != NULL)
  515. strcpy(newword, (char *) replace(newword,
  516. nument, entities[i + 2]));
  517. }
  518. }
  520. while (hasnonascii(newword))
  521. strcpy(newword, (char *) converttoascii(newword));
  523. return newword;
  524. }
  526. /* Does a string still contain numbered or named entities that can
  527. ** be converted to ascii equivalents?
  528. */
  530. int hasnonascii(s)
  531. char *s;
  532. {
  533. int i;
  534. char *c, *d, wrdent[MAXENTLEN], nument[MAXENTLEN];
  536. for (i = 0; entities[i] != NULL; i += 3) {
  538. sprintf(wrdent, "%s;", entities[i]);
  539. sprintf(nument, "%s;", entities[i + 1]);
  541. c = d = NULL;
  542. if ((entities[i])[0] != '')
  543. c = (char *) strstr(s, wrdent);
  544. if ((entities[i + 1])[0] != '')
  545. d = (char *) strstr(s, nument);
  546. if ((entities[i + 2])[0] != '')
  547. if (c != NULL || d != NULL)
  548. return 1;
  549. }
  551. return 0;
  552. }
  554. /* That regular expression matching and replacing thing */
  555. char * matchAndChange (char *str, char *pattern, char *subs) 
  556. {
  557. int  status, lenSub, lenBeg, lenTmp;
  558. regex_t re;
  559. regmatch_t pmatch[MAXPAR];
  560. char *tmpstr;
  561. char begin[MAXSTRLEN],newstr[MAXSTRLEN];
  562. static char oldStr[MAXSTRLEN];
  564. /* Save the old string just in case */
  565. strcpy(oldStr,str);
  567. status = regcomp(&re, pattern, REG_EXTENDED);
  568. if ( status != 0) {
  569. return oldStr;
  570. }
  572. status = regexec(&re,str,(size_t)MAXPAR,pmatch,0);
  573. if (status != 0)
  574. return oldStr;
  576. tmpstr = str;
  577. while (!status) {
  579. /* Stuff the new piece were needed */
  580. strncpy(begin,tmpstr,pmatch[0].rm_so); /* get the beginning */
  581. begin[pmatch[0].rm_so] = '';  /* Null terminate */
  583. lenTmp = strlen(tmpstr);
  584. lenSub = strlen(subs);
  585. lenBeg = strlen(begin);
  586. if ( (lenTmp + lenSub + lenBeg) >= MAXSTRLEN)
  587. return oldStr;
  589. sprintf (newstr, "%s%s%s", begin,subs,&(tmpstr[pmatch[0].rm_eo]));
  590. /* Copy the newstr into the tmpstr */
  591. strcpy(tmpstr,newstr);
  592. /* Position the pointer to the end of the subs string */
  593. tmpstr = &(tmpstr[pmatch[0].rm_so+lenSub]);
  594. status = regexec(&re,tmpstr,(size_t)5,pmatch,0);
  595. }
  596. regfree(&re);
  597. return str;
  598. }
  599. /*---------------------------------------------------------*/
  600. /* Match a regex and a string */
  602. int matchARegex( char *str, char *pattern) 
  603. {
  604. int  status;
  605. regex_t re;
  607. status = regcomp(&re, pattern, REG_EXTENDED);
  608. if ( status != 0)
  609. return 0;
  611. status = regexec(&re,str,(size_t)0,NULL,0);
  612. if (status != 0)
  613. return 0;
  615. return 1;
  616. }
  617. /*-----------------------------------------------------*/
  618. void makeItLow (char *str)
  619. {
  620.   int i;
  621.   int len = strlen(str);
  622.   for (i = 0; i < len; i++)
  623.     str[i] = tolower(str[i]);
  624. }
  625. /*----------------------------------------------------*/
  627. /* Check if a file with a particular suffix should be indexed
  628. ** according to the settings in the configuration file.
  629. */
  631. int isoksuffix(filename, rulelist)
  632. char *filename;
  633. struct swline *rulelist;
  634. {
  635. int badfile;
  636. char *c, suffix[MAXSUFFIXLEN], checksuffix[MAXSUFFIXLEN];
  637. struct swline *tmplist;
  639. tmplist = rulelist;
  640. if (tmplist == NULL)
  641. return 1;
  642. if ((c = (char *) strrchr(filename, '.')) == NULL)
  643. return 0;
  645. if (strlen(c+1) >= MAXSUFFIXLEN)
  646.   return 0;
  648. badfile = 1;
  649. strcpy(checksuffix, c + 1);
  650. while (tmplist != NULL) {
  651. if ((c = (char *) strrchr(tmplist->line, '.')) == NULL)
  652. strcpy(suffix, tmplist->line);
  653. else
  654. strcpy(suffix, c + 1);
  655. if (lstrstr(suffix, checksuffix) && strlen(suffix) ==
  656. strlen(checksuffix))
  657. badfile = 0;
  658. tmplist = tmplist->next;
  659. }
  660. return !(badfile);
  661. }