src/sp_spell.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 2001 The LyX Team.
   7  *
   8  * ======================================================
   9  *
  10  * \file sp_pspell.C
  11  * \author Kevin Atkinson
  12  */
  13
  14 #include <config.h>
  15
  16 #ifdef __GNUG__
  17 #pragma implementation
  18 #endif
  19
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <stdio.h>
  23
  24 #if TIME_WITH_SYS_TIME
  25 # include <sys/time.h>
  26 # include <ctime>
  27 #else
  28 # if HAVE_SYS_TIME_H
  29 #  include <sys/time.h>
  30 # else
  31 #  include <ctime>
  32 # endif
  33 #endif
  34
  35 #ifdef HAVE_SYS_SELECT_H
  36 # ifdef HAVE_STRINGS_H
  37    // <strings.h> is needed at least on AIX because FD_ZERO uses bzero().
  38    // BUT we cannot include both string.h and strings.h on Irix 6.5 :(
  39 #  ifdef _AIX
  40 #   include <strings.h>
  41 #  endif
  42 # endif
  43 #include <sys/select.h>
  44 #endif
  45
  46 #include "LString.h"
  47 #include "support/lstrings.h"
  48 #include "lyxrc.h"
  49 #include "debug.h"
  50 #include "encoding.h"
  51 #include "sp_ispell.h"
  52
  53 using std::endl;
  54
  55 namespace {
  56         /// pid for the `ispell' process.
  57         pid_t isp_pid = -1;
  58 }
  59
  60 /// can be found in src/insets/figinset.C
  61 extern void sigchldchecker(pid_t pid, int * status);
  62
  63 ///
  64 // ------------------- start special pspell code/class --------------------
  65 ///
  66 #ifdef USE_PSPELL
  67
  68 #include "support/LAssert.h"
  69
  70 #define USE_ORIGINAL_MANAGER_FUNCS 1
  71 # include <pspell/pspell.h>
  72
  73 #include "sp_pspell.h"
  74
  75
  76 PSpell::PSpell()
  77 {
  78         els = 0;
  79         sc = 0;
  80         spell_error_object = 0;
  81         flag = ISP_UNKNOWN;
  82 }
  83
  84 PSpell::PSpell(BufferParams const & params, string const & lang)
  85 {
  86         els = 0;
  87         sc = 0;
  88         spell_error_object = 0;
  89         flag = ISP_UNKNOWN;
  90         initialize(params, lang);
  91 }
  92
  93 PSpell::~PSpell()
  94 {
  95         cleanUp();
  96         close();
  97         if (els)
  98                 delete_pspell_string_emulation(els);
  99 }
 100
 101
 102 void PSpell::initialize(BufferParams const &, string const & lang)
 103 {
 104         PspellConfig * config = new_pspell_config();
 105         string code;
 106         split(lang, code, '_');
 107         config->replace("language-tag", code.c_str());
 108         spell_error_object = new_pspell_manager(config);
 109         if (pspell_error_number(spell_error_object) != 0) {
 110                 error_ = pspell_error_message(spell_error_object);
 111         } else {
 112                 error_ = 0;
 113                 sc = to_pspell_manager(spell_error_object);
 114                 spell_error_object = 0;
 115         }
 116 }
 117
 118
 119 void PSpell::cleanUp()
 120 {
 121         if (spell_error_object) {
 122                 delete_pspell_can_have_error(spell_error_object);
 123                 spell_error_object = 0;
 124         }
 125 }
 126
 127
 128 enum PSpell::spellStatus PSpell::check(string const & word)
 129 {
 130         if (!sc)
 131                 return flag;
 132
 133         int word_ok = pspell_manager_check(sc, word.c_str());
 134         lyx::Assert(word_ok != -1);
 135
 136         if (word_ok) {
 137                 flag = ISP_OK;
 138         } else {
 139                 PspellWordList const * sugs =
 140                         pspell_manager_suggest(sc, word.c_str());
 141                 lyx::Assert(sugs != 0);
 142                 els = pspell_word_list_elements(sugs);
 143                 if (pspell_word_list_empty(sugs))
 144                         flag = ISP_UNKNOWN;
 145                 else
 146                         flag = ISP_MISSED;
 147         }
 148         return flag;
 149 }
 150
 151
 152 void PSpell::close()
 153 {
 154         if (sc)
 155                 pspell_manager_save_all_word_lists(sc);
 156 }
 157
 158
 159 void PSpell::insert(string const & word)
 160 {
 161         if (sc)
 162                 pspell_manager_add_to_personal(sc, word.c_str());
 163 }
 164
 165
 166 void PSpell::accept(string const & word)
 167 {
 168         if (sc)
 169                 pspell_manager_add_to_session(sc, word.c_str());
 170 }
 171
 172
 173 void PSpell::store(string const & mis, string const & cor)
 174 {
 175         if (sc)
 176                 pspell_manager_store_replacement(sc, mis.c_str(), cor.c_str());
 177 }
 178
 179
 180 char const * PSpell::nextMiss()
 181 {
 182         if (els)
 183                 return pspell_string_emulation_next(els);
 184         return "";
 185 }
 186
 187 char const * PSpell::error()
 188 {
 189         return error_;
 190 }
 191
 192 void PSpell::sigchldhandler(pid_t pid, int * status)
 193 {
 194         sigchldchecker(pid, status);
 195 }
 196
 197 #endif
 198
 199 ///
 200 // ------------------- start special ispell code/class --------------------
 201 ///
 202
 203 ISpell::ISpell()
 204 {
 205         str = 0;
 206         flag = ISP_UNKNOWN;
 207 }
 208
 209
 210 ISpell::ISpell(BufferParams const & params, string const & lang)
 211 {
 212         str = 0;
 213         flag = ISP_UNKNOWN;
 214         initialize(params, lang);
 215 }
 216
 217
 218 ISpell::~ISpell()
 219 {
 220         delete[] str;
 221 }
 222
 223
 224 char const * ISpell::nextMiss()
 225 {
 226         if (str == 0 || *(e+1) == '\0') return 0;
 227         b = e + 2;
 228         e = strpbrk(b, ",\n");
 229         *e = '\0';
 230         return b;
 231 }
 232
 233
 234 void ISpell::initialize(BufferParams const & params, string const & lang)
 235 {
 236         static char o_buf[BUFSIZ];  // jc: it could be smaller
 237         int pipein[2], pipeout[2];
 238         char * argv[14];
 239         int argc;
 240
 241         isp_pid = -1;
 242
 243         if (pipe(pipein) == -1 || pipe(pipeout) == -1) {
 244                 lyxerr << "LyX: Can't create pipe for spellchecker!" << endl;
 245                 goto END;
 246         }
 247
 248         if ((out = fdopen(pipein[1], "w")) == 0) {
 249                 lyxerr << "LyX: Can't create stream for pipe for spellchecker!"
 250                        << endl;
 251                 goto END;
 252         }
 253
 254         if ((in = fdopen(pipeout[0], "r")) == 0) {
 255                 lyxerr <<"LyX: Can't create stream for pipe for spellchecker!"
 256                        << endl;
 257                 goto END;
 258         }
 259
 260         setvbuf(out, o_buf, _IOLBF, BUFSIZ);
 261
 262         isp_fd = pipeout[0];
 263
 264         isp_pid = fork();
 265
 266         if (isp_pid == -1) {
 267                 lyxerr << "LyX: Can't create child process for spellchecker!"
 268                        << endl;
 269                 goto END;
 270         }
 271
 272         if (isp_pid == 0) {
 273                 /* child process */
 274                 dup2(pipein[0], STDIN_FILENO);
 275                 dup2(pipeout[1], STDOUT_FILENO);
 276                 ::close(pipein[0]);
 277                 ::close(pipein[1]);
 278                 ::close(pipeout[0]);
 279                 ::close(pipeout[1]);
 280
 281                 argc = 0;
 282                 char * tmp = new char[lyxrc.isp_command.length() + 1];
 283                 lyxrc.isp_command.copy(tmp, lyxrc.isp_command.length());
 284                 tmp[lyxrc.isp_command.length()] = '\0';
 285                 argv[argc++] = tmp;
 286                 tmp = new char[3];
 287                 string("-a").copy(tmp, 2); tmp[2] = '\0'; // pipe mode
 288                 argv[argc++] = tmp;
 289
 290                 if (lang != "default") {
 291                         tmp = new char[3];
 292                         string("-d").copy(tmp, 2); tmp[2] = '\0'; // Dictionary file
 293                         argv[argc++] = tmp;
 294                         tmp = new char[lang.length() + 1];
 295                         lang.copy(tmp, lang.length()); tmp[lang.length()] = '\0';
 296                         argv[argc++] = tmp;
 297                 }
 298
 299                 if (lyxrc.isp_accept_compound) {
 300                         // Consider run-together words as legal compounds
 301                         tmp = new char[3];
 302                         string("-C").copy(tmp, 2); tmp[2] = '\0';
 303                         argv[argc++] = tmp;
 304                 } else {
 305                         // Report run-together words with
 306                         // missing blanks as errors
 307                         tmp = new char[3];
 308                         string("-B").copy(tmp, 2); tmp[2] = '\0';
 309                         argv[argc++] = tmp;
 310                 }
 311                 if (lyxrc.isp_use_esc_chars) {
 312                         // Specify additional characters that
 313                         // can be part of a word
 314                         tmp = new char[3];
 315                         string("-w").copy(tmp, 2); tmp[2] = '\0';
 316                         argv[argc++] = tmp;
 317                         // Put the escape chars in ""s
 318                         string tms = "\"" + lyxrc.isp_esc_chars + "\"";
 319                         tmp = new char[tms.length() + 1];
 320                         tms.copy(tmp, tms.length()); tmp[tms.length()] = '\0';
 321                         argv[argc++] = tmp;
 322                 }
 323                 if (lyxrc.isp_use_pers_dict) {
 324                         // Specify an alternate personal dictionary
 325                         tmp = new char[3];
 326                         string("-p").copy(tmp, 2);
 327                         tmp[2]= '\0';
 328                         argv[argc++] = tmp;
 329                         tmp = new char[lyxrc.isp_pers_dict.length() + 1];
 330                         lyxrc.isp_pers_dict.copy(tmp, lyxrc.isp_pers_dict.length());
 331                         tmp[lyxrc.isp_pers_dict.length()] = '\0';
 332                         argv[argc++] = tmp;
 333                 }
 334                 if (lyxrc.isp_use_input_encoding &&
 335                     params.inputenc != "default") {
 336                         string enc = (params.inputenc == "auto")
 337                                 ? params.language->encoding()->LatexName()
 338                                 : params.inputenc;
 339                         string::size_type n = enc.length();
 340                         tmp = new char[3];
 341                         string("-T").copy(tmp, 2); tmp[2] = '\0';
 342                         argv[argc++] = tmp; // Input encoding
 343                         tmp = new char[n + 1];
 344                         enc.copy(tmp, n);
 345                         tmp[n] = '\0';
 346                         argv[argc++] = tmp;
 347                 }
 348
 349                 argv[argc++] = 0;
 350
 351                 execvp(argv[0], const_cast<char * const *>(argv));
 352
 353                 // free the memory used by string::copy in the
 354                 // setup of argv
 355                 for (int i= 0; i < argc -1; ++i)
 356                         delete[] argv[i];
 357
 358                 lyxerr << "LyX: Failed to start ispell!" << endl;
 359                 _exit(0);
 360         }
 361         {
 362                 /* Parent process: Read ispells identification message */
 363                 // Hmm...what are we using this id msg for? Nothing? (Lgb)
 364                 // Actually I used it to tell if it's truly Ispell or if it's
 365                 // aspell -- (kevinatk@home.com)
 366                 char buf[2048];
 367                 fd_set infds;
 368                 struct timeval tv;
 369                 int retval = 0;
 370                 FD_ZERO(&infds);
 371                 FD_SET(pipeout[0], &infds);
 372                 tv.tv_sec = 15; // fifteen second timeout. Probably too much,
 373                 // but it can't really hurt.
 374                 tv.tv_usec = 0;
 375
 376                 // Configure provides us with macros which are supposed to do
 377                 // the right typecast.
 378                 retval = select(SELECT_TYPE_ARG1 (pipeout[0]+1),
 379                                 SELECT_TYPE_ARG234 (&infds),
 380                                 0,
 381                                 0,
 382                                 SELECT_TYPE_ARG5 (&tv));
 383
 384                 if (retval > 0) {
 385                         // Ok, do the reading. We don't have to FD_ISSET since
 386                         // there is only one fd in infds.
 387                         fgets(buf, 2048, in);
 388
 389                         // determine if the spell checker is really Aspell
 390                         if (strstr(buf, "Aspell"))
 391                                 actual_spell_checker = ASC_ASPELL;
 392                         else
 393                                 actual_spell_checker = ASC_ISPELL;
 394
 395                         fputs("!\n", out); // Set terse mode (silently accept correct words)
 396
 397
 398                 } else if (retval == 0) {
 399                         // timeout. Give nice message to user.
 400                         lyxerr << "Ispell read timed out, what now?" << endl;
 401                         // This probably works but could need some thought
 402                         isp_pid = -1;
 403                         ::close(pipeout[0]);
 404                         ::close(pipeout[1]);
 405                         ::close(pipein[0]);
 406                         ::close(pipein[1]);
 407                         isp_fd = -1;
 408                 } else {
 409                         // Select returned error
 410                         lyxerr << "Select on ispell returned error, what now?" << endl;
 411                 }
 412         }
 413   END:
 414         if (isp_pid == -1) {
 415                 error_ =
 416                         "\n\n"
 417                         "The ispell-process has died for some reason. *One* possible reason\n"
 418                         "could be that you do not have a dictionary file\n"
 419                         "for the language of this document installed.\n"
 420                         "Check /usr/lib/ispell or set another\n"
 421                         "dictionary in the Spellchecker Options menu.";
 422         } else {
 423                 error_ = 0;
 424         }
 425 }
 426
 427
 428 bool ISpell::alive()
 429 {
 430         return isp_pid != -1;
 431 }
 432
 433
 434 void ISpell::cleanUp()
 435 {
 436         ::fclose(out);
 437 }
 438
 439
 440 enum ISpell::spellStatus ISpell::check(string const & word)
 441 {
 442         //Please rewrite to use string.
 443
 444         ::fputs(word.c_str(), out);
 445         ::fputc('\n', out);
 446
 447         char buf[1024];
 448         ::fgets(buf, 1024, in);
 449
 450         /* I think we have to check if ispell is still alive here because
 451            the signal-handler could have disabled blocking on the fd */
 452         if (!alive()) return ISP_UNKNOWN;
 453
 454         switch (*buf) {
 455         case '*': // Word found
 456                 flag = ISP_OK;
 457                 break;
 458         case '+': // Word found through affix removal
 459                 flag = ISP_ROOT;
 460                 break;
 461         case '-': // Word found through compound formation
 462                 flag = ISP_COMPOUNDWORD;
 463                 break;
 464         case '\n': // Number or when in terse mode: no problems
 465                 flag = ISP_IGNORE;
 466                 break;
 467         case '#': // Not found, no near misses and guesses
 468                 flag = ISP_UNKNOWN;
 469                 break;
 470         case '?': // Not found, and no near misses, but guesses (guesses are ignored)
 471         case '&': // Not found, but we have near misses
 472         {
 473                 flag = ISP_MISSED;
 474                 char * p = strpbrk(buf, ":");
 475                 str = new char[strlen(p) + 1];
 476                 e   = str;
 477                 strcpy(str, p);
 478                 break;
 479         }
 480         default: // This shouldn't happend, but you know Murphy
 481                 flag = ISP_UNKNOWN;
 482         }
 483
 484         *buf = 0;
 485         if (flag!= ISP_IGNORE) {
 486                 while (*buf!= '\n') fgets(buf, 255, in); /* wait for ispell to finish */
 487         }
 488         return flag;
 489 }
 490
 491
 492 void ISpell::close()
 493 {
 494         // Note: If you decide to optimize this out when it is not
 495         // needed please note that when Aspell is used this command
 496         // is also needed to save the replacement dictionary.
 497         // -- Kevin Atkinson (kevinatk@home.com)
 498
 499         fputs("#\n", out); // Save personal dictionary
 500
 501         fflush(out);
 502         fclose(out);
 503 }
 504
 505
 506 void ISpell::insert(string const & word)
 507 {
 508         ::fputc('*', out); // Insert word in personal dictionary
 509         ::fputs(word.c_str(), out);
 510         ::fputc('\n', out);
 511 }
 512
 513
 514 void ISpell::accept(string const & word)
 515 {
 516         ::fputc('@', out); // Accept in this session
 517         ::fputs(word.c_str(), out);
 518         ::fputc('\n', out);
 519 }
 520
 521
 522 void ISpell::store(string const & mis, string const & cor)
 523 {
 524         if (actual_spell_checker == ASC_ASPELL) {
 525                 ::fputs("$$ra ", out);
 526                 ::fputs(mis.c_str(), out);
 527                 ::fputc(',', out);
 528                 ::fputs(cor.c_str(), out);
 529                 ::fputc('\n', out);
 530         }
 531 }
 532
 533
 534 void ISpell::sigchldhandler(pid_t pid, int * status)
 535 {
 536         if (isp_pid > 0) {
 537                 if (pid == isp_pid) {
 538                         isp_pid= -1;
 539                         fcntl(isp_fd, F_SETFL, O_NONBLOCK); /* set the file descriptor
 540                                                                to nonblocking so we can
 541                                                                continue */
 542                 }
 543         }
 544         sigchldchecker(pid, status);
 545 }
 546
 547 char const * ISpell::error()
 548 {
 549         return error_;
 550 }