| 1 | /* |
| 2 | The software in this package is distributed under the GNU General |
| 3 | Public License version 2 (with a special exception described below). |
| 4 | |
| 5 | A copy of GNU General Public License (GPL) is included in this distribution, |
| 6 | in the file COPYING.GPL. |
| 7 | |
| 8 | As a special exception, if other files instantiate templates or use macros |
| 9 | or inline functions from this file, or you compile this file and link it |
| 10 | with other works to produce a work based on this file, this file |
| 11 | does not by itself cause the resulting work to be covered |
| 12 | by the GNU General Public License. |
| 13 | |
| 14 | However the source code for this file must still be made available |
| 15 | in accordance with section (3) of the GNU General Public License. |
| 16 | |
| 17 | This exception does not invalidate any other reasons why a work based |
| 18 | on this file might be covered by the GNU General Public License. |
| 19 | */ |
| 20 | /** @file |
| 21 | * |
| 22 | * (c) Copyright 2007-2008 by Intra2net AG |
| 23 | */ |
| 24 | |
| 25 | #include <iostream> |
| 26 | #include <string> |
| 27 | #include <sstream> |
| 28 | #include <stdexcept> |
| 29 | #include <algorithm> |
| 30 | #include <cmath> // for round() |
| 31 | |
| 32 | #include <wchar.h> |
| 33 | #include <stdlib.h> |
| 34 | #include <iconv.h> |
| 35 | #include <i18n.h> |
| 36 | |
| 37 | #include <boost/numeric/conversion/cast.hpp> |
| 38 | #include <boost/foreach.hpp> |
| 39 | |
| 40 | #include <stringfunc.hxx> |
| 41 | |
| 42 | using namespace std; |
| 43 | |
| 44 | namespace I2n |
| 45 | { |
| 46 | |
| 47 | |
| 48 | namespace |
| 49 | { |
| 50 | |
| 51 | const std::string hexDigitsLower("0123456789abcdef"); |
| 52 | const std::string hexDigitsUpper("0123456789ABCDEF"); |
| 53 | |
| 54 | |
| 55 | struct UpperFunc |
| 56 | { |
| 57 | char operator() (char c) |
| 58 | { |
| 59 | return std::toupper(c); |
| 60 | } |
| 61 | }; // eo struct UpperFunc |
| 62 | |
| 63 | |
| 64 | struct LowerFunc |
| 65 | { |
| 66 | char operator() (char c) |
| 67 | { |
| 68 | return std::tolower(c); |
| 69 | } |
| 70 | }; // eo struct LowerFunc |
| 71 | |
| 72 | |
| 73 | } // eo namespace <anonymous> |
| 74 | |
| 75 | |
| 76 | |
| 77 | /** |
| 78 | * default list of Whitespaces (" \t\r\n"); |
| 79 | */ |
| 80 | const std::string Whitespaces = " \t\r\n"; |
| 81 | |
| 82 | /** |
| 83 | * default list of lineendings ("\r\n"); |
| 84 | */ |
| 85 | const std::string LineEndings= "\r\n"; |
| 86 | |
| 87 | |
| 88 | |
| 89 | /** |
| 90 | * @brief checks if a string begins with a given prefix. |
| 91 | * @param[in,out] str the string which is tested |
| 92 | * @param prefix the prefix which should be tested for. |
| 93 | * @return @a true iff the prefix is not empty and the string begins with that prefix. |
| 94 | */ |
| 95 | bool has_prefix(const std::string& str, const std::string& prefix) |
| 96 | { |
| 97 | if (prefix.empty() || str.empty() || str.size() < prefix.size() ) |
| 98 | { |
| 99 | return false; |
| 100 | } |
| 101 | return str.compare(0, prefix.size(), prefix) == 0; |
| 102 | } // eo has_prefix(const std::string&,const std::string&) |
| 103 | |
| 104 | |
| 105 | /** |
| 106 | * @brief checks if a string ends with a given suffix. |
| 107 | * @param[in,out] str the string which is tested |
| 108 | * @param suffix the suffix which should be tested for. |
| 109 | * @return @a true iff the suffix is not empty and the string ends with that suffix. |
| 110 | */ |
| 111 | bool has_suffix(const std::string& str, const std::string& suffix) |
| 112 | { |
| 113 | if (suffix.empty() || str.empty() || str.size() < suffix.size() ) |
| 114 | { |
| 115 | return false; |
| 116 | } |
| 117 | return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; |
| 118 | } // eo has_suffix(const std::string&,const std::string&) |
| 119 | |
| 120 | |
| 121 | /** |
| 122 | * cut off characters from a given list from front and end of a string. |
| 123 | * @param[in,out] str the string which should be trimmed. |
| 124 | * @param charlist the list of characters to remove from beginning and end of string |
| 125 | * @return the result string. |
| 126 | */ |
| 127 | std::string trim_mod(std::string& str, const std::string& charlist) |
| 128 | { |
| 129 | // first: trim the beginning: |
| 130 | std::string::size_type pos= str.find_first_not_of (charlist); |
| 131 | if (pos == std::string::npos) |
| 132 | { |
| 133 | // whole string consists of charlist (or is already empty) |
| 134 | str.clear(); |
| 135 | return str; |
| 136 | } |
| 137 | else if (pos>0) |
| 138 | { |
| 139 | // str starts with charlist |
| 140 | str.erase(0,pos); |
| 141 | } |
| 142 | // now let's look at the tail: |
| 143 | pos= str.find_last_not_of(charlist) +1; // note: we already know there is at least one other char! |
| 144 | if ( pos < str.size() ) |
| 145 | { |
| 146 | str.erase(pos, str.size()-pos); |
| 147 | } |
| 148 | return str; |
| 149 | } // eo trim_mod(std::string&,const std::string&) |
| 150 | |
| 151 | |
| 152 | |
| 153 | /** |
| 154 | * removes last character from a string when it is in a list of chars to be removed. |
| 155 | * @param[in,out] str the string. |
| 156 | * @param what the list of chars which will be tested for. |
| 157 | * @return the resulting string with last char removed (if applicable) |
| 158 | */ |
| 159 | std::string chomp_mod(std::string& str, const std::string& what) |
| 160 | { |
| 161 | if (str.empty() || what.empty() ) |
| 162 | { |
| 163 | return str; |
| 164 | } |
| 165 | if (what.find(str.at (str.size()-1) ) != std::string::npos) |
| 166 | { |
| 167 | str.erase(str.size() - 1); |
| 168 | } |
| 169 | return str; |
| 170 | } // eo chomp_mod(std::string&,const std::string&) |
| 171 | |
| 172 | |
| 173 | /** |
| 174 | * @brief converts a string to lower case. |
| 175 | * @param[in,out] str the string to modify. |
| 176 | * @return the string |
| 177 | */ |
| 178 | std::string to_lower_mod(std::string& str) |
| 179 | { |
| 180 | std::transform(str.begin(), str.end(), str.begin(), LowerFunc() ); |
| 181 | return str; |
| 182 | } // eo to_lower_mod(std::string&) |
| 183 | |
| 184 | |
| 185 | /** |
| 186 | * @brief converts a string to upper case. |
| 187 | * @param[in,out] str the string to modify. |
| 188 | * @return the string |
| 189 | */ |
| 190 | std::string to_upper_mod(std::string& str) |
| 191 | { |
| 192 | std::transform( str.begin(), str.end(), str.begin(), UpperFunc() ); |
| 193 | return str; |
| 194 | } // eo to_upper_mod(std::string&) |
| 195 | |
| 196 | |
| 197 | |
| 198 | /** |
| 199 | * cut off characters from a given list from front and end of a string. |
| 200 | * @param str the string which should be trimmed. |
| 201 | * @param charlist the list of characters to remove from beginning and end of string |
| 202 | * @return the result string. |
| 203 | */ |
| 204 | std::string trim (const std::string& str, const std::string& charlist) |
| 205 | { |
| 206 | // first: trim the beginning: |
| 207 | std::string::size_type pos0= str.find_first_not_of(charlist); |
| 208 | if (pos0 == std::string::npos) |
| 209 | { |
| 210 | // whole string consists of charlist (or is already empty) |
| 211 | return std::string(); |
| 212 | } |
| 213 | // now let's look at the end: |
| 214 | std::string::size_type pos1= str.find_last_not_of(charlist); |
| 215 | return str.substr(pos0, pos1 - pos0 + 1); |
| 216 | } // eo trim(const std:.string&,const std::string&) |
| 217 | |
| 218 | |
| 219 | /** |
| 220 | * removes last character from a string when it is in a list of chars to be removed. |
| 221 | * @param str the string. |
| 222 | * @param what the list of chars which will be tested for. |
| 223 | * @return the resulting string with last char removed (if applicable) |
| 224 | */ |
| 225 | std::string chomp (const std::string& str, const std::string& what) |
| 226 | { |
| 227 | if (str.empty() || what.empty() ) |
| 228 | { |
| 229 | return str; |
| 230 | } |
| 231 | if (what.find(str.at (str.size()-1) ) != std::string::npos) |
| 232 | { |
| 233 | return str.substr(0, str.size()-1); |
| 234 | } |
| 235 | return str; |
| 236 | } // eo chomp(const std:.string&,const std::string&) |
| 237 | |
| 238 | |
| 239 | /** |
| 240 | * @brief returns a lower case version of a given string. |
| 241 | * @param str the string |
| 242 | * @return the lower case version of the string |
| 243 | */ |
| 244 | std::string to_lower (const std::string& str) |
| 245 | { |
| 246 | std::string result(str); |
| 247 | return to_lower_mod(result); |
| 248 | } // eo to_lower(const std::string&) |
| 249 | |
| 250 | |
| 251 | /** |
| 252 | * @brief returns a upper case version of a given string. |
| 253 | * @param str the string |
| 254 | * @return the upper case version of the string |
| 255 | */ |
| 256 | std::string to_upper(const std::string& str) |
| 257 | { |
| 258 | std::string result(str); |
| 259 | return to_upper_mod(result); |
| 260 | } // eo to_upper(const std::string&) |
| 261 | |
| 262 | |
| 263 | |
| 264 | /** |
| 265 | * @brief removes a given suffix from a string. |
| 266 | * @param str the string. |
| 267 | * @param suffix the suffix which should be removed if the string ends with it. |
| 268 | * @return the string without the suffix. |
| 269 | * |
| 270 | * If the string ends with the suffix, it is removed. If the the string doesn't end |
| 271 | * with the suffix the original string is returned. |
| 272 | */ |
| 273 | std::string remove_suffix(const std::string& str, const std::string& suffix) |
| 274 | { |
| 275 | if (has_suffix(str,suffix) ) |
| 276 | { |
| 277 | return str.substr(0, str.size()-suffix.size() ); |
| 278 | } |
| 279 | return str; |
| 280 | } // eo remove_suffix(const std::string&,const std::string&) |
| 281 | |
| 282 | |
| 283 | |
| 284 | /** |
| 285 | * @brief removes a given prefix from a string. |
| 286 | * @param str the string. |
| 287 | * @param prefix the prefix which should be removed if the string begins with it. |
| 288 | * @return the string without the prefix. |
| 289 | * |
| 290 | * If the string begins with the prefix, it is removed. If the the string doesn't begin |
| 291 | * with the prefix the original string is returned. |
| 292 | */ |
| 293 | std::string remove_prefix(const std::string& str, const std::string& prefix) |
| 294 | { |
| 295 | if (has_prefix(str,prefix) ) |
| 296 | { |
| 297 | return str.substr( prefix.size() ); |
| 298 | } |
| 299 | return str; |
| 300 | } // eo remove_prefix(const std::string&,const std::string&) |
| 301 | |
| 302 | |
| 303 | /** |
| 304 | * split a string to key and value delimited by a given delimiter. |
| 305 | * The resulting key and value strings are trimmed (Whitespaces removed at beginning and end). |
| 306 | * @param str the string which should be splitted. |
| 307 | * @param[out] key the resulting key |
| 308 | * @param[out] value the resulting value |
| 309 | * @param delimiter the delimiter between key and value; default is '='. |
| 310 | * @return @a true if the split was successful. |
| 311 | */ |
| 312 | bool pair_split( |
| 313 | const std::string& str, |
| 314 | std::string& key, |
| 315 | std::string& value, |
| 316 | char delimiter) |
| 317 | { |
| 318 | std::string::size_type pos = str.find (delimiter); |
| 319 | if (pos == std::string::npos) return false; |
| 320 | key= str.substr(0,pos); |
| 321 | value= str.substr(pos+1); |
| 322 | trim_mod(key); |
| 323 | trim_mod(value); |
| 324 | return true; |
| 325 | } // eo pair_split(const std::string&,std::string&,std::string&,char) |
| 326 | |
| 327 | |
| 328 | /** |
| 329 | * splits a string by given delimiter |
| 330 | * |
| 331 | * @param[in] str the string which should be splitted. |
| 332 | * @param[out] result the list resulting from splitting @a str. |
| 333 | * @param[in] delimiter the delimiter (word/phrase) at which @a str should be splitted. |
| 334 | * @param[in] omit_empty should empty parts not be stored? |
| 335 | * @param[in] trim_list list of characters the parts should be trimmed by. |
| 336 | * (empty string results in no trim) |
| 337 | */ |
| 338 | void split_string( |
| 339 | const std::string& str, |
| 340 | std::list<std::string>& result, |
| 341 | const std::string& delimiter, |
| 342 | bool omit_empty, |
| 343 | const std::string& trim_list |
| 344 | ) |
| 345 | { |
| 346 | std::string::size_type pos, last_pos=0; |
| 347 | bool delimiter_found= false; |
| 348 | while ( last_pos < str.size() && last_pos != std::string::npos) |
| 349 | { |
| 350 | pos= str.find(delimiter, last_pos); |
| 351 | std::string part; |
| 352 | if (pos == std::string::npos) |
| 353 | { |
| 354 | part= str.substr(last_pos); |
| 355 | delimiter_found= false; |
| 356 | } |
| 357 | else |
| 358 | { |
| 359 | part= str.substr(last_pos, pos-last_pos); |
| 360 | delimiter_found=true; |
| 361 | } |
| 362 | if (pos != std::string::npos) |
| 363 | { |
| 364 | last_pos= pos+ delimiter.size(); |
| 365 | } |
| 366 | else |
| 367 | { |
| 368 | last_pos= std::string::npos; |
| 369 | } |
| 370 | if (!trim_list.empty() ) trim_mod (part, trim_list); |
| 371 | if (omit_empty && part.empty() ) continue; |
| 372 | result.push_back( part ); |
| 373 | } |
| 374 | // if the string ends with a delimiter we need to append an empty string if no omit_empty |
| 375 | // was given. |
| 376 | // (this way we keep the split result consistent to a join operation) |
| 377 | if (delimiter_found && !omit_empty) |
| 378 | { |
| 379 | result.push_back(""); |
| 380 | } |
| 381 | } // eo split_string(const std::string&,std::list< std::string >&,const std::string&,bool,const std::string&) |
| 382 | |
| 383 | |
| 384 | /** |
| 385 | * splits a string by a given delimiter |
| 386 | * @param str the string which should be splitted. |
| 387 | * @param delimiter delimiter the delimiter (word/phrase) at which @a str should be splitted. |
| 388 | * @param[in] omit_empty should empty parts not be stored? |
| 389 | * @param[in] trim_list list of characters the parts should be trimmed by. |
| 390 | * (empty string results in no trim) |
| 391 | * @return the list resulting from splitting @a str. |
| 392 | */ |
| 393 | std::list<std::string> split_string( |
| 394 | const std::string& str, |
| 395 | const std::string& delimiter, |
| 396 | bool omit_empty, |
| 397 | const std::string& trim_list |
| 398 | ) |
| 399 | { |
| 400 | std::list<std::string> result; |
| 401 | split_string(str, result, delimiter, omit_empty, trim_list); |
| 402 | return result; |
| 403 | } // eo split_string(const std::string&,const std::string&,bool,const std::string&) |
| 404 | |
| 405 | |
| 406 | /** |
| 407 | * @brief joins a list of strings into a single string. |
| 408 | * |
| 409 | * This funtion is (basically) the reverse operation of @a split_string. |
| 410 | * |
| 411 | * @param parts the list of strings. |
| 412 | * @param delimiter the delimiter which is inserted between the strings. |
| 413 | * @return the joined string. |
| 414 | */ |
| 415 | std::string join_string( |
| 416 | const std::list< std::string >& parts, |
| 417 | const std::string& delimiter |
| 418 | ) |
| 419 | { |
| 420 | std::string result; |
| 421 | if (! parts.empty() ) |
| 422 | { |
| 423 | std::list< std::string >::const_iterator it= parts.begin(); |
| 424 | result = *it; |
| 425 | while ( ++it != parts.end() ) |
| 426 | { |
| 427 | result+= delimiter; |
| 428 | result+= *it; |
| 429 | } |
| 430 | } |
| 431 | return result; |
| 432 | } // eo join_string(const std::list< std::string >&,const std::string&) |
| 433 | |
| 434 | |
| 435 | /** @brief same as join_string for list, except uses a vector */ |
| 436 | std::string join_string( |
| 437 | const std::vector< std::string >& parts, |
| 438 | const std::string& delimiter |
| 439 | ) |
| 440 | { |
| 441 | std::string result; |
| 442 | if (! parts.empty() ) |
| 443 | { |
| 444 | std::vector< std::string >::const_iterator it= parts.begin(); |
| 445 | result = *it; |
| 446 | while ( ++it != parts.end() ) |
| 447 | { |
| 448 | result+= delimiter; |
| 449 | result+= *it; |
| 450 | } |
| 451 | } |
| 452 | return result; |
| 453 | } // eo join_string(const std::vector< std::string >&,const std::string&) |
| 454 | |
| 455 | |
| 456 | |
| 457 | /* |
| 458 | ** conversions |
| 459 | */ |
| 460 | |
| 461 | |
| 462 | /** |
| 463 | * @brief returns a hex string from a binary string. |
| 464 | * @param str the (binary) string |
| 465 | * @param upper_case_digits determine whether to use upper case characters for digits A-F. |
| 466 | * @return the string in hex notation. |
| 467 | */ |
| 468 | std::string convert_binary_to_hex( |
| 469 | const std::string& str, |
| 470 | bool upper_case_digits |
| 471 | ) |
| 472 | { |
| 473 | std::string result; |
| 474 | std::string hexDigits(upper_case_digits ? hexDigitsUpper : hexDigitsLower); |
| 475 | for ( std::string::const_iterator it= str.begin(); |
| 476 | it != str.end(); |
| 477 | ++it) |
| 478 | { |
| 479 | result.push_back( hexDigits[ ( (*it) >> 4) & 0x0f ] ); |
| 480 | result.push_back( hexDigits[ (*it) & 0x0f ] ); |
| 481 | } |
| 482 | return result; |
| 483 | } // eo convert_binary_to_hex(const std::string&,bool) |
| 484 | |
| 485 | |
| 486 | /** |
| 487 | * @brief converts a hex digit string to binary string. |
| 488 | * @param str hex digit string |
| 489 | * @return the binary string. |
| 490 | * |
| 491 | * The hex digit string may contains white spaces or colons which are treated |
| 492 | * as delimiters between hex digit groups. |
| 493 | * |
| 494 | * @todo rework the handling of half nibbles (consistency)! |
| 495 | */ |
| 496 | std::string convert_hex_to_binary( |
| 497 | const std::string& str |
| 498 | ) |
| 499 | throw (std::runtime_error) |
| 500 | { |
| 501 | std::string result; |
| 502 | char c= 0; |
| 503 | bool hasNibble= false; |
| 504 | bool lastWasWS= true; |
| 505 | for ( std::string::const_iterator it= str.begin(); |
| 506 | it != str.end(); |
| 507 | ++it) |
| 508 | { |
| 509 | std::string::size_type p = hexDigitsLower.find( *it ); |
| 510 | if (p== std::string::npos) |
| 511 | { |
| 512 | p= hexDigitsUpper.find( *it ); |
| 513 | } |
| 514 | if (p == std::string::npos) |
| 515 | { |
| 516 | if ( ( Whitespaces.find( *it ) != std::string::npos) // is it a whitespace? |
| 517 | or ( *it == ':') // or a colon? |
| 518 | ) |
| 519 | { |
| 520 | // we treat that as a valid delimiter: |
| 521 | if (hasNibble) |
| 522 | { |
| 523 | // 1 nibble before WS is treate as lower part: |
| 524 | result.push_back(c); |
| 525 | // reset state: |
| 526 | hasNibble= false; |
| 527 | } |
| 528 | lastWasWS= true; |
| 529 | continue; |
| 530 | } |
| 531 | } |
| 532 | if (p == std::string::npos ) |
| 533 | { |
| 534 | throw runtime_error("illegal character in hex digit string: " + str); |
| 535 | } |
| 536 | lastWasWS= false; |
| 537 | if (hasNibble) |
| 538 | { |
| 539 | c<<=4; |
| 540 | } |
| 541 | else |
| 542 | { |
| 543 | c=0; |
| 544 | } |
| 545 | c+= (p & 0x0f); |
| 546 | if (hasNibble) |
| 547 | { |
| 548 | //we already had a nibble, so a char is complete now: |
| 549 | result.push_back( c ); |
| 550 | hasNibble=false; |
| 551 | } |
| 552 | else |
| 553 | { |
| 554 | // this is the first nibble of a new char: |
| 555 | hasNibble=true; |
| 556 | } |
| 557 | } |
| 558 | if (hasNibble) |
| 559 | { |
| 560 | //well, there is one nibble left |
| 561 | // let's do some heuristics: |
| 562 | if (lastWasWS) |
| 563 | { |
| 564 | // if the preceeding character was a white space (or a colon) |
| 565 | // we treat the nibble as lower part: |
| 566 | //( this is consistent with shortened hex notations where leading zeros are not noted) |
| 567 | result.push_back( c ); |
| 568 | } |
| 569 | else |
| 570 | { |
| 571 | // if it was part of a hex digit chain, we treat it as UPPER part (!!) |
| 572 | result.push_back( c << 4 ); |
| 573 | } |
| 574 | } |
| 575 | return result; |
| 576 | } // eo convert_hex_to_binary(const std::string&) |
| 577 | |
| 578 | |
| 579 | } // eo namespace I2n |
| 580 | |
| 581 | |
| 582 | |
| 583 | |
| 584 | std::string iso_to_utf8(const std::string& isostring) |
| 585 | { |
| 586 | string result; |
| 587 | |
| 588 | iconv_t i2utf8 = iconv_open("UTF-8", "ISO-8859-1"); |
| 589 | |
| 590 | if (iso_to_utf8 == (iconv_t)-1) |
| 591 | throw runtime_error("iconv can't convert from ISO-8859-1 to UTF-8"); |
| 592 | |
| 593 | size_t in_size=isostring.size(); |
| 594 | size_t out_size=in_size*4; |
| 595 | |
| 596 | char *buf = (char *)malloc(out_size+1); |
| 597 | if (buf == NULL) |
| 598 | throw runtime_error("out of memory for iconv buffer"); |
| 599 | |
| 600 | char *in = (char *)isostring.c_str(); |
| 601 | char *out = buf; |
| 602 | iconv(i2utf8, &in, &in_size, &out, &out_size); |
| 603 | |
| 604 | buf[isostring.size()*4-out_size]=0; |
| 605 | |
| 606 | result=buf; |
| 607 | |
| 608 | free(buf); |
| 609 | iconv_close(i2utf8); |
| 610 | |
| 611 | return result; |
| 612 | } |
| 613 | |
| 614 | std::string utf8_to_iso(const std::string& utf8string) |
| 615 | { |
| 616 | string result; |
| 617 | |
| 618 | iconv_t utf82iso = iconv_open("ISO-8859-1","UTF-8"); |
| 619 | |
| 620 | if (utf82iso == (iconv_t)-1) |
| 621 | throw runtime_error("iconv can't convert from UTF-8 to ISO-8859-1"); |
| 622 | |
| 623 | size_t in_size=utf8string.size(); |
| 624 | size_t out_size=in_size; |
| 625 | |
| 626 | char *buf = (char *)malloc(out_size+1); |
| 627 | if (buf == NULL) |
| 628 | throw runtime_error("out of memory for iconv buffer"); |
| 629 | |
| 630 | char *in = (char *)utf8string.c_str(); |
| 631 | char *out = buf; |
| 632 | iconv(utf82iso, &in, &in_size, &out, &out_size); |
| 633 | |
| 634 | buf[utf8string.size()-out_size]=0; |
| 635 | |
| 636 | result=buf; |
| 637 | |
| 638 | free(buf); |
| 639 | iconv_close(utf82iso); |
| 640 | |
| 641 | return result; |
| 642 | } |
| 643 | |
| 644 | wchar_t* utf8_to_wbuf(const std::string& utf8string) |
| 645 | { |
| 646 | iconv_t utf82wstr = iconv_open("UCS-4LE","UTF-8"); |
| 647 | |
| 648 | if (utf82wstr == (iconv_t)-1) |
| 649 | throw runtime_error("iconv can't convert from UTF-8 to UCS-4"); |
| 650 | |
| 651 | size_t in_size=utf8string.size(); |
| 652 | size_t out_size= (in_size+1)*sizeof(wchar_t); |
| 653 | |
| 654 | wchar_t *buf = (wchar_t *)malloc(out_size); |
| 655 | if (buf == NULL) |
| 656 | throw runtime_error("out of memory for iconv buffer"); |
| 657 | |
| 658 | char *in = (char *)utf8string.c_str(); |
| 659 | char *out = (char*) buf; |
| 660 | if (iconv(utf82wstr, &in, &in_size, &out, &out_size) == (size_t)-1) |
| 661 | throw runtime_error("error converting char encodings"); |
| 662 | |
| 663 | buf[ ( (utf8string.size()+1)*sizeof(wchar_t)-out_size) /sizeof(wchar_t) ]=0; |
| 664 | |
| 665 | iconv_close(utf82wstr); |
| 666 | |
| 667 | return buf; |
| 668 | } |
| 669 | |
| 670 | std::string utf7imap_to_utf8(const std::string& utf7imapstring) |
| 671 | { |
| 672 | string result; |
| 673 | |
| 674 | iconv_t utf7imap2utf8 = iconv_open("UTF-8","UTF-7-IMAP"); |
| 675 | |
| 676 | if (utf7imap2utf8 == (iconv_t)-1) |
| 677 | throw runtime_error("iconv can't convert from UTF-7-IMAP to UTF-8"); |
| 678 | |
| 679 | size_t in_size=utf7imapstring.size(); |
| 680 | size_t out_size=in_size*4; |
| 681 | |
| 682 | char *buf = (char *)malloc(out_size+1); |
| 683 | if (buf == NULL) |
| 684 | throw runtime_error("out of memory for iconv buffer"); |
| 685 | |
| 686 | char *in = (char *)utf7imapstring.c_str(); |
| 687 | char *out = buf; |
| 688 | iconv(utf7imap2utf8, &in, &in_size, &out, &out_size); |
| 689 | |
| 690 | buf[utf7imapstring.size()*4-out_size]=0; |
| 691 | |
| 692 | result=buf; |
| 693 | |
| 694 | free(buf); |
| 695 | iconv_close(utf7imap2utf8); |
| 696 | |
| 697 | return result; |
| 698 | } |
| 699 | |
| 700 | std::string utf8_to_utf7imap(const std::string& utf8string) |
| 701 | { |
| 702 | string result; |
| 703 | |
| 704 | iconv_t utf82utf7imap = iconv_open("UTF-7-IMAP", "UTF-8"); |
| 705 | |
| 706 | if (utf82utf7imap == (iconv_t)-1) |
| 707 | throw runtime_error("iconv can't convert from UTF-7-IMAP to UTF-8"); |
| 708 | |
| 709 | // UTF-7 is base64 encoded, a buffer 10x as large |
| 710 | // as the utf-8 buffer should be enough. If not the string will be truncated. |
| 711 | size_t in_size=utf8string.size(); |
| 712 | size_t out_size=in_size*10; |
| 713 | |
| 714 | char *buf = (char *)malloc(out_size+1); |
| 715 | if (buf == NULL) |
| 716 | throw runtime_error("out of memory for iconv buffer"); |
| 717 | |
| 718 | char *in = (char *)utf8string.c_str(); |
| 719 | char *out = buf; |
| 720 | iconv(utf82utf7imap, &in, &in_size, &out, &out_size); |
| 721 | |
| 722 | buf[utf8string.size()*10-out_size]= 0; |
| 723 | |
| 724 | result=buf; |
| 725 | |
| 726 | free(buf); |
| 727 | iconv_close(utf82utf7imap); |
| 728 | |
| 729 | return result; |
| 730 | } |
| 731 | |
| 732 | // Tokenize string by (html) tags |
| 733 | void tokenize_by_tag(vector<pair<string,bool> > &tokenized, const std::string &input) |
| 734 | { |
| 735 | string::size_type pos, len = input.size(); |
| 736 | bool inside_tag = false; |
| 737 | string current; |
| 738 | |
| 739 | for (pos = 0; pos < len; pos++) |
| 740 | { |
| 741 | if (input[pos] == '<') |
| 742 | { |
| 743 | inside_tag = true; |
| 744 | |
| 745 | if (!current.empty() ) |
| 746 | { |
| 747 | tokenized.push_back( make_pair(current, false) ); |
| 748 | current = ""; |
| 749 | } |
| 750 | |
| 751 | current += input[pos]; |
| 752 | } |
| 753 | else if (input[pos] == '>' && inside_tag) |
| 754 | { |
| 755 | current += input[pos]; |
| 756 | inside_tag = false; |
| 757 | if (!current.empty() ) |
| 758 | { |
| 759 | tokenized.push_back( make_pair(current, true) ); |
| 760 | current = ""; |
| 761 | } |
| 762 | } |
| 763 | else |
| 764 | current += input[pos]; |
| 765 | } |
| 766 | |
| 767 | // String left over in buffer? |
| 768 | if (!current.empty() ) |
| 769 | tokenized.push_back( make_pair(current, false) ); |
| 770 | } // eo tokenize_by_tag |
| 771 | |
| 772 | |
| 773 | std::string strip_html_tags(const std::string &input) |
| 774 | { |
| 775 | // Pair first: string, second: isTag |
| 776 | vector<pair<string,bool> > tokenized; |
| 777 | tokenize_by_tag (tokenized, input); |
| 778 | |
| 779 | string output; |
| 780 | vector<pair<string,bool> >::const_iterator token, tokens_end = tokenized.end(); |
| 781 | for (token = tokenized.begin(); token != tokens_end; ++token) |
| 782 | if (!token->second) |
| 783 | output += token->first; |
| 784 | |
| 785 | return output; |
| 786 | } // eo strip_html_tags |
| 787 | |
| 788 | |
| 789 | // Smart-encode HTML en |
| 790 | string smart_html_entities(const std::string &input) |
| 791 | { |
| 792 | // Pair first: string, second: isTag |
| 793 | vector<pair<string,bool> > tokenized; |
| 794 | tokenize_by_tag (tokenized, input); |
| 795 | |
| 796 | string output; |
| 797 | vector<pair<string,bool> >::const_iterator token, tokens_end = tokenized.end(); |
| 798 | for (token = tokenized.begin(); token != tokens_end; ++token) |
| 799 | { |
| 800 | // keep HTML tags as they are |
| 801 | if (token->second) |
| 802 | output += token->first; |
| 803 | else |
| 804 | output += html_entities(token->first); |
| 805 | } |
| 806 | |
| 807 | return output; |
| 808 | } |
| 809 | |
| 810 | |
| 811 | string::size_type find_8bit(const std::string &str) |
| 812 | { |
| 813 | string::size_type l=str.size(); |
| 814 | for (string::size_type p=0; p < l; p++) |
| 815 | if (static_cast<unsigned char>(str[p]) > 127) |
| 816 | return p; |
| 817 | |
| 818 | return string::npos; |
| 819 | } |
| 820 | |
| 821 | // encoded UTF-8 chars into HTML entities |
| 822 | string html_entities(std::string str) |
| 823 | { |
| 824 | // Normal chars |
| 825 | replace_all (str, "&", "&"); |
| 826 | replace_all (str, "<", "<"); |
| 827 | replace_all (str, ">", ">"); |
| 828 | replace_all (str, "\"", """); |
| 829 | replace_all (str, "'", "'"); |
| 830 | replace_all (str, "/", "/"); |
| 831 | |
| 832 | // Umlauts |
| 833 | replace_all (str, "\xC3\xA4", "ä"); |
| 834 | replace_all (str, "\xC3\xB6", "ö"); |
| 835 | replace_all (str, "\xC3\xBC", "ü"); |
| 836 | replace_all (str, "\xC3\x84", "Ä"); |
| 837 | replace_all (str, "\xC3\x96", "Ö"); |
| 838 | replace_all (str, "\xC3\x9C", "Ü"); |
| 839 | |
| 840 | // Misc |
| 841 | replace_all (str, "\xC3\x9F", "ß"); |
| 842 | |
| 843 | // conversion of remaining non-ASCII chars needed? |
| 844 | // just do if needed because of performance |
| 845 | if (find_8bit(str) != string::npos) |
| 846 | { |
| 847 | // convert to fixed-size encoding UTF-32 |
| 848 | wchar_t* wbuf=utf8_to_wbuf(str); |
| 849 | ostringstream target; |
| 850 | |
| 851 | // replace all non-ASCII chars with HTML representation |
| 852 | for (int p=0; wbuf[p] != 0; p++) |
| 853 | { |
| 854 | unsigned int c=wbuf[p]; |
| 855 | |
| 856 | if (c <= 127) |
| 857 | target << static_cast<unsigned char>(c); |
| 858 | else |
| 859 | target << "&#" << c << ';'; |
| 860 | } |
| 861 | |
| 862 | free(wbuf); |
| 863 | |
| 864 | str=target.str(); |
| 865 | } |
| 866 | |
| 867 | return str; |
| 868 | } // eo html_entities(std::string) |
| 869 | |
| 870 | // convert HTML entities to something that can be viewed on a basic text console (restricted to ASCII-7) |
| 871 | string html_entities_to_console(std::string str) |
| 872 | { |
| 873 | // Normal chars |
| 874 | replace_all (str, "&", "&"); |
| 875 | replace_all (str, "<", "<"); |
| 876 | replace_all (str, ">", ">"); |
| 877 | replace_all (str, """, "\""); |
| 878 | replace_all (str, "'", "'"); |
| 879 | replace_all (str, "/", "/"); |
| 880 | |
| 881 | // Umlauts |
| 882 | replace_all (str, "ä", "ae"); |
| 883 | replace_all (str, "ö", "oe"); |
| 884 | replace_all (str, "ü", "ue"); |
| 885 | replace_all (str, "Ä", "Ae"); |
| 886 | replace_all (str, "Ö", "Oe"); |
| 887 | replace_all (str, "Ü", "Ue"); |
| 888 | |
| 889 | // Misc |
| 890 | replace_all (str, "ß", "ss"); |
| 891 | |
| 892 | return str; |
| 893 | } |
| 894 | |
| 895 | // find_html_comments + remove_html_comments(str, comments) |
| 896 | void remove_html_comments(string &str) |
| 897 | { |
| 898 | vector<CommentZone> comments; |
| 899 | find_html_comments(str, comments); |
| 900 | remove_html_comments(str, comments); |
| 901 | } |
| 902 | |
| 903 | // find all html comments, behaving correctly if they are nested; ignores comment tags ("<!--FOO .... BAR-->") |
| 904 | // If there are invalid comments ("-->" before "<!--" or different number of closing and opening tags), |
| 905 | // then the unknown index of corresponding start/end tag will be represented by a string::npos |
| 906 | // Indices are from start of start tag until first index after closing tag |
| 907 | void find_html_comments(const std::string &str, vector<CommentZone> &comments) |
| 908 | { |
| 909 | static const string START = "<!--"; |
| 910 | static const string CLOSE = "-->"; |
| 911 | static const string::size_type START_LEN = START.length(); |
| 912 | static const string::size_type CLOSE_LEN = CLOSE.length(); |
| 913 | |
| 914 | // in order to find nested comments, need either recursion or a stack |
| 915 | vector<string::size_type> starts; // stack of start tags |
| 916 | |
| 917 | string::size_type pos = 0; |
| 918 | string::size_type len = str.length(); |
| 919 | string::size_type next_start, next_close; |
| 920 | |
| 921 | while (pos < len) // not really needed but just in case |
| 922 | { |
| 923 | next_start = str.find(START, pos); |
| 924 | next_close = str.find(CLOSE, pos); |
| 925 | |
| 926 | if ( (next_start == string::npos) && (next_close == string::npos) ) |
| 927 | break; // we are done |
| 928 | |
| 929 | else if ( (next_start == string::npos) || (next_close < next_start) ) // close one comment (pop) |
| 930 | { |
| 931 | if (starts.empty()) // closing tag without a start |
| 932 | comments.push_back(CommentZone(string::npos, next_close+CLOSE_LEN)); |
| 933 | else |
| 934 | { |
| 935 | comments.push_back(CommentZone(starts.back(), next_close+CLOSE_LEN)); |
| 936 | starts.pop_back(); |
| 937 | } |
| 938 | pos = next_close + CLOSE_LEN; |
| 939 | } |
| 940 | |
| 941 | else if ( (next_close == string::npos) || (next_start < next_close) ) // start a new comment (push) |
| 942 | { |
| 943 | starts.push_back(next_start); |
| 944 | pos = next_start + START_LEN; |
| 945 | } |
| 946 | } |
| 947 | |
| 948 | // add comments that have no closing tag from back to front (important for remove_html_comments!) |
| 949 | while (!starts.empty()) |
| 950 | { |
| 951 | comments.push_back(CommentZone(starts.back(), string::npos)); |
| 952 | starts.pop_back(); |
| 953 | } |
| 954 | } |
| 955 | |
| 956 | // remove all html comments foundby find_html_comments |
| 957 | void remove_html_comments(std::string &str, const vector<CommentZone> &comments) |
| 958 | { |
| 959 | // remember position where last removal started |
| 960 | string::size_type last_removal_start = str.length(); |
| 961 | |
| 962 | // Go from back to front to not mess up indices. |
| 963 | // This requires that bigger comments, that contain smaller comments, come AFTER |
| 964 | // the small contained comments in the comments vector (i.e. comments are ordered by |
| 965 | // their closing tag, not their opening tag). This is true for results from find_html_comments |
| 966 | BOOST_REVERSE_FOREACH(const CommentZone &comment, comments) |
| 967 | { |
| 968 | if (comment.first == string::npos) |
| 969 | { |
| 970 | str = str.replace(0, comment.second, ""); // comment starts "before" str --> delete from start |
| 971 | break; // there can be no more |
| 972 | } |
| 973 | else if (comment.first >= last_removal_start) |
| 974 | { |
| 975 | continue; // this comment is inside another comment that we have removed already |
| 976 | } |
| 977 | else if (comment.second == string::npos) // comment ends "after" str --> delete until end |
| 978 | { |
| 979 | str = str.replace(comment.first, string::npos, ""); |
| 980 | last_removal_start = comment.first; |
| 981 | } |
| 982 | else |
| 983 | { |
| 984 | str = str.replace(comment.first, comment.second-comment.first, ""); |
| 985 | last_removal_start = comment.first; |
| 986 | } |
| 987 | } |
| 988 | } |
| 989 | |
| 990 | bool replace_all(string &base, const char *ist, const char *soll) |
| 991 | { |
| 992 | string i=ist; |
| 993 | string s=soll; |
| 994 | return replace_all(base,&i,&s); |
| 995 | } |
| 996 | |
| 997 | bool replace_all(string &base, const string &ist, const char *soll) |
| 998 | { |
| 999 | string s=soll; |
| 1000 | return replace_all(base,&ist,&s); |
| 1001 | } |
| 1002 | |
| 1003 | bool replace_all(string &base, const string *ist, const string *soll) |
| 1004 | { |
| 1005 | return replace_all(base,*ist,*soll); |
| 1006 | } |
| 1007 | |
| 1008 | bool replace_all(string &base, const char *ist, const string *soll) |
| 1009 | { |
| 1010 | string i=ist; |
| 1011 | return replace_all(base,&i,soll); |
| 1012 | } |
| 1013 | |
| 1014 | bool replace_all(string &base, const string &ist, const string &soll) |
| 1015 | { |
| 1016 | bool found_ist = false; |
| 1017 | string::size_type a=0; |
| 1018 | |
| 1019 | if (ist.empty() ) |
| 1020 | throw runtime_error ("replace_all called with empty search string"); |
| 1021 | |
| 1022 | while ( (a=base.find(ist,a) ) != string::npos) |
| 1023 | { |
| 1024 | base.replace(a,ist.size(),soll); |
| 1025 | a=a+soll.size(); |
| 1026 | found_ist = true; |
| 1027 | } |
| 1028 | |
| 1029 | return found_ist; |
| 1030 | } |
| 1031 | |
| 1032 | /** |
| 1033 | * @brief replaces all characters that could be problematic or impose a security risk when being logged |
| 1034 | * @param str the original string |
| 1035 | * @param replace_with the character to replace the unsafe chars with |
| 1036 | * @return a string that is safe to send to syslog or other logfiles |
| 1037 | * |
| 1038 | * All chars between 0x20 (space) and 0x7E (~) (including) are considered safe for logging. |
| 1039 | * See e.g. RFC 5424, section 8.2 or the posix character class "printable". |
| 1040 | * This eliminates all possible problems with NUL, control characters, 8 bit chars, UTF8. |
| 1041 | * |
| 1042 | */ |
| 1043 | std::string sanitize_for_logging(const std::string &str, const char replace_with) |
| 1044 | { |
| 1045 | std::string output=str; |
| 1046 | |
| 1047 | const string::size_type len = output.size(); |
| 1048 | for (std::string::size_type p=0; p < len; p++) |
| 1049 | if (output[p] < 0x20 || output[p] > 0x7E) |
| 1050 | output[p]=replace_with; |
| 1051 | |
| 1052 | return output; |
| 1053 | } |
| 1054 | |
| 1055 | #if 0 |
| 1056 | string to_lower(const string &src) |
| 1057 | { |
| 1058 | string dst = src; |
| 1059 | |
| 1060 | string::size_type pos, end = dst.size(); |
| 1061 | for (pos = 0; pos < end; pos++) |
| 1062 | dst[pos] = tolower(dst[pos]); |
| 1063 | |
| 1064 | return dst; |
| 1065 | } |
| 1066 | |
| 1067 | string to_upper(const string &src) |
| 1068 | { |
| 1069 | string dst = src; |
| 1070 | |
| 1071 | string::size_type pos, end = dst.size(); |
| 1072 | for (pos = 0; pos < end; pos++) |
| 1073 | dst[pos] = toupper(dst[pos]); |
| 1074 | |
| 1075 | return dst; |
| 1076 | } |
| 1077 | #endif |
| 1078 | |
| 1079 | const int MAX_UNIT_FORMAT_SYMBOLS = 6; |
| 1080 | |
| 1081 | const string shortUnitFormatSymbols[MAX_UNIT_FORMAT_SYMBOLS] = { |
| 1082 | " B", |
| 1083 | " KB", |
| 1084 | " MB", |
| 1085 | " GB", |
| 1086 | " TB", |
| 1087 | " PB" |
| 1088 | }; |
| 1089 | |
| 1090 | const string longUnitFormatSymbols[MAX_UNIT_FORMAT_SYMBOLS] = { |
| 1091 | i18n_noop(" Bytes"), |
| 1092 | i18n_noop(" KBytes"), |
| 1093 | i18n_noop(" MBytes"), |
| 1094 | i18n_noop(" GBytes"), |
| 1095 | i18n_noop(" TBytes"), |
| 1096 | i18n_noop(" PBytes") |
| 1097 | }; |
| 1098 | |
| 1099 | |
| 1100 | long double rounding_upwards( |
| 1101 | const long double number, |
| 1102 | const int rounding_multiplier |
| 1103 | ) |
| 1104 | { |
| 1105 | long double rounded_number; |
| 1106 | rounded_number = number * rounding_multiplier; |
| 1107 | rounded_number += 0.5; |
| 1108 | rounded_number = (int64_t) (rounded_number); |
| 1109 | rounded_number = (long double) (rounded_number) / (long double) (rounding_multiplier); |
| 1110 | |
| 1111 | return rounded_number; |
| 1112 | } |
| 1113 | |
| 1114 | |
| 1115 | string nice_unit_format( |
| 1116 | const int64_t input, |
| 1117 | const UnitFormat format, |
| 1118 | const UnitBase base |
| 1119 | ) |
| 1120 | { |
| 1121 | // select the system of units (decimal or binary) |
| 1122 | int multiple = 0; |
| 1123 | if (base == UnitBase1000) |
| 1124 | { |
| 1125 | multiple = 1000; |
| 1126 | } |
| 1127 | else |
| 1128 | { |
| 1129 | multiple = 1024; |
| 1130 | } |
| 1131 | |
| 1132 | long double size = input; |
| 1133 | |
| 1134 | // check the size of the input number to fit in the appropriate symbol |
| 1135 | int sizecount = 0; |
| 1136 | while (size > multiple) |
| 1137 | { |
| 1138 | size = size / multiple; |
| 1139 | sizecount++; |
| 1140 | |
| 1141 | // rollback to the previous values and stop the loop when cannot |
| 1142 | // represent the number length. |
| 1143 | if (sizecount >= MAX_UNIT_FORMAT_SYMBOLS) |
| 1144 | { |
| 1145 | size = size * multiple; |
| 1146 | sizecount--; |
| 1147 | break; |
| 1148 | } |
| 1149 | } |
| 1150 | |
| 1151 | // round the input number "half up" to multiples of 10 |
| 1152 | const int rounding_multiplier = 10; |
| 1153 | size = rounding_upwards(size, rounding_multiplier); |
| 1154 | |
| 1155 | // format the input number, placing the appropriate symbol |
| 1156 | ostringstream out; |
| 1157 | out.setf (ios::fixed); |
| 1158 | if (format == ShortUnitFormat) |
| 1159 | { |
| 1160 | out.precision(1); |
| 1161 | out << size << i18n( shortUnitFormatSymbols[sizecount].c_str() ); |
| 1162 | } |
| 1163 | else |
| 1164 | { |
| 1165 | out.precision (2); |
| 1166 | out << size << i18n( longUnitFormatSymbols[sizecount].c_str() ); |
| 1167 | } |
| 1168 | |
| 1169 | return out.str(); |
| 1170 | } // eo nice_unit_format(int input) |
| 1171 | |
| 1172 | |
| 1173 | string nice_unit_format( |
| 1174 | const double input, |
| 1175 | const UnitFormat format, |
| 1176 | const UnitBase base |
| 1177 | ) |
| 1178 | { |
| 1179 | // round as double and cast to int64_t |
| 1180 | // cast raised overflow error near max val of int64_t (~9.2e18, see unittest) |
| 1181 | int64_t input_casted_and_rounded = |
| 1182 | boost::numeric_cast<int64_t>( round(input) ); |
| 1183 | |
| 1184 | // now call other |
| 1185 | return nice_unit_format( input_casted_and_rounded, format, base ); |
| 1186 | } // eo nice_unit_format(double input) |
| 1187 | |
| 1188 | |
| 1189 | string escape(const string &s) |
| 1190 | { |
| 1191 | string out(s); |
| 1192 | string::size_type p; |
| 1193 | |
| 1194 | p=0; |
| 1195 | while ( (p=out.find_first_of("\"\\",p) ) !=out.npos) |
| 1196 | { |
| 1197 | out.insert (p,"\\"); |
| 1198 | p+=2; |
| 1199 | } |
| 1200 | |
| 1201 | p=0; |
| 1202 | while ( (p=out.find_first_of("\r",p) ) !=out.npos) |
| 1203 | { |
| 1204 | out.replace (p,1,"\\r"); |
| 1205 | p+=2; |
| 1206 | } |
| 1207 | |
| 1208 | p=0; |
| 1209 | while ( (p=out.find_first_of("\n",p) ) !=out.npos) |
| 1210 | { |
| 1211 | out.replace (p,1,"\\n"); |
| 1212 | p+=2; |
| 1213 | } |
| 1214 | |
| 1215 | out='"'+out+'"'; |
| 1216 | |
| 1217 | return out; |
| 1218 | } // eo scape(const std::string&) |
| 1219 | |
| 1220 | |
| 1221 | string descape(const string &s, int startpos, int &endpos) |
| 1222 | { |
| 1223 | string out; |
| 1224 | |
| 1225 | if (s.at(startpos) != '"') |
| 1226 | throw out_of_range("value not type escaped string"); |
| 1227 | |
| 1228 | out=s.substr(startpos+1); |
| 1229 | string::size_type p=0; |
| 1230 | |
| 1231 | // search for the end of the string |
| 1232 | while ( (p=out.find("\"",p) ) !=out.npos) |
| 1233 | { |
| 1234 | int e=p-1; |
| 1235 | bool escaped=false; |
| 1236 | |
| 1237 | // the " might be escaped with a backslash |
| 1238 | while (e>=0 && out.at (e) =='\\') |
| 1239 | { |
| 1240 | if (escaped == false) |
| 1241 | escaped=true; |
| 1242 | else |
| 1243 | escaped=false; |
| 1244 | |
| 1245 | e--; |
| 1246 | } |
| 1247 | |
| 1248 | if (escaped==false) |
| 1249 | break; |
| 1250 | else |
| 1251 | p++; |
| 1252 | } |
| 1253 | |
| 1254 | // we now have the end of the string |
| 1255 | out=out.substr(0,p); |
| 1256 | |
| 1257 | // tell calling prog about the endposition |
| 1258 | endpos=startpos+p+1; |
| 1259 | |
| 1260 | // descape all \ stuff inside the string now |
| 1261 | p=0; |
| 1262 | while ( (p=out.find_first_of("\\",p) ) !=out.npos) |
| 1263 | { |
| 1264 | switch (out.at(p+1) ) |
| 1265 | { |
| 1266 | case 'r': |
| 1267 | out.replace(p,2,"\r"); |
| 1268 | break; |
| 1269 | case 'n': |
| 1270 | out.replace(p,2,"\n"); |
| 1271 | break; |
| 1272 | default: |
| 1273 | out.erase(p,1); |
| 1274 | } |
| 1275 | p++; |
| 1276 | } |
| 1277 | |
| 1278 | return out; |
| 1279 | } // eo descape(const std::string&,int,int&) |
| 1280 | |
| 1281 | |
| 1282 | string escape_shellarg(const string &input) |
| 1283 | { |
| 1284 | string output = "'"; |
| 1285 | string::const_iterator it, it_end = input.end(); |
| 1286 | for (it = input.begin(); it != it_end; ++it) |
| 1287 | { |
| 1288 | if ( (*it) == '\'') |
| 1289 | output += "'\\'"; |
| 1290 | |
| 1291 | output += *it; |
| 1292 | } |
| 1293 | |
| 1294 | output += "'"; |
| 1295 | return output; |
| 1296 | } |