lib/strutil/strutil.c

   1 /* common strings utilities
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3
   4    Written 2007 by:
   5    Rostislav Benes
   6
   7    The file_date routine is mostly from GNU's fileutils package,
   8    written by Richard Stallman and David MacKenzie.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  */
  24
  25 #include <config.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <langinfo.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <stdarg.h>
  32
  33 #include "lib/global.h"
  34 #include "lib/strutil.h"
  35
  36 /*names, that are used for utf-8 */
  37 static const char *str_utf8_encodings[] = {
  38     "utf-8",
  39     "utf8",
  40     NULL
  41 };
  42
  43 /* standard 8bit encodings, no wide or multibytes characters */
  44 static const char *str_8bit_encodings[] = {
  45     "cp-1251",
  46     "cp1251",
  47     "cp-1250",
  48     "cp1250",
  49     "cp-866",
  50     "cp866",
  51     "ibm-866",
  52     "ibm866",
  53     "cp-850",
  54     "cp850",
  55     "cp-852",
  56     "cp852",
  57     "iso-8859",
  58     "iso8859",
  59     "koi8",
  60     NULL
  61 };
  62
  63 /* terminal encoding */
  64 static char *codeset = NULL;
  65 /* function for encoding specific operations */
  66 static struct str_class used_class;
  67
  68 GIConv str_cnv_to_term;
  69 GIConv str_cnv_from_term;
  70 GIConv str_cnv_not_convert;
  71
  72 /* if enc is same encoding like on terminal */
  73 static int
  74 str_test_not_convert (const char *enc)
  75 {
  76     return g_ascii_strcasecmp (enc, codeset) == 0;
  77 }
  78
  79 GIConv
  80 str_crt_conv_to (const char *to_enc)
  81 {
  82     return (!str_test_not_convert (to_enc)) ? g_iconv_open (to_enc, codeset) : str_cnv_not_convert;
  83 }
  84
  85 GIConv
  86 str_crt_conv_from (const char *from_enc)
  87 {
  88     return (!str_test_not_convert (from_enc))
  89         ? g_iconv_open (codeset, from_enc) : str_cnv_not_convert;
  90 }
  91
  92 void
  93 str_close_conv (GIConv conv)
  94 {
  95     if (conv != str_cnv_not_convert)
  96         g_iconv_close (conv);
  97 }
  98
  99 static estr_t
 100 _str_convert (GIConv coder, const char *string, int size, GString * buffer)
 101 {
 102     estr_t state = ESTR_SUCCESS;
 103     gchar *tmp_buff = NULL;
 104     gssize left;
 105     gsize bytes_read = 0;
 106     gsize bytes_written = 0;
 107     GError *error = NULL;
 108     errno = 0;
 109
 110     if (coder == INVALID_CONV)
 111         return ESTR_FAILURE;
 112
 113     if (string == NULL || buffer == NULL)
 114         return ESTR_FAILURE;
 115
 116     /*
 117        if (! used_class.is_valid_string (string))
 118        {
 119        return ESTR_FAILURE;
 120        }
 121      */
 122     if (size < 0)
 123     {
 124         size = strlen (string);
 125     }
 126     else
 127     {
 128         left = strlen (string);
 129         if (left < size)
 130             size = left;
 131     }
 132
 133     left = size;
 134     g_iconv (coder, NULL, NULL, NULL, NULL);
 135
 136     while (left)
 137     {
 138         tmp_buff = g_convert_with_iconv ((const gchar *) string,
 139                                          left, coder, &bytes_read, &bytes_written, &error);
 140         if (error)
 141         {
 142             int code = error->code;
 143
 144             g_error_free (error);
 145             error = NULL;
 146
 147             switch (code)
 148             {
 149             case G_CONVERT_ERROR_NO_CONVERSION:
 150                 /* Conversion between the requested character sets is not supported. */
 151                 tmp_buff = g_strnfill (strlen (string), '?');
 152                 g_string_append (buffer, tmp_buff);
 153                 g_free (tmp_buff);
 154                 return ESTR_FAILURE;
 155
 156             case G_CONVERT_ERROR_ILLEGAL_SEQUENCE:
 157                 /* Invalid byte sequence in conversion input. */
 158                 if ((tmp_buff == NULL) && (bytes_read != 0))
 159                     /* recode valid byte sequence */
 160                     tmp_buff = g_convert_with_iconv ((const gchar *) string,
 161                                                      bytes_read, coder, NULL, NULL, NULL);
 162
 163                 if (tmp_buff != NULL)
 164                 {
 165                     g_string_append (buffer, tmp_buff);
 166                     g_free (tmp_buff);
 167                 }
 168
 169                 if ((int) bytes_read < left)
 170                 {
 171                     string += bytes_read + 1;
 172                     size -= (bytes_read + 1);
 173                     left -= (bytes_read + 1);
 174                     g_string_append_c (buffer, *(string - 1));
 175                 }
 176                 else
 177                 {
 178                     return ESTR_PROBLEM;
 179                 }
 180                 state = ESTR_PROBLEM;
 181                 break;
 182
 183             case G_CONVERT_ERROR_PARTIAL_INPUT:
 184                 /* Partial character sequence at end of input. */
 185                 g_string_append (buffer, tmp_buff);
 186                 g_free (tmp_buff);
 187                 if ((int) bytes_read < left)
 188                 {
 189                     left = left - bytes_read;
 190                     tmp_buff = g_strnfill (left, '?');
 191                     g_string_append (buffer, tmp_buff);
 192                     g_free (tmp_buff);
 193                 }
 194                 return ESTR_PROBLEM;
 195
 196             case G_CONVERT_ERROR_BAD_URI:      /* Don't know how handle this error :( */
 197             case G_CONVERT_ERROR_NOT_ABSOLUTE_PATH:    /* Don't know how handle this error :( */
 198             case G_CONVERT_ERROR_FAILED:       /* Conversion failed for some reason. */
 199             default:
 200                 g_free (tmp_buff);
 201                 return ESTR_FAILURE;
 202             }
 203         }
 204         else
 205         {
 206             if (tmp_buff != NULL)
 207             {
 208                 if (*tmp_buff)
 209                 {
 210                     g_string_append (buffer, tmp_buff);
 211                     g_free (tmp_buff);
 212                     string += bytes_read;
 213                     left -= bytes_read;
 214                 }
 215                 else
 216                 {
 217                     g_free (tmp_buff);
 218                     g_string_append (buffer, string);
 219                     return state;
 220                 }
 221             }
 222             else
 223             {
 224                 g_string_append (buffer, string);
 225                 return ESTR_PROBLEM;
 226             }
 227         }
 228     }
 229     return state;
 230 }
 231
 232 estr_t
 233 str_convert (GIConv coder, const char *string, GString * buffer)
 234 {
 235     return _str_convert (coder, string, -1, buffer);
 236 }
 237
 238 estr_t
 239 str_nconvert (GIConv coder, const char *string, int size, GString * buffer)
 240 {
 241     return _str_convert (coder, string, size, buffer);
 242 }
 243
 244 gchar *
 245 str_conv_gerror_message (GError * error, const char *def_msg)
 246 {
 247     return used_class.conv_gerror_message (error, def_msg);
 248 }
 249
 250 estr_t
 251 str_vfs_convert_from (GIConv coder, const char *string, GString * buffer)
 252 {
 253     estr_t result;
 254
 255     if (coder == str_cnv_not_convert)
 256     {
 257         g_string_append (buffer, string != NULL ? string : "");
 258         result = ESTR_SUCCESS;
 259     }
 260     else
 261         result = _str_convert (coder, string, -1, buffer);
 262
 263     return result;
 264 }
 265
 266 estr_t
 267 str_vfs_convert_to (GIConv coder, const char *string, int size, GString * buffer)
 268 {
 269     return used_class.vfs_convert_to (coder, string, size, buffer);
 270 }
 271
 272 void
 273 str_printf (GString * buffer, const char *format, ...)
 274 {
 275     va_list ap;
 276     va_start (ap, format);
 277 #if GLIB_CHECK_VERSION (2, 14, 0)
 278     g_string_append_vprintf (buffer, format, ap);
 279 #else
 280     {
 281         gchar *tmp;
 282         tmp = g_strdup_vprintf (format, ap);
 283         g_string_append (buffer, tmp);
 284         g_free (tmp);
 285     }
 286 #endif
 287     va_end (ap);
 288 }
 289
 290 void
 291 str_insert_replace_char (GString * buffer)
 292 {
 293     used_class.insert_replace_char (buffer);
 294 }
 295
 296 estr_t
 297 str_translate_char (GIConv conv, const char *keys, size_t ch_size, char *output, size_t out_size)
 298 {
 299     size_t left;
 300     size_t cnv;
 301
 302     g_iconv (conv, NULL, NULL, NULL, NULL);
 303
 304     left = (ch_size == (size_t) (-1)) ? strlen (keys) : ch_size;
 305
 306     cnv = g_iconv (conv, (gchar **) & keys, &left, &output, &out_size);
 307     if (cnv == (size_t) (-1))
 308     {
 309         return (errno == EINVAL) ? ESTR_PROBLEM : ESTR_FAILURE;
 310     }
 311     else
 312     {
 313         output[0] = '\0';
 314         return ESTR_SUCCESS;
 315     }
 316 }
 317
 318
 319 const char *
 320 str_detect_termencoding (void)
 321 {
 322     return (nl_langinfo (CODESET));
 323 }
 324
 325 static int
 326 str_test_encoding_class (const char *encoding, const char **table)
 327 {
 328     int t;
 329     int result = 0;
 330     if (encoding == NULL)
 331         return result;
 332
 333     for (t = 0; table[t] != NULL; t++)
 334     {
 335         result += (g_ascii_strncasecmp (encoding, table[t], strlen (table[t])) == 0);
 336     }
 337     return result;
 338 }
 339
 340 static void
 341 str_choose_str_functions (void)
 342 {
 343     if (str_test_encoding_class (codeset, str_utf8_encodings))
 344     {
 345         used_class = str_utf8_init ();
 346     }
 347     else if (str_test_encoding_class (codeset, str_8bit_encodings))
 348     {
 349         used_class = str_8bit_init ();
 350     }
 351     else
 352     {
 353         used_class = str_ascii_init ();
 354     }
 355 }
 356
 357 int
 358 str_isutf8 (const char *codeset_name)
 359 {
 360     int result = 0;
 361     if (str_test_encoding_class (codeset_name, str_utf8_encodings))
 362     {
 363         result = 1;
 364     }
 365     return result;
 366 }
 367
 368 void
 369 str_init_strings (const char *termenc)
 370 {
 371     codeset = g_strdup ((termenc != NULL) ? termenc : str_detect_termencoding ());
 372
 373     str_cnv_not_convert = g_iconv_open (codeset, codeset);
 374     if (str_cnv_not_convert == INVALID_CONV)
 375     {
 376         if (termenc != NULL)
 377         {
 378             g_free (codeset);
 379             codeset = g_strdup (str_detect_termencoding ());
 380             str_cnv_not_convert = g_iconv_open (codeset, codeset);
 381         }
 382
 383         if (str_cnv_not_convert == INVALID_CONV)
 384         {
 385             g_free (codeset);
 386             codeset = g_strdup ("ascii");
 387             str_cnv_not_convert = g_iconv_open (codeset, codeset);
 388         }
 389     }
 390
 391     str_cnv_to_term = str_cnv_not_convert;
 392     str_cnv_from_term = str_cnv_not_convert;
 393
 394     str_choose_str_functions ();
 395 }
 396
 397 void
 398 str_uninit_strings (void)
 399 {
 400     if (str_cnv_not_convert != INVALID_CONV)
 401         g_iconv_close (str_cnv_not_convert);
 402     g_free (codeset);
 403 }
 404
 405 const char *
 406 str_term_form (const char *text)
 407 {
 408     return used_class.term_form (text);
 409 }
 410
 411 const char *
 412 str_fit_to_term (const char *text, int width, align_crt_t just_mode)
 413 {
 414     return used_class.fit_to_term (text, width, just_mode);
 415 }
 416
 417 const char *
 418 str_term_trim (const char *text, int width)
 419 {
 420     return used_class.term_trim (text, width);
 421 }
 422
 423 const char *
 424 str_term_substring (const char *text, int start, int width)
 425 {
 426     return used_class.term_substring (text, start, width);
 427 }
 428
 429 char *
 430 str_get_next_char (char *text)
 431 {
 432
 433     used_class.cnext_char ((const char **) &text);
 434     return text;
 435 }
 436
 437 const char *
 438 str_cget_next_char (const char *text)
 439 {
 440     used_class.cnext_char (&text);
 441     return text;
 442 }
 443
 444 void
 445 str_next_char (char **text)
 446 {
 447     used_class.cnext_char ((const char **) text);
 448 }
 449
 450 void
 451 str_cnext_char (const char **text)
 452 {
 453     used_class.cnext_char (text);
 454 }
 455
 456 char *
 457 str_get_prev_char (char *text)
 458 {
 459     used_class.cprev_char ((const char **) &text);
 460     return text;
 461 }
 462
 463 const char *
 464 str_cget_prev_char (const char *text)
 465 {
 466     used_class.cprev_char (&text);
 467     return text;
 468 }
 469
 470 void
 471 str_prev_char (char **text)
 472 {
 473     used_class.cprev_char ((const char **) text);
 474 }
 475
 476 void
 477 str_cprev_char (const char **text)
 478 {
 479     used_class.cprev_char (text);
 480 }
 481
 482 char *
 483 str_get_next_char_safe (char *text)
 484 {
 485     used_class.cnext_char_safe ((const char **) &text);
 486     return text;
 487 }
 488
 489 const char *
 490 str_cget_next_char_safe (const char *text)
 491 {
 492     used_class.cnext_char_safe (&text);
 493     return text;
 494 }
 495
 496 void
 497 str_next_char_safe (char **text)
 498 {
 499     used_class.cnext_char_safe ((const char **) text);
 500 }
 501
 502 void
 503 str_cnext_char_safe (const char **text)
 504 {
 505     used_class.cnext_char_safe (text);
 506 }
 507
 508 char *
 509 str_get_prev_char_safe (char *text)
 510 {
 511     used_class.cprev_char_safe ((const char **) &text);
 512     return text;
 513 }
 514
 515 const char *
 516 str_cget_prev_char_safe (const char *text)
 517 {
 518     used_class.cprev_char_safe (&text);
 519     return text;
 520 }
 521
 522 void
 523 str_prev_char_safe (char **text)
 524 {
 525     used_class.cprev_char_safe ((const char **) text);
 526 }
 527
 528 void
 529 str_cprev_char_safe (const char **text)
 530 {
 531     used_class.cprev_char_safe (text);
 532 }
 533
 534 int
 535 str_next_noncomb_char (char **text)
 536 {
 537     return used_class.cnext_noncomb_char ((const char **) text);
 538 }
 539
 540 int
 541 str_cnext_noncomb_char (const char **text)
 542 {
 543     return used_class.cnext_noncomb_char (text);
 544 }
 545
 546 int
 547 str_prev_noncomb_char (char **text, const char *begin)
 548 {
 549     return used_class.cprev_noncomb_char ((const char **) text, begin);
 550 }
 551
 552 int
 553 str_cprev_noncomb_char (const char **text, const char *begin)
 554 {
 555     return used_class.cprev_noncomb_char (text, begin);
 556 }
 557
 558 int
 559 str_is_valid_char (const char *ch, size_t size)
 560 {
 561     return used_class.is_valid_char (ch, size);
 562 }
 563
 564 int
 565 str_term_width1 (const char *text)
 566 {
 567     return used_class.term_width1 (text);
 568 }
 569
 570 int
 571 str_term_width2 (const char *text, size_t length)
 572 {
 573     return used_class.term_width2 (text, length);
 574 }
 575
 576 int
 577 str_term_char_width (const char *text)
 578 {
 579     return used_class.term_char_width (text);
 580 }
 581
 582 int
 583 str_offset_to_pos (const char *text, size_t length)
 584 {
 585     return used_class.offset_to_pos (text, length);
 586 }
 587
 588 int
 589 str_length (const char *text)
 590 {
 591     return used_class.length (text);
 592 }
 593
 594 int
 595 str_length_char (const char *text)
 596 {
 597     return str_cget_next_char_safe (text) - text;
 598 }
 599
 600 int
 601 str_length2 (const char *text, int size)
 602 {
 603     return used_class.length2 (text, size);
 604 }
 605
 606 int
 607 str_length_noncomb (const char *text)
 608 {
 609     return used_class.length_noncomb (text);
 610 }
 611
 612 int
 613 str_column_to_pos (const char *text, size_t pos)
 614 {
 615     return used_class.column_to_pos (text, pos);
 616 }
 617
 618 int
 619 str_isspace (const char *ch)
 620 {
 621     return used_class.isspace (ch);
 622 }
 623
 624 int
 625 str_ispunct (const char *ch)
 626 {
 627     return used_class.ispunct (ch);
 628 }
 629
 630 int
 631 str_isalnum (const char *ch)
 632 {
 633     return used_class.isalnum (ch);
 634 }
 635
 636 int
 637 str_isdigit (const char *ch)
 638 {
 639     return used_class.isdigit (ch);
 640 }
 641
 642 int
 643 str_toupper (const char *ch, char **out, size_t * remain)
 644 {
 645     return used_class.toupper (ch, out, remain);
 646 }
 647
 648 int
 649 str_tolower (const char *ch, char **out, size_t * remain)
 650 {
 651     return used_class.tolower (ch, out, remain);
 652 }
 653
 654 int
 655 str_isprint (const char *ch)
 656 {
 657     return used_class.isprint (ch);
 658 }
 659
 660 int
 661 str_iscombiningmark (const char *ch)
 662 {
 663     return used_class.iscombiningmark (ch);
 664 }
 665
 666 const char *
 667 str_trunc (const char *text, int width)
 668 {
 669     return used_class.trunc (text, width);
 670 }
 671
 672 char *
 673 str_create_search_needle (const char *needle, int case_sen)
 674 {
 675     return used_class.create_search_needle (needle, case_sen);
 676 }
 677
 678
 679 void
 680 str_release_search_needle (char *needle, int case_sen)
 681 {
 682     used_class.release_search_needle (needle, case_sen);
 683 }
 684
 685 const char *
 686 str_search_first (const char *text, const char *search, int case_sen)
 687 {
 688     return used_class.search_first (text, search, case_sen);
 689 }
 690
 691 const char *
 692 str_search_last (const char *text, const char *search, int case_sen)
 693 {
 694     return used_class.search_last (text, search, case_sen);
 695 }
 696
 697 int
 698 str_is_valid_string (const char *text)
 699 {
 700     return used_class.is_valid_string (text);
 701 }
 702
 703 int
 704 str_compare (const char *t1, const char *t2)
 705 {
 706     return used_class.compare (t1, t2);
 707 }
 708
 709 int
 710 str_ncompare (const char *t1, const char *t2)
 711 {
 712     return used_class.ncompare (t1, t2);
 713 }
 714
 715 int
 716 str_casecmp (const char *t1, const char *t2)
 717 {
 718     return used_class.casecmp (t1, t2);
 719 }
 720
 721 int
 722 str_ncasecmp (const char *t1, const char *t2)
 723 {
 724     return used_class.ncasecmp (t1, t2);
 725 }
 726
 727 int
 728 str_prefix (const char *text, const char *prefix)
 729 {
 730     return used_class.prefix (text, prefix);
 731 }
 732
 733 int
 734 str_caseprefix (const char *text, const char *prefix)
 735 {
 736     return used_class.caseprefix (text, prefix);
 737 }
 738
 739 void
 740 str_fix_string (char *text)
 741 {
 742     used_class.fix_string (text);
 743 }
 744
 745 char *
 746 str_create_key (const char *text, int case_sen)
 747 {
 748     return used_class.create_key (text, case_sen);
 749 }
 750
 751 char *
 752 str_create_key_for_filename (const char *text, int case_sen)
 753 {
 754     return used_class.create_key_for_filename (text, case_sen);
 755 }
 756
 757 int
 758 str_key_collate (const char *t1, const char *t2, int case_sen)
 759 {
 760     return used_class.key_collate (t1, t2, case_sen);
 761 }
 762
 763 void
 764 str_release_key (char *key, int case_sen)
 765 {
 766     used_class.release_key (key, case_sen);
 767 }
 768
 769 void
 770 str_msg_term_size (const char *text, int *lines, int *columns)
 771 {
 772     char *p, *tmp;
 773     char *q;
 774     char c = '\0';
 775     int width;
 776
 777     *lines = 1;
 778     *columns = 0;
 779
 780     tmp = g_strdup (text);
 781     p = tmp;
 782
 783     while (TRUE)
 784     {
 785         q = strchr (p, '\n');
 786         if (q != NULL)
 787         {
 788             c = q[0];
 789             q[0] = '\0';
 790         }
 791
 792         width = str_term_width1 (p);
 793         if (width > *columns)
 794             *columns = width;
 795
 796         if (q == NULL)
 797             break;
 798
 799         q[0] = c;
 800         p = q + 1;
 801         (*lines)++;
 802     }
 803
 804     g_free (tmp);
 805 }
 806
 807 /* --------------------------------------------------------------------------------------------- */
 808
 809 char *
 810 strrstr_skip_count (const char *haystack, const char *needle, size_t skip_count)
 811 {
 812     char *semi;
 813     ssize_t len;
 814
 815     len = strlen (haystack);
 816
 817     do
 818     {
 819         semi = g_strrstr_len (haystack, len, needle);
 820         if (semi == NULL)
 821             return NULL;
 822         len = semi - haystack - 1;
 823     }
 824     while (skip_count-- != 0);
 825     return semi;
 826 }
 827
 828 /* --------------------------------------------------------------------------------------------- */