3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
6 * \author Lars Gullik Bjønnes
7 * \author Jean-Marc Lasgouttes
9 * Full author contact details are available in file CREDITS.
19 #include "BoostFormat.h"
22 #include <boost/regex.hpp>
23 #include <boost/tokenizer.hpp>
34 #ifndef CXX_GLOBAL_CSTD
45 int compare_no_case(string const & s, string const & s2)
47 string::const_iterator p = s.begin();
48 string::const_iterator p2 = s2.begin();
50 while (p != s.end() && p2 != s2.end()) {
51 int const lc1 = tolower(*p);
52 int const lc2 = tolower(*p2);
54 return (lc1 < lc2) ? -1 : 1;
59 if (s.size() == s2.size())
61 if (s.size() < s2.size())
68 int ascii_tolower(int c) {
69 if (c >= 'A' && c <= 'Z')
76 int compare_ascii_no_case(string const & s, string const & s2)
78 string::const_iterator p = s.begin();
79 string::const_iterator p2 = s2.begin();
81 while (p != s.end() && p2 != s2.end()) {
82 int const lc1 = ascii_tolower(*p);
83 int const lc2 = ascii_tolower(*p2);
85 return (lc1 < lc2) ? -1 : 1;
90 if (s.size() == s2.size())
92 if (s.size() < s2.size())
98 int compare_no_case(string const & s, string const & s2, unsigned int len)
100 string::const_iterator p = s.begin();
101 string::const_iterator p2 = s2.begin();
103 while (i < len && p != s.end() && p2 != s2.end()) {
104 int const lc1 = tolower(*p);
105 int const lc2 = tolower(*p2);
107 return (lc1 < lc2) ? -1 : 1;
113 if (s.size() >= len && s2.size() >= len)
115 if (s.size() < s2.size())
121 bool isStrInt(string const & str)
123 if (str.empty()) return false;
125 // Remove leading and trailing white space chars.
126 string const tmpstr = trim(str);
127 if (tmpstr.empty()) return false;
129 string::const_iterator cit = tmpstr.begin();
130 if ((*cit) == '-') ++cit;
131 string::const_iterator end = tmpstr.end();
132 for (; cit != end; ++cit) {
133 if (!isdigit((*cit))) return false;
139 bool isStrUnsignedInt(string const & str)
141 if (str.empty()) return false;
143 // Remove leading and trailing white space chars.
144 string const tmpstr = trim(str);
145 if (tmpstr.empty()) return false;
147 string::const_iterator cit = tmpstr.begin();
148 string::const_iterator end = tmpstr.end();
149 for (; cit != end; ++cit) {
150 if (!isdigit((*cit))) return false;
156 int strToInt(string const & str)
159 // Remove leading and trailing white space chars.
160 string const tmpstr = trim(str);
161 // Do the conversion proper.
169 unsigned int strToUnsignedInt(string const & str)
171 if (isStrUnsignedInt(str)) {
172 // Remove leading and trailing white space chars.
173 string const tmpstr = trim(str);
174 // Do the conversion proper.
182 bool isStrDbl(string const & str)
184 if (str.empty()) return false;
186 // Remove leading and trailing white space chars.
187 string const tmpstr = trim(str);
188 if (tmpstr.empty()) return false;
189 // if (1 < tmpstr.count('.')) return false;
191 string::const_iterator cit = tmpstr.begin();
192 bool found_dot(false);
193 if ((*cit) == '-') ++cit;
194 string::const_iterator end = tmpstr.end();
195 for (; cit != end; ++cit) {
212 double strToDbl(string const & str)
215 // Remove leading and trailing white space chars.
216 string const tmpstr = trim(str);
217 // Do the conversion proper.
218 return ::atof(tmpstr.c_str());
225 char lowercase(char c)
227 return char(tolower(c));
231 char uppercase(char c)
233 return char(toupper(c));
239 // since we cannot use std::tolower and std::toupper directly in the
240 // calls to std::transform yet, we use these helper clases. (Lgb)
242 struct local_lowercase {
243 char operator()(char c) const {
248 struct local_uppercase {
249 char operator()(char c) const {
254 struct local_ascii_lowercase {
255 char operator()(char c) const {
256 return ascii_tolower(c);
260 } // end of anon namespace
262 string const lowercase(string const & a)
265 transform(tmp.begin(), tmp.end(), tmp.begin(), local_lowercase());
269 string const uppercase(string const & a)
272 transform(tmp.begin(), tmp.end(), tmp.begin(), local_uppercase());
277 string const ascii_lowercase(string const & a)
280 transform(tmp.begin(), tmp.end(), tmp.begin(),
281 local_ascii_lowercase());
286 bool prefixIs(string const & a, string const & pre)
288 string::size_type const prelen = pre.length();
289 string::size_type const alen = a.length();
291 if (prelen > alen || a.empty())
294 #if !defined(USE_INCLUDED_STRING) && !defined(STD_STRING_IS_GOOD)
295 return ::strncmp(a.c_str(), pre.c_str(), prelen) == 0;
297 return a.compare(0, prelen, pre) == 0;
303 bool suffixIs(string const & a, char c)
305 if (a.empty()) return false;
306 return a[a.length() - 1] == c;
310 bool suffixIs(string const & a, string const & suf)
312 string::size_type const suflen = suf.length();
313 string::size_type const alen = a.length();
318 #if !defined(USE_INCLUDED_STRING) && !defined(STD_STRING_IS_GOOD)
319 string tmp(a, alen - suflen);
320 return ::strncmp(tmp.c_str(), suf.c_str(), suflen) == 0;
322 return a.compare(alen - suflen, suflen, suf) == 0;
328 bool contains(string const & a, string const & b)
332 return a.find(b) != string::npos;
336 bool contains(string const & a, char b)
340 return a.find(b) != string::npos;
344 bool containsOnly(string const & s, string const & cset)
346 return s.find_first_not_of(cset) == string::npos;
350 // ale970405+lasgoutt-970425
351 // rewritten to use new string (Lgb)
352 string const token(string const & a, char delim, int n)
354 if (a.empty()) return string();
356 string::size_type k = 0;
357 string::size_type i = 0;
359 // Find delimiter or end of string
361 if ((i = a.find(delim, i)) == string::npos)
365 // i is now the n'th delim (or string::npos)
366 if (i == string::npos) return string();
367 k = a.find(delim, i);
368 // k is now the n'th + 1 delim (or string::npos)
370 return a.substr(i, k - i);
374 // this could probably be faster and/or cleaner, but it seems to work (JMarc)
375 // rewritten to use new string (Lgb)
376 int tokenPos(string const & a, char delim, string const & tok)
382 while (!str.empty()) {
383 str = split(str, tmptok, delim);
392 bool regexMatch(string const & a, string const & pattern)
394 // We massage the pattern a bit so that the usual
395 // shell pattern we all are used to will work.
396 // One nice thing about using a real regex is that
397 // things like "*.*[^~]" will work also.
398 // build the regex string.
399 string regex(pattern);
400 regex = subst(regex, ".", "\\.");
401 regex = subst(regex, "*", ".*");
402 boost::regex reg(STRCONV(regex));
403 return boost::regex_match(STRCONV(a), reg);
407 string const subst(string const & a, char oldchar, char newchar)
410 string::iterator lit = tmp.begin();
411 string::iterator end = tmp.end();
412 for (; lit != end; ++lit)
413 if ((*lit) == oldchar)
419 string const subst(string const & a,
420 string const & oldstr, string const & newstr)
423 string::size_type i = 0;
424 string::size_type const olen = oldstr.length();
425 while ((i = lstr.find(oldstr, i)) != string::npos) {
426 lstr.replace(i, olen, newstr);
427 i += newstr.length(); // We need to be sure that we dont
428 // use the same i over and over again.
434 string const trim(string const & a, char const * p)
438 if (a.empty() || !*p)
441 string::size_type r = a.find_last_not_of(p);
442 string::size_type l = a.find_first_not_of(p);
444 // Is this the minimal test? (lgb)
445 if (r == string::npos && l == string::npos)
448 return a.substr(l, r - l + 1);
452 string const rtrim(string const & a, char const * p)
456 if (a.empty() || !*p)
459 string::size_type r = a.find_last_not_of(p);
461 // Is this test really needed? (Lgb)
462 if (r == string::npos)
465 return a.substr(0, r + 1);
469 string const ltrim(string const & a, char const * p)
473 if (a.empty() || !*p)
476 string::size_type l = a.find_first_not_of(p);
478 if (l == string::npos)
481 return a.substr(l, string::npos);
485 string const split(string const & a, string & piece, char delim)
488 string::size_type i = a.find(delim);
489 if (i == a.length() - 1) {
490 piece = a.substr(0, i);
491 } else if (i != string::npos) {
492 piece = a.substr(0, i);
493 tmp = a.substr(i + 1);
496 tmp = a.substr(i + 1);
504 string const split(string const & a, char delim)
507 string::size_type i = a.find(delim);
508 if (i != string::npos) // found delim
509 tmp = a.substr(i + 1);
515 string const rsplit(string const & a, string & piece, char delim)
518 string::size_type i = a.rfind(delim);
519 if (i != string::npos) { // delimiter was found
520 piece = a.substr(0, i);
521 tmp = a.substr(i + 1);
522 } else { // delimiter was not found
529 // This function escapes 8-bit characters and other problematic
530 // characters that cause problems in latex labels.
531 string const escape(string const & lab)
533 char hexdigit[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
534 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
536 for (string::size_type i = 0; i < lab.length(); ++i) {
537 unsigned char c= lab[i];
538 if (c >= 128 || c == '=' || c == '%') {
540 enc += hexdigit[c>>4];
541 enc += hexdigit[c & 15];
550 /// gives a vector of stringparts which have the delimiter delim
551 vector<string> const getVectorFromString(string const & str,
552 string const & delim)
554 // Lars would like this code to go, but for now his replacement (below)
555 // doesn't fullfil the same function. I have, therefore, reactivated the
556 // old code for now. Angus 11 Nov 2002.
561 string keys(rtrim(str));
563 string::size_type const idx = keys.find(delim);
564 if (idx == string::npos) {
565 vec.push_back(ltrim(keys));
568 string const key = trim(keys.substr(0, idx));
571 string::size_type const start = idx + delim.size();
572 keys = keys.substr(start);
576 boost::char_separator<char> sep(delim.c_str());
577 boost::tokenizer<boost::char_separator<char> > tokens(str, sep);
578 #ifndef USE_INCLUDED_STRING
579 return vector<string>(tokens.begin(), tokens.end());
582 using boost::tokenizer;
583 using boost::char_separator;
585 tokenizer<char_separator<char> >::iterator it = tokens.begin();
586 tokenizer<char_separator<char> >::iterator end = tokens.end();
587 for (; it != end; ++it) {
588 vec.push_back(STRCONV((*it)));
596 // the same vice versa
597 string const getStringFromVector(vector<string> const & vec,
598 string const & delim)
602 for (vector<string>::const_iterator it = vec.begin();
603 it != vec.end(); ++it) {
604 string item = trim(*it);
617 string bformat(string const & fmt, string const & arg1)
619 return STRCONV((boost::format(STRCONV(fmt)) % STRCONV(arg1)).str());
623 string bformat(string const & fmt, string const & arg1, string const & arg2)
625 return STRCONV((boost::format(STRCONV(fmt)) % STRCONV(arg1)
626 % STRCONV(arg2)).str());
630 string bformat(string const & fmt, int arg1, int arg2)
632 return STRCONV((boost::format(STRCONV(fmt)) % arg1 % arg2).str());
636 string bformat(string const & fmt, string const & arg1, string const & arg2,
639 return STRCONV((boost::format(STRCONV(fmt)) % STRCONV(arg1)
640 % STRCONV(arg2) % STRCONV(arg3)).str());
644 string bformat(string const & fmt, string const & arg1, string const & arg2,
645 string const & arg3, string const & arg4)
647 return STRCONV((boost::format(STRCONV(fmt)) % STRCONV(arg1)
648 % STRCONV(arg2) % STRCONV(arg3) % STRCONV(arg4)).str());
652 string bformat(string const & fmt, string const & arg1, string const & arg2,
653 string const & arg3, string const & arg4, string const & arg5)
655 return STRCONV((boost::format(STRCONV(fmt)) % STRCONV(arg1)
656 % STRCONV(arg2) % STRCONV(arg3) % STRCONV(arg4)
657 % STRCONV(arg5)).str());
662 string bformat(string const & fmt, string const & arg1)
664 Assert(contains(fmt, "%1$s"));
665 string const str = subst(fmt, "%1$s", arg1);
666 return subst(str, "%%", "%");
670 string bformat(string const & fmt, string const & arg1, string const & arg2)
672 Assert(contains(fmt, "%1$s"));
673 Assert(contains(fmt, "%2$s"));
674 string str = subst(fmt, "%1$s", arg1);
675 str = subst(str, "%2$s", arg2);
676 return subst(str, "%%", "%");
680 string bformat(string const & fmt, int arg1, int arg2)
682 Assert(contains(fmt, "%1$d"));
683 Assert(contains(fmt, "%2$d"));
684 string str = subst(fmt, "%1$d", arg1);
685 str = subst(str, "%2$d", arg2);
686 return subst(str, "%%", "%");
690 string bformat(string const & fmt, string const & arg1, string const & arg2,
693 Assert(contains(fmt, "%1$s"));
694 Assert(contains(fmt, "%2$s"));
695 Assert(contains(fmt, "%3$s"));
696 string str = subst(fmt, "%1$s", arg1);
697 str = subst(str, "%2$s", arg2);
698 str = subst(str, "%3$s", arg3);
699 return subst(str, "%%", "%");
703 string bformat(string const & fmt, string const & arg1, string const & arg2,
704 string const & arg3, string const & arg4)
706 Assert(contains(fmt, "%1$s"));
707 Assert(contains(fmt, "%2$s"));
708 Assert(contains(fmt, "%3$s"));
709 Assert(contains(fmt, "%4$s"));
710 string str = subst(fmt, "%1$s", arg1);
711 str = subst(str, "%2$s", arg2);
712 str = subst(str, "%3$s", arg3);
713 str = subst(str, "%4$s", arg4);
714 return subst(str, "%%", "%");
718 string bformat(string const & fmt, string const & arg1, string const & arg2,
719 string const & arg3, string const & arg4, string const & arg5)
721 Assert(contains(fmt, "%1$s"));
722 Assert(contains(fmt, "%2$s"));
723 Assert(contains(fmt, "%3$s"));
724 Assert(contains(fmt, "%4$s"));
725 Assert(contains(fmt, "%5$s"));
726 string str = subst(fmt, "%1$s", arg1);
727 str = subst(str, "%2$s", arg2);
728 str = subst(str, "%3$s", arg3);
729 str = subst(str, "%4$s", arg4);
730 str = subst(str, "%5$s", arg5);
731 return subst(str, "%%", "%");
736 } // namespace support