change call to shared_ptr::reset, move some using declarations around

[lyx.git] / src / support / LRegex.C

diff --git a/src/support/LRegex.C b/src/support/LRegex.C
index 1babf22127d05f10c34ca5c56d3c190345f04a5d..a82b6642301e3e666388108a78d20247b5a851d7 100644 (file)
--- a/src/support/LRegex.C
+++ b/src/support/LRegex.C
@@ -1,7 +1,3 @@
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include <config.h>
 
 #include <sys/types.h>
@@ -12,6 +8,10 @@
 #include "lyxregex.h"
 #endif
 
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
 #include "LRegex.h"
 
 using std::make_pair;
@@ -20,63 +20,63 @@ using std::make_pair;
 struct LRegex::Impl {
        ///
        regex_t * preg;
-       
+
        ///
        int error_code;
-       
+
        ///
        mutable LRegex::SubMatches matches;
-       
+
        ///
-       Impl(string const & regex) 
+       Impl(string const & regex)
                : preg(new regex_t), error_code(0)
        {
                error_code = regcomp(preg, regex.c_str(), REG_EXTENDED);
        }
-       
+
        ///
        ~Impl()
        {
                regfree(preg);
                delete preg;
        }
-       
+
        ///
        bool exact_match(string const & str) const
        {
                regmatch_t tmp;
                if (!regexec(preg, str.c_str(), 1, &tmp, 0)) {
-                       if (tmp.rm_so == 0 && 
+                       if (tmp.rm_so == 0 &&
                            tmp.rm_eo == static_cast<signed int>(str.length()))
                                return true;
                }
                // no match
                return false;
        }
-       
+
        ///
-       LRegex::MatchPair first_match(string const & str) const
+       LRegex::MatchPair const first_match(string const & str) const
        {
                regmatch_t tmp;
                regexec(preg, str.c_str(), 1, &tmp, 0);
-               unsigned int first = tmp.rm_so != -1 ?
-                       static_cast<unsigned int>(tmp.rm_so) : string::npos;
-               unsigned int second = tmp.rm_eo != -1 ?
-                       static_cast<unsigned int>(tmp.rm_eo) : string::npos;
+               string::size_type const first = tmp.rm_so != -1 ?
+                       tmp.rm_so : string::npos;
+               string::size_type const second = tmp.rm_eo != -1 ?
+                       tmp.rm_eo : string::npos;
                return make_pair(first, second - first);
        }
-       
+
        ///
-       string getError() const
+       string const getError() const
        {
                size_t nr = regerror(error_code, preg, 0, 0);
                char * tmp = new char[nr];
                regerror(error_code, preg, tmp, nr);
-               string ret(tmp);
+               string const ret(tmp);
                delete [] tmp;
                return ret;
        }
-       
+
        ///
        LRegex::SubMatches const & exec(string const & str) const
        {
@@ -88,20 +88,19 @@ struct LRegex::Impl {
                // func much faster, but client code will be simpler,
                // because then it will only be needed to scan through
                // all the entries in matches.
-               size_t subs = (preg->re_nsub != 0 ? (preg->re_nsub + 1) : 1);
+               size_t const subs =
+                       (preg->re_nsub != 0 ? (preg->re_nsub + 1) : 1);
                regmatch_t * mat = new regmatch_t[subs];
-               unsigned int first = 0;
-               unsigned int second = 0;
+               string::size_type first = 0;
+               string::size_type second = 0;
                matches.erase(matches.begin(), matches.end());
                if (!regexec(preg, str.c_str(), subs, mat, 0)) { // some match
                        matches.reserve(subs);
                        for (size_t i = 0; i < subs; ++i) {
                                first = mat[i].rm_so != -1 ?
-                                       static_cast<unsigned int>
-                                       (mat[i].rm_so) : string::npos;
+                                       mat[i].rm_so : string::npos;
                                second = mat[i].rm_eo != -1 ?
-                                       static_cast<unsigned int>
-                                       (mat[i].rm_eo) : string::npos;
+                                       mat[i].rm_eo : string::npos;
                                matches.push_back(make_pair(first,
                                                            second - first));
                        }
@@ -134,13 +133,13 @@ bool LRegex::exact_match(string const & str) const
 }
 
 
-LRegex::MatchPair LRegex::first_match(string const & str) const
+LRegex::MatchPair const LRegex::first_match(string const & str) const
 {
        return impl->first_match(str);
 }
 
 
-string LRegex::getError() const
+string const LRegex::getError() const
 {
        return impl->getError();
 }