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