unix/uxucs.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <ctype.h>
   4 #include <locale.h>
   5 #include <limits.h>
   6 #include <wchar.h>
   7
   8 #include <time.h>
   9
  10 #include "putty.h"
  11 #include "terminal.h"
  12 #include "misc.h"
  13
  14 /*
  15  * Unix Unicode-handling routines.
  16  */
  17
  18 int is_dbcs_leadbyte(int codepage, char byte)
  19 {
  20     return 0;                          /* we don't do DBCS */
  21 }
  22
  23 int mb_to_wc(int codepage, int flags, char *mbstr, int mblen,
  24              wchar_t *wcstr, int wclen)
  25 {
  26     if (codepage == DEFAULT_CODEPAGE) {
  27         int n = 0;
  28         mbstate_t state = { 0 };
  29
  30         setlocale(LC_CTYPE, "");
  31
  32         while (mblen > 0) {
  33             size_t i = mbrtowc(wcstr+n, mbstr, (size_t)mblen, &state);
  34             if (i == (size_t)-1 || i == (size_t)-2)
  35                 break;
  36             n++;
  37             mbstr += i;
  38             mblen -= i;
  39         }
  40
  41         setlocale(LC_CTYPE, "C");
  42
  43         return n;
  44     } else if (codepage == CS_NONE) {
  45         int n = 0;
  46
  47         while (mblen > 0) {
  48             wcstr[n] = 0xD800 | (mbstr[0] & 0xFF);
  49             n++;
  50             mbstr++;
  51             mblen--;
  52         }
  53
  54         return n;
  55     } else
  56         return charset_to_unicode(&mbstr, &mblen, wcstr, wclen, codepage,
  57                                   NULL, NULL, 0);
  58 }
  59
  60 int wc_to_mb(int codepage, int flags, wchar_t *wcstr, int wclen,
  61              char *mbstr, int mblen, char *defchr, int *defused)
  62 {
  63     /* FIXME: we should remove the defused param completely... */
  64     if (defused)
  65         *defused = 0;
  66
  67     if (codepage == DEFAULT_CODEPAGE) {
  68         char output[MB_LEN_MAX];
  69         mbstate_t state = { 0 };
  70         int n = 0;
  71
  72         setlocale(LC_CTYPE, "");
  73
  74         while (wclen > 0) {
  75             int i = wcrtomb(output, wcstr[0], &state);
  76             if (i == (size_t)-1 || i > n - mblen)
  77                 break;
  78             memcpy(mbstr+n, output, i);
  79             n += i;
  80             wcstr++;
  81             wclen--;
  82         }
  83
  84         setlocale(LC_CTYPE, "C");
  85
  86         return n;
  87     } else if (codepage == CS_NONE) {
  88         int n = 0;
  89         while (wclen > 0 && n < mblen) {
  90             if (*wcstr >= 0xD800 && *wcstr < 0xD900)
  91                 mbstr[n++] = (*wcstr & 0xFF);
  92             else if (defchr)
  93                 mbstr[n++] = *defchr;
  94             wcstr++;
  95             wclen--;
  96         }
  97         return n;
  98     } else {
  99         return charset_from_unicode(&wcstr, &wclen, mbstr, mblen, codepage,
 100                                     NULL, NULL, 0);
 101     }
 102 }
 103
 104 void init_ucs(int font_charset)
 105 {
 106     int i;
 107
 108     /*
 109      * In the platform-independent parts of the code, font_codepage
 110      * is used only for system DBCS support - which we don't
 111      * support at all. So we set this to something which will never
 112      * be used.
 113      */
 114     font_codepage = -1;
 115
 116     /*
 117      * line_codepage should be decoded from the specification in
 118      * cfg.
 119      */
 120     line_codepage = charset_from_mimeenc(cfg.line_codepage);
 121     if (line_codepage == CS_NONE)
 122         line_codepage = charset_from_xenc(cfg.line_codepage);
 123
 124     /*
 125      * If line_codepage is _still_ CS_NONE, we assume we're using
 126      * the font's own encoding. This has been passed in to us, so
 127      * we use that. If it's still CS_NONE after _that_ - i.e. the
 128      * font we were given had an incomprehensible charset - then we
 129      * fall back to using the D800 page.
 130      */
 131     if (line_codepage == CS_NONE)
 132         line_codepage = font_charset;
 133
 134     /*
 135      * Set up unitab_line, by translating each individual character
 136      * in the line codepage into Unicode.
 137      */
 138     for (i = 0; i < 256; i++) {
 139         char c[1], *p;
 140         wchar_t wc[1];
 141         int len;
 142         c[0] = i;
 143         p = c;
 144         len = 1;
 145         if (line_codepage == CS_NONE)
 146             unitab_line[i] = 0xD800 | i;
 147         else if (1 == charset_to_unicode(&p, &len, wc, 1, line_codepage,
 148                                          NULL, L"", 0))
 149             unitab_line[i] = wc[0];
 150         else
 151             unitab_line[i] = 0xFFFD;
 152     }
 153
 154     /*
 155      * Set up unitab_xterm. This is the same as unitab_line except
 156      * in the line-drawing regions, where it follows the Unicode
 157      * encoding.
 158      *
 159      * (Note that the strange X encoding of line-drawing characters
 160      * in the bottom 32 glyphs of ISO8859-1 fonts is taken care of
 161      * by the font encoding, which will spot such a font and act as
 162      * if it were in a variant encoding of ISO8859-1.)
 163      */
 164     for (i = 0; i < 256; i++) {
 165         static const wchar_t unitab_xterm_std[32] = {
 166             0x2666, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
 167             0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
 168             0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
 169             0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x0020
 170         };
 171         if (i >= 0x5F && i < 0x7F)
 172             unitab_xterm[i] = unitab_xterm_std[i & 0x1F];
 173         else
 174             unitab_xterm[i] = unitab_line[i];
 175     }
 176
 177     /*
 178      * Set up unitab_scoacs. The SCO Alternate Character Set is
 179      * simply CP437.
 180      */
 181     for (i = 0; i < 256; i++) {
 182         char c[1], *p;
 183         wchar_t wc[1];
 184         int len;
 185         c[0] = i;
 186         p = c;
 187         len = 1;
 188         if (1 == charset_to_unicode(&p, &len, wc, 1, CS_CP437, NULL, L"", 0))
 189             unitab_scoacs[i] = wc[0];
 190         else
 191             unitab_scoacs[i] = 0xFFFD;
 192     }
 193
 194     /*
 195      * Find the control characters in the line codepage. For
 196      * direct-to-font mode using the D800 hack, we assume 00-1F and
 197      * 7F are controls, but allow 80-9F through. (It's as good a
 198      * guess as anything; and my bet is that half the weird fonts
 199      * used in this way will be IBM or MS code pages anyway.)
 200      */
 201     for (i = 0; i < 256; i++) {
 202         int lineval = unitab_line[i];
 203         if (lineval < ' ' || (lineval >= 0x7F && lineval < 0xA0) ||
 204             (lineval >= 0xD800 && lineval < 0xD820) || (lineval == 0xD87F))
 205             unitab_ctrl[i] = i;
 206         else
 207             unitab_ctrl[i] = 0xFF;
 208     }
 209 }