src/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 "global.h"
  34 #include "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))
  83         ? g_iconv_open (to_enc, codeset) : str_cnv_not_convert;
  84 }
  85
  86 GIConv
  87 str_crt_conv_from (const char *from_enc)
  88 {
  89     return (!str_test_not_convert (from_enc))
  90         ? g_iconv_open (codeset, from_enc) : str_cnv_not_convert;
  91 }
  92
  93 void
  94 str_close_conv (GIConv conv)
  95 {
  96     if (conv != str_cnv_not_convert)
  97         g_iconv_close (conv);
  98 }
  99
 100 static estr_t
 101 _str_convert (GIConv coder, const char *string, int size, GString * buffer)
 102 {
 103     estr_t state  = ESTR_SUCCESS;
 104     gchar *tmp_buff = NULL;
 105     gssize left;
 106     gsize bytes_read = 0;
 107     gsize bytes_written = 0;
 108     GError *error = NULL;
 109     errno = 0;
 110
 111     if (coder == INVALID_CONV)
 112         return ESTR_FAILURE;
 113
 114     if (string == NULL || buffer == NULL)
 115         return ESTR_FAILURE;
 116
 117 /*
 118     if (! used_class.is_valid_string (string))
 119     {
 120         return ESTR_FAILURE;
 121     }
 122 */
 123     if (size < 0)
 124     {
 125         size = strlen (string);
 126     }
 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)
 138     {
 139         tmp_buff = g_convert_with_iconv ((const gchar *) string,
 140                                          left,
 141                                          coder,
 142                                          &bytes_read,
 143                                          &bytes_written, &error);
 144         if (error)
 145         {
 146             int code = error->code;
 147
 148             g_error_free (error);
 149             error = NULL;
 150
 151             switch (code)
 152             {
 153             case G_CONVERT_ERROR_NO_CONVERSION:
 154                 /* Conversion between the requested character sets is not supported. */
 155                 tmp_buff = g_strnfill (strlen (string), '?');
 156                 g_string_append (buffer, tmp_buff);
 157                 g_free (tmp_buff);
 158                 return ESTR_FAILURE;
 159
 160             case G_CONVERT_ERROR_ILLEGAL_SEQUENCE:
 161                 /* Invalid byte sequence in conversion input. */
 162                 if ((tmp_buff == NULL) && (bytes_read != 0))
 163                     /* recode valid byte sequence */
 164                     tmp_buff = g_convert_with_iconv ((const gchar *) string,
 165                                                         bytes_read,
 166                                                         coder, NULL, NULL, NULL);
 167
 168                 if (tmp_buff != NULL)
 169                 {
 170                     g_string_append (buffer, tmp_buff);
 171                     g_free (tmp_buff);
 172                 }
 173
 174                 if ((int)bytes_read < left)
 175                 {
 176                     string += bytes_read + 1;
 177                     size -= (bytes_read + 1);
 178                     left -= (bytes_read + 1);
 179                     g_string_append_c (buffer, *(string-1));
 180                 }
 181                 else
 182                 {
 183                     return ESTR_PROBLEM;
 184                 }
 185                 state = ESTR_PROBLEM;
 186                 break;
 187
 188             case G_CONVERT_ERROR_PARTIAL_INPUT:
 189                 /* Partial character sequence at end of input. */
 190                 g_string_append (buffer, tmp_buff);
 191                 g_free (tmp_buff);
 192                 if ((int)bytes_read < left)
 193                 {
 194                     left = left - bytes_read;
 195                     tmp_buff = g_strnfill (left, '?');
 196                     g_string_append (buffer, tmp_buff);
 197                     g_free (tmp_buff);
 198                 }
 199                 return ESTR_PROBLEM;
 200
 201             case G_CONVERT_ERROR_BAD_URI:       /* Don't know how handle this error :( */
 202             case G_CONVERT_ERROR_NOT_ABSOLUTE_PATH:     /* Don't know how handle this error :( */
 203             case G_CONVERT_ERROR_FAILED:        /* Conversion failed for some reason. */
 204             default:
 205                 g_free (tmp_buff);
 206                 return ESTR_FAILURE;
 207             }
 208         }
 209         else
 210         {
 211             if (tmp_buff != NULL)
 212             {
 213                 if (*tmp_buff)
 214                 {
 215                     g_string_append (buffer, tmp_buff);
 216                     g_free (tmp_buff);
 217                     string += bytes_read;
 218                     left -= bytes_read;
 219                 }
 220                 else
 221                 {
 222                     g_free (tmp_buff);
 223                     g_string_append (buffer, string);
 224                     return state;
 225                 }
 226             }
 227             else
 228             {
 229                 g_string_append (buffer, string);
 230                 return ESTR_PROBLEM;
 231             }
 232         }
 233     }
 234     return state;
 235 }
 236
 237 estr_t
 238 str_convert (GIConv coder, const char *string, GString * buffer)
 239 {
 240     return _str_convert (coder, string, -1, buffer);
 241 }
 242
 243 estr_t
 244 str_nconvert (GIConv coder, const char *string, int size, GString * buffer)
 245 {
 246     return _str_convert (coder, string, size, buffer);
 247 }
 248
 249 gchar *
 250 str_conv_gerror_message (GError *error, const char *def_msg)
 251 {
 252     return used_class.conv_gerror_message (error, def_msg);
 253 }
 254
 255 estr_t
 256 str_vfs_convert_from (GIConv coder, const char *string, GString * buffer)
 257 {
 258     estr_t result;
 259
 260     if (coder == str_cnv_not_convert)
 261     {
 262         g_string_append (buffer, string != NULL ? string : "");
 263         result = ESTR_SUCCESS;
 264     }
 265     else
 266         result = _str_convert (coder, string, -1, buffer);
 267
 268     return result;
 269 }
 270
 271 estr_t
 272 str_vfs_convert_to (GIConv coder, const char *string, int size,
 273                     GString * buffer)
 274 {
 275     return used_class.vfs_convert_to (coder, string, size, buffer);
 276 }
 277
 278 void
 279 str_printf (GString * buffer, const char *format, ...)
 280 {
 281     va_list ap;
 282     va_start (ap, format);
 283 #if GLIB_CHECK_VERSION (2, 14, 0)
 284     g_string_append_vprintf (buffer, format, ap);
 285 #else
 286     {
 287         gchar *tmp;
 288         tmp = g_strdup_vprintf (format, ap);
 289         g_string_append (buffer, tmp);
 290         g_free(tmp);
 291     }
 292 #endif
 293     va_end (ap);
 294 }
 295
 296 void
 297 str_insert_replace_char (GString * buffer)
 298 {
 299     used_class.insert_replace_char (buffer);
 300 }
 301
 302 estr_t
 303 str_translate_char (GIConv conv, const char *keys, size_t ch_size,
 304                     char *output, size_t out_size)
 305 {
 306     size_t left;
 307     size_t cnv;
 308
 309     g_iconv (conv, NULL, NULL, NULL, NULL);
 310
 311     left = (ch_size == (size_t) (-1)) ? strlen (keys) : ch_size;
 312
 313     cnv = g_iconv (conv, (gchar **) &keys, &left, &output, &out_size);
 314     if (cnv == (size_t)(-1)) {
 315         return (errno == EINVAL) ? ESTR_PROBLEM : ESTR_FAILURE;
 316     } else {
 317         output[0] = '\0';
 318         return ESTR_SUCCESS;
 319     }
 320 }
 321
 322
 323 const char *
 324 str_detect_termencoding (void)
 325 {
 326     return (nl_langinfo (CODESET));
 327 }
 328
 329 static int
 330 str_test_encoding_class (const char *encoding, const char **table)
 331 {
 332     int t;
 333     int result = 0;
 334     if ( encoding == NULL )
 335         return result;
 336
 337     for (t = 0; table[t] != NULL; t++)
 338     {
 339         result += (g_ascii_strncasecmp (encoding, table[t],
 340                                         strlen (table[t])) == 0);
 341     }
 342     return result;
 343 }
 344
 345 static void
 346 str_choose_str_functions ()
 347 {
 348     if (str_test_encoding_class (codeset, str_utf8_encodings))
 349     {
 350         used_class = str_utf8_init ();
 351     }
 352     else if (str_test_encoding_class (codeset, str_8bit_encodings))
 353     {
 354         used_class = str_8bit_init ();
 355     }
 356     else
 357     {
 358         used_class = str_ascii_init ();
 359     }
 360 }
 361
 362 int
 363 str_isutf8 (const char *codeset_name)
 364 {
 365     int result = 0;
 366     if (str_test_encoding_class (codeset_name, str_utf8_encodings))
 367     {
 368         result = 1;
 369     }
 370     return result;
 371 }
 372
 373 void
 374 str_init_strings (const char *termenc)
 375 {
 376     codeset = g_strdup ((termenc != NULL)
 377                         ? termenc
 378                         : str_detect_termencoding ());
 379
 380     str_cnv_not_convert = g_iconv_open (codeset, codeset);
 381     if (str_cnv_not_convert == INVALID_CONV)
 382     {
 383         if (termenc != NULL)
 384         {
 385             g_free (codeset);
 386             codeset = g_strdup (str_detect_termencoding ());
 387             str_cnv_not_convert = g_iconv_open (codeset, codeset);
 388         }
 389
 390         if (str_cnv_not_convert == INVALID_CONV)
 391         {
 392             g_free (codeset);
 393             codeset = g_strdup ("ascii");
 394             str_cnv_not_convert = g_iconv_open (codeset, codeset);
 395         }
 396     }
 397
 398     str_cnv_to_term = str_cnv_not_convert;
 399     str_cnv_from_term = str_cnv_not_convert;
 400
 401     str_choose_str_functions ();
 402 }
 403
 404 void
 405 str_uninit_strings (void)
 406 {
 407     g_iconv_close (str_cnv_not_convert);
 408     g_free (codeset);
 409 }
 410
 411 const char *
 412 str_term_form (const char *text)
 413 {
 414     return used_class.term_form (text);
 415 }
 416
 417 const char *
 418 str_fit_to_term (const char *text, int width, align_crt_t just_mode)
 419 {
 420     return used_class.fit_to_term (text, width, just_mode);
 421 }
 422
 423 const char *
 424 str_term_trim (const char *text, int width)
 425 {
 426     return used_class.term_trim (text, width);
 427 }
 428
 429 void
 430 str_msg_term_size (const char *text, int *lines, int *columns)
 431 {
 432     used_class.msg_term_size (text, lines, columns);
 433 }
 434
 435 const char *
 436 str_term_substring (const char *text, int start, int width)
 437 {
 438     return used_class.term_substring (text, start, width);
 439 }
 440
 441 char *
 442 str_get_next_char (char *text)
 443 {
 444
 445     used_class.cnext_char ((const char **) &text);
 446     return text;
 447 }
 448
 449 const char *
 450 str_cget_next_char (const char *text)
 451 {
 452     used_class.cnext_char(&text);
 453     return text;
 454 }
 455
 456 void
 457 str_next_char (char **text)
 458 {
 459     used_class.cnext_char ((const char **) text);
 460 }
 461
 462 void
 463 str_cnext_char (const char **text)
 464 {
 465     used_class.cnext_char (text);
 466 }
 467
 468 char *
 469 str_get_prev_char (char *text)
 470 {
 471     used_class.cprev_char ((const char **) &text);
 472     return text;
 473 }
 474
 475 const char *
 476 str_cget_prev_char (const char *text)
 477 {
 478     used_class.cprev_char (&text);
 479     return text;
 480 }
 481
 482 void
 483 str_prev_char (char **text)
 484 {
 485     used_class.cprev_char ((const char **) text);
 486 }
 487
 488 void
 489 str_cprev_char (const char **text)
 490 {
 491     used_class.cprev_char (text);
 492 }
 493
 494 char *
 495 str_get_next_char_safe (char *text)
 496 {
 497     used_class.cnext_char_safe ((const char **) &text);
 498     return text;
 499 }
 500
 501 const char *
 502 str_cget_next_char_safe (const char *text)
 503 {
 504     used_class.cnext_char_safe (&text);
 505     return text;
 506 }
 507
 508 void
 509 str_next_char_safe (char **text)
 510 {
 511     used_class.cnext_char_safe ((const char **) text);
 512 }
 513
 514 void
 515 str_cnext_char_safe (const char **text)
 516 {
 517     used_class.cnext_char_safe (text);
 518 }
 519
 520 char *
 521 str_get_prev_char_safe (char *text)
 522 {
 523     used_class.cprev_char_safe ((const char **) &text);
 524     return text;
 525 }
 526
 527 const char *
 528 str_cget_prev_char_safe (const char *text)
 529 {
 530     used_class.cprev_char_safe (&text);
 531     return text;
 532 }
 533
 534 void
 535 str_prev_char_safe (char **text)
 536 {
 537     used_class.cprev_char_safe ((const char **) text);
 538 }
 539
 540 void
 541 str_cprev_char_safe (const char **text)
 542 {
 543     used_class.cprev_char_safe (text);
 544 }
 545
 546 int
 547 str_next_noncomb_char (char **text)
 548 {
 549     return used_class.cnext_noncomb_char ((const char **) text);
 550 }
 551
 552 int
 553 str_cnext_noncomb_char (const char **text)
 554 {
 555     return used_class.cnext_noncomb_char (text);
 556 }
 557
 558 int
 559 str_prev_noncomb_char (char **text, const char *begin)
 560 {
 561     return used_class.cprev_noncomb_char ((const char **) text, begin);
 562 }
 563
 564 int
 565 str_cprev_noncomb_char (const char **text, const char *begin)
 566 {
 567     return used_class.cprev_noncomb_char (text, begin);
 568 }
 569
 570 int
 571 str_is_valid_char (const char *ch, size_t size)
 572 {
 573     return used_class.is_valid_char (ch, size);
 574 }
 575
 576 int
 577 str_term_width1 (const char *text)
 578 {
 579     return used_class.term_width1 (text);
 580 }
 581
 582 int
 583 str_term_width2 (const char *text, size_t length)
 584 {
 585     return used_class.term_width2 (text, length);
 586 }
 587
 588 int
 589 str_term_char_width (const char *text)
 590 {
 591     return used_class.term_char_width (text);
 592 }
 593
 594 int
 595 str_offset_to_pos (const char *text, size_t length)
 596 {
 597     return used_class.offset_to_pos (text, length);
 598 }
 599
 600 int
 601 str_length (const char *text)
 602 {
 603     return used_class.length (text);
 604 }
 605
 606 int
 607 str_length_char (const char *text)
 608 {
 609     return str_cget_next_char_safe (text)-text;
 610 }
 611
 612 int
 613 str_length2 (const char *text, int size)
 614 {
 615     return used_class.length2 (text, size);
 616 }
 617
 618 int
 619 str_length_noncomb (const char *text)
 620 {
 621     return used_class.length_noncomb (text);
 622 }
 623
 624 int
 625 str_column_to_pos (const char *text, size_t pos)
 626 {
 627     return used_class.column_to_pos (text, pos);
 628 }
 629
 630 int
 631 str_isspace (const char *ch)
 632 {
 633     return used_class.isspace (ch);
 634 }
 635
 636 int
 637 str_ispunct (const char *ch)
 638 {
 639     return used_class.ispunct (ch);
 640 }
 641
 642 int
 643 str_isalnum (const char *ch)
 644 {
 645     return used_class.isalnum (ch);
 646 }
 647
 648 int
 649 str_isdigit (const char *ch)
 650 {
 651     return used_class.isdigit (ch);
 652 }
 653
 654 int
 655 str_toupper (const char *ch, char **out, size_t * remain)
 656 {
 657     return used_class.toupper (ch, out, remain);
 658 }
 659
 660 int
 661 str_tolower (const char *ch, char **out, size_t * remain)
 662 {
 663     return used_class.tolower (ch, out, remain);
 664 }
 665
 666 int
 667 str_isprint (const char *ch)
 668 {
 669     return used_class.isprint (ch);
 670 }
 671
 672 int
 673 str_iscombiningmark (const char *ch)
 674 {
 675     return used_class.iscombiningmark (ch);
 676 }
 677
 678 const char *
 679 str_trunc (const char *text, int width)
 680 {
 681     return used_class.trunc (text, width);
 682 }
 683
 684 char *
 685 str_create_search_needle (const char *needle, int case_sen)
 686 {
 687     return used_class.create_search_needle (needle, case_sen);
 688 }
 689
 690
 691 void
 692 str_release_search_needle (char *needle, int case_sen)
 693 {
 694     used_class.release_search_needle (needle, case_sen);
 695 }
 696
 697 const char *
 698 str_search_first (const char *text, const char *search, int case_sen)
 699 {
 700     return used_class.search_first (text, search, case_sen);
 701 }
 702
 703 const char *
 704 str_search_last (const char *text, const char *search, int case_sen)
 705 {
 706     return used_class.search_last (text, search, case_sen);
 707 }
 708
 709 int
 710 str_is_valid_string (const char *text)
 711 {
 712     return used_class.is_valid_string (text);
 713 }
 714
 715 int
 716 str_compare (const char *t1, const char *t2)
 717 {
 718     return used_class.compare (t1, t2);
 719 }
 720
 721 int
 722 str_ncompare (const char *t1, const char *t2)
 723 {
 724     return used_class.ncompare (t1, t2);
 725 }
 726
 727 int
 728 str_casecmp (const char *t1, const char *t2)
 729 {
 730     return used_class.casecmp (t1, t2);
 731 }
 732
 733 int
 734 str_ncasecmp (const char *t1, const char *t2)
 735 {
 736     return used_class.ncasecmp (t1, t2);
 737 }
 738
 739 int
 740 str_prefix (const char *text, const char *prefix)
 741 {
 742     return used_class.prefix (text, prefix);
 743 }
 744
 745 int
 746 str_caseprefix (const char *text, const char *prefix)
 747 {
 748     return used_class.caseprefix (text, prefix);
 749 }
 750
 751 void
 752 str_fix_string (char *text)
 753 {
 754     used_class.fix_string (text);
 755 }
 756
 757 char *
 758 str_create_key (const char *text, int case_sen)
 759 {
 760     return used_class.create_key (text, case_sen);
 761 }
 762
 763 char *
 764 str_create_key_for_filename (const char *text, int case_sen)
 765 {
 766     return used_class.create_key_for_filename (text, case_sen);
 767 }
 768
 769 int
 770 str_key_collate (const char *t1, const char *t2, int case_sen)
 771 {
 772     return used_class.key_collate (t1, t2, case_sen);
 773 }
 774
 775 void
 776 str_release_key (char *key, int case_sen)
 777 {
 778     used_class.release_key (key, case_sen);
 779 }