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     if (str_cnv_not_convert != INVALID_CONV)
 408         g_iconv_close (str_cnv_not_convert);
 409     g_free (codeset);
 410 }
 411
 412 const char *
 413 str_term_form (const char *text)
 414 {
 415     return used_class.term_form (text);
 416 }
 417
 418 const char *
 419 str_fit_to_term (const char *text, int width, align_crt_t just_mode)
 420 {
 421     return used_class.fit_to_term (text, width, just_mode);
 422 }
 423
 424 const char *
 425 str_term_trim (const char *text, int width)
 426 {
 427     return used_class.term_trim (text, width);
 428 }
 429
 430 void
 431 str_msg_term_size (const char *text, int *lines, int *columns)
 432 {
 433     used_class.msg_term_size (text, lines, columns);
 434 }
 435
 436 const char *
 437 str_term_substring (const char *text, int start, int width)
 438 {
 439     return used_class.term_substring (text, start, width);
 440 }
 441
 442 char *
 443 str_get_next_char (char *text)
 444 {
 445
 446     used_class.cnext_char ((const char **) &text);
 447     return text;
 448 }
 449
 450 const char *
 451 str_cget_next_char (const char *text)
 452 {
 453     used_class.cnext_char(&text);
 454     return text;
 455 }
 456
 457 void
 458 str_next_char (char **text)
 459 {
 460     used_class.cnext_char ((const char **) text);
 461 }
 462
 463 void
 464 str_cnext_char (const char **text)
 465 {
 466     used_class.cnext_char (text);
 467 }
 468
 469 char *
 470 str_get_prev_char (char *text)
 471 {
 472     used_class.cprev_char ((const char **) &text);
 473     return text;
 474 }
 475
 476 const char *
 477 str_cget_prev_char (const char *text)
 478 {
 479     used_class.cprev_char (&text);
 480     return text;
 481 }
 482
 483 void
 484 str_prev_char (char **text)
 485 {
 486     used_class.cprev_char ((const char **) text);
 487 }
 488
 489 void
 490 str_cprev_char (const char **text)
 491 {
 492     used_class.cprev_char (text);
 493 }
 494
 495 char *
 496 str_get_next_char_safe (char *text)
 497 {
 498     used_class.cnext_char_safe ((const char **) &text);
 499     return text;
 500 }
 501
 502 const char *
 503 str_cget_next_char_safe (const char *text)
 504 {
 505     used_class.cnext_char_safe (&text);
 506     return text;
 507 }
 508
 509 void
 510 str_next_char_safe (char **text)
 511 {
 512     used_class.cnext_char_safe ((const char **) text);
 513 }
 514
 515 void
 516 str_cnext_char_safe (const char **text)
 517 {
 518     used_class.cnext_char_safe (text);
 519 }
 520
 521 char *
 522 str_get_prev_char_safe (char *text)
 523 {
 524     used_class.cprev_char_safe ((const char **) &text);
 525     return text;
 526 }
 527
 528 const char *
 529 str_cget_prev_char_safe (const char *text)
 530 {
 531     used_class.cprev_char_safe (&text);
 532     return text;
 533 }
 534
 535 void
 536 str_prev_char_safe (char **text)
 537 {
 538     used_class.cprev_char_safe ((const char **) text);
 539 }
 540
 541 void
 542 str_cprev_char_safe (const char **text)
 543 {
 544     used_class.cprev_char_safe (text);
 545 }
 546
 547 int
 548 str_next_noncomb_char (char **text)
 549 {
 550     return used_class.cnext_noncomb_char ((const char **) text);
 551 }
 552
 553 int
 554 str_cnext_noncomb_char (const char **text)
 555 {
 556     return used_class.cnext_noncomb_char (text);
 557 }
 558
 559 int
 560 str_prev_noncomb_char (char **text, const char *begin)
 561 {
 562     return used_class.cprev_noncomb_char ((const char **) text, begin);
 563 }
 564
 565 int
 566 str_cprev_noncomb_char (const char **text, const char *begin)
 567 {
 568     return used_class.cprev_noncomb_char (text, begin);
 569 }
 570
 571 int
 572 str_is_valid_char (const char *ch, size_t size)
 573 {
 574     return used_class.is_valid_char (ch, size);
 575 }
 576
 577 int
 578 str_term_width1 (const char *text)
 579 {
 580     return used_class.term_width1 (text);
 581 }
 582
 583 int
 584 str_term_width2 (const char *text, size_t length)
 585 {
 586     return used_class.term_width2 (text, length);
 587 }
 588
 589 int
 590 str_term_char_width (const char *text)
 591 {
 592     return used_class.term_char_width (text);
 593 }
 594
 595 int
 596 str_offset_to_pos (const char *text, size_t length)
 597 {
 598     return used_class.offset_to_pos (text, length);
 599 }
 600
 601 int
 602 str_length (const char *text)
 603 {
 604     return used_class.length (text);
 605 }
 606
 607 int
 608 str_length_char (const char *text)
 609 {
 610     return str_cget_next_char_safe (text)-text;
 611 }
 612
 613 int
 614 str_length2 (const char *text, int size)
 615 {
 616     return used_class.length2 (text, size);
 617 }
 618
 619 int
 620 str_length_noncomb (const char *text)
 621 {
 622     return used_class.length_noncomb (text);
 623 }
 624
 625 int
 626 str_column_to_pos (const char *text, size_t pos)
 627 {
 628     return used_class.column_to_pos (text, pos);
 629 }
 630
 631 int
 632 str_isspace (const char *ch)
 633 {
 634     return used_class.isspace (ch);
 635 }
 636
 637 int
 638 str_ispunct (const char *ch)
 639 {
 640     return used_class.ispunct (ch);
 641 }
 642
 643 int
 644 str_isalnum (const char *ch)
 645 {
 646     return used_class.isalnum (ch);
 647 }
 648
 649 int
 650 str_isdigit (const char *ch)
 651 {
 652     return used_class.isdigit (ch);
 653 }
 654
 655 int
 656 str_toupper (const char *ch, char **out, size_t * remain)
 657 {
 658     return used_class.toupper (ch, out, remain);
 659 }
 660
 661 int
 662 str_tolower (const char *ch, char **out, size_t * remain)
 663 {
 664     return used_class.tolower (ch, out, remain);
 665 }
 666
 667 int
 668 str_isprint (const char *ch)
 669 {
 670     return used_class.isprint (ch);
 671 }
 672
 673 int
 674 str_iscombiningmark (const char *ch)
 675 {
 676     return used_class.iscombiningmark (ch);
 677 }
 678
 679 const char *
 680 str_trunc (const char *text, int width)
 681 {
 682     return used_class.trunc (text, width);
 683 }
 684
 685 char *
 686 str_create_search_needle (const char *needle, int case_sen)
 687 {
 688     return used_class.create_search_needle (needle, case_sen);
 689 }
 690
 691
 692 void
 693 str_release_search_needle (char *needle, int case_sen)
 694 {
 695     used_class.release_search_needle (needle, case_sen);
 696 }
 697
 698 const char *
 699 str_search_first (const char *text, const char *search, int case_sen)
 700 {
 701     return used_class.search_first (text, search, case_sen);
 702 }
 703
 704 const char *
 705 str_search_last (const char *text, const char *search, int case_sen)
 706 {
 707     return used_class.search_last (text, search, case_sen);
 708 }
 709
 710 int
 711 str_is_valid_string (const char *text)
 712 {
 713     return used_class.is_valid_string (text);
 714 }
 715
 716 int
 717 str_compare (const char *t1, const char *t2)
 718 {
 719     return used_class.compare (t1, t2);
 720 }
 721
 722 int
 723 str_ncompare (const char *t1, const char *t2)
 724 {
 725     return used_class.ncompare (t1, t2);
 726 }
 727
 728 int
 729 str_casecmp (const char *t1, const char *t2)
 730 {
 731     return used_class.casecmp (t1, t2);
 732 }
 733
 734 int
 735 str_ncasecmp (const char *t1, const char *t2)
 736 {
 737     return used_class.ncasecmp (t1, t2);
 738 }
 739
 740 int
 741 str_prefix (const char *text, const char *prefix)
 742 {
 743     return used_class.prefix (text, prefix);
 744 }
 745
 746 int
 747 str_caseprefix (const char *text, const char *prefix)
 748 {
 749     return used_class.caseprefix (text, prefix);
 750 }
 751
 752 void
 753 str_fix_string (char *text)
 754 {
 755     used_class.fix_string (text);
 756 }
 757
 758 char *
 759 str_create_key (const char *text, int case_sen)
 760 {
 761     return used_class.create_key (text, case_sen);
 762 }
 763
 764 char *
 765 str_create_key_for_filename (const char *text, int case_sen)
 766 {
 767     return used_class.create_key_for_filename (text, case_sen);
 768 }
 769
 770 int
 771 str_key_collate (const char *t1, const char *t2, int case_sen)
 772 {
 773     return used_class.key_collate (t1, t2, case_sen);
 774 }
 775
 776 void
 777 str_release_key (char *key, int case_sen)
 778 {
 779     used_class.release_key (key, case_sen);
 780 }