src/charsets.c

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