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 "lstrings.h"
  15 #include "debug.h"
  16 #include "lyxlib.h"
  17 #include "tostr.h"
  18
  19 #include <boost/tokenizer.hpp>
  20 #include <boost/assert.hpp>
  21 #include <boost/format.hpp>
  22
  23 #include <algorithm>
  24
  25 #include <cctype>
  26 #include <cstdlib>
  27
  28 #include <sstream>
  29
  30 using std::transform;
  31 using std::string;
  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(STD_STRING_IS_GOOD)
 295                 return a.compare(0, prelen, pre) == 0;
 296 #else
 297                 return ::strncmp(a.c_str(), pre.c_str(), prelen) == 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 containsOnly(string const & s, string const & cset)
 329 {
 330         return s.find_first_not_of(cset) == string::npos;
 331 }
 332
 333
 334 // ale970405+lasgoutt-970425
 335 // rewritten to use new string (Lgb)
 336 string const token(string const & a, char delim, int n)
 337 {
 338         if (a.empty()) return string();
 339
 340         string::size_type k = 0;
 341         string::size_type i = 0;
 342
 343         // Find delimiter or end of string
 344         for (; n--;)
 345                 if ((i = a.find(delim, i)) == string::npos)
 346                         break;
 347                 else
 348                         ++i; // step delim
 349         // i is now the n'th delim (or string::npos)
 350         if (i == string::npos) return string();
 351         k = a.find(delim, i);
 352         // k is now the n'th + 1 delim (or string::npos)
 353
 354         return a.substr(i, k - i);
 355 }
 356
 357
 358 // this could probably be faster and/or cleaner, but it seems to work (JMarc)
 359 // rewritten to use new string (Lgb)
 360 int tokenPos(string const & a, char delim, string const & tok)
 361 {
 362         int i = 0;
 363         string str(a);
 364         string tmptok;
 365
 366         while (!str.empty()) {
 367                 str = split(str, tmptok, delim);
 368                 if (tok == tmptok)
 369                         return i;
 370                 ++i;
 371         }
 372         return -1;
 373 }
 374
 375
 376 string const subst(string const & a, char oldchar, char newchar)
 377 {
 378         string tmp(a);
 379         string::iterator lit = tmp.begin();
 380         string::iterator end = tmp.end();
 381         for (; lit != end; ++lit)
 382                 if ((*lit) == oldchar)
 383                         (*lit) = newchar;
 384         return tmp;
 385 }
 386
 387
 388 string const subst(string const & a,
 389                    string const & oldstr, string const & newstr)
 390 {
 391         string lstr = a;
 392         string::size_type i = 0;
 393         string::size_type const olen = oldstr.length();
 394         while ((i = lstr.find(oldstr, i)) != string::npos) {
 395                 lstr.replace(i, olen, newstr);
 396                 i += newstr.length(); // We need to be sure that we dont
 397                 // use the same i over and over again.
 398         }
 399         return lstr;
 400 }
 401
 402
 403 string const trim(string const & a, char const * p)
 404 {
 405         BOOST_ASSERT(p);
 406
 407         if (a.empty() || !*p)
 408                 return a;
 409
 410         string::size_type r = a.find_last_not_of(p);
 411         string::size_type l = a.find_first_not_of(p);
 412
 413         // Is this the minimal test? (lgb)
 414         if (r == string::npos && l == string::npos)
 415                 return string();
 416
 417         return a.substr(l, r - l + 1);
 418 }
 419
 420
 421 string const rtrim(string const & a, char const * p)
 422 {
 423         BOOST_ASSERT(p);
 424
 425         if (a.empty() || !*p)
 426                 return a;
 427
 428         string::size_type r = a.find_last_not_of(p);
 429
 430         // Is this test really needed? (Lgb)
 431         if (r == string::npos)
 432                 return string();
 433
 434         return a.substr(0, r + 1);
 435 }
 436
 437
 438 string const ltrim(string const & a, char const * p)
 439 {
 440         BOOST_ASSERT(p);
 441
 442         if (a.empty() || !*p)
 443                 return a;
 444
 445         string::size_type l = a.find_first_not_of(p);
 446
 447         if (l == string::npos)
 448                 return string();
 449
 450         return a.substr(l, string::npos);
 451 }
 452
 453
 454 string const split(string const & a, string & piece, char delim)
 455 {
 456         string tmp;
 457         string::size_type i = a.find(delim);
 458         if (i == a.length() - 1) {
 459                 piece = a.substr(0, i);
 460         } else if (i != string::npos) {
 461                 piece = a.substr(0, i);
 462                 tmp = a.substr(i + 1);
 463         } else if (i == 0) {
 464                 piece.erase();
 465                 tmp = a.substr(i + 1);
 466         } else {
 467                 piece = a;
 468         }
 469         return tmp;
 470 }
 471
 472
 473 string const split(string const & a, char delim)
 474 {
 475         string tmp;
 476         string::size_type i = a.find(delim);
 477         if (i != string::npos) // found delim
 478                 tmp = a.substr(i + 1);
 479         return tmp;
 480 }
 481
 482
 483 // ale970521
 484 string const rsplit(string const & a, string & piece, char delim)
 485 {
 486         string tmp;
 487         string::size_type i = a.rfind(delim);
 488         if (i != string::npos) { // delimiter was found
 489                 piece = a.substr(0, i);
 490                 tmp = a.substr(i + 1);
 491         } else { // delimiter was not found
 492                 piece.erase();
 493         }
 494         return tmp;
 495 }
 496
 497
 498 // This function escapes 8-bit characters and other problematic
 499 // characters that cause problems in latex labels.
 500 string const escape(string const & lab)
 501 {
 502         char hexdigit[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
 503                               '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 504         string enc;
 505         for (string::size_type i = 0; i < lab.length(); ++i) {
 506                 unsigned char c= lab[i];
 507                 if (c >= 128 || c == '=' || c == '%') {
 508                         enc += '=';
 509                         enc += hexdigit[c>>4];
 510                         enc += hexdigit[c & 15];
 511                 } else {
 512                         enc += c;
 513                 }
 514         }
 515         return enc;
 516 }
 517
 518
 519 /// gives a vector of stringparts which have the delimiter delim
 520 vector<string> const getVectorFromString(string const & str,
 521                                          string const & delim)
 522 {
 523 // Lars would like this code to go, but for now his replacement (below)
 524 // doesn't fullfil the same function. I have, therefore, reactivated the
 525 // old code for now. Angus 11 Nov 2002.
 526 #if 1
 527         vector<string> vec;
 528         if (str.empty())
 529                 return vec;
 530         string keys(rtrim(str));
 531         for(;;) {
 532                 string::size_type const idx = keys.find(delim);
 533                 if (idx == string::npos) {
 534                         vec.push_back(ltrim(keys));
 535                         break;
 536                 }
 537                 string const key = trim(keys.substr(0, idx));
 538                 if (!key.empty())
 539                         vec.push_back(key);
 540                 string::size_type const start = idx + delim.size();
 541                 keys = keys.substr(start);
 542         }
 543         return vec;
 544 #else
 545         boost::char_separator<char> sep(delim.c_str());
 546         boost::tokenizer<boost::char_separator<char> > tokens(str, sep);
 547 #ifndef USE_INCLUDED_STRING
 548         return vector<string>(tokens.begin(), tokens.end());
 549 #else
 550         vector<string> vec;
 551         using boost::tokenizer;
 552         using boost::char_separator;
 553
 554         tokenizer<char_separator<char> >::iterator it = tokens.begin();
 555         tokenizer<char_separator<char> >::iterator end = tokens.end();
 556         for (; it != end; ++it) {
 557                 vec.push_back(STRCONV((*it)));
 558         }
 559         return vec;
 560 #endif
 561 #endif
 562 }
 563
 564
 565 // the same vice versa
 566 string const getStringFromVector(vector<string> const & vec,
 567                                  string const & delim)
 568 {
 569         string str;
 570         int i = 0;
 571         for (vector<string>::const_iterator it = vec.begin();
 572              it != vec.end(); ++it) {
 573                 string item = trim(*it);
 574                 if (item.empty())
 575                         continue;
 576                 if (i++ > 0)
 577                         str += delim;
 578                 str += item;
 579         }
 580         return str;
 581 }
 582
 583
 584 #if USE_BOOST_FORMAT
 585
 586 string bformat(string const & fmt, string const & arg1)
 587 {
 588         return (boost::format(fmt) % arg1).str();
 589 }
 590
 591
 592 string bformat(string const & fmt, string const & arg1, string const & arg2)
 593 {
 594         return (boost::format(fmt) % arg1 % arg2).str();
 595 }
 596
 597
 598 string bformat(string const & fmt, int arg1, int arg2)
 599 {
 600         return (boost::format(fmt) % arg1 % arg2).str();
 601 }
 602
 603
 604 string bformat(string const & fmt, string const & arg1, string const & arg2,
 605         string const & arg3)
 606 {
 607         return (boost::format(fmt) % arg1 % arg2 % arg3).str();
 608 }
 609
 610
 611 string bformat(string const & fmt, string const & arg1, string const & arg2,
 612         string const & arg3, string const & arg4)
 613 {
 614         return (boost::format(fmt) % arg1 % arg2 % arg3 % arg4).str();
 615 }
 616
 617
 618 string bformat(string const & fmt, string const & arg1, string const & arg2,
 619         string const & arg3, string const & arg4, string const & arg5)
 620 {
 621         return (boost::format(fmt) % arg1 % arg2 % arg3 % arg4 % arg5).str();
 622 }
 623
 624 #else
 625
 626 string bformat(string const & fmt, string const & arg1)
 627 {
 628         BOOST_ASSERT(contains(fmt, "%1$s"));
 629         string const str = subst(fmt, "%1$s", arg1);
 630         return subst(str, "%%", "%");
 631 }
 632
 633
 634 string bformat(string const & fmt, string const & arg1, string const & arg2)
 635 {
 636         BOOST_ASSERT(contains(fmt, "%1$s"));
 637         BOOST_ASSERT(contains(fmt, "%2$s"));
 638         string str = subst(fmt, "%1$s", arg1);
 639         str = subst(str, "%2$s", arg2);
 640         return subst(str, "%%", "%");
 641 }
 642
 643
 644 string bformat(string const & fmt, int arg1, int arg2)
 645 {
 646         BOOST_ASSERT(contains(fmt, "%1$d"));
 647         BOOST_ASSERT(contains(fmt, "%2$d"));
 648         string str = subst(fmt, "%1$d", tostr(arg1));
 649         str = subst(str, "%2$d", tostr(arg2));
 650         return subst(str, "%%", "%");
 651 }
 652
 653
 654 string bformat(string const & fmt, string const & arg1, string const & arg2,
 655         string const & arg3)
 656 {
 657         BOOST_ASSERT(contains(fmt, "%1$s"));
 658         BOOST_ASSERT(contains(fmt, "%2$s"));
 659         BOOST_ASSERT(contains(fmt, "%3$s"));
 660         string str = subst(fmt, "%1$s", arg1);
 661         str = subst(str, "%2$s", arg2);
 662         str = subst(str, "%3$s", arg3);
 663         return subst(str, "%%", "%");
 664 }
 665
 666
 667 string bformat(string const & fmt, string const & arg1, string const & arg2,
 668         string const & arg3, string const & arg4)
 669 {
 670         BOOST_ASSERT(contains(fmt, "%1$s"));
 671         BOOST_ASSERT(contains(fmt, "%2$s"));
 672         BOOST_ASSERT(contains(fmt, "%3$s"));
 673         BOOST_ASSERT(contains(fmt, "%4$s"));
 674         string str = subst(fmt, "%1$s", arg1);
 675         str = subst(str, "%2$s", arg2);
 676         str = subst(str, "%3$s", arg3);
 677         str = subst(str, "%4$s", arg4);
 678         return subst(str, "%%", "%");
 679 }
 680
 681
 682 string bformat(string const & fmt, string const & arg1, string const & arg2,
 683         string const & arg3, string const & arg4, string const & arg5)
 684 {
 685         BOOST_ASSERT(contains(fmt, "%1$s"));
 686         BOOST_ASSERT(contains(fmt, "%2$s"));
 687         BOOST_ASSERT(contains(fmt, "%3$s"));
 688         BOOST_ASSERT(contains(fmt, "%4$s"));
 689         BOOST_ASSERT(contains(fmt, "%5$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         str = subst(str, "%5$s", arg5);
 695         return subst(str, "%%", "%");
 696 }
 697
 698 #endif
 699
 700 } // namespace support
 701 } // namespace lyx