* output_plaintext.C: cosmetics in comment: line length cannot be < 0

[lyx.git] / src / ispell.C

diff --git a/src/ispell.C b/src/ispell.C
index cdef2fb907acef9cf7565b763bb704ec4a0a663d..1a798cd29ec3ff32713ef3cd5180c1fffd880ccd 100644 (file)
--- a/src/ispell.C
+++ b/src/ispell.C
@@ -23,6 +23,8 @@
 #include "WordLangTuple.h"
 
 #include "support/forkedcall.h"
+#include "support/lstrings.h"
+#include "support/unicode.h"
 
 // HP-UX 11.x doesn't have this header
 #ifdef HAVE_SYS_SELECT_H
@@ -32,6 +34,11 @@
 # include <sys/time.h>
 #endif
 
+
+namespace lyx {
+
+using support::bformat;
+
 using boost::shared_ptr;
 
 #ifndef CXX_GLOBAL_CSTD
@@ -47,8 +54,8 @@ using std::string;
 
 namespace {
 
-class LaunchIspell : public lyx::support::ForkedProcess {
-       typedef lyx::support::ForkedProcess ForkedProcess;
+class LaunchIspell : public support::ForkedProcess {
+       typedef support::ForkedProcess ForkedProcess;
 public:
        ///
        LaunchIspell(BufferParams const & p, string const & l,
@@ -160,7 +167,7 @@ int LaunchIspell::generateChild()
                string enc = (params.inputenc == "auto")
                        ? params.language->encoding()->latexName()
                        : params.inputenc;
-               string::size_type n = enc.length();
+               size_t const n = enc.length();
                tmp = new char[3];
                string("-T").copy(tmp, 2);
                tmp[2] = '\0';
@@ -185,6 +192,29 @@ int LaunchIspell::generateChild()
 }
 
 
+string const to_iconv_encoding(docstring const & s, string const & encoding)
+{
+       if (lyxrc.isp_use_input_encoding) {
+               std::vector<char> const encoded =
+                       ucs4_to_eightbit(s.data(), s.length(), encoding);
+               return string(encoded.begin(), encoded.end());
+       }
+       // FIXME UNICODE: we don't need to convert to UTF8, but probably to the locale encoding
+       return to_utf8(s);
+}
+
+
+docstring const from_iconv_encoding(string const & s, string const & encoding)
+{
+       if (lyxrc.isp_use_input_encoding) {
+               std::vector<char_type> const ucs4 =
+                       eightbit_to_ucs4(s.data(), s.length(), encoding);
+               return docstring(ucs4.begin(), ucs4.end());
+       }
+       // FIXME UNICODE: s is not in UTF8, but probably the locale encoding
+       return from_utf8(s);
+}
+
 } // namespace anon
 
 
@@ -193,6 +223,8 @@ ISpell::ISpell(BufferParams const & params, string const & lang)
 {
        lyxerr[Debug::GUI] << "Created ispell" << endl;
 
+       encoding = params.encoding().iconvName();
+
        // static due to the setvbuf. Ugly.
        static char o_buf[BUFSIZ];
 
@@ -244,12 +276,12 @@ ISpell::ISpell(BufferParams const & params, string const & lang)
        child_.reset(li);
        if (li->start() == -1) {
                error_ = _("Could not create an ispell process.\nYou may not have "
-                       "the right languages installed.");
+                                       "the right languages installed.");
                child_.reset(0);
                return;
        }
 
-       /* Parent process: Read ispells identification message */
+       // Parent process: Read ispells identification message
 
        bool err_read;
        bool error = select(err_read);
@@ -261,12 +293,13 @@ ISpell::ISpell(BufferParams const & params, string const & lang)
                        return;
                }
 
-               /* must have read something from stderr */
-               error_ = buf;
+               // must have read something from stderr
+               // FIXME UNICODE: buf is not in UTF8, but probably the locale encoding
+               error_ = from_utf8(buf);
        } else {
                // select returned error
                error_ = _("The ispell process returned an error.\nPerhaps "
-                               "it has been configured wrongly ?");
+                          "it has been configured wrongly ?");
        }
 
        close(pipein[0]);
@@ -340,18 +373,18 @@ bool ISpell::select(bool & err_read)
 }
 
 
-string const ISpell::nextMiss()
+docstring const ISpell::nextMiss()
 {
        // Well, somebody is a sick fuck.
 
        if (str == 0 || *(e+1) == '\0')
-               return "";
+               return docstring();
        char * b = e + 2;
        e = strpbrk(b, ",\n");
        *e = '\0';
        if (b)
-               return b;
-       return "";
+               return from_iconv_encoding(b, encoding);
+       return docstring();
 }
 
 
@@ -367,7 +400,14 @@ enum ISpell::Result ISpell::check(WordLangTuple const & word)
 
        Result res;
 
-       ::fputs(word.word().c_str(), out);
+       string const encoded = to_iconv_encoding(word.word(), encoding);
+       if (encoded.empty()) {
+               error_ = bformat(
+                       _("Could not check word `%1$s' because it could not be converted to encoding `%2$s'."),
+                       word.word(), from_ascii(encoding));
+               return UNKNOWN_WORD;
+       }
+       ::fputs(encoded.c_str(), out);
        ::fputc('\n', out);
 
        bool err_read;
@@ -379,7 +419,8 @@ enum ISpell::Result ISpell::check(WordLangTuple const & word)
        }
 
        if (err_read) {
-               error_ = buf;
+               // FIXME UNICODE: buf is not in UTF8, but probably the locale encoding
+               error_ = from_utf8(buf);
                return UNKNOWN_WORD;
        }
 
@@ -430,21 +471,38 @@ enum ISpell::Result ISpell::check(WordLangTuple const & word)
 
 void ISpell::insert(WordLangTuple const & word)
 {
+       string const encoded = to_iconv_encoding(word.word(), encoding);
+       if (encoded.empty()) {
+               error_ = bformat(
+                       _("Could not insert word `%1$s' because it could not be converted to encoding `%2$s'."),
+                       word.word(), from_ascii(encoding));
+               return;
+       }
        ::fputc('*', out); // Insert word in personal dictionary
-       ::fputs(word.word().c_str(), out);
+       ::fputs(encoded.c_str(), out);
        ::fputc('\n', out);
 }
 
 
 void ISpell::accept(WordLangTuple const & word)
 {
+       string const encoded = to_iconv_encoding(word.word(), encoding);
+       if (encoded.empty()) {
+               error_ = bformat(
+                       _("Could not accept word `%1$s' because it could not be converted to encoding `%2$s'."),
+                       word.word(), from_ascii(encoding));
+               return;
+       }
        ::fputc('@', out); // Accept in this session
-       ::fputs(word.word().c_str(), out);
+       ::fputs(encoded.c_str(), out);
        ::fputc('\n', out);
 }
 
 
-string const ISpell::error()
+docstring const ISpell::error()
 {
        return error_;
 }
+
+
+} // namespace lyx