lib/charsets.c

   1 /*
   2    Text conversion from one charset to another.
   3
   4    Copyright (C) 2001, 2011
   5    The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Walery Studennikov <despair@sama.ru>
   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 /** \file charsets.c
  27  *  \brief Source: Text conversion from one charset to another
  28  */
  29
  30 #include <config.h>
  31
  32 #ifdef HAVE_CHARSET
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "lib/global.h"
  39 #include "lib/strutil.h"        /* utf-8 functions */
  40 #include "lib/fileloc.h"
  41 #include "lib/charsets.h"
  42
  43 /*** global variables ****************************************************************************/
  44
  45 GPtrArray *codepages = NULL;
  46
  47 unsigned char conv_displ[256];
  48 unsigned char conv_input[256];
  49
  50 const char *cp_display = NULL;
  51 const char *cp_source = NULL;
  52
  53 /*** file scope macro definitions ****************************************************************/
  54
  55 #define OTHER_8BIT "Other_8_bit"
  56
  57 /*
  58  * FIXME: This assumes that ASCII is always the first encoding
  59  * in mc.charsets
  60  */
  61 #define CP_ASCII 0
  62
  63 /*** file scope type declarations ****************************************************************/
  64
  65 /*** file scope variables ************************************************************************/
  66
  67 /*** file scope functions ************************************************************************/
  68 /* --------------------------------------------------------------------------------------------- */
  69
  70 static codepage_desc *
  71 new_codepage_desc (const char *id, const char *name)
  72 {
  73     codepage_desc *desc;
  74
  75     desc = g_new (codepage_desc, 1);
  76     desc->id = g_strdup (id);
  77     desc->name = g_strdup (name);
  78
  79     return desc;
  80 }
  81
  82 /* --------------------------------------------------------------------------------------------- */
  83
  84 static void
  85 free_codepage_desc (gpointer data, gpointer user_data)
  86 {
  87     codepage_desc *desc = (codepage_desc *) data;
  88     (void) user_data;
  89
  90     g_free (desc->id);
  91     g_free (desc->name);
  92     g_free (desc);
  93 }
  94
  95 /* --------------------------------------------------------------------------------------------- */
  96 /* returns display codepage */
  97
  98 static void
  99 load_codepages_list_from_file (GPtrArray ** list, const char *fname)
 100 {
 101     FILE *f;
 102     guint i;
 103     char buf[BUF_MEDIUM];
 104     char *default_codepage = NULL;
 105
 106     f = fopen (fname, "r");
 107     if (f == NULL)
 108         return;
 109
 110     for (i = 0; fgets (buf, sizeof buf, f) != NULL;)
 111     {
 112         /* split string into id and cpname */
 113         char *p = buf;
 114         size_t buflen = strlen (buf);
 115
 116         if (*p == '\n' || *p == '\0' || *p == '#')
 117             continue;
 118
 119         if (buflen > 0 && buf[buflen - 1] == '\n')
 120             buf[buflen - 1] = '\0';
 121         while (*p != '\t' && *p != ' ' && *p != '\0')
 122             ++p;
 123         if (*p == '\0')
 124             goto fail;
 125
 126         *p++ = '\0';
 127         g_strstrip (p);
 128         if (*p == '\0')
 129             goto fail;
 130
 131         if (strcmp (buf, "default") == 0)
 132             default_codepage = g_strdup (p);
 133         else
 134         {
 135             const char *id = buf;
 136
 137             if (*list == NULL)
 138             {
 139                 *list = g_ptr_array_sized_new (16);
 140                 g_ptr_array_add (*list, new_codepage_desc (id, p));
 141             }
 142             else
 143             {
 144                 /* whether id is already present in list */
 145                 /* if yes, overwrite description */
 146                 for (i = 0; i < (*list)->len; i++)
 147                 {
 148                     codepage_desc *desc;
 149
 150                     desc = (codepage_desc *) g_ptr_array_index (*list, i);
 151
 152                     if (strcmp (id, desc->id) == 0)
 153                     {
 154                         /* found */
 155                         g_free (desc->name);
 156                         desc->name = g_strdup (p);
 157                         break;
 158                     }
 159                 }
 160
 161                 /* not found */
 162                 if (i == (*list)->len)
 163                     g_ptr_array_add (*list, new_codepage_desc (id, p));
 164             }
 165         }
 166     }
 167
 168     if (default_codepage != NULL)
 169     {
 170         mc_global.display_codepage = get_codepage_index (default_codepage);
 171         g_free (default_codepage);
 172     }
 173
 174   fail:
 175     fclose (f);
 176 }
 177
 178 /* --------------------------------------------------------------------------------------------- */
 179
 180 static char
 181 translate_character (GIConv cd, char c)
 182 {
 183     gchar *tmp_buff = NULL;
 184     gsize bytes_read, bytes_written = 0;
 185     const char *ibuf = &c;
 186     char ch = UNKNCHAR;
 187
 188     int ibuflen = 1;
 189
 190     tmp_buff = g_convert_with_iconv (ibuf, ibuflen, cd, &bytes_read, &bytes_written, NULL);
 191     if (tmp_buff)
 192         ch = tmp_buff[0];
 193     g_free (tmp_buff);
 194     return ch;
 195 }
 196
 197 /* --------------------------------------------------------------------------------------------- */
 198 /*** public functions ****************************************************************************/
 199 /* --------------------------------------------------------------------------------------------- */
 200
 201 void
 202 load_codepages_list (void)
 203 {
 204     char *fname;
 205
 206     /* 1: try load /usr/share/mc/mc.charsets */
 207     fname = g_build_filename (mc_global.share_data_dir, CHARSETS_LIST, (char *) NULL);
 208     load_codepages_list_from_file (&codepages, fname);
 209     g_free (fname);
 210
 211     /* 2: try load /etc/mc/mc.charsets */
 212     fname = g_build_filename (mc_global.sysconfig_dir, CHARSETS_LIST, (char *) NULL);
 213     load_codepages_list_from_file (&codepages, fname);
 214     g_free (fname);
 215
 216     if (codepages == NULL)
 217     {
 218         /* files are not found, add defaullt codepage */
 219         fprintf (stderr, "%s\n", _("Warning: cannot load codepages list"));
 220
 221         codepages = g_ptr_array_new ();
 222         g_ptr_array_add (codepages, new_codepage_desc ("ASCII", _("7-bit ASCII")));
 223     }
 224 }
 225
 226 /* --------------------------------------------------------------------------------------------- */
 227
 228 void
 229 free_codepages_list (void)
 230 {
 231     g_ptr_array_foreach (codepages, free_codepage_desc, NULL);
 232     g_ptr_array_free (codepages, TRUE);
 233 }
 234
 235 /* --------------------------------------------------------------------------------------------- */
 236
 237 const char *
 238 get_codepage_id (const int n)
 239 {
 240     return (n < 0) ? OTHER_8BIT : ((codepage_desc *) g_ptr_array_index (codepages, n))->id;
 241 }
 242
 243 /* --------------------------------------------------------------------------------------------- */
 244
 245 int
 246 get_codepage_index (const char *id)
 247 {
 248     size_t i;
 249     if (strcmp (id, OTHER_8BIT) == 0)
 250         return -1;
 251     if (codepages == NULL)
 252         return -1;
 253     for (i = 0; i < codepages->len; i++)
 254         if (strcmp (id, ((codepage_desc *) g_ptr_array_index (codepages, i))->id) == 0)
 255             return i;
 256     return -1;
 257 }
 258
 259 /* --------------------------------------------------------------------------------------------- */
 260 /** Check if specified encoding can be used in mc.
 261  * @param encoding name of encoding
 262  * @returns TRUE if encoding has supported by mc, FALSE otherwise
 263  */
 264
 265 gboolean
 266 is_supported_encoding (const char *encoding)
 267 {
 268     gboolean result = FALSE;
 269     guint t;
 270
 271     for (t = 0; t < codepages->len; t++)
 272     {
 273         const char *id = ((codepage_desc *) g_ptr_array_index (codepages, t))->id;
 274         result |= (g_ascii_strncasecmp (encoding, id, strlen (id)) == 0);
 275     }
 276
 277     return result;
 278 }
 279
 280 /* --------------------------------------------------------------------------------------------- */
 281
 282 char *
 283 init_translation_table (int cpsource, int cpdisplay)
 284 {
 285     int i;
 286     GIConv cd;
 287
 288     /* Fill inpit <-> display tables */
 289
 290     if (cpsource < 0 || cpdisplay < 0 || cpsource == cpdisplay)
 291     {
 292         for (i = 0; i <= 255; ++i)
 293         {
 294             conv_displ[i] = i;
 295             conv_input[i] = i;
 296             cp_source = cp_display;
 297         }
 298         return NULL;
 299     }
 300
 301     for (i = 0; i <= 127; ++i)
 302     {
 303         conv_displ[i] = i;
 304         conv_input[i] = i;
 305     }
 306     cp_source = ((codepage_desc *) g_ptr_array_index (codepages, cpsource))->id;
 307     cp_display = ((codepage_desc *) g_ptr_array_index (codepages, cpdisplay))->id;
 308
 309     /* display <- inpit table */
 310
 311     cd = g_iconv_open (cp_display, cp_source);
 312     if (cd == INVALID_CONV)
 313         return g_strdup_printf (_("Cannot translate from %s to %s"), cp_source, cp_display);
 314
 315     for (i = 128; i <= 255; ++i)
 316         conv_displ[i] = translate_character (cd, i);
 317
 318     g_iconv_close (cd);
 319
 320     /* inpit <- display table */
 321
 322     cd = g_iconv_open (cp_source, cp_display);
 323     if (cd == INVALID_CONV)
 324         return g_strdup_printf (_("Cannot translate from %s to %s"), cp_display, cp_source);
 325
 326     for (i = 128; i <= 255; ++i)
 327     {
 328         unsigned char ch;
 329         ch = translate_character (cd, i);
 330         conv_input[i] = (ch == UNKNCHAR) ? i : ch;
 331     }
 332
 333     g_iconv_close (cd);
 334
 335     return NULL;
 336 }
 337
 338 /* --------------------------------------------------------------------------------------------- */
 339
 340 void
 341 convert_to_display (char *str)
 342 {
 343     if (!str)
 344         return;
 345
 346     while (*str)
 347     {
 348         *str = conv_displ[(unsigned char) *str];
 349         str++;
 350     }
 351 }
 352
 353 /* --------------------------------------------------------------------------------------------- */
 354
 355 GString *
 356 str_convert_to_display (char *str)
 357 {
 358     return str_nconvert_to_display (str, -1);
 359
 360 }
 361
 362 /* --------------------------------------------------------------------------------------------- */
 363
 364 GString *
 365 str_nconvert_to_display (char *str, int len)
 366 {
 367     GString *buff;
 368     GIConv conv;
 369
 370     if (!str)
 371         return g_string_new ("");
 372
 373     if (cp_display == cp_source)
 374         return g_string_new (str);
 375
 376     conv = str_crt_conv_from (cp_source);
 377
 378     buff = g_string_new ("");
 379     str_nconvert (conv, str, len, buff);
 380     str_close_conv (conv);
 381     return buff;
 382 }
 383
 384 /* --------------------------------------------------------------------------------------------- */
 385
 386 void
 387 convert_from_input (char *str)
 388 {
 389     if (!str)
 390         return;
 391
 392     while (*str)
 393     {
 394         *str = conv_input[(unsigned char) *str];
 395         str++;
 396     }
 397 }
 398
 399 /* --------------------------------------------------------------------------------------------- */
 400
 401 GString *
 402 str_convert_to_input (char *str)
 403 {
 404     return str_nconvert_to_input (str, -1);
 405 }
 406
 407 /* --------------------------------------------------------------------------------------------- */
 408
 409 GString *
 410 str_nconvert_to_input (char *str, int len)
 411 {
 412     GString *buff;
 413     GIConv conv;
 414
 415     if (!str)
 416         return g_string_new ("");
 417
 418     if (cp_display == cp_source)
 419         return g_string_new (str);
 420
 421     conv = str_crt_conv_to (cp_source);
 422
 423     buff = g_string_new ("");
 424     str_nconvert (conv, str, len, buff);
 425     str_close_conv (conv);
 426     return buff;
 427 }
 428
 429 /* --------------------------------------------------------------------------------------------- */
 430
 431 unsigned char
 432 convert_from_utf_to_current (const char *str)
 433 {
 434     unsigned char buf_ch[6 + 1];
 435     unsigned char ch = '.';
 436     GIConv conv;
 437     const char *cp_to;
 438
 439     if (!str)
 440         return '.';
 441
 442     cp_to = get_codepage_id (mc_global.source_codepage);
 443     conv = str_crt_conv_to (cp_to);
 444
 445     if (conv != INVALID_CONV)
 446     {
 447         switch (str_translate_char (conv, str, -1, (char *) buf_ch, sizeof (buf_ch)))
 448         {
 449         case ESTR_SUCCESS:
 450             ch = buf_ch[0];
 451             break;
 452         case ESTR_PROBLEM:
 453         case ESTR_FAILURE:
 454             ch = '.';
 455             break;
 456         }
 457         str_close_conv (conv);
 458     }
 459
 460     return ch;
 461
 462 }
 463
 464 /* --------------------------------------------------------------------------------------------- */
 465
 466 unsigned char
 467 convert_from_utf_to_current_c (const int input_char, GIConv conv)
 468 {
 469     unsigned char str[6 + 1];
 470     unsigned char buf_ch[6 + 1];
 471     unsigned char ch = '.';
 472
 473     int res = 0;
 474
 475     res = g_unichar_to_utf8 (input_char, (char *) str);
 476     if (res == 0)
 477     {
 478         return ch;
 479     }
 480     str[res] = '\0';
 481
 482     switch (str_translate_char (conv, (char *) str, -1, (char *) buf_ch, sizeof (buf_ch)))
 483     {
 484     case ESTR_SUCCESS:
 485         ch = buf_ch[0];
 486         break;
 487     case ESTR_PROBLEM:
 488     case ESTR_FAILURE:
 489         ch = '.';
 490         break;
 491     }
 492     return ch;
 493 }
 494
 495 /* --------------------------------------------------------------------------------------------- */
 496
 497 int
 498 convert_from_8bit_to_utf_c (const char input_char, GIConv conv)
 499 {
 500     unsigned char str[2];
 501     unsigned char buf_ch[6 + 1];
 502     int ch = '.';
 503     int res = 0;
 504
 505     str[0] = (unsigned char) input_char;
 506     str[1] = '\0';
 507
 508     switch (str_translate_char (conv, (char *) str, -1, (char *) buf_ch, sizeof (buf_ch)))
 509     {
 510     case ESTR_SUCCESS:
 511         res = g_utf8_get_char_validated ((char *) buf_ch, -1);
 512         if (res < 0)
 513         {
 514             ch = buf_ch[0];
 515         }
 516         else
 517         {
 518             ch = res;
 519         }
 520         break;
 521     case ESTR_PROBLEM:
 522     case ESTR_FAILURE:
 523         ch = '.';
 524         break;
 525     }
 526     return ch;
 527 }
 528
 529 /* --------------------------------------------------------------------------------------------- */
 530
 531 int
 532 convert_from_8bit_to_utf_c2 (const char input_char)
 533 {
 534     unsigned char str[2];
 535     unsigned char buf_ch[6 + 1];
 536     int ch = '.';
 537     int res = 0;
 538     GIConv conv;
 539     const char *cp_from;
 540
 541     str[0] = (unsigned char) input_char;
 542     str[1] = '\0';
 543
 544     cp_from = get_codepage_id (mc_global.source_codepage);
 545     conv = str_crt_conv_to (cp_from);
 546
 547     if (conv != INVALID_CONV)
 548     {
 549         switch (str_translate_char (conv, (char *) str, -1, (char *) buf_ch, sizeof (buf_ch)))
 550         {
 551         case ESTR_SUCCESS:
 552             res = g_utf8_get_char_validated ((char *) buf_ch, -1);
 553             if (res < 0)
 554             {
 555                 ch = buf_ch[0];
 556             }
 557             else
 558             {
 559                 ch = res;
 560             }
 561             break;
 562         case ESTR_PROBLEM:
 563         case ESTR_FAILURE:
 564             ch = '.';
 565             break;
 566         }
 567         str_close_conv (conv);
 568     }
 569     return ch;
 570
 571 }
 572
 573 /* --------------------------------------------------------------------------------------------- */
 574
 575 #endif /* HAVE_CHARSET */