lib/strutil/strutil.c

   1 /*
   2    Common strings utilities
   3
   4    Copyright (C) 2007-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Rostislav Benes, 2007
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 #include <config.h>
  27
  28 #include <stdlib.h>
  29 #include <langinfo.h>
  30 #include <string.h>
  31 #include <errno.h>
  32
  33 #include "lib/global.h"
  34 #include "lib/util.h"           /* MC_PTR_FREE */
  35 #include "lib/strutil.h"
  36
  37 /*** global variables ****************************************************************************/
  38
  39 GIConv str_cnv_to_term;
  40 GIConv str_cnv_from_term;
  41 GIConv str_cnv_not_convert = INVALID_CONV;
  42
  43 /*** file scope macro definitions ****************************************************************/
  44
  45 /*** file scope type declarations ****************************************************************/
  46
  47 /*** forward declarations (file scope functions) *************************************************/
  48
  49 /*** file scope variables ************************************************************************/
  50
  51 /* names, that are used for utf-8 */
  52 static const char *const str_utf8_encodings[] = {
  53     "utf-8",
  54     "utf8",
  55     NULL
  56 };
  57
  58 /* standard 8bit encodings, no wide or multibytes characters */
  59 static const char *const str_8bit_encodings[] = {
  60     /* Solaris has different names of Windows 1251 encoding */
  61 #ifdef __sun
  62     "ansi-1251",
  63     "ansi1251",
  64 #else
  65     "cp-1251",
  66     "cp1251",
  67 #endif
  68     "cp-1250",
  69     "cp1250",
  70     "cp-866",
  71     "cp866",
  72     "ibm-866",
  73     "ibm866",
  74     "cp-850",
  75     "cp850",
  76     "cp-852",
  77     "cp852",
  78     "iso-8859",
  79     "iso8859",
  80     "koi8",
  81     NULL
  82 };
  83
  84 /* terminal encoding */
  85 static char *codeset = NULL;
  86 static char *term_encoding = NULL;
  87 /* function for encoding specific operations */
  88 static struct str_class used_class;
  89
  90 /* --------------------------------------------------------------------------------------------- */
  91 /*** file scope functions ************************************************************************/
  92 /* --------------------------------------------------------------------------------------------- */
  93
  94 /* if enc is same encoding like on terminal */
  95 static int
  96 str_test_not_convert (const char *enc)
  97 {
  98     return g_ascii_strcasecmp (enc, codeset) == 0;
  99 }
 100
 101 /* --------------------------------------------------------------------------------------------- */
 102
 103 static estr_t
 104 _str_convert (GIConv coder, const char *string, int size, GString *buffer)
 105 {
 106     estr_t state = ESTR_SUCCESS;
 107     gssize left;
 108     gsize bytes_read = 0;
 109     gsize bytes_written = 0;
 110
 111     errno = 0;                  /* FIXME: is it really needed? */
 112
 113     if (coder == INVALID_CONV)
 114         return ESTR_FAILURE;
 115
 116     if (string == NULL || buffer == NULL)
 117         return ESTR_FAILURE;
 118
 119     /*
 120        if (! used_class.is_valid_string (string))
 121        {
 122        return ESTR_FAILURE;
 123        }
 124      */
 125     if (size < 0)
 126         size = strlen (string);
 127     else
 128     {
 129         left = strlen (string);
 130         if (left < size)
 131             size = left;
 132     }
 133
 134     left = size;
 135     g_iconv (coder, NULL, NULL, NULL, NULL);
 136
 137     while (left != 0)
 138     {
 139         gchar *tmp_buff;
 140         GError *mcerror = NULL;
 141
 142         tmp_buff = g_convert_with_iconv ((const gchar *) string,
 143                                          left, coder, &bytes_read, &bytes_written, &mcerror);
 144         if (mcerror != NULL)
 145         {
 146             int code = mcerror->code;
 147
 148             g_error_free (mcerror);
 149             mcerror = NULL;
 150
 151             switch (code)
 152             {
 153             case G_CONVERT_ERROR_NO_CONVERSION:
 154                 /* Conversion between the requested character sets is not supported. */
 155                 g_free (tmp_buff);
 156                 mc_g_string_append_c_len (buffer, '?', strlen (string));
 157                 return ESTR_FAILURE;
 158
 159             case G_CONVERT_ERROR_ILLEGAL_SEQUENCE:
 160                 /* Invalid byte sequence in conversion input. */
 161                 if ((tmp_buff == NULL) && (bytes_read != 0))
 162                     /* recode valid byte sequence */
 163                     tmp_buff = g_convert_with_iconv ((const gchar *) string,
 164                                                      bytes_read, coder, NULL, NULL, NULL);
 165
 166                 if (tmp_buff != NULL)
 167                 {
 168                     g_string_append (buffer, tmp_buff);
 169                     g_free (tmp_buff);
 170                 }
 171
 172                 if ((int) bytes_read >= left)
 173                     return ESTR_PROBLEM;
 174
 175                 string += bytes_read + 1;
 176                 size -= (bytes_read + 1);
 177                 left -= (bytes_read + 1);
 178                 g_string_append_c (buffer, *(string - 1));
 179                 state = ESTR_PROBLEM;
 180                 break;
 181
 182             case G_CONVERT_ERROR_PARTIAL_INPUT:
 183                 /* Partial character sequence at end of input. */
 184                 g_string_append (buffer, tmp_buff);
 185                 g_free (tmp_buff);
 186                 if ((int) bytes_read < left)
 187                     mc_g_string_append_c_len (buffer, '?', left - bytes_read);
 188                 return ESTR_PROBLEM;
 189
 190             case G_CONVERT_ERROR_BAD_URI:      /* Don't know how handle this error :( */
 191             case G_CONVERT_ERROR_NOT_ABSOLUTE_PATH:    /* Don't know how handle this error :( */
 192             case G_CONVERT_ERROR_FAILED:       /* Conversion failed for some reason. */
 193             default:
 194                 g_free (tmp_buff);
 195                 return ESTR_FAILURE;
 196             }
 197         }
 198         else if (tmp_buff == NULL)
 199         {
 200             g_string_append (buffer, string);
 201             return ESTR_PROBLEM;
 202         }
 203         else if (*tmp_buff == '\0')
 204         {
 205             g_free (tmp_buff);
 206             g_string_append (buffer, string);
 207             return state;
 208         }
 209         else
 210         {
 211             g_string_append (buffer, tmp_buff);
 212             g_free (tmp_buff);
 213             string += bytes_read;
 214             left -= bytes_read;
 215         }
 216     }
 217
 218     return state;
 219 }
 220
 221 /* --------------------------------------------------------------------------------------------- */
 222
 223 static int
 224 str_test_encoding_class (const char *encoding, const char *const *table)
 225 {
 226     int result = 0;
 227
 228     if (encoding != NULL)
 229     {
 230         int t;
 231
 232         for (t = 0; table[t] != NULL; t++)
 233             if (g_ascii_strncasecmp (encoding, table[t], strlen (table[t])) == 0)
 234                 result++;
 235     }
 236
 237     return result;
 238 }
 239
 240 /* --------------------------------------------------------------------------------------------- */
 241
 242 static void
 243 str_choose_str_functions (void)
 244 {
 245     if (str_test_encoding_class (codeset, str_utf8_encodings))
 246         used_class = str_utf8_init ();
 247     else if (str_test_encoding_class (codeset, str_8bit_encodings))
 248         used_class = str_8bit_init ();
 249     else
 250         used_class = str_ascii_init ();
 251 }
 252
 253 /* --------------------------------------------------------------------------------------------- */
 254 /*** public functions ****************************************************************************/
 255 /* --------------------------------------------------------------------------------------------- */
 256
 257 GIConv
 258 str_crt_conv_to (const char *to_enc)
 259 {
 260     return (!str_test_not_convert (to_enc)) ? g_iconv_open (to_enc, codeset) : str_cnv_not_convert;
 261 }
 262
 263 /* --------------------------------------------------------------------------------------------- */
 264
 265 GIConv
 266 str_crt_conv_from (const char *from_enc)
 267 {
 268     return (!str_test_not_convert (from_enc))
 269         ? g_iconv_open (codeset, from_enc) : str_cnv_not_convert;
 270 }
 271
 272 /* --------------------------------------------------------------------------------------------- */
 273
 274 void
 275 str_close_conv (GIConv conv)
 276 {
 277     if (conv != str_cnv_not_convert)
 278         g_iconv_close (conv);
 279 }
 280
 281 /* --------------------------------------------------------------------------------------------- */
 282
 283 estr_t
 284 str_convert (GIConv coder, const char *string, GString *buffer)
 285 {
 286     return _str_convert (coder, string, -1, buffer);
 287 }
 288
 289 /* --------------------------------------------------------------------------------------------- */
 290
 291 estr_t
 292 str_nconvert (GIConv coder, const char *string, int size, GString *buffer)
 293 {
 294     return _str_convert (coder, string, size, buffer);
 295 }
 296
 297 /* --------------------------------------------------------------------------------------------- */
 298
 299 gchar *
 300 str_conv_gerror_message (GError *mcerror, const char *def_msg)
 301 {
 302     return used_class.conv_gerror_message (mcerror, def_msg);
 303 }
 304
 305 /* --------------------------------------------------------------------------------------------- */
 306
 307 estr_t
 308 str_vfs_convert_from (GIConv coder, const char *string, GString *buffer)
 309 {
 310     estr_t result = ESTR_SUCCESS;
 311
 312     if (coder == str_cnv_not_convert)
 313         g_string_append (buffer, string != NULL ? string : "");
 314     else
 315         result = _str_convert (coder, string, -1, buffer);
 316
 317     return result;
 318 }
 319
 320 /* --------------------------------------------------------------------------------------------- */
 321
 322 estr_t
 323 str_vfs_convert_to (GIConv coder, const char *string, int size, GString *buffer)
 324 {
 325     return used_class.vfs_convert_to (coder, string, size, buffer);
 326 }
 327
 328 /* --------------------------------------------------------------------------------------------- */
 329
 330 void
 331 str_printf (GString *buffer, const char *format, ...)
 332 {
 333     va_list ap;
 334     va_start (ap, format);
 335
 336     g_string_append_vprintf (buffer, format, ap);
 337     va_end (ap);
 338 }
 339
 340 /* --------------------------------------------------------------------------------------------- */
 341
 342 void
 343 str_insert_replace_char (GString *buffer)
 344 {
 345     used_class.insert_replace_char (buffer);
 346 }
 347
 348 /* --------------------------------------------------------------------------------------------- */
 349
 350 estr_t
 351 str_translate_char (GIConv conv, const char *keys, size_t ch_size, char *output, size_t out_size)
 352 {
 353     size_t left;
 354     size_t cnv;
 355
 356     g_iconv (conv, NULL, NULL, NULL, NULL);
 357
 358     left = (ch_size == (size_t) (-1)) ? strlen (keys) : ch_size;
 359
 360     cnv = g_iconv (conv, (gchar **) & keys, &left, &output, &out_size);
 361     if (cnv == (size_t) (-1))
 362         return (errno == EINVAL) ? ESTR_PROBLEM : ESTR_FAILURE;
 363
 364     output[0] = '\0';
 365     return ESTR_SUCCESS;
 366 }
 367
 368 /* --------------------------------------------------------------------------------------------- */
 369
 370 const char *
 371 str_detect_termencoding (void)
 372 {
 373     if (term_encoding == NULL)
 374     {
 375         /* On Linux, nl_langinfo (CODESET) returns upper case UTF-8 whether the LANG is set
 376            to utf-8 or UTF-8.
 377            On Mac OS X, it returns the same case as the LANG input.
 378            So let transform result of nl_langinfo (CODESET) to upper case  unconditionally. */
 379         term_encoding = g_ascii_strup (nl_langinfo (CODESET), -1);
 380     }
 381
 382     return term_encoding;
 383 }
 384
 385 /* --------------------------------------------------------------------------------------------- */
 386
 387 gboolean
 388 str_isutf8 (const char *codeset_name)
 389 {
 390     return (str_test_encoding_class (codeset_name, str_utf8_encodings) != 0);
 391 }
 392
 393 /* --------------------------------------------------------------------------------------------- */
 394
 395 void
 396 str_init_strings (const char *termenc)
 397 {
 398     codeset = termenc != NULL ? g_ascii_strup (termenc, -1) : g_strdup (str_detect_termencoding ());
 399
 400     str_cnv_not_convert = g_iconv_open (codeset, codeset);
 401     if (str_cnv_not_convert == INVALID_CONV)
 402     {
 403         if (termenc != NULL)
 404         {
 405             g_free (codeset);
 406             codeset = g_strdup (str_detect_termencoding ());
 407             str_cnv_not_convert = g_iconv_open (codeset, codeset);
 408         }
 409
 410         if (str_cnv_not_convert == INVALID_CONV)
 411         {
 412             g_free (codeset);
 413             codeset = g_strdup (DEFAULT_CHARSET);
 414             str_cnv_not_convert = g_iconv_open (codeset, codeset);
 415         }
 416     }
 417
 418     str_cnv_to_term = str_cnv_not_convert;
 419     str_cnv_from_term = str_cnv_not_convert;
 420
 421     str_choose_str_functions ();
 422 }
 423
 424 /* --------------------------------------------------------------------------------------------- */
 425
 426 void
 427 str_uninit_strings (void)
 428 {
 429     if (str_cnv_not_convert != INVALID_CONV)
 430         g_iconv_close (str_cnv_not_convert);
 431     /* NULL-ize pointers to avoid double free in unit tests */
 432     MC_PTR_FREE (term_encoding);
 433     MC_PTR_FREE (codeset);
 434 }
 435
 436 /* --------------------------------------------------------------------------------------------- */
 437
 438 const char *
 439 str_term_form (const char *text)
 440 {
 441     return used_class.term_form (text);
 442 }
 443
 444 /* --------------------------------------------------------------------------------------------- */
 445
 446 const char *
 447 str_fit_to_term (const char *text, int width, align_crt_t just_mode)
 448 {
 449     return used_class.fit_to_term (text, width, just_mode);
 450 }
 451
 452 /* --------------------------------------------------------------------------------------------- */
 453
 454 const char *
 455 str_term_trim (const char *text, int width)
 456 {
 457     return used_class.term_trim (text, width);
 458 }
 459
 460 /* --------------------------------------------------------------------------------------------- */
 461
 462 const char *
 463 str_term_substring (const char *text, int start, int width)
 464 {
 465     return used_class.term_substring (text, start, width);
 466 }
 467
 468 /* --------------------------------------------------------------------------------------------- */
 469
 470 char *
 471 str_get_next_char (char *text)
 472 {
 473
 474     used_class.cnext_char ((const char **) &text);
 475     return text;
 476 }
 477
 478 /* --------------------------------------------------------------------------------------------- */
 479
 480 const char *
 481 str_cget_next_char (const char *text)
 482 {
 483     used_class.cnext_char (&text);
 484     return text;
 485 }
 486
 487 /* --------------------------------------------------------------------------------------------- */
 488
 489 void
 490 str_next_char (char **text)
 491 {
 492     used_class.cnext_char ((const char **) text);
 493 }
 494
 495 /* --------------------------------------------------------------------------------------------- */
 496
 497 void
 498 str_cnext_char (const char **text)
 499 {
 500     used_class.cnext_char (text);
 501 }
 502
 503 /* --------------------------------------------------------------------------------------------- */
 504
 505 char *
 506 str_get_prev_char (char *text)
 507 {
 508     used_class.cprev_char ((const char **) &text);
 509     return text;
 510 }
 511
 512 /* --------------------------------------------------------------------------------------------- */
 513
 514 const char *
 515 str_cget_prev_char (const char *text)
 516 {
 517     used_class.cprev_char (&text);
 518     return text;
 519 }
 520
 521 /* --------------------------------------------------------------------------------------------- */
 522
 523 void
 524 str_prev_char (char **text)
 525 {
 526     used_class.cprev_char ((const char **) text);
 527 }
 528
 529 /* --------------------------------------------------------------------------------------------- */
 530
 531 void
 532 str_cprev_char (const char **text)
 533 {
 534     used_class.cprev_char (text);
 535 }
 536
 537 /* --------------------------------------------------------------------------------------------- */
 538
 539 char *
 540 str_get_next_char_safe (char *text)
 541 {
 542     used_class.cnext_char_safe ((const char **) &text);
 543     return text;
 544 }
 545
 546 /* --------------------------------------------------------------------------------------------- */
 547
 548 const char *
 549 str_cget_next_char_safe (const char *text)
 550 {
 551     used_class.cnext_char_safe (&text);
 552     return text;
 553 }
 554
 555 /* --------------------------------------------------------------------------------------------- */
 556
 557 void
 558 str_next_char_safe (char **text)
 559 {
 560     used_class.cnext_char_safe ((const char **) text);
 561 }
 562
 563 /* --------------------------------------------------------------------------------------------- */
 564
 565 void
 566 str_cnext_char_safe (const char **text)
 567 {
 568     used_class.cnext_char_safe (text);
 569 }
 570
 571 /* --------------------------------------------------------------------------------------------- */
 572
 573 char *
 574 str_get_prev_char_safe (char *text)
 575 {
 576     used_class.cprev_char_safe ((const char **) &text);
 577     return text;
 578 }
 579
 580 /* --------------------------------------------------------------------------------------------- */
 581
 582 const char *
 583 str_cget_prev_char_safe (const char *text)
 584 {
 585     used_class.cprev_char_safe (&text);
 586     return text;
 587 }
 588
 589 /* --------------------------------------------------------------------------------------------- */
 590
 591 void
 592 str_prev_char_safe (char **text)
 593 {
 594     used_class.cprev_char_safe ((const char **) text);
 595 }
 596
 597 /* --------------------------------------------------------------------------------------------- */
 598
 599 void
 600 str_cprev_char_safe (const char **text)
 601 {
 602     used_class.cprev_char_safe (text);
 603 }
 604
 605 /* --------------------------------------------------------------------------------------------- */
 606
 607 int
 608 str_next_noncomb_char (char **text)
 609 {
 610     return used_class.cnext_noncomb_char ((const char **) text);
 611 }
 612
 613 /* --------------------------------------------------------------------------------------------- */
 614
 615 int
 616 str_cnext_noncomb_char (const char **text)
 617 {
 618     return used_class.cnext_noncomb_char (text);
 619 }
 620
 621 /* --------------------------------------------------------------------------------------------- */
 622
 623 int
 624 str_prev_noncomb_char (char **text, const char *begin)
 625 {
 626     return used_class.cprev_noncomb_char ((const char **) text, begin);
 627 }
 628
 629 /* --------------------------------------------------------------------------------------------- */
 630
 631 int
 632 str_cprev_noncomb_char (const char **text, const char *begin)
 633 {
 634     return used_class.cprev_noncomb_char (text, begin);
 635 }
 636
 637 /* --------------------------------------------------------------------------------------------- */
 638
 639 int
 640 str_is_valid_char (const char *ch, size_t size)
 641 {
 642     return used_class.is_valid_char (ch, size);
 643 }
 644
 645 /* --------------------------------------------------------------------------------------------- */
 646
 647 int
 648 str_term_width1 (const char *text)
 649 {
 650     return used_class.term_width1 (text);
 651 }
 652
 653 /* --------------------------------------------------------------------------------------------- */
 654
 655 int
 656 str_term_width2 (const char *text, size_t length)
 657 {
 658     return used_class.term_width2 (text, length);
 659 }
 660
 661 /* --------------------------------------------------------------------------------------------- */
 662
 663 int
 664 str_term_char_width (const char *text)
 665 {
 666     return used_class.term_char_width (text);
 667 }
 668
 669 /* --------------------------------------------------------------------------------------------- */
 670
 671 int
 672 str_offset_to_pos (const char *text, size_t length)
 673 {
 674     return used_class.offset_to_pos (text, length);
 675 }
 676
 677 /* --------------------------------------------------------------------------------------------- */
 678
 679 int
 680 str_length (const char *text)
 681 {
 682     return used_class.length (text);
 683 }
 684
 685 /* --------------------------------------------------------------------------------------------- */
 686
 687 int
 688 str_length_char (const char *text)
 689 {
 690     return str_cget_next_char_safe (text) - text;
 691 }
 692
 693 /* --------------------------------------------------------------------------------------------- */
 694
 695 int
 696 str_length2 (const char *text, int size)
 697 {
 698     return used_class.length2 (text, size);
 699 }
 700
 701 /* --------------------------------------------------------------------------------------------- */
 702
 703 int
 704 str_length_noncomb (const char *text)
 705 {
 706     return used_class.length_noncomb (text);
 707 }
 708
 709 /* --------------------------------------------------------------------------------------------- */
 710
 711 int
 712 str_column_to_pos (const char *text, size_t pos)
 713 {
 714     return used_class.column_to_pos (text, pos);
 715 }
 716
 717 /* --------------------------------------------------------------------------------------------- */
 718
 719 gboolean
 720 str_isspace (const char *ch)
 721 {
 722     return used_class.char_isspace (ch);
 723 }
 724
 725 /* --------------------------------------------------------------------------------------------- */
 726
 727 gboolean
 728 str_ispunct (const char *ch)
 729 {
 730     return used_class.char_ispunct (ch);
 731 }
 732
 733 /* --------------------------------------------------------------------------------------------- */
 734
 735 gboolean
 736 str_isalnum (const char *ch)
 737 {
 738     return used_class.char_isalnum (ch);
 739 }
 740
 741 /* --------------------------------------------------------------------------------------------- */
 742
 743 gboolean
 744 str_isdigit (const char *ch)
 745 {
 746     return used_class.char_isdigit (ch);
 747 }
 748
 749 /* --------------------------------------------------------------------------------------------- */
 750
 751 gboolean
 752 str_toupper (const char *ch, char **out, size_t *remain)
 753 {
 754     return used_class.char_toupper (ch, out, remain);
 755 }
 756
 757 /* --------------------------------------------------------------------------------------------- */
 758
 759 gboolean
 760 str_tolower (const char *ch, char **out, size_t *remain)
 761 {
 762     return used_class.char_tolower (ch, out, remain);
 763 }
 764
 765 /* --------------------------------------------------------------------------------------------- */
 766
 767 gboolean
 768 str_isprint (const char *ch)
 769 {
 770     return used_class.char_isprint (ch);
 771 }
 772
 773 /* --------------------------------------------------------------------------------------------- */
 774
 775 gboolean
 776 str_iscombiningmark (const char *ch)
 777 {
 778     return used_class.char_iscombiningmark (ch);
 779 }
 780
 781 /* --------------------------------------------------------------------------------------------- */
 782
 783 const char *
 784 str_trunc (const char *text, int width)
 785 {
 786     return used_class.trunc (text, width);
 787 }
 788
 789 /* --------------------------------------------------------------------------------------------- */
 790
 791 char *
 792 str_create_search_needle (const char *needle, gboolean case_sen)
 793 {
 794     return used_class.create_search_needle (needle, case_sen);
 795 }
 796
 797 /* --------------------------------------------------------------------------------------------- */
 798
 799 void
 800 str_release_search_needle (char *needle, gboolean case_sen)
 801 {
 802     used_class.release_search_needle (needle, case_sen);
 803 }
 804
 805 /* --------------------------------------------------------------------------------------------- */
 806
 807 const char *
 808 str_search_first (const char *text, const char *search, gboolean case_sen)
 809 {
 810     return used_class.search_first (text, search, case_sen);
 811 }
 812
 813 /* --------------------------------------------------------------------------------------------- */
 814
 815 const char *
 816 str_search_last (const char *text, const char *search, gboolean case_sen)
 817 {
 818     return used_class.search_last (text, search, case_sen);
 819 }
 820
 821 /* --------------------------------------------------------------------------------------------- */
 822
 823 gboolean
 824 str_is_valid_string (const char *text)
 825 {
 826     return used_class.is_valid_string (text);
 827 }
 828
 829 /* --------------------------------------------------------------------------------------------- */
 830
 831 int
 832 str_compare (const char *t1, const char *t2)
 833 {
 834     return used_class.compare (t1, t2);
 835 }
 836
 837 /* --------------------------------------------------------------------------------------------- */
 838
 839 int
 840 str_ncompare (const char *t1, const char *t2)
 841 {
 842     return used_class.ncompare (t1, t2);
 843 }
 844
 845 /* --------------------------------------------------------------------------------------------- */
 846
 847 int
 848 str_casecmp (const char *t1, const char *t2)
 849 {
 850     return used_class.casecmp (t1, t2);
 851 }
 852
 853 /* --------------------------------------------------------------------------------------------- */
 854
 855 int
 856 str_ncasecmp (const char *t1, const char *t2)
 857 {
 858     return used_class.ncasecmp (t1, t2);
 859 }
 860
 861 /* --------------------------------------------------------------------------------------------- */
 862
 863 int
 864 str_prefix (const char *text, const char *prefix)
 865 {
 866     return used_class.prefix (text, prefix);
 867 }
 868
 869 /* --------------------------------------------------------------------------------------------- */
 870
 871 int
 872 str_caseprefix (const char *text, const char *prefix)
 873 {
 874     return used_class.caseprefix (text, prefix);
 875 }
 876
 877 /* --------------------------------------------------------------------------------------------- */
 878
 879 void
 880 str_fix_string (char *text)
 881 {
 882     used_class.fix_string (text);
 883 }
 884
 885 /* --------------------------------------------------------------------------------------------- */
 886
 887 char *
 888 str_create_key (const char *text, gboolean case_sen)
 889 {
 890     return used_class.create_key (text, case_sen);
 891 }
 892
 893 /* --------------------------------------------------------------------------------------------- */
 894
 895 char *
 896 str_create_key_for_filename (const char *text, gboolean case_sen)
 897 {
 898     return used_class.create_key_for_filename (text, case_sen);
 899 }
 900
 901 /* --------------------------------------------------------------------------------------------- */
 902
 903 int
 904 str_key_collate (const char *t1, const char *t2, gboolean case_sen)
 905 {
 906     return used_class.key_collate (t1, t2, case_sen);
 907 }
 908
 909 /* --------------------------------------------------------------------------------------------- */
 910
 911 void
 912 str_release_key (char *key, gboolean case_sen)
 913 {
 914     used_class.release_key (key, case_sen);
 915 }
 916
 917 /* --------------------------------------------------------------------------------------------- */
 918
 919 void
 920 str_msg_term_size (const char *text, int *lines, int *columns)
 921 {
 922     char *p, *tmp;
 923     char *q;
 924     char c = '\0';
 925
 926     *lines = 1;
 927     *columns = 0;
 928
 929     tmp = g_strdup (text);
 930     p = tmp;
 931
 932     while (TRUE)
 933     {
 934         int width;
 935
 936         q = strchr (p, '\n');
 937         if (q != NULL)
 938         {
 939             c = q[0];
 940             q[0] = '\0';
 941         }
 942
 943         width = str_term_width1 (p);
 944         if (width > *columns)
 945             *columns = width;
 946
 947         if (q == NULL)
 948             break;
 949
 950         q[0] = c;
 951         p = q + 1;
 952         (*lines)++;
 953     }
 954
 955     g_free (tmp);
 956 }
 957
 958 /* --------------------------------------------------------------------------------------------- */
 959
 960 char *
 961 strrstr_skip_count (const char *haystack, const char *needle, size_t skip_count)
 962 {
 963     char *semi;
 964     ssize_t len;
 965
 966     len = strlen (haystack);
 967
 968     do
 969     {
 970         semi = g_strrstr_len (haystack, len, needle);
 971         if (semi == NULL)
 972             return NULL;
 973         len = semi - haystack - 1;
 974     }
 975     while (skip_count-- != 0);
 976
 977     return semi;
 978 }
 979
 980 /* --------------------------------------------------------------------------------------------- */
 981 /* Interpret string as a non-negative decimal integer, optionally multiplied by various values.
 982  *
 983  * @param str input value
 984  * @param invalid set to TRUE if "str" does not represent a number in this format
 985  *
 986  * @return non-negative integer representation of "str", 0 in case of error.
 987  */
 988
 989 uintmax_t
 990 parse_integer (const char *str, gboolean *invalid)
 991 {
 992     uintmax_t n;
 993     char *suffix;
 994     strtol_error_t e;
 995
 996     e = xstrtoumax (str, &suffix, 10, &n, "bcEGkKMPTwYZ0");
 997     if (e == LONGINT_INVALID_SUFFIX_CHAR && *suffix == 'x')
 998     {
 999         uintmax_t multiplier;
1000
1001         multiplier = parse_integer (suffix + 1, invalid);
1002         if (multiplier != 0 && n * multiplier / multiplier != n)
1003         {
1004             *invalid = TRUE;
1005             return 0;
1006         }
1007
1008         n *= multiplier;
1009     }
1010     else if (e != LONGINT_OK)
1011     {
1012         *invalid = TRUE;
1013         n = 0;
1014     }
1015
1016     return n;
1017 }
1018
1019 /* --------------------------------------------------------------------------------------------- */