686 lines
20 KiB
C
686 lines
20 KiB
C
/* $XTermId: charsets.c,v 1.67 2013/12/01 16:38:13 tom Exp $ */
|
|
|
|
/*
|
|
* Copyright 1998-2011,2013 by Thomas E. Dickey
|
|
*
|
|
* All Rights Reserved
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name(s) of the above copyright
|
|
* holders shall not be used in advertising or otherwise to promote the
|
|
* sale, use or other dealings in this Software without prior written
|
|
* authorization.
|
|
*
|
|
*/
|
|
|
|
#include <xterm.h>
|
|
#include <data.h>
|
|
#include <fontutils.h>
|
|
|
|
#include <X11/keysym.h>
|
|
|
|
/*
|
|
* This module performs translation as needed to support the DEC VT220 national
|
|
* replacement character sets. We assume that xterm's font is based on the ISO
|
|
* 8859-1 (Latin 1) character set, which is almost the same as the DEC
|
|
* multinational character set. Glyph positions 0-31 have to be the DEC
|
|
* graphic characters, though.
|
|
*
|
|
* References:
|
|
* "VT220 Programmer Pocket Guide" EK-VT220-HR-002 (2nd ed., 1984), which
|
|
* contains character charts for the national character sets.
|
|
* "VT330/VT340 Programmer Reference Manual Volume 1: Text Programming"
|
|
* EK-VT3XX-TP-001 (1st ed, 1987), which contains a table (2-1)
|
|
* listing the glyphs which are mapped from the multinational
|
|
* character set to the national character set.
|
|
*
|
|
* The latter reference, though easier to read, has a few errors and omissions.
|
|
*/
|
|
|
|
#define map_NRCS_Dutch(code) \
|
|
switch (code) { \
|
|
MAP(0x23, XK_sterling); \
|
|
MAP(0x40, XK_threequarters); \
|
|
UNI(0x5b, 0x0133); /* ij ligature */ \
|
|
MAP(0x5c, XK_onehalf); \
|
|
MAP(0x5d, XK_bar); \
|
|
MAP(0x7b, XK_diaeresis); \
|
|
UNI(0x7c, 0x0192); /* florin */ \
|
|
MAP(0x7d, XK_onequarter); \
|
|
MAP(0x7e, XK_acute); \
|
|
}
|
|
|
|
#define map_NRCS_Finnish(code) \
|
|
switch (code) { \
|
|
MAP(0x5b, XK_Adiaeresis); \
|
|
MAP(0x5c, XK_Odiaeresis); \
|
|
MAP(0x5d, XK_Aring); \
|
|
MAP(0x5e, XK_Udiaeresis); \
|
|
MAP(0x60, XK_eacute); \
|
|
MAP(0x7b, XK_adiaeresis); \
|
|
MAP(0x7c, XK_odiaeresis); \
|
|
MAP(0x7d, XK_aring); \
|
|
MAP(0x7e, XK_udiaeresis); \
|
|
}
|
|
|
|
#define map_NRCS_French(code) \
|
|
switch (code) { \
|
|
MAP(0x23, XK_sterling); \
|
|
MAP(0x40, XK_agrave); \
|
|
MAP(0x5b, XK_degree); \
|
|
MAP(0x5c, XK_ccedilla); \
|
|
MAP(0x5d, XK_section); \
|
|
MAP(0x7b, XK_eacute); \
|
|
MAP(0x7c, XK_ugrave); \
|
|
MAP(0x7d, XK_egrave); \
|
|
MAP(0x7e, XK_diaeresis); \
|
|
}
|
|
|
|
#define map_NRCS_French_Canadian(code) \
|
|
switch (code) { \
|
|
MAP(0x40, XK_agrave); \
|
|
MAP(0x5b, XK_acircumflex); \
|
|
MAP(0x5c, XK_ccedilla); \
|
|
MAP(0x5d, XK_ecircumflex); \
|
|
MAP(0x5e, XK_icircumflex); \
|
|
MAP(0x60, XK_ocircumflex); \
|
|
MAP(0x7b, XK_eacute); \
|
|
MAP(0x7c, XK_ugrave); \
|
|
MAP(0x7d, XK_egrave); \
|
|
MAP(0x7e, XK_ucircumflex); \
|
|
}
|
|
|
|
#define map_NRCS_German(code) \
|
|
switch (code) { \
|
|
MAP(0x40, XK_section); \
|
|
MAP(0x5b, XK_Adiaeresis); \
|
|
MAP(0x5c, XK_Odiaeresis); \
|
|
MAP(0x5d, XK_Udiaeresis); \
|
|
MAP(0x7b, XK_adiaeresis); \
|
|
MAP(0x7c, XK_odiaeresis); \
|
|
MAP(0x7d, XK_udiaeresis); \
|
|
MAP(0x7e, XK_ssharp); \
|
|
}
|
|
|
|
#define map_NRCS_Italian(code) \
|
|
switch (code) { \
|
|
MAP(0x23, XK_sterling); \
|
|
MAP(0x40, XK_section); \
|
|
MAP(0x5b, XK_degree); \
|
|
MAP(0x5c, XK_ccedilla); \
|
|
MAP(0x5d, XK_eacute); \
|
|
MAP(0x60, XK_ugrave); \
|
|
MAP(0x7b, XK_agrave); \
|
|
MAP(0x7c, XK_ograve); \
|
|
MAP(0x7d, XK_egrave); \
|
|
MAP(0x7e, XK_igrave); \
|
|
}
|
|
|
|
#define map_NRCS_Norwegian_Danish(code) \
|
|
switch (code) { \
|
|
MAP(0x40, XK_Adiaeresis); \
|
|
MAP(0x5b, XK_AE); \
|
|
MAP(0x5c, XK_Ooblique); \
|
|
MAP(0x5d, XK_Aring); \
|
|
MAP(0x5e, XK_Udiaeresis); \
|
|
MAP(0x60, XK_adiaeresis); \
|
|
MAP(0x7b, XK_ae); \
|
|
MAP(0x7c, XK_oslash); \
|
|
MAP(0x7d, XK_aring); \
|
|
MAP(0x7e, XK_udiaeresis); \
|
|
}
|
|
|
|
#define map_NRCS_Portuguese(code) \
|
|
switch (code) { \
|
|
MAP(0x5b, XK_Atilde); \
|
|
MAP(0x5c, XK_Ccedilla); \
|
|
MAP(0x5d, XK_Otilde); \
|
|
MAP(0x7b, XK_atilde); \
|
|
MAP(0x7c, XK_ccedilla); \
|
|
MAP(0x7d, XK_otilde); \
|
|
}
|
|
|
|
#define map_NRCS_Spanish(code) \
|
|
switch (code) { \
|
|
MAP(0x23, XK_sterling); \
|
|
MAP(0x40, XK_section); \
|
|
MAP(0x5b, XK_exclamdown); \
|
|
MAP(0x5c, XK_Ntilde); \
|
|
MAP(0x5d, XK_questiondown); \
|
|
MAP(0x7b, XK_degree); \
|
|
MAP(0x7c, XK_ntilde); \
|
|
MAP(0x7d, XK_ccedilla); \
|
|
}
|
|
|
|
#define map_NRCS_Swedish(code) \
|
|
switch (code) { \
|
|
MAP(0x40, XK_Eacute); \
|
|
MAP(0x5b, XK_Adiaeresis); \
|
|
MAP(0x5c, XK_Odiaeresis); \
|
|
MAP(0x5d, XK_Aring); \
|
|
MAP(0x5e, XK_Udiaeresis); \
|
|
MAP(0x60, XK_eacute); \
|
|
MAP(0x7b, XK_adiaeresis); \
|
|
MAP(0x7c, XK_odiaeresis); \
|
|
MAP(0x7d, XK_aring); \
|
|
MAP(0x7e, XK_udiaeresis); \
|
|
}
|
|
|
|
#define map_NRCS_Swiss(code) \
|
|
switch (code) { \
|
|
MAP(0x23, XK_ugrave); \
|
|
MAP(0x40, XK_agrave); \
|
|
MAP(0x5b, XK_eacute); \
|
|
MAP(0x5c, XK_ccedilla); \
|
|
MAP(0x5d, XK_ecircumflex); \
|
|
MAP(0x5e, XK_icircumflex); \
|
|
MAP(0x5f, XK_egrave); \
|
|
MAP(0x60, XK_ocircumflex); \
|
|
MAP(0x7b, XK_adiaeresis); \
|
|
MAP(0x7c, XK_odiaeresis); \
|
|
MAP(0x7d, XK_udiaeresis); \
|
|
MAP(0x7e, XK_ucircumflex); \
|
|
}
|
|
|
|
/*
|
|
* Unlike NRCS, which splices a few characters onto ASCII, the supplementary
|
|
* character sets are complete, normally mapped to GR. Most of these mappings
|
|
* rely upon glyphs not found in ISO-8859-1. We can display most of those
|
|
* using Unicode, thereby supporting specialized applications that use SCS
|
|
* with luit, subject to the limitation that select/paste will give meaningless
|
|
* results in terms of the application which uses these mappings.
|
|
*
|
|
* Since the VT320, etc, use only 8-bit encodings, there is no plausible
|
|
* argument to be made that these mappings "use" UTF-8, even though there is
|
|
* a hidden step in the terminal emulator which relies upon UTF-8.
|
|
*/
|
|
#define map_SCS_DEC_Supp(code,dft) \
|
|
switch (code) { \
|
|
XXX(0x24, 0x2e2e); \
|
|
XXX(0x26, 0x2e2e); \
|
|
XXX(0x2c, 0x2e2e); \
|
|
XXX(0x2d, 0x2e2e); \
|
|
XXX(0x2e, 0x2e2e); \
|
|
XXX(0x2f, 0x2e2e); \
|
|
XXX(0x34, 0x2e2e); \
|
|
XXX(0x38, 0x2e2e); \
|
|
XXX(0x3e, 0x2e2e); \
|
|
UNI(0x47, 0x2426); \
|
|
MAP(0x48, 0xc7); \
|
|
MAP(0x49, 0xc8); \
|
|
MAP(0x4a, 0xc9); \
|
|
MAP(0x4b, 0xca); \
|
|
MAP(0x4c, 0xcb); \
|
|
MAP(0x4d, 0xcc); \
|
|
MAP(0x4e, 0xcd); \
|
|
MAP(0x4f, 0xce); \
|
|
XXX(0x50, 0x2e2e); \
|
|
UNI(0x57, 0x0152); \
|
|
XXX(0x5e, 0x2e2e); \
|
|
XXX(0x70, 0x2e2e); \
|
|
UNI(0x77, 0x0153); \
|
|
MAP(0x7d, 0xff); \
|
|
XXX(0x7e, 0x2e2e); \
|
|
default: dft; break; \
|
|
}
|
|
|
|
#define map_SCS_DEC_Supp_Graphic(code,dft) \
|
|
switch (code) { \
|
|
XXX(0x24, 0x2e2e); \
|
|
XXX(0x26, 0x2e2e); \
|
|
XXX(0x2c, 0x2e2e); \
|
|
XXX(0x2d, 0x2e2e); \
|
|
XXX(0x2e, 0x2e2e); \
|
|
XXX(0x2f, 0x2e2e); \
|
|
XXX(0x34, 0x2e2e); \
|
|
XXX(0x38, 0x2e2e); \
|
|
XXX(0x3e, 0x2e2e); \
|
|
XXX(0x50, 0x2e2e); \
|
|
UNI(0x57, 0x0152); \
|
|
XXX(0x5e, 0x2e2e); \
|
|
XXX(0x70, 0x2e2e); \
|
|
UNI(0x77, 0x0153); \
|
|
MAP(0x7d, 0xff); \
|
|
XXX(0x7e, 0x2e2e); \
|
|
XXX(0x7f, 0x2e2e); \
|
|
default: dft; break; \
|
|
}
|
|
|
|
/* derived from http://www.vt100.net/charsets/technical.html */
|
|
#if OPT_WIDE_CHARS
|
|
#define map_SCS_DEC_Technical(code) \
|
|
switch (code) { \
|
|
UNI(0x21, 0x23b7); /* RADICAL SYMBOL BOTTOM Centred left to right, so that it joins up with 02/02 */ \
|
|
UNI(0x22, 0x250c); /* BOX DRAWINGS LIGHT DOWN AND RIGHT */ \
|
|
UNI(0x23, 0x2500); /* BOX DRAWINGS LIGHT HORIZONTAL */ \
|
|
UNI(0x24, 0x2320); /* TOP HALF INTEGRAL with the proviso that the stem is vertical, to join with 02/06 */ \
|
|
UNI(0x25, 0x2321); /* BOTTOM HALF INTEGRAL with the proviso above. */ \
|
|
UNI(0x26, 0x2502); /* BOX DRAWINGS LIGHT VERTICAL */ \
|
|
UNI(0x27, 0x23a1); /* LEFT SQUARE BRACKET UPPER CORNER Joins vertically to 02/06, 02/08. Doesn't join to its right. */ \
|
|
UNI(0x28, 0x23a3); /* LEFT SQUARE BRACKET LOWER CORNER Joins vertically to 02/06, 02/07. Doesn't join to its right. */ \
|
|
UNI(0x29, 0x23a4); /* RIGHT SQUARE BRACKET UPPER CORNER Joins vertically to 026, 02a. Doesn't join to its left. */ \
|
|
UNI(0x2a, 0x23a6); /* RIGHT SQUARE BRACKET LOWER CORNER Joins vertically to 026, 029. Doesn't join to its left. */ \
|
|
UNI(0x2b, 0x239b); /* LEFT PARENTHESIS UPPER HOOK Joins vertically to 026, 02c, 02/15. Doesn't join to its right. */ \
|
|
UNI(0x2c, 0x239d); /* LEFT PARENTHESIS LOWER HOOK Joins vertically to 026, 02b, 02/15. Doesn't join to its right. */ \
|
|
UNI(0x2d, 0x239e); /* RIGHT PARENTHESIS UPPER HOOK Joins vertically to 026, 02e, 03/00. Doesn't join to its left. */ \
|
|
UNI(0x2e, 0x23a0); /* RIGHT PARENTHESIS LOWER HOOK Joins vertically to 026, 02d, 03/00. Doesn't join to its left. */ \
|
|
UNI(0x2f, 0x23a8); /* LEFT CURLY BRACKET MIDDLE PIECE Joins vertically to 026, 02b, 02c. */ \
|
|
UNI(0x30, 0x23ac); /* RIGHT CURLY BRACKET MIDDLE PIECE Joins vertically to 02/06, 02d, 02e. */ \
|
|
XXX(0x31, 0x2426); /* Top Left Sigma. Joins to right with 02/03, 03/05. Joins diagonally below right with 03/03, 03/07. */ \
|
|
XXX(0x32, 0x2426); /* Bottom Left Sigma. Joins to right with 02/03, 03/06. Joins diagonally above right with 03/04, 03/07. */ \
|
|
XXX(0x33, 0x2426); /* Top Diagonal Sigma. Line for joining 03/01 to 03/04 or 03/07. */ \
|
|
XXX(0x34, 0x2426); /* Bottom Diagonal Sigma. Line for joining 03/02 to 03/03 or 03/07. */ \
|
|
XXX(0x35, 0x2426); /* Top Right Sigma. Joins to left with 02/03, 03/01. */ \
|
|
XXX(0x36, 0x2426); /* Bottom Right Sigma. Joins to left with 02/03, 03/02. */ \
|
|
XXX(0x37, 0x2426); /* Middle Sigma. Joins diagonally with 03/01, 03/02, 03/03, 03/04. */ \
|
|
XXX(0x38, 0x2426); /* undefined */ \
|
|
XXX(0x39, 0x2426); /* undefined */ \
|
|
XXX(0x3a, 0x2426); /* undefined */ \
|
|
XXX(0x3b, 0x2426); /* undefined */ \
|
|
UNI(0x3c, 0x2264); /* LESS-THAN OR EQUAL TO */ \
|
|
UNI(0x3d, 0x2260); /* NOT EQUAL TO */ \
|
|
UNI(0x3e, 0x2265); /* GREATER-THAN OR EQUAL TO */ \
|
|
UNI(0x3f, 0x222B); /* INTEGRAL */ \
|
|
UNI(0x40, 0x2234); /* THEREFORE */ \
|
|
UNI(0x41, 0x221d); /* PROPORTIONAL TO */ \
|
|
UNI(0x42, 0x221e); /* INFINITY */ \
|
|
UNI(0x43, 0x00f7); /* DIVISION SIGN */ \
|
|
UNI(0x44, 0x039a); /* GREEK CAPITAL DELTA */ \
|
|
UNI(0x45, 0x2207); /* NABLA */ \
|
|
UNI(0x46, 0x03a6); /* GREEK CAPITAL LETTER PHI */ \
|
|
UNI(0x47, 0x0393); /* GREEK CAPITAL LETTER GAMMA */ \
|
|
UNI(0x48, 0x223c); /* TILDE OPERATOR */ \
|
|
UNI(0x49, 0x2243); /* ASYMPTOTICALLY EQUAL TO */ \
|
|
UNI(0x4a, 0x0398); /* GREEK CAPITAL LETTER THETA */ \
|
|
UNI(0x4b, 0x00d7); /* MULTIPLICATION SIGN */ \
|
|
UNI(0x4c, 0x039b); /* GREEK CAPITAL LETTER LAMDA */ \
|
|
UNI(0x4d, 0x21d4); /* LEFT RIGHT DOUBLE ARROW */ \
|
|
UNI(0x4e, 0x21d2); /* RIGHTWARDS DOUBLE ARROW */ \
|
|
UNI(0x4f, 0x2261); /* IDENTICAL TO */ \
|
|
UNI(0x50, 0x03a0); /* GREEK CAPITAL LETTER PI */ \
|
|
UNI(0x51, 0x03a8); /* GREEK CAPITAL LETTER PSI */ \
|
|
UNI(0x52, 0x2426); /* undefined */ \
|
|
UNI(0x53, 0x03a3); /* GREEK CAPITAL LETTER SIGMA */ \
|
|
XXX(0x54, 0x2426); /* undefined */ \
|
|
XXX(0x55, 0x2426); /* undefined */ \
|
|
UNI(0x56, 0x221a); /* SQUARE ROOT */ \
|
|
UNI(0x57, 0x03a9); /* GREEK CAPITAL LETTER OMEGA */ \
|
|
UNI(0x58, 0x039e); /* GREEK CAPITAL LETTER XI */ \
|
|
UNI(0x59, 0x03a5); /* GREEK CAPITAL LETTER UPSILON */ \
|
|
UNI(0x5a, 0x2282); /* SUBSET OF */ \
|
|
UNI(0x5b, 0x2283); /* SUPERSET OF */ \
|
|
UNI(0x5c, 0x2229); /* INTERSECTION */ \
|
|
UNI(0x5d, 0x222a); /* UNION */ \
|
|
UNI(0x5e, 0x2227); /* LOGICAL AND */ \
|
|
UNI(0x5f, 0x2228); /* LOGICAL OR */ \
|
|
UNI(0x60, 0x00ac); /* NOT SIGN */ \
|
|
UNI(0x61, 0x03b1); /* GREEK SMALL LETTER ALPHA */ \
|
|
UNI(0x62, 0x03b2); /* GREEK SMALL LETTER BETA */ \
|
|
UNI(0x63, 0x03c7); /* GREEK SMALL LETTER CHI */ \
|
|
UNI(0x64, 0x03b4); /* GREEK SMALL LETTER DELTA */ \
|
|
UNI(0x65, 0x03b5); /* GREEK SMALL LETTER EPSILON */ \
|
|
UNI(0x66, 0x03c6); /* GREEK SMALL LETTER PHI */ \
|
|
UNI(0x67, 0x03b3); /* GREEK SMALL LETTER GAMMA */ \
|
|
UNI(0x68, 0x03b7); /* GREEK SMALL LETTER ETA */ \
|
|
UNI(0x69, 0x03b9); /* GREEK SMALL LETTER IOTA */ \
|
|
UNI(0x6a, 0x03b8); /* GREEK SMALL LETTER THETA */ \
|
|
UNI(0x6b, 0x03ba); /* GREEK SMALL LETTER KAPPA */ \
|
|
UNI(0x6c, 0x03bb); /* GREEK SMALL LETTER LAMDA */ \
|
|
XXX(0x6d, 0x2426); /* undefined */ \
|
|
UNI(0x6e, 0x03bd); /* GREEK SMALL LETTER NU */ \
|
|
UNI(0x6f, 0x2202); /* PARTIAL DIFFERENTIAL */ \
|
|
UNI(0x70, 0x03c0); /* GREEK SMALL LETTER PI */ \
|
|
UNI(0x71, 0x03c8); /* GREEK SMALL LETTER PSI */ \
|
|
UNI(0x72, 0x03c1); /* GREEK SMALL LETTER RHO */ \
|
|
UNI(0x73, 0x03c3); /* GREEK SMALL LETTER SIGMA */ \
|
|
UNI(0x74, 0x03c4); /* GREEK SMALL LETTER TAU */ \
|
|
XXX(0x75, 0x2426); /* undefined */ \
|
|
UNI(0x76, 0x0192); /* LATIN SMALL LETTER F WITH HOOK Probably chosen for its meaning of "function" */ \
|
|
UNI(0x77, 0x03c9); /* GREEK SMALL LETTER OMEGA */ \
|
|
UNI(0x78, 0x03bE); /* GREEK SMALL LETTER XI */ \
|
|
UNI(0x79, 0x03c5); /* GREEK SMALL LETTER UPSILON */ \
|
|
UNI(0x7a, 0x03b6); /* GREEK SMALL LETTER ZETA */ \
|
|
UNI(0x7b, 0x2190); /* LEFTWARDS ARROW */ \
|
|
UNI(0x7c, 0x2191); /* UPWARDS ARROW */ \
|
|
UNI(0x7d, 0x2192); /* RIGHTWARDS ARROW */ \
|
|
UNI(0x7e, 0x2193); /* DOWNWARDS ARROW */ \
|
|
}
|
|
#else
|
|
#define map_SCS_DEC_Technical(code) /* nothing */
|
|
#endif /* OPT_WIDE_CHARS */
|
|
|
|
/*
|
|
* Translate an input keysym to the corresponding NRC keysym.
|
|
*/
|
|
unsigned
|
|
xtermCharSetIn(TScreen *screen, unsigned code, int charset)
|
|
{
|
|
#define MAP(to, from) case from: code = to; break
|
|
|
|
#if OPT_WIDE_CHARS
|
|
#define UNI(to, from) case from: if (screen->utf8_nrc_mode) code = to; break
|
|
#else
|
|
#define UNI(to, from) case from: break
|
|
#endif
|
|
|
|
#define XXX(to, from) /* no defined mapping to 0..255 */
|
|
|
|
TRACE(("CHARSET-IN GL=%s(G%d) GR=%s(G%d) SS%d\n\t%s\n",
|
|
visibleScsCode(screen->gsets[screen->curgl]), screen->curgl,
|
|
visibleScsCode(screen->gsets[screen->curgr]), screen->curgr,
|
|
screen->curss,
|
|
visibleUChar(code)));
|
|
|
|
switch (charset) {
|
|
case nrc_British: /* United Kingdom set (or Latin 1) */
|
|
if (code == XK_sterling)
|
|
code = 0x23;
|
|
code &= 0x7f;
|
|
break;
|
|
|
|
#if OPT_XMC_GLITCH
|
|
case nrc_Unknown:
|
|
#endif
|
|
case nrc_DEC_Alt_Chars:
|
|
case nrc_DEC_Alt_Graphics:
|
|
case nrc_ASCII:
|
|
break;
|
|
|
|
case nrc_DEC_Spec_Graphic:
|
|
break;
|
|
|
|
case nrc_DEC_Supp:
|
|
map_SCS_DEC_Supp(code, code &= 0x7f);
|
|
break;
|
|
|
|
case nrc_DEC_Supp_Graphic:
|
|
map_SCS_DEC_Supp_Graphic(code, code |= 0x80);
|
|
break;
|
|
|
|
case nrc_DEC_Technical:
|
|
map_SCS_DEC_Technical(code);
|
|
break;
|
|
|
|
case nrc_Dutch:
|
|
map_NRCS_Dutch(code);
|
|
break;
|
|
|
|
case nrc_Finnish:
|
|
case nrc_Finnish2:
|
|
map_NRCS_Finnish(code);
|
|
break;
|
|
|
|
case nrc_French:
|
|
case nrc_French2:
|
|
map_NRCS_French(code);
|
|
break;
|
|
|
|
case nrc_French_Canadian:
|
|
map_NRCS_French_Canadian(code);
|
|
break;
|
|
|
|
case nrc_German:
|
|
map_NRCS_German(code);
|
|
break;
|
|
|
|
case nrc_Hebrew:
|
|
case nrc_Hebrew2:
|
|
/* FIXME */
|
|
break;
|
|
|
|
case nrc_Italian:
|
|
map_NRCS_Italian(code);
|
|
break;
|
|
|
|
case nrc_Norwegian_Danish:
|
|
case nrc_Norwegian_Danish2:
|
|
case nrc_Norwegian_Danish3:
|
|
map_NRCS_Norwegian_Danish(code);
|
|
break;
|
|
|
|
case nrc_Portugese:
|
|
map_NRCS_Portuguese(code);
|
|
break;
|
|
|
|
case nrc_SCS_NRCS: /* vt5xx - probably Serbo/Croatian */
|
|
/* FIXME */
|
|
break;
|
|
|
|
case nrc_Spanish:
|
|
map_NRCS_Spanish(code);
|
|
break;
|
|
|
|
case nrc_Swedish2:
|
|
case nrc_Swedish:
|
|
map_NRCS_Swedish(code);
|
|
break;
|
|
|
|
case nrc_Swiss:
|
|
map_NRCS_Swiss(code);
|
|
break;
|
|
|
|
case nrc_Turkish:
|
|
case nrc_Turkish2:
|
|
/* FIXME */
|
|
break;
|
|
|
|
default: /* any character sets we don't recognize */
|
|
break;
|
|
}
|
|
code &= 0x7f; /* NRC in any case is 7-bit */
|
|
TRACE(("->\t%s\n",
|
|
visibleUChar(code)));
|
|
return code;
|
|
#undef MAP
|
|
#undef UNI
|
|
#undef XXX
|
|
}
|
|
|
|
/*
|
|
* Translate a string to the display form. This assumes the font has the
|
|
* DEC graphic characters in cells 0-31, and otherwise is ISO-8859-1.
|
|
*/
|
|
int
|
|
xtermCharSetOut(XtermWidget xw, IChar *buf, IChar *ptr, int leftset)
|
|
{
|
|
IChar *s;
|
|
TScreen *screen = TScreenOf(xw);
|
|
int count = 0;
|
|
int rightset = screen->gsets[(int) (screen->curgr)];
|
|
|
|
#define MAP(from, to) case from: chr = to; break
|
|
|
|
#if OPT_WIDE_CHARS
|
|
#define UNI(from, to) case from: if (screen->utf8_nrc_mode) chr = to; break
|
|
#define XXX(from, to) UNI(from, to)
|
|
#else
|
|
#define UNI(old, new) chr = old; break
|
|
#define XXX(from, to) /* nothing */
|
|
#endif
|
|
|
|
TRACE(("CHARSET-OUT GL=%s(G%d) GR=%s(G%d) SS%d\n\t%s\n",
|
|
visibleScsCode(leftset), screen->curgl,
|
|
visibleScsCode(rightset), screen->curgr,
|
|
screen->curss,
|
|
visibleIChars(buf, (unsigned) (ptr - buf))));
|
|
|
|
for (s = buf; s < ptr; ++s) {
|
|
int eight = CharOf(E2A(*s));
|
|
int seven = eight & 0x7f;
|
|
int cs = (eight >= 128) ? rightset : leftset;
|
|
int chr = eight;
|
|
|
|
count++;
|
|
#if OPT_WIDE_CHARS
|
|
/*
|
|
* This is only partly right - prevent inadvertant remapping of
|
|
* the replacement character and other non-8bit codes into bogus
|
|
* 8bit codes.
|
|
*/
|
|
if (screen->utf8_mode || screen->utf8_nrc_mode) {
|
|
if (*s > 255)
|
|
continue;
|
|
}
|
|
#endif
|
|
if (*s < 32)
|
|
continue;
|
|
|
|
switch (cs) {
|
|
case nrc_British_Latin_1:
|
|
/* FALLTHRU */
|
|
case nrc_British: /* United Kingdom set (or Latin 1) */
|
|
if ((xw->flags & NATIONAL)
|
|
|| (screen->vtXX_level <= 1)) {
|
|
if ((xw->flags & NATIONAL)) {
|
|
chr = seven;
|
|
}
|
|
if (chr == 0x23) {
|
|
chr = XTERM_POUND;
|
|
#if OPT_WIDE_CHARS
|
|
if (screen->utf8_nrc_mode) {
|
|
chr = 0xa3;
|
|
}
|
|
#endif
|
|
}
|
|
} else {
|
|
chr = (seven | 0x80);
|
|
}
|
|
break;
|
|
|
|
#if OPT_XMC_GLITCH
|
|
case nrc_Unknown:
|
|
#endif
|
|
case nrc_DEC_Alt_Chars:
|
|
case nrc_DEC_Alt_Graphics:
|
|
case nrc_ASCII:
|
|
break;
|
|
|
|
case nrc_DEC_Spec_Graphic:
|
|
if (seven > 0x5f && seven <= 0x7e) {
|
|
#if OPT_WIDE_CHARS
|
|
if (screen->utf8_mode || screen->utf8_nrc_mode)
|
|
chr = (int) dec2ucs((unsigned) (seven - 0x5f));
|
|
else
|
|
#endif
|
|
chr = seven - 0x5f;
|
|
} else {
|
|
chr = seven;
|
|
}
|
|
break;
|
|
|
|
case nrc_DEC_Supp:
|
|
map_SCS_DEC_Supp(chr = seven, chr |= 0x80);
|
|
break;
|
|
|
|
case nrc_DEC_Supp_Graphic:
|
|
map_SCS_DEC_Supp_Graphic(chr = seven, chr |= 0x80);
|
|
break;
|
|
|
|
case nrc_DEC_Technical:
|
|
map_SCS_DEC_Technical(chr = seven);
|
|
break;
|
|
|
|
case nrc_Dutch:
|
|
map_NRCS_Dutch(chr = seven);
|
|
break;
|
|
|
|
case nrc_Finnish:
|
|
case nrc_Finnish2:
|
|
map_NRCS_Finnish(chr = seven);
|
|
break;
|
|
|
|
case nrc_French:
|
|
case nrc_French2:
|
|
map_NRCS_French(chr = seven);
|
|
break;
|
|
|
|
case nrc_French_Canadian:
|
|
case nrc_French_Canadian2:
|
|
map_NRCS_French_Canadian(chr = seven);
|
|
break;
|
|
|
|
case nrc_German:
|
|
map_NRCS_German(chr = seven);
|
|
break;
|
|
|
|
case nrc_Hebrew:
|
|
case nrc_Hebrew2:
|
|
/* FIXME */
|
|
break;
|
|
|
|
case nrc_Italian:
|
|
map_NRCS_Italian(chr = seven);
|
|
break;
|
|
|
|
case nrc_Norwegian_Danish:
|
|
case nrc_Norwegian_Danish2:
|
|
case nrc_Norwegian_Danish3:
|
|
map_NRCS_Norwegian_Danish(chr = seven);
|
|
break;
|
|
|
|
case nrc_Portugese:
|
|
map_NRCS_Portuguese(chr = seven);
|
|
break;
|
|
|
|
case nrc_SCS_NRCS: /* vt5xx - probably Serbo/Croatian */
|
|
/* FIXME */
|
|
break;
|
|
|
|
case nrc_Spanish:
|
|
map_NRCS_Spanish(chr = seven);
|
|
break;
|
|
|
|
case nrc_Swedish2:
|
|
case nrc_Swedish:
|
|
map_NRCS_Swedish(chr = seven);
|
|
break;
|
|
|
|
case nrc_Swiss:
|
|
map_NRCS_Swiss(chr = seven);
|
|
break;
|
|
|
|
case nrc_Turkish:
|
|
case nrc_Turkish2:
|
|
/* FIXME */
|
|
break;
|
|
|
|
default: /* any character sets we don't recognize */
|
|
count--;
|
|
break;
|
|
}
|
|
/*
|
|
* The state machine already treated DEL as a nonprinting and
|
|
* nonspacing character. If we have DEL now, simply render
|
|
* it as a blank.
|
|
*/
|
|
if (chr == ANSI_DEL)
|
|
chr = ' ';
|
|
*s = (IChar) A2E(chr);
|
|
}
|
|
TRACE(("%d\t%s\n",
|
|
count,
|
|
visibleIChars(buf, (unsigned) (ptr - buf))));
|
|
return count;
|
|
#undef MAP
|
|
#undef UNI
|
|
#undef XXX
|
|
}
|