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 f44259d349335623789c34d891bd4d6a72aa3f36..cbee18a20a4584ce9f41e87eec322d080cb102f6 100644 (file)
--- a/src/support/docstring.cpp
+++ b/src/support/docstring.cpp
@@ -113,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.";
        }
@@ -251,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
@@ -273,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.";
        }
@@ -291,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.";
        }
@@ -344,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;
@@ -360,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)
@@ -376,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)
@@ -392,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();
@@ -411,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)
@@ -430,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)
@@ -459,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)
@@ -497,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);
        }
@@ -596,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;
@@ -626,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)
@@ -649,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);
        }
@@ -693,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);
@@ -820,6 +819,6 @@ namespace {
 /// make sure that our facets get used
 static locale_initializer initializer;
 
-}
-}
+} // namespace
+} // namespace lyx
 #endif