Let paragraph::requestSpellcheck() consider contained insets

[lyx.git] / src / support / docstring.cpp

diff --git a/src/support/docstring.cpp b/src/support/docstring.cpp
index 5a4ddccd3605d4175f9426093abda475eefb75a4..cbee18a20a4584ce9f41e87eec322d080cb102f6 100644 (file)
--- a/src/support/docstring.cpp
+++ b/src/support/docstring.cpp
@@ -69,14 +69,6 @@ string const to_ascii(docstring const & ucs4)
 }
 
 
-IconvProcessor & utf8ToUcs4()
-{
-       static IconvProcessor iconv(ucs4_codeset, "UTF-8");
-       return iconv;
-}
-
-
-
 void utf8_to_ucs4(string const & utf8, docstring & ucs4)
 {
        size_t n = utf8.size();
@@ -121,9 +113,9 @@ docstring const from_local8bit(string const & s)
 /// Exception thrown by to_local8bit if the string could not be converted
 class to_local8bit_failure : public bad_cast {
 public:
-       to_local8bit_failure() throw() : bad_cast() {}
-       virtual ~to_local8bit_failure() throw() {}
-       virtual const char* what() const throw()
+       to_local8bit_failure() noexcept : bad_cast() {}
+       virtual ~to_local8bit_failure() noexcept {}
+       const char* what() const noexcept override
        {
                return "A string could not be converted from unicode to the local 8 bit encoding.";
        }
@@ -259,7 +251,7 @@ lyx::docstring & operator+=(lyx::docstring & l, char r)
 
 // We get undefined references to these virtual methods. This looks like
 // a bug in gcc. The implementation here does not do anything useful, since
-// it is overriden in ascii_ctype_facet.
+// it is overridden in ascii_ctype_facet.
 namespace std {
 template<> ctype<lyx::char_type>::~ctype() {}
 template<> bool
@@ -281,16 +273,16 @@ template<> char
 ctype<lyx::char_type>::do_narrow(const lyx::char_type, char) const { return 0; }
 template<> const lyx::char_type *
 ctype<lyx::char_type>::do_narrow(const lyx::char_type *, const lyx::char_type *, char, char *) const { return 0; }
-}
+} // namespace std
 
 
 namespace lyx {
 
 class ctype_failure : public bad_cast {
 public:
-       ctype_failure() throw() : bad_cast() {}
-       virtual ~ctype_failure() throw() {}
-       virtual const char* what() const throw()
+       ctype_failure() noexcept : bad_cast() {}
+       virtual ~ctype_failure() noexcept {}
+       const char* what() const noexcept override
        {
                return "The ctype<lyx::char_type> locale facet does only support ASCII characters on this platform.";
        }
@@ -299,9 +291,9 @@ public:
 
 class num_put_failure : public bad_cast {
 public:
-       num_put_failure() throw() : bad_cast() {}
-       virtual ~num_put_failure() throw() {}
-       virtual const char* what() const throw()
+       num_put_failure() noexcept : bad_cast() {}
+       virtual ~num_put_failure() noexcept {}
+       const char* what() const noexcept override
        {
                return "The num_put locale facet does only support ASCII characters on this platform.";
        }
@@ -352,8 +344,7 @@ protected:
                        const int c = wctob(i);
                        if (c == EOF)
                                break;
-                       else
-                               M_narrow[i] = static_cast<char>(c);
+                       M_narrow[i] = static_cast<char>(c);
                }
                if (i == 128)
                        M_narrow_ok = true;
@@ -368,13 +359,13 @@ protected:
                }
        }
        virtual ~ascii_ctype_facet() {}
-       char_type do_toupper(char_type c) const
+       char_type do_toupper(char_type c) const override
        {
                if (c >= 0x80)
                        throw ctype_failure();
                return toupper(static_cast<int>(c));
        }
-       char_type const * do_toupper(char_type * lo, char_type const * hi) const
+       char_type const * do_toupper(char_type * lo, char_type const * hi) const override
        {
                while (lo < hi) {
                        if (*lo >= 0x80)
@@ -384,13 +375,13 @@ protected:
                }
                return hi;
        }
-       char_type do_tolower(char_type c) const
+       char_type do_tolower(char_type c) const override
        {
                if (c >= 0x80)
                        throw ctype_failure();
                return tolower(c);
        }
-       char_type const * do_tolower(char_type * lo, char_type const * hi) const
+       char_type const * do_tolower(char_type * lo, char_type const * hi) const override
        {
                while (lo < hi) {
                        if (*lo >= 0x80)
@@ -400,7 +391,7 @@ protected:
                }
                return hi;
        }
-       bool do_is(mask m, char_type c) const
+       bool do_is(mask m, char_type c) const override
        {
                if (c >= 0x80)
                        throw ctype_failure();
@@ -419,7 +410,7 @@ protected:
                        }
                return ret;
        }
-       char_type const * do_is(char_type const * lo, char_type const * hi, mask * vec) const
+       char_type const * do_is(char_type const * lo, char_type const * hi, mask * vec) const override
        {
                for (;lo < hi; ++vec, ++lo) {
                        if (*lo >= 0x80)
@@ -438,25 +429,25 @@ protected:
                }
                return hi;
        }
-       char_type const * do_scan_is(mask m, char_type const * lo, char_type const * hi) const
+       char_type const * do_scan_is(mask m, char_type const * lo, char_type const * hi) const override
        {
                while (lo < hi && !this->do_is(m, *lo))
                        ++lo;
                return lo;
        }
-       char_type const * do_scan_not(mask m, char_type const * lo, char_type const * hi) const
+       char_type const * do_scan_not(mask m, char_type const * lo, char_type const * hi) const override
        {
                while (lo < hi && this->do_is(m, *lo) != 0)
                        ++lo;
                return lo;
        }
-       char_type do_widen(char c) const
+       char_type do_widen(char c) const override
        {
                if (static_cast<unsigned char>(c) < 0x80)
                        return c;
                throw ctype_failure();
        }
-       const char* do_widen(const char* lo, const char* hi, char_type* dest) const
+       const char* do_widen(const char* lo, const char* hi, char_type* dest) const override
        {
                while (lo < hi) {
                        if (static_cast<unsigned char>(*lo) >= 0x80)
@@ -467,13 +458,13 @@ protected:
                }
                return hi;
        }
-       char do_narrow(char_type wc, char) const
+       char do_narrow(char_type wc, char) const override
        {
                if (wc < 0x80)
                        return static_cast<char>(wc);
                throw ctype_failure();
        }
-       const char_type * do_narrow(const char_type * lo, const char_type * hi, char, char * dest) const
+       const char_type * do_narrow(const char_type * lo, const char_type * hi, char, char * dest) const override
        {
                while (lo < hi) {
                        if (*lo < 0x80)
@@ -505,51 +496,51 @@ public:
 
 protected:
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, bool v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, bool v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, long v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, long v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, unsigned long v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, unsigned long v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 
-#ifdef _GLIBCXX_USE_LONG_LONG
+#ifdef HAVE_LONG_LONG_INT
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, long long v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, long long v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, unsigned long long v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, unsigned long long v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 #endif
 
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, double v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, double v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, long double v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, long double v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
 
        iter_type
-       do_put(iter_type oit, ios_base & b, char_type fill, void const * v) const
+       do_put(iter_type oit, ios_base & b, char_type fill, void const * v) const override
        {
                return do_put_helper(oit, b, fill, v);
        }
@@ -604,7 +595,7 @@ public:
 protected:
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, bool & v) const
+               ios_base::iostate & err, bool & v) const override
        {
                if (b.flags() & ios_base::boolalpha) {
                        numpunct_facet p;
@@ -634,7 +625,7 @@ protected:
                        }
                        if (ok) {
                                err = ios_base::goodbit;
-                               v = truename == s ? true : false;
+                               v = (truename == s);
                        } else
                                err = ios_base::failbit;
                        if (iit == eit)
@@ -657,43 +648,43 @@ protected:
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, long & v) const
+               ios_base::iostate & err, long & v) const override
        {
                return do_get_integer(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, unsigned short & v) const
+               ios_base::iostate & err, unsigned short & v) const override
        {
                return do_get_integer(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, unsigned int & v) const
+               ios_base::iostate & err, unsigned int & v) const override
        {
                return do_get_integer(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, unsigned long & v) const
+               ios_base::iostate & err, unsigned long & v) const override
        {
                return do_get_integer(iit, eit, b, err, v);
        }
 
-#ifdef _GLIBCXX_USE_LONG_LONG
+#ifdef HAVE_LONG_LONG_INT
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, long long & v) const
+               ios_base::iostate & err, long long & v) const override
        {
                return do_get_integer(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, unsigned long long & v) const
+               ios_base::iostate & err, unsigned long long & v) const override
        {
                return do_get_integer(iit, eit, b, err, v);
        }
@@ -701,28 +692,28 @@ protected:
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, float & v) const
+               ios_base::iostate & err, float & v) const override
        {
                return do_get_float(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, double & v) const
+               ios_base::iostate & err, double & v) const override
        {
                return do_get_float(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, long double & v) const
+               ios_base::iostate & err, long double & v) const override
        {
                return do_get_float(iit, eit, b, err, v);
        }
 
        iter_type
        do_get(iter_type iit, iter_type eit, ios_base & b,
-               ios_base::iostate & err, void * & v) const
+               ios_base::iostate & err, void * & v) const override
        {
                unsigned long val;
                iter_type end = do_get_integer(iit, eit, b, err, val);
@@ -771,7 +762,6 @@ private:
                // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)?
                string s;
                s.reserve(64);
-               char c;
                numpunct_facet p;
                char const dot = p.decimal_point();
                char const sep = p.thousands_sep();
@@ -829,6 +819,6 @@ namespace {
 /// make sure that our facets get used
 static locale_initializer initializer;
 
-}
-}
+} // namespace
+} // namespace lyx
 #endif