/// Maximum valid UCS4 code point
char_type const ucs4_max = 0x10ffff;
-} // anon namespace
+} // namespace
bool isLetterChar(char_type c)
{
if (!is_utf16(c)) {
// assume that no non-utf16 character is a space
- // c outside the UCS4 range is catched as well
+ // c outside the UCS4 range is caught as well
return false;
}
QChar const qc = ucs4_to_qchar(c);
{
if (!is_utf16(c))
// assume that no non-utf16 character is a numeral
- // c outside the UCS4 range is catched as well
+ // c outside the UCS4 range is caught as well
return false;
return ucs4_to_qchar(c).isNumber();
}
+bool isCommonNumberSeparator(char_type c)
+{
+ if (!is_utf16(c))
+ // assume that no non-utf16 character is a numeral
+ // c outside the UCS4 range is caught as well
+ return false;
+ return ucs4_to_qchar(c).direction() == QChar::DirCS;
+}
+
+
+bool isEuropeanNumberTerminator(char_type c)
+{
+ if (!is_utf16(c))
+ // assume that no non-utf16 character is a numeral
+ // c outside the UCS4 range is caught as well
+ return false;
+ return ucs4_to_qchar(c).direction() == QChar::DirET;
+}
+
+
bool isDigitASCII(char_type c)
{
return '0' <= c && c <= '9';
{
if (!is_utf16(c)) {
// assume that no non-utf16 character is an op
- // c outside the UCS4 range is catched as well
+ // c outside the UCS4 range is caught as well
return false;
}
QChar const qc = ucs4_to_qchar(c);
return c;
}
-}
+} // namespace
int compare_ascii_no_case(string const & s, string const & s2)
bool isHex(docstring const & str)
{
- int index = 0;
+ size_t index = 0;
if (str.length() > 2 && str[0] == '0' &&
(str[1] == 'x' || str[1] == 'X'))
index = 2;
- int const len = str.length();
+ size_t const len = str.length();
for (; index < len; ++index) {
if (!isHexChar(str[index]))
}
-int hexToInt(docstring const & str)
+unsigned int hexToInt(docstring const & str)
{
string s = to_ascii(str);
- int h;
+ unsigned int h;
sscanf(s.c_str(), "%x", &h);
return h;
}
bool isAscii(docstring const & str)
{
- int const len = str.length();
- for (int i = 0; i < len; ++i)
+ size_t const len = str.length();
+ for (size_t i = 0; i < len; ++i)
if (str[i] >= 0x80)
return false;
return true;
bool isAscii(string const & str)
{
- int const len = str.length();
- for (int i = 0; i < len; ++i)
+ size_t const len = str.length();
+ for (size_t i = 0; i < len; ++i)
if (static_cast<unsigned char>(str[i]) >= 0x80)
return false;
return true;
Char operator()(Char c) const { return ascii_tolower(c); }
};
-} // end of anon namespace
+} // namespace
docstring const lowercase(docstring const & a)
size_t const olen = oldstr.length();
while ((i = lstr.find(oldstr, i)) != string::npos) {
lstr.replace(i, olen, newstr);
- i += newstr.length(); // We need to be sure that we dont
+ i += newstr.length(); // We need to be sure that we don't
// use the same i over and over again.
}
return lstr;
size_t const olen = oldstr.length();
while ((i = lstr.find(oldstr, i)) != string::npos) {
lstr.replace(i, olen, newstr);
- i += newstr.length(); // We need to be sure that we dont
+ i += newstr.length(); // We need to be sure that we don't
// use the same i over and over again.
}
return lstr;
}
-}
+} // namespace
string const subst(string const & a, char oldchar, char newchar)
}
-/// Count all occurences of char \a chr inside \a str
+/// Count all occurrences of char \a chr inside \a str
int count_char(docstring const & str, docstring::value_type chr)
{
int count = 0;
return tmp;
}
-} // anon
+} // namespace
string const split(string const & a, string & piece, char delim)
}
-bool truncateWithEllipsis(docstring & str, size_t const len)
+bool truncateWithEllipsis(docstring & str, size_t const len, bool const mid)
{
if (str.size() <= len)
return false;
- str.resize(len);
- if (len > 0)
- str[len - 1] = 0x2026;// HORIZONTAL ELLIPSIS
+ if (mid && len > 0) {
+ size_t const hlen = len / 2;
+ docstring suffix = str.substr(str.size() - hlen);
+ str.resize(hlen);
+ str[hlen - 1] = 0x2026;// HORIZONTAL ELLIPSIS
+ str += suffix;
+ } else {
+ str.resize(len);
+ if (len > 0)
+ str[len - 1] = 0x2026;// HORIZONTAL ELLIPSIS
+ }
return true;
}
return retval;
}
-}
+} // namespace
docstring wrap(docstring const & str, int const ind, size_t const width)
namespace {
template<typename String> vector<String> const
-getVectorFromStringT(String const & str, String const & delim, bool keepempty)
+getVectorFromStringT(String const & str, String const & delim,
+ bool keepempty, bool trimit)
{
// Lars would like this code to go, but for now his replacement (below)
// doesn't fullfil the same function. I have, therefore, reactivated the
vector<String> vec;
if (str.empty())
return vec;
- String keys = rtrim(str);
+ String keys = trimit ? rtrim(str) : str;
while (true) {
size_t const idx = keys.find(delim);
if (idx == String::npos) {
- vec.push_back(ltrim(keys));
+ vec.push_back(trimit ? ltrim(keys) : keys);
break;
}
- String const key = trim(keys.substr(0, idx));
+ String const key = trimit ?
+ trim(keys.substr(0, idx)) : keys.substr(0, idx);
if (!key.empty() || keepempty)
vec.push_back(key);
size_t const start = idx + delim.size();
return str;
}
-} // namespace anon
+} // namespace
vector<string> const getVectorFromString(string const & str,
- string const & delim,
- bool keepempty)
+ string const & delim, bool keepempty, bool trimit)
{
- return getVectorFromStringT<string>(str, delim, keepempty);
+ return getVectorFromStringT<string>(str, delim, keepempty, trimit);
}
vector<docstring> const getVectorFromString(docstring const & str,
- docstring const & delim,
- bool keepempty)
+ docstring const & delim, bool keepempty, bool trimit)
{
- return getVectorFromStringT<docstring>(str, delim, keepempty);
+ return getVectorFromStringT<docstring>(str, delim, keepempty, trimit);
}
}
+docstring to_percent_encoding(docstring const & in, docstring const & ex)
+{
+ QByteArray input = to_utf8(in).c_str();
+ QByteArray excludes = to_utf8(ex).c_str();
+ return from_utf8(string(input.toPercentEncoding(excludes).data()));
+}
+
+
+string from_percent_encoding(string const & in)
+{
+ return QByteArray::fromPercentEncoding(in.c_str()).data();
+}
+
+
docstring bformat(docstring const & fmt, int arg1)
{
LATTEST(contains(fmt, from_ascii("%1$d")));
}
-#ifdef LYX_USE_LONG_LONG
+#ifdef HAVE_LONG_LONG_INT
docstring bformat(docstring const & fmt, long long arg1)
{
LATTEST(contains(fmt, from_ascii("%1$d")));
return subst(str, from_ascii("%%"), from_ascii("%"));
}
+docstring bformat(docstring const & fmt, docstring const & arg1,
+ docstring const & arg2, docstring const & arg3,
+ docstring const & arg4, docstring const & arg5)
+{
+ LATTEST(contains(fmt, from_ascii("%1$s")));
+ LATTEST(contains(fmt, from_ascii("%2$s")));
+ LATTEST(contains(fmt, from_ascii("%3$s")));
+ LATTEST(contains(fmt, from_ascii("%4$s")));
+ LATTEST(contains(fmt, from_ascii("%5$s")));
+ docstring str = subst(fmt, from_ascii("%1$s"), arg1);
+ str = subst(str, from_ascii("%2$s"), arg2);
+ str = subst(str, from_ascii("%3$s"), arg3);
+ str = subst(str, from_ascii("%4$s"), arg4);
+ str = subst(str, from_ascii("%5$s"), arg5);
+ return subst(str, from_ascii("%%"), from_ascii("%"));
+}
+
} // namespace support
} // namespace lyx