Replace the text class shared ptr by good old index-into-global-list.

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

diff --git a/src/support/lstrings.cpp b/src/support/lstrings.cpp
index 16d7946ef623fbc6aa09fb52ba41671f4e50d44b..8c0633fd7d7d46d94395af4b012995114035d86e 100644 (file)
--- a/src/support/lstrings.cpp
+++ b/src/support/lstrings.cpp
@@ -13,35 +13,34 @@
 
 #include "support/lstrings.h"
 
-#include "support/lyxlib.h"
 #include "support/convert.h"
 #include "support/qstring_helpers.h"
 #include "support/textutils.h"
 
-#include "debug.h"
-
 #include <boost/tokenizer.hpp>
 #include <boost/assert.hpp>
 
-#include <cctype>
-#include <cstdlib>
-
 #include <algorithm>
-#include <sstream>
-
 
-using std::transform;
-using std::string;
-using std::vector;
+using namespace std;
 
-#ifndef CXX_GLOBAL_CSTD
-using std::isdigit;
-using std::tolower;
-using std::toupper;
-#endif
+namespace lyx {
 
+// Using this allows us to have docstring default arguments in headers
+// without #include "support/docstring" there.
+docstring const & empty_docstring()
+{
+       static docstring s;
+       return s;
+}
 
-namespace lyx {
+// Using this allows us to have string default arguments in headers
+// without #include <string>
+string const & empty_string()
+{
+       static string s;
+       return s;
+}
 
 /**
  * Convert a QChar into a UCS4 character.
@@ -233,73 +232,77 @@ int compare_ascii_no_case(docstring const & s, docstring const & s2)
 
 bool isStrInt(string const & str)
 {
-       if (str.empty()) return false;
+       if (str.empty())
+               return false;
 
        // Remove leading and trailing white space chars.
        string const tmpstr = trim(str);
-       if (tmpstr.empty()) return false;
+       if (tmpstr.empty())
+               return false;
 
        string::const_iterator cit = tmpstr.begin();
-       if ((*cit) == '-') ++cit;
+       if ((*cit) == '-')
+               ++cit;
+
        string::const_iterator end = tmpstr.end();
-       for (; cit != end; ++cit) {
-               if (!isdigit((*cit))) return false;
-       }
+       for (; cit != end; ++cit)
+               if (!isdigit((*cit)))
+                       return false;
+
        return true;
 }
 
 
 bool isStrUnsignedInt(string const & str)
 {
-       if (str.empty()) return false;
+       if (str.empty())
+               return false;
 
        // Remove leading and trailing white space chars.
        string const tmpstr = trim(str);
-       if (tmpstr.empty()) return false;
+       if (tmpstr.empty())
+               return false;
 
        string::const_iterator cit = tmpstr.begin();
        string::const_iterator end = tmpstr.end();
-       for (; cit != end; ++cit) {
-               if (!isdigit((*cit))) return false;
-       }
+       for (; cit != end; ++cit)
+               if (!isdigit((*cit)))
+                       return false;
+
        return true;
 }
 
 
 bool isStrDbl(string const & str)
 {
-       if (str.empty()) return false;
+       if (str.empty())
+               return false;
 
        // Remove leading and trailing white space chars.
        string const tmpstr = trim(str);
-       if (tmpstr.empty()) return false;
-       //      if (1 < tmpstr.count('.')) return false;
+       if (tmpstr.empty())
+               return false;
+       //      if (tmpstr.count('.') > 1) return false;
 
        string::const_iterator cit = tmpstr.begin();
-       bool found_dot(false);
-       if ((*cit) == '-') ++cit;
+       bool found_dot = false;
+       if (*cit == '-')
+               ++cit;
        string::const_iterator end = tmpstr.end();
        for (; cit != end; ++cit) {
-               if (!isdigit((*cit))
-                   && '.' != (*cit)) {
+               if (!isdigit(*cit) && *cit != '.')
                        return false;
-               }
                if ('.' == (*cit)) {
-                       if (found_dot) {
+                       if (found_dot)
                                return false;
-                       } else {
-                               found_dot = true;
-                       }
+                       found_dot = true;
                }
        }
        return true;
 }
 
 
-namespace {
-
-inline
-bool isHexChar(char_type c)
+static bool isHexChar(char_type c)
 {
        return c == '0' ||
                c == '1' ||
@@ -319,8 +322,6 @@ bool isHexChar(char_type c)
                c == 'f' || c == 'F';
 }
 
-} // anon namespace
-
 
 bool isHex(docstring const & str)
 {
@@ -403,8 +404,8 @@ char_type uppercase(char_type c)
 
 namespace {
 
-// since we cannot use std::tolower and std::toupper directly in the
-// calls to std::transform yet, we use these helper clases. (Lgb)
+// since we cannot use tolower and toupper directly in the
+// calls to transform yet, we use these helper clases. (Lgb)
 
 struct local_lowercase {
        char_type operator()(char_type c) const {
@@ -476,14 +477,7 @@ bool prefixIs(string const & a, string const & pre)
 {
        size_t const prelen = pre.length();
        size_t const alen = a.length();
-
-       if (prelen > alen || a.empty())
-               return false;
-#if defined(STD_STRING_IS_GOOD)
-       return a.compare(0, prelen, pre) == 0;
-#else
-       return ::strncmp(a.c_str(), pre.c_str(), prelen) == 0;
-#endif
+       return prelen <= alen && !a.empty() && a.compare(0, prelen, pre) == 0;
 }
 
 
@@ -491,11 +485,7 @@ bool prefixIs(docstring const & a, docstring const & pre)
 {
        size_t const prelen = pre.length();
        size_t const alen = a.length();
-
-       if (prelen > alen || a.empty())
-               return false;
-       else
-               return a.compare(0, prelen, pre) == 0;
+       return prelen <= alen && !a.empty() && a.compare(0, prelen, pre) == 0;
 }
 
 
@@ -518,16 +508,7 @@ bool suffixIs(string const & a, string const & suf)
 {
        size_t const suflen = suf.length();
        size_t const alen = a.length();
-
-       if (suflen > alen)
-               return false;
-
-#if !defined(USE_INCLUDED_STRING) && !defined(STD_STRING_IS_GOOD)
-       string tmp(a, alen - suflen);
-       return ::strncmp(tmp.c_str(), suf.c_str(), suflen) == 0;
-#else
-       return a.compare(alen - suflen, suflen, suf) == 0;
-#endif
+       return suflen <= alen && a.compare(alen - suflen, suflen, suf) == 0;
 }
 
 
@@ -568,7 +549,8 @@ string const token(string const & a, char delim, int n)
 
 docstring const token(docstring const & a, char_type delim, int n)
 {
-       if (a.empty()) return docstring();
+       if (a.empty())
+               return docstring();
 
        size_t k = 0;
        size_t i = 0;
@@ -614,10 +596,10 @@ namespace {
 
 /// Substitute all \a oldchar with \a newchar
 template<typename Ch> inline
-std::basic_string<Ch> const subst_char(std::basic_string<Ch> const & a,
+basic_string<Ch> const subst_char(basic_string<Ch> const & a,
                Ch oldchar, Ch newchar)
 {
-       typedef std::basic_string<Ch> String;
+       typedef basic_string<Ch> String;
        String tmp(a);
        typename String::iterator lit = tmp.begin();
        typename String::iterator end = tmp.end();