src/support/lstrings.C

   1 /**
   2  * \file lstrings.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Jean-Marc Lasgouttes
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "support/std_string.h"
  15 #include "lstrings.h"
  16 #include "support/std_sstream.h"
  17 #include "debug.h"
  18 #include "BoostFormat.h"
  19 #include "lyxlib.h"
  20 #include "tostr.h"
  21
  22 #include <boost/tokenizer.hpp>
  23 #include <boost/assert.hpp>
  24
  25 #include <algorithm>
  26
  27 #include <cctype>
  28 #include <cstdlib>
  29
  30 using std::transform;
  31
  32 using std::vector;
  33
  34 #ifndef CXX_GLOBAL_CSTD
  35 using std::atof;
  36 using std::isdigit;
  37 using std::tolower;
  38 using std::toupper;
  39 #endif
  40
  41
  42 namespace lyx {
  43 namespace support {
  44
  45 int compare_no_case(string const & s, string const & s2)
  46 {
  47         string::const_iterator p = s.begin();
  48         string::const_iterator p2 = s2.begin();
  49
  50         while (p != s.end() && p2 != s2.end()) {
  51                 int const lc1 = tolower(*p);
  52                 int const lc2 = tolower(*p2);
  53                 if (lc1 != lc2)
  54                         return (lc1 < lc2) ? -1 : 1;
  55                 ++p;
  56                 ++p2;
  57         }
  58
  59         if (s.size() == s2.size())
  60                 return 0;
  61         if (s.size() < s2.size())
  62                 return -1;
  63         return 1;
  64 }
  65
  66
  67 namespace {
  68         int ascii_tolower(int c) {
  69                 if (c >= 'A' && c <= 'Z')
  70                         return c - 'A' + 'a';
  71                 return c;
  72         }
  73 }
  74
  75
  76 int compare_ascii_no_case(string const & s, string const & s2)
  77 {
  78         string::const_iterator p = s.begin();
  79         string::const_iterator p2 = s2.begin();
  80
  81         while (p != s.end() && p2 != s2.end()) {
  82                 int const lc1 = ascii_tolower(*p);
  83                 int const lc2 = ascii_tolower(*p2);
  84                 if (lc1 != lc2)
  85                         return (lc1 < lc2) ? -1 : 1;
  86                 ++p;
  87                 ++p2;
  88         }
  89
  90         if (s.size() == s2.size())
  91                 return 0;
  92         if (s.size() < s2.size())
  93                 return -1;
  94         return 1;
  95 }
  96
  97
  98 int compare_no_case(string const & s, string const & s2, unsigned int len)
  99 {
 100         string::const_iterator p = s.begin();
 101         string::const_iterator p2 = s2.begin();
 102         unsigned int i = 0;
 103         while (i < len && p != s.end() && p2 != s2.end()) {
 104                 int const lc1 = tolower(*p);
 105                 int const lc2 = tolower(*p2);
 106                 if (lc1 != lc2)
 107                         return (lc1 < lc2) ? -1 : 1;
 108                 ++i;
 109                 ++p;
 110                 ++p2;
 111         }
 112
 113         if (s.size() >= len && s2.size() >= len)
 114                 return 0;
 115         if (s.size() < s2.size())
 116                 return -1;
 117         return 1;
 118 }
 119
 120
 121 bool isStrInt(string const & str)
 122 {
 123         if (str.empty()) return false;
 124
 125         // Remove leading and trailing white space chars.
 126         string const tmpstr = trim(str);
 127         if (tmpstr.empty()) return false;
 128
 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;
 134         }
 135         return true;
 136 }
 137
 138
 139 bool isStrUnsignedInt(string const & str)
 140 {
 141         if (str.empty()) return false;
 142
 143         // Remove leading and trailing white space chars.
 144         string const tmpstr = trim(str);
 145         if (tmpstr.empty()) return false;
 146
 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;
 151         }
 152         return true;
 153 }
 154
 155
 156 int strToInt(string const & str)
 157 {
 158         if (isStrInt(str)) {
 159                 // Remove leading and trailing white space chars.
 160                 string const tmpstr = trim(str);
 161                 // Do the conversion proper.
 162                 return atoi(tmpstr);
 163         } else {
 164                 return 0;
 165         }
 166 }
 167
 168
 169 unsigned int strToUnsignedInt(string const & str)
 170 {
 171         if (isStrUnsignedInt(str)) {
 172                 // Remove leading and trailing white space chars.
 173                 string const tmpstr = trim(str);
 174                 // Do the conversion proper.
 175                 return atoi(tmpstr);
 176         } else {
 177                 return 0;
 178         }
 179 }
 180
 181
 182 bool isStrDbl(string const & str)
 183 {
 184         if (str.empty()) return false;
 185
 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;
 190
 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) {
 196                 if (!isdigit((*cit))
 197                     && '.' != (*cit)) {
 198                         return false;
 199                 }
 200                 if ('.' == (*cit)) {
 201                         if (found_dot) {
 202                                 return false;
 203                         } else {
 204                                 found_dot = true;
 205                         }
 206                 }
 207         }
 208         return true;
 209 }
 210
 211
 212 double strToDbl(string const & str)
 213 {
 214         if (isStrDbl(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());
 219         } else {
 220                 return 0.0;
 221         }
 222 }
 223
 224
 225 char lowercase(char c)
 226 {
 227         return char(tolower(c));
 228 }
 229
 230
 231 char uppercase(char c)
 232 {
 233         return char(toupper(c));
 234 }
 235
 236
 237 namespace {
 238
 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)
 241
 242 struct local_lowercase {
 243         char operator()(char c) const {
 244                 return tolower(c);
 245         }
 246 };
 247
 248 struct local_uppercase {
 249         char operator()(char c) const {
 250                 return toupper(c);
 251         }
 252 };
 253
 254 struct local_ascii_lowercase {
 255         char operator()(char c) const {
 256                 return ascii_tolower(c);
 257         }
 258 };
 259
 260 } // end of anon namespace
 261
 262 string const lowercase(string const & a)
 263 {
 264         string tmp(a);
 265         transform(tmp.begin(), tmp.end(), tmp.begin(), local_lowercase());
 266         return tmp;
 267 }
 268
 269 string const uppercase(string const & a)
 270 {
 271         string tmp(a);
 272         transform(tmp.begin(), tmp.end(), tmp.begin(), local_uppercase());
 273         return tmp;
 274 }
 275
 276
 277 string const ascii_lowercase(string const & a)
 278 {
 279         string tmp(a);
 280         transform(tmp.begin(), tmp.end(), tmp.begin(),
 281                   local_ascii_lowercase());
 282         return tmp;
 283 }
 284
 285
 286 bool prefixIs(string const & a, string const & pre)
 287 {
 288         string::size_type const prelen = pre.length();
 289         string::size_type const alen = a.length();
 290
 291         if (prelen > alen || a.empty())
 292                 return false;
 293         else {
 294 #if !defined(USE_INCLUDED_STRING) && !defined(STD_STRING_IS_GOOD)
 295                 return ::strncmp(a.c_str(), pre.c_str(), prelen) == 0;
 296 #else
 297                 return a.compare(0, prelen, pre) == 0;
 298 #endif
 299         }
 300 }
 301
 302
 303 bool suffixIs(string const & a, char c)
 304 {
 305         if (a.empty()) return false;
 306         return a[a.length() - 1] == c;
 307 }
 308
 309
 310 bool suffixIs(string const & a, string const & suf)
 311 {
 312         string::size_type const suflen = suf.length();
 313         string::size_type const alen = a.length();
 314
 315         if (suflen > alen) {
 316                 return false;
 317         } else {
 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;
 321 #else
 322                 return a.compare(alen - suflen, suflen, suf) == 0;
 323 #endif
 324         }
 325 }
 326
 327
 328 bool contains(string const & a, string const & b)
 329 {
 330         if (a.empty())
 331                 return false;
 332         return a.find(b) != string::npos;
 333 }
 334
 335
 336 bool contains(string const & a, char b)
 337 {
 338         if (a.empty())
 339                 return false;
 340         return a.find(b) != string::npos;
 341 }
 342
 343
 344 bool containsOnly(string const & s, string const & cset)
 345 {
 346         return s.find_first_not_of(cset) == string::npos;
 347 }
 348
 349
 350 // ale970405+lasgoutt-970425
 351 // rewritten to use new string (Lgb)
 352 string const token(string const & a, char delim, int n)
 353 {
 354         if (a.empty()) return string();
 355
 356         string::size_type k = 0;
 357         string::size_type i = 0;
 358
 359         // Find delimiter or end of string
 360         for (; n--;)
 361                 if ((i = a.find(delim, i)) == string::npos)
 362                         break;
 363                 else
 364                         ++i; // step delim
 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)
 369
 370         return a.substr(i, k - i);
 371 }
 372
 373
 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)
 377 {
 378         int i = 0;
 379         string str(a);
 380         string tmptok;
 381
 382         while (!str.empty()) {
 383                 str = split(str, tmptok, delim);
 384                 if (tok == tmptok)
 385                         return i;
 386                 ++i;
 387         }
 388         return -1;
 389 }
 390
 391
 392 string const subst(string const & a, char oldchar, char newchar)
 393 {
 394         string tmp(a);
 395         string::iterator lit = tmp.begin();
 396         string::iterator end = tmp.end();
 397         for (; lit != end; ++lit)
 398                 if ((*lit) == oldchar)
 399                         (*lit) = newchar;
 400         return tmp;
 401 }
 402
 403
 404 string const subst(string const & a,
 405                    string const & oldstr, string const & newstr)
 406 {
 407         string lstr = a;
 408         string::size_type i = 0;
 409         string::size_type const olen = oldstr.length();
 410         while ((i = lstr.find(oldstr, i)) != string::npos) {
 411                 lstr.replace(i, olen, newstr);
 412                 i += newstr.length(); // We need to be sure that we dont
 413                 // use the same i over and over again.
 414         }
 415         return lstr;
 416 }
 417
 418
 419 string const trim(string const & a, char const * p)
 420 {
 421         BOOST_ASSERT(p);
 422
 423         if (a.empty() || !*p)
 424                 return a;
 425
 426         string::size_type r = a.find_last_not_of(p);
 427         string::size_type l = a.find_first_not_of(p);
 428
 429         // Is this the minimal test? (lgb)
 430         if (r == string::npos && l == string::npos)
 431                 return string();
 432
 433         return a.substr(l, r - l + 1);
 434 }
 435
 436
 437 string const rtrim(string const & a, char const * p)
 438 {
 439         BOOST_ASSERT(p);
 440
 441         if (a.empty() || !*p)
 442                 return a;
 443
 444         string::size_type r = a.find_last_not_of(p);
 445
 446         // Is this test really needed? (Lgb)
 447         if (r == string::npos)
 448                 return string();
 449
 450         return a.substr(0, r + 1);
 451 }
 452
 453
 454 string const ltrim(string const & a, char const * p)
 455 {
 456         BOOST_ASSERT(p);
 457
 458         if (a.empty() || !*p)
 459                 return a;
 460
 461         string::size_type l = a.find_first_not_of(p);
 462
 463         if (l == string::npos)
 464                 return string();
 465
 466         return a.substr(l, string::npos);
 467 }
 468
 469
 470 string const split(string const & a, string & piece, char delim)
 471 {
 472         string tmp;
 473         string::size_type i = a.find(delim);
 474         if (i == a.length() - 1) {
 475                 piece = a.substr(0, i);
 476         } else if (i != string::npos) {
 477                 piece = a.substr(0, i);
 478                 tmp = a.substr(i + 1);
 479         } else if (i == 0) {
 480                 piece.erase();
 481                 tmp = a.substr(i + 1);
 482         } else {
 483                 piece = a;
 484         }
 485         return tmp;
 486 }
 487
 488
 489 string const split(string const & a, char delim)
 490 {
 491         string tmp;
 492         string::size_type i = a.find(delim);
 493         if (i != string::npos) // found delim
 494                 tmp = a.substr(i + 1);
 495         return tmp;
 496 }
 497
 498
 499 // ale970521
 500 string const rsplit(string const & a, string & piece, char delim)
 501 {
 502         string tmp;
 503         string::size_type i = a.rfind(delim);
 504         if (i != string::npos) { // delimiter was found
 505                 piece = a.substr(0, i);
 506                 tmp = a.substr(i + 1);
 507         } else { // delimiter was not found
 508                 piece.erase();
 509         }
 510         return tmp;
 511 }
 512
 513
 514 // This function escapes 8-bit characters and other problematic
 515 // characters that cause problems in latex labels.
 516 string const escape(string const & lab)
 517 {
 518         char hexdigit[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
 519                               '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 520         string enc;
 521         for (string::size_type i = 0; i < lab.length(); ++i) {
 522                 unsigned char c= lab[i];
 523                 if (c >= 128 || c == '=' || c == '%') {
 524                         enc += '=';
 525                         enc += hexdigit[c>>4];
 526                         enc += hexdigit[c & 15];
 527                 } else {
 528                         enc += c;
 529                 }
 530         }
 531         return enc;
 532 }
 533
 534
 535 /// gives a vector of stringparts which have the delimiter delim
 536 vector<string> const getVectorFromString(string const & str,
 537                                          string const & delim)
 538 {
 539 // Lars would like this code to go, but for now his replacement (below)
 540 // doesn't fullfil the same function. I have, therefore, reactivated the
 541 // old code for now. Angus 11 Nov 2002.
 542 #if 1
 543         vector<string> vec;
 544         if (str.empty())
 545                 return vec;
 546         string keys(rtrim(str));
 547         for(;;) {
 548                 string::size_type const idx = keys.find(delim);
 549                 if (idx == string::npos) {
 550                         vec.push_back(ltrim(keys));
 551                         break;
 552                 }
 553                 string const key = trim(keys.substr(0, idx));
 554                 if (!key.empty())
 555                         vec.push_back(key);
 556                 string::size_type const start = idx + delim.size();
 557                 keys = keys.substr(start);
 558         }
 559         return vec;
 560 #else
 561         boost::char_separator<char> sep(delim.c_str());
 562         boost::tokenizer<boost::char_separator<char> > tokens(str, sep);
 563 #ifndef USE_INCLUDED_STRING
 564         return vector<string>(tokens.begin(), tokens.end());
 565 #else
 566         vector<string> vec;
 567         using boost::tokenizer;
 568         using boost::char_separator;
 569
 570         tokenizer<char_separator<char> >::iterator it = tokens.begin();
 571         tokenizer<char_separator<char> >::iterator end = tokens.end();
 572         for (; it != end; ++it) {
 573                 vec.push_back(STRCONV((*it)));
 574         }
 575         return vec;
 576 #endif
 577 #endif
 578 }
 579
 580
 581 // the same vice versa
 582 string const getStringFromVector(vector<string> const & vec,
 583                                  string const & delim)
 584 {
 585         string str;
 586         int i = 0;
 587         for (vector<string>::const_iterator it = vec.begin();
 588              it != vec.end(); ++it) {
 589                 string item = trim(*it);
 590                 if (item.empty())
 591                         continue;
 592                 if (i++ > 0)
 593                         str += delim;
 594                 str += item;
 595         }
 596         return str;
 597 }
 598
 599
 600 #if USE_BOOST_FORMAT
 601
 602 string bformat(string const & fmt, string const & arg1)
 603 {
 604         return (boost::format(fmt) % arg1).str();
 605 }
 606
 607
 608 string bformat(string const & fmt, string const & arg1, string const & arg2)
 609 {
 610         return (boost::format(fmt) % arg1 % arg2).str();
 611 }
 612
 613
 614 string bformat(string const & fmt, int arg1, int arg2)
 615 {
 616         return (boost::format(fmt) % arg1 % arg2).str();
 617 }
 618
 619
 620 string bformat(string const & fmt, string const & arg1, string const & arg2,
 621         string const & arg3)
 622 {
 623         return (boost::format(fmt) % arg1 % arg2 % arg3).str();
 624 }
 625
 626
 627 string bformat(string const & fmt, string const & arg1, string const & arg2,
 628         string const & arg3, string const & arg4)
 629 {
 630         return (boost::format(fmt) % arg1 % arg2 % arg3 % arg4).str();
 631 }
 632
 633
 634 string bformat(string const & fmt, string const & arg1, string const & arg2,
 635         string const & arg3, string const & arg4, string const & arg5)
 636 {
 637         return (boost::format(fmt) % arg1 % arg2 % arg3 % arg4 % arg5).str();
 638 }
 639
 640 #else
 641
 642 string bformat(string const & fmt, string const & arg1)
 643 {
 644         BOOST_ASSERT(contains(fmt, "%1$s"));
 645         string const str = subst(fmt, "%1$s", arg1);
 646         return subst(str, "%%", "%");
 647 }
 648
 649
 650 string bformat(string const & fmt, string const & arg1, string const & arg2)
 651 {
 652         BOOST_ASSERT(contains(fmt, "%1$s"));
 653         BOOST_ASSERT(contains(fmt, "%2$s"));
 654         string str = subst(fmt, "%1$s", arg1);
 655         str = subst(str, "%2$s", arg2);
 656         return subst(str, "%%", "%");
 657 }
 658
 659
 660 string bformat(string const & fmt, int arg1, int arg2)
 661 {
 662         BOOST_ASSERT(contains(fmt, "%1$d"));
 663         BOOST_ASSERT(contains(fmt, "%2$d"));
 664         string str = subst(fmt, "%1$d", tostr(arg1));
 665         str = subst(str, "%2$d", tostr(arg2));
 666         return subst(str, "%%", "%");
 667 }
 668
 669
 670 string bformat(string const & fmt, string const & arg1, string const & arg2,
 671         string const & arg3)
 672 {
 673         BOOST_ASSERT(contains(fmt, "%1$s"));
 674         BOOST_ASSERT(contains(fmt, "%2$s"));
 675         BOOST_ASSERT(contains(fmt, "%3$s"));
 676         string str = subst(fmt, "%1$s", arg1);
 677         str = subst(str, "%2$s", arg2);
 678         str = subst(str, "%3$s", arg3);
 679         return subst(str, "%%", "%");
 680 }
 681
 682
 683 string bformat(string const & fmt, string const & arg1, string const & arg2,
 684         string const & arg3, string const & arg4)
 685 {
 686         BOOST_ASSERT(contains(fmt, "%1$s"));
 687         BOOST_ASSERT(contains(fmt, "%2$s"));
 688         BOOST_ASSERT(contains(fmt, "%3$s"));
 689         BOOST_ASSERT(contains(fmt, "%4$s"));
 690         string str = subst(fmt, "%1$s", arg1);
 691         str = subst(str, "%2$s", arg2);
 692         str = subst(str, "%3$s", arg3);
 693         str = subst(str, "%4$s", arg4);
 694         return subst(str, "%%", "%");
 695 }
 696
 697
 698 string bformat(string const & fmt, string const & arg1, string const & arg2,
 699         string const & arg3, string const & arg4, string const & arg5)
 700 {
 701         BOOST_ASSERT(contains(fmt, "%1$s"));
 702         BOOST_ASSERT(contains(fmt, "%2$s"));
 703         BOOST_ASSERT(contains(fmt, "%3$s"));
 704         BOOST_ASSERT(contains(fmt, "%4$s"));
 705         BOOST_ASSERT(contains(fmt, "%5$s"));
 706         string str = subst(fmt, "%1$s", arg1);
 707         str = subst(str, "%2$s", arg2);
 708         str = subst(str, "%3$s", arg3);
 709         str = subst(str, "%4$s", arg4);
 710         str = subst(str, "%5$s", arg5);
 711         return subst(str, "%%", "%");
 712 }
 713
 714 #endif
 715
 716 } // namespace support
 717 } // namespace lyx