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