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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
sqispell.c
资源名称：sqwebmail-0.37a.38pre2.tar.gz　[点击查看]
上传用户：s81996212
上传日期：2007-01-04
资源大小：722k
文件大小：14k
源码类别：

WEB邮件程序

开发平台：

C/C++

sqispell.c：源码内容
  1. /*
  2. ** Copyright 1998 - 1999 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  7. /*
  8. ** $Id: sqispell.c,v 1.13 2000/03/14 18:58:35 mrsam Exp $
  9. */
  10. #include "sqwebmail.h"
  11. #include "maildir.h"
  12. #include "folder.h"
  13. #include "cgi/cgi.h"
  14. #include "rfc2045/rfc2045.h"
  15. #include "maildir/maildirmisc.h"
  16. #include "buf.h"
  17. #include "ispell.h"
  18. #include "filter.h"
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <fcntl.h>
  22. #include <ctype.h>
  24. extern void output_form(const char *);
  25. extern char form_args[];
  26. extern const char *sqwebmail_content_ispelldict;
  27. extern void output_attrencoded(const char *);
  28. extern char *newmsg_createdraft_do(const char *, const char *, int);
  30. static void spelladd(const char *);
  31. static int search_spell(const char *, unsigned, unsigned);
  33. int spell_start(const char *c)
  34. {
  35. char *filename=maildir_find(DRAFTS, c);
  37. if (!c) return (-1);
  39. if (search_spell(filename, 0, 0) == 0)
  40. return (-1);
  42. return (0);
  43. }
  45. /*
  46. ** Search for misspelled words.
  47. */
  49. static struct rfc2045 *findtext(struct rfc2045 *);
  51. static char *spell_check(const char *, unsigned, unsigned,
  52. const char *, const char *, const char *, int *);
  54. static int search_spell(const char *filename, unsigned parnum, unsigned pos)
  55. {
  56. struct rfc2045 *rfcp, *textp;
  57. struct buf newtext, current_line;
  58. off_t start_pos, end_pos, start_body;
  59. int made_replacements, has_misspelling;
  60. char *new_line;
  61. unsigned paragraph;
  62. const char *ignoreword="";
  63. const char *replacefrom="";
  64. const char *replaceto="";
  65. int checked=0;
  66. off_t dummy;
  67. FILE *fp=0;
  68. int x;
  70. x=maildir_safeopen(filename, O_RDONLY, 0);
  71. if (x >= 0)
  72. if ((fp=fdopen(x, "r")) == 0)
  73. close(x);
  75. if (!fp) return (0);
  76. rfcp=rfc2045_fromfp(fp);
  77. if (!rfcp) enomem();
  79. textp=findtext(rfcp);
  81. if (!textp)
  82. {
  83. rfc2045_free(rfcp);
  84. fclose(fp);
  85. return (0);
  86. }
  88. buf_init(&newtext);
  89. buf_init(&current_line);
  91.         rfc2045_mimepos(textp, &start_pos, &end_pos, &start_body,
  92. &dummy, &dummy);
  93.         if (fseek(fp, start_body, SEEK_SET) == -1)
  94.                 enomem();
  96. made_replacements=0;
  97. has_misspelling=0;
  98. paragraph=0;
  99.         for ( ; start_body < end_pos; start_body++)
  100. {
  101. int c=getc(fp);
  103. if (c < 0) enomem();
  104. if (c != 'n')
  105. {
  106. buf_append(&current_line, c);
  107. continue;
  108. }
  109. buf_append(&current_line, '');
  110. if (parnum)
  111. {
  112. --parnum;
  113. buf_cat(&newtext, current_line.ptr);
  114. buf_cat(&newtext, "n");
  115. current_line.cnt=0;
  116. ++paragraph;
  117. continue;
  118. }
  120. if (!checked)
  121. {
  122. int l;
  124. checked=1;
  125. if ((l=strlen(cgi("word"))) > 0)
  126. {
  128. /* Ok, what should we do? */
  130. const char *newword=cgi("REPLACE");
  132. if (!*newword || strcmp(newword, "#other") == 0)
  133. newword=cgi("OTHER");
  134. /*
  135. ** Perhaps they entered the word without
  136. ** checking this checkmark.
  137. */
  138. else if (*newword == '#')
  139. newword="";
  141. if (*newword && pos + l <= strlen(current_line.ptr))
  142. {
  143. struct buf tempbuf;
  145. buf_init(&tempbuf);
  146. buf_cpyn(&tempbuf, current_line.ptr,
  147. pos);
  148. buf_cat(&tempbuf, newword);
  149. buf_cat(&tempbuf,
  150. current_line.ptr+pos+l);
  151. pos += strlen(newword);
  152. if (*cgi("REPLACEALL"))
  153. {
  154. replacefrom=cgi("word");
  155. replaceto=newword;
  156. }
  157. buf_append(&tempbuf, '');
  158. buf_cpy(&current_line, tempbuf.ptr);
  159. buf_append(&current_line, '');
  160. buf_free(&tempbuf);
  161. made_replacements=1;
  162. }
  163. else
  164. {
  165. pos += l;
  166. if (strcmp(cgi("REPLACE"),
  167. "#ignoreall") == 0)
  168. ignoreword=cgi("word");
  169. }
  171. if (strcmp(cgi("REPLACE"),
  172. "#insert") == 0)
  173. {
  174. spelladd(cgi("word"));
  175. }
  176. }
  177. }
  180. if (*current_line.ptr == '>')
  181. {
  182. buf_cat(&newtext, current_line.ptr);
  183. buf_cat(&newtext, "n");
  184. pos=0;
  185. current_line.cnt=0;
  186. ++paragraph;
  187. continue;
  188. }
  189. if (!has_misspelling)
  190. {
  191. new_line=spell_check(current_line.ptr, paragraph, pos,
  192. ignoreword, replacefrom, replaceto,
  193. &has_misspelling);
  194. if (new_line)
  195. {
  196. buf_cat(&newtext, new_line);
  197. free(new_line);
  198. made_replacements=1;
  199. }
  200. else buf_cat(&newtext, current_line.ptr);
  201. }
  202. else buf_cat(&newtext, current_line.ptr);
  203. buf_cat(&newtext, "n");
  204. pos=0;
  205. current_line.cnt=0;
  206. ++paragraph;
  207. }
  208. if (current_line.cnt)
  209. buf_cat(&newtext, "n");
  210. rfc2045_free(rfcp);
  211. fclose(fp);
  212. if (made_replacements)
  213. {
  214. char *p=newmsg_createdraft_do(filename, newtext.ptr, 1);
  216. if (p) free(p);
  218. if (*cgi("error"))
  219. {
  220. has_misspelling=0; /* Abort spell checking */
  221. }
  222. }
  224. buf_free(&newtext);
  225. buf_free(&current_line);
  227. if (*ignoreword)
  228. {
  229. static char *p=0;
  231. if (p) free(p);
  232. p=malloc(strlen(cgi("globignore")) + 2 + strlen(ignoreword));
  234. if (!p) enomem();
  236. strcpy(p, cgi("globignore"));
  237. if (*p) strcat(p, ":");
  238. strcat(p, ignoreword);
  239. cgi_put("globignore", p);
  240. }
  242. if (*replacefrom)
  243. {
  244. static char *p=0;
  246. if (p) free(p);
  247. p=malloc(strlen(cgi("globreplace"))+3
  248. +strlen(replacefrom)+strlen(replaceto));
  250. if (!p) enomem();
  251. strcpy(p, cgi("globreplace"));
  252. if (*p) strcat(p, ":");
  253. strcat(strcat(strcat(p, replacefrom), ":"), replaceto);
  254. cgi_put("globreplace", p);
  255. free(p);
  256. }
  257. if (has_misspelling) return (1);
  258. return (0);
  259. }
  261. static struct rfc2045 *findtext(struct rfc2045 *rfcp)
  262. {
  263. struct rfc2045 *textp;
  264. const char *content_type;
  265. const char *content_transfer_encoding;
  266. const char *charset;
  268. rfc2045_mimeinfo(rfcp, &content_type,
  269. &content_transfer_encoding, &charset);
  270. if (strncmp(content_type, "text/", 5) == 0)
  271. textp=rfcp;
  272. else
  273. {
  274. for (textp=rfcp->firstpart; textp; textp=textp->next)
  275. {
  276. if (textp->isdummy) continue;
  277. rfc2045_mimeinfo(textp, &content_type,
  278. &content_transfer_encoding, &charset);
  279. if (strncmp(content_type, "text/", 5) == 0)
  280. break;
  281. }
  282. }
  283. return (textp);
  284. }
  286. /*
  287. ** Ok, check a single paragraph, starting at position #pos.
  288. **
  289. ** If some replacements were made due to previous saved 'replace all' words,
  290. ** return the text of the modified line.  Otherwise return NULL.
  291. **
  292. ** Set *hasmisspelled to 1 if there are some misspellings in this line.
  293. */
  295. static struct ispell *ispellptr;
  296. static char *ispellline=0;
  297. static unsigned paragraph;
  299. static int spellignore(const char *);
  300. static char *spellreplace(const char *);
  302. static char *spell_check(const char *line, unsigned pnum, unsigned pos,
  303. const char *ignoreword,
  304. const char *replacefrom,
  305. const char *replaceto,
  306. int *hasmisspelled)
  307. {
  308. struct ispell_misspelled *msp, *np;
  309. char *newline=0;
  310. const char *newword;
  311. char *w;
  313. if (strlen(line) <= pos) return (0); /* Sanity check */
  315. ispellptr=ispell_run(sqwebmail_content_ispelldict, line+pos);
  316. if (!ispellptr) enomem();
  317. for (msp=ispellptr->first_misspelled; msp; msp=msp->next)
  318. if (msp->misspelled_word)
  319. msp->word_pos += pos;
  321. for (msp=ispellptr->first_misspelled; msp; msp=msp->next)
  322. {
  323. if ((*ignoreword &&
  324. strcmp(msp->misspelled_word, ignoreword) == 0)
  325. || spellignore(msp->misspelled_word))
  326. {
  327. msp->misspelled_word=0;
  328. continue;
  329. }
  331. newword=0;
  332. if ( *replacefrom &&
  333. strcmp(msp->misspelled_word, replacefrom) == 0)
  334. newword=replaceto;
  336. w=0;
  337. if (newword ||
  338. (newword=w=spellreplace(msp->misspelled_word)) != 0)
  339. {
  340. char *p=malloc(strlen(newline ? newline:line)+strlen(newword)+1);
  342. if (!p) enomem();
  343. memcpy(p, (newline ? newline:line), msp->word_pos);
  344. strcpy(p+msp->word_pos, newword);
  345. strcat(p, (newline ? newline:line)+msp->word_pos+
  346. strlen(msp->misspelled_word));
  347. if (newline) free(newline);
  348. newline=p;
  349. for (np=msp; (np=np->next) != 0; )
  350. np->word_pos += strlen(newword)-strlen(msp->misspelled_word);
  351. msp->misspelled_word=0;
  352. if (w)
  353. free(w);
  354. continue;
  355. }
  356. *hasmisspelled=1;
  357. paragraph=pnum;
  358. break;
  359. }
  360. if (!hasmisspelled)
  361. {
  362. ispell_free(ispellptr);
  363. ispellptr=0;
  364. }
  365. else
  366. {
  367. if (ispellline) free(ispellline);
  368. if ((ispellline=malloc(strlen( newline ? newline:line)+1)) == 0)
  369. enomem();
  370. strcpy(ispellline, newline ? newline:line);
  371. }
  372. return (newline);
  373. }
  375. static void showfunc(const char *p, size_t n)
  376. {
  377. while (n)
  378. {
  379. if (*p == ' ')
  380. printf("&nbsp;");
  381. else if (*p != 'n')
  382. putchar(*p);
  383. p++;
  384. --n;
  385. }
  386. }
  388. void spell_show()
  389. {
  390. const char *draftmessage=cgi("draftmessage");
  391. struct ispell_misspelled *msp;
  392. struct ispell_suggestion *isps;
  393. size_t p, l=strlen(ispellline), n;
  394. char *ignorelab=strtok(form_args, "|");
  395. char *ignorealllab=strtok(NULL, "|");
  396. char *replacelab=strtok(NULL, "|");
  397. char *replacealllab=strtok(NULL, "|");
  398. char *insertlab=strtok(NULL, "|");
  399. char *continuelab=strtok(NULL, "|");
  400. char *finishlab=strtok(NULL, "|");
  402. if (!ispellptr) enomem();
  404. if (!ignorelab) ignorelab="";
  405. if (!ignorealllab) ignorealllab="";
  406. if (!replacelab) replacelab="";
  407. if (!replacealllab) replacealllab="";
  408. if (!continuelab) continuelab="";
  409. if (!finishlab) finishlab="";
  411. for (msp=ispellptr->first_misspelled; msp; msp=msp->next)
  412. if (msp->misspelled_word) break;
  413. if (!msp) enomem();
  415. CHECKFILENAME(draftmessage);
  417. printf("<INPUT TYPE=HIDDEN NAME=form VALUE="spellchk">n");
  418. printf("<INPUT TYPE=HIDDEN NAME=pos VALUE="%s">n", cgi("pos"));
  419. if (*cgi("globignore"))
  420. {
  421. printf("<INPUT TYPE=HIDDEN NAME=globignore VALUE="");
  422. output_attrencoded(cgi("globignore"));
  423. printf("">n");
  424. }
  425. if (*cgi("globreplace"))
  426. {
  427. printf("<INPUT TYPE=HIDDEN NAME=globreplace VALUE="");
  428. output_attrencoded(cgi("globreplace"));
  429. printf("">n");
  430. }
  432. printf("<INPUT TYPE=HIDDEN NAME=draftmessage VALUE="");
  433. output_attrencoded(draftmessage);
  434. printf("">");
  435. printf("<INPUT TYPE=HIDDEN NAME=row VALUE="%u"><INPUT TYPE=HIDDEN NAME=col VALUE="%u"><INPUT TYPE=HIDDEN NAME=word VALUE="",
  436. (unsigned)paragraph,
  437. (unsigned)msp->word_pos);
  438. output_attrencoded(msp->misspelled_word);
  440. printf(""><TABLE BORDER=0 CELLSPACING=0><TR><TD>");
  442. printf("<TABLE BORDER=1 WIDTH="100%%" BGCOLOR="#EEEEEE" CELLSPACING=0 CELLPADDING=8><TR><TD ALIGN=CENTER><TT><FONT COLOR="#000000">");
  444. if (msp->word_pos > 30)
  445. {
  446. p=msp->word_pos-30;
  447. for (n=p; n<msp->word_pos; n++)
  448. if (ispellline[n] == ' ')
  449. {
  450. while (n < p && ispellline[n] == ' ')
  451. ++n;
  452. p=n;
  453. break;
  454. }
  455. printf("...&nbsp;");
  456. }
  457. else
  458. p=0;
  459. filter_start(FILTER_FOR_DISPLAY, &showfunc);
  460. filter(ispellline+p, msp->word_pos-p);
  461. filter_end();
  462. printf("<B>");
  463. filter_start(FILTER_FOR_DISPLAY, &showfunc);
  464. filter(ispellline+msp->word_pos, strlen(msp->misspelled_word));
  465. filter_end();
  466. printf("</B>");
  467. p=msp->word_pos+strlen(msp->misspelled_word);
  468. if (l-p < 30)
  469. {
  470. n=l-p;
  471. }
  472. else n=30;
  474. while (n)
  475. {
  476. if (ispellline[n+p] != ' ')
  477. {
  478. --n;
  479. continue;
  480. }
  481. while (n && ispellline[n+p-1] == ' ')
  482. --n;
  483. break;
  484. }
  485. filter_start(FILTER_FOR_DISPLAY, &showfunc);
  486. filter(ispellline+p, n);
  487. filter_end();
  488. if (n != l-p)
  489. printf("&nbsp;...");
  490. printf("</FONT></TT></TD></TR></TABLE><BR>");
  491. printf("<TABLE BORDER=1 BGCOLOR="#FFFFC0" CELLPADDING=8><TR><TD>");
  493. printf("<TABLE BORDER=0 WIDTH="100%%"><TR><TD>");
  494. for (isps=msp->first_suggestion; isps; isps=isps->next)
  495. {
  496. printf("<TR><TD>%s</TD><TD><INPUT BORDER=0 TYPE=RADIO NAME=REPLACE VALUE="%s"></TD><TD>%s</TD></TR>n",
  497. replacelab,
  498. isps->suggested_word,
  499. isps->suggested_word);
  500. replacelab=" ";
  501. }
  502. printf("<TR><TD>%s</TD><TD><INPUT BORDER=0 TYPE=RADIO NAME=REPLACE VALUE="#other"></TD><TD><INPUT TYPE=TEXT NAME=OTHER WIDTH=20></TD></TR>n",
  503. replacelab);
  504. printf("<TR><TD> </TD><TD><INPUT BORDER=0 TYPE=RADIO NAME=REPLACE VALUE="#insert"></TD><TD>%s</TD></TR>n",
  505. insertlab);
  507. printf("<TR><TD> </TD><TD><INPUT BORDER=0 TYPE=CHECKBOX NAME=REPLACEALL></TD><TD>%s</TD></TR>n",
  508. replacealllab);
  509. printf("<TR><TD> </TD><TD COLSPAN=2><HR WIDTH="100%%"></TD></TR>n");
  510. printf("<TR><TD> </TD><TD><INPUT BORDER=0 TYPE=RADIO NAME=REPLACE VALUE="#ignore"></TD><TD>%s</TD></TR>n",
  511. ignorelab);
  512. printf("<TR><TD> </TD><TD><INPUT BORDER=0 TYPE=RADIO NAME=REPLACE VALUE="#ignoreall"></TD><TD>%s</TD></TR>n",
  513. ignorealllab);
  514. printf("</TABLE>");
  515. printf("</TR></TD></TABLE><BR>");
  516. printf("<TABLE BORDER=1 CELLPADDING=8 BGCOLOR="#EEEEEE" WIDTH="100%%"><TR><TD>");
  517. printf("<INPUT TYPE=SUBMIT NAME="continue" VALUE="%s">n",
  518. continuelab);
  519. printf("<INPUT TYPE=SUBMIT NAME="finish" VALUE="%s">n",
  520. finishlab);
  521. printf("</TD></TR></TABLE>n");
  523. printf("</TD></TR></TABLE>n");
  524. }
  526. static FILE *opendict(const char *mode)
  527. {
  528. FILE *fp;
  529. char *p=malloc(sqwebmail_content_ispelldict ?
  530. strlen(sqwebmail_content_ispelldict)+20:20);
  532. if (!p) enomem();
  533. strcat(strcpy(p, sqwebmail_content_ispelldict ?
  534. "sqwebmail-dict-":"sqwebmail-dict"),
  535. sqwebmail_content_ispelldict ? sqwebmail_content_ispelldict:"");
  536. fp=fopen(p, mode);
  537. free(p);
  538. return (fp);
  539. }
  541. static int spellignore(const char *word)
  542. {
  543. char buf[100];
  544. const char *c;
  545. char *p, *q;
  546. FILE *fp=opendict("r");
  548. if (!fp) return (0);
  549. while (fgets(buf, sizeof(buf), fp) != NULL)
  550. {
  551. if ((p=strchr(buf, 'n')) != 0) *p=0;
  552. if (strcmp(word, buf) == 0)
  553. {
  554. fclose(fp);
  555. return (1);
  556. }
  557. }
  558. fclose(fp);
  560. c=cgi("globignore");
  562. p=malloc(strlen(c)+1);
  563. if (!p) enomem();
  564. strcpy(p, c);
  566. for (q=p; (q=strtok(q, ":")) != 0; q=0)
  567. if (strcmp(q, word) == 0)
  568. {
  569. free(p);
  570. return (1);
  571. }
  573. return (0);
  574. }
  576. static void spelladd(const char *word)
  577. {
  578. FILE *fp=opendict("a");
  580. if (fp)
  581. {
  582. fprintf(fp, "%sn", word);
  583. fclose(fp);
  584. }
  585. }
  587. static char *spellreplace(const char *word)
  588. {
  589. char *p, *q, *r;
  590. const char *c=cgi("globreplace");
  592. p=malloc(strlen(c)+1);
  593. if (!p) enomem();
  594. strcpy(p, c);
  595. for (q=p; (q=strtok(q, ":")) != 0 && (r=strtok(0, ":")) != 0; q=0)
  596. {
  597. if (strcmp(q, word) == 0)
  598. {
  599. q=malloc(strlen(r)+1);
  600. if (!q) enomem();
  601. strcpy(q, r);
  602. free(p);
  603. return (q);
  604. }
  605. }
  606. free(p);
  607. return (0);
  608. }
  610. void spell_check_continue()
  611. {
  612. const char *filename=cgi("draftmessage");
  613. unsigned parnum=atol(cgi("row"));
  614. unsigned pos=atol(cgi("col"));
  615. char *draftfilename;
  617. CHECKFILENAME(filename);
  618. draftfilename=maildir_find(DRAFTS, filename);
  619. if (!draftfilename)
  620. {
  621. output_form("folder.html");
  622. return;
  623. }
  625. if (search_spell(draftfilename, parnum, pos) &&
  626. *cgi("continue"))
  627. output_form("spellchk.html");
  628. else
  629. {
  630. cgi_put("draft", cgi("draftmessage"));
  631. cgi_put("previewmsg","SPELLCHK");
  632. output_form("newmsg.html");
  633. }
  634. free(draftfilename);
  635. }
  637. void ispell_cleanup()
  638. {
  639. if(ispellline) free(ispellline);
  640. ispellline=NULL;
  641. }