/* Functions to handle multilingual characters.
Copyright (C) 1992, 1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
- Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
+ Copyright (C) 1999,2000,2001,2002 MORIOKA Tomohiko
This file is part of XEmacs.
Lisp_Object Vcharset_ucs_bmp;
Lisp_Object Vcharset_ucs_smp;
Lisp_Object Vcharset_ucs_sip;
+Lisp_Object Vcharset_ucs_gb;
Lisp_Object Vcharset_ucs_cns;
Lisp_Object Vcharset_ucs_jis;
Lisp_Object Vcharset_ucs_ks;
Lisp_Object Vcharset_latin_tcvn5712;
Lisp_Object Vcharset_latin_viscii_lower;
Lisp_Object Vcharset_latin_viscii_upper;
+Lisp_Object Vcharset_jis_x0208;
Lisp_Object Vcharset_chinese_big5;
-Lisp_Object Vcharset_chinese_big5_cdp;
Lisp_Object Vcharset_ideograph_hanziku_1;
Lisp_Object Vcharset_ideograph_hanziku_2;
Lisp_Object Vcharset_ideograph_hanziku_3;
Lisp_Object Vcharset_ideograph_hanziku_10;
Lisp_Object Vcharset_ideograph_hanziku_11;
Lisp_Object Vcharset_ideograph_hanziku_12;
-Lisp_Object Vcharset_china3_jef;
Lisp_Object Vcharset_ideograph_cbeta;
Lisp_Object Vcharset_ideograph_gt;
Lisp_Object Vcharset_ideograph_gt_pj_1;
#ifdef UTF2000
-INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs);
-INLINE_HEADER int
-CHARSET_BYTE_SIZE (Lisp_Charset* cs)
-{
- /* ad-hoc method for `ascii' */
- if ((CHARSET_CHARS (cs) == 94) &&
- (CHARSET_BYTE_OFFSET (cs) != 33))
- return 128 - CHARSET_BYTE_OFFSET (cs);
- else
- return CHARSET_CHARS (cs);
-}
-
-#define XCHARSET_BYTE_SIZE(ccs) CHARSET_BYTE_SIZE (XCHARSET (ccs))
-
int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len);
int
decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
return 0;
}
-INLINE_HEADER void
-decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset,
- int code_point);
-INLINE_HEADER void
-decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset,
- int code_point)
-{
- int i = -1;
-
- while (dim > 0)
- {
- Lisp_Object nv;
-
- dim--;
- i = ((code_point >> (8 * dim)) & 255) - byte_offset;
- nv = XVECTOR_DATA(v)[i];
- if (!VECTORP (nv))
- break;
- v = nv;
- }
- if (i >= 0)
- XVECTOR_DATA(v)[i] = Qnil;
-}
-
-INLINE_HEADER void
-decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
- int code_point, Lisp_Object character);
-INLINE_HEADER void
-decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
- int code_point, Lisp_Object character)
-{
- int i = -1;
- Lisp_Object nv;
- int ccs_len = XVECTOR_LENGTH (v);
-
- while (dim > 0)
- {
- dim--;
- i = ((code_point >> (8 * dim)) & 255) - byte_offset;
- nv = XVECTOR_DATA(v)[i];
- if (dim > 0)
- {
- if (!VECTORP (nv))
- nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil));
- v = nv;
- }
- else
- break;
- }
- XVECTOR_DATA(v)[i] = character;
-}
-
Lisp_Object
put_char_ccs_code_point (Lisp_Object character,
Lisp_Object ccs, Lisp_Object value)
|| (XCHAR (character) != XINT (value)))
{
Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
- int dim = XCHARSET_DIMENSION (ccs);
- int ccs_len = XCHARSET_BYTE_SIZE (ccs);
- int byte_offset = XCHARSET_BYTE_OFFSET (ccs);
int code_point;
if (CONSP (value))
Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
if (INTP (cpos))
{
- decoding_table_remove_char (v, dim, byte_offset, XINT (cpos));
+ decoding_table_remove_char (ccs, XINT (cpos));
}
}
- else
- {
- XCHARSET_DECODING_TABLE (ccs)
- = v = make_vector (ccs_len, Qnil);
- }
-
- decoding_table_put_char (v, dim, byte_offset, code_point, character);
+ decoding_table_put_char (ccs, code_point, character);
}
return value;
}
if (!NILP (cpos))
{
- decoding_table_remove_char (decoding_table,
- XCHARSET_DIMENSION (ccs),
- XCHARSET_BYTE_OFFSET (ccs),
- XINT (cpos));
+ decoding_table_remove_char (ccs, XINT (cpos));
}
}
if (CHAR_TABLEP (encoding_table))
{
- put_char_id_table (XCHAR_TABLE(encoding_table), character, Qnil);
+ put_char_id_table (XCHAR_TABLE(encoding_table), character, Qunbound);
}
return Qt;
}
Qucs_bmp,
Qucs_smp,
Qucs_sip,
+ Qucs_gb,
Qucs_cns,
Qucs_jis,
Qucs_ks,
Qlatin_viscii_upper,
Qvietnamese_viscii_lower,
Qvietnamese_viscii_upper,
+ Qjis_x0208,
Qchinese_big5,
- Qchinese_big5_cdp,
+ /* Qchinese_big5_cdp, */
Qideograph_hanziku_1,
Qideograph_hanziku_2,
Qideograph_hanziku_3,
Qideograph_hanziku_10,
Qideograph_hanziku_11,
Qideograph_hanziku_12,
- Qchina3_jef,
Qideograph_cbeta,
Qideograph_daikanwa_2,
Qideograph_daikanwa,
CHARSET_CCL_PROGRAM (cs) = Qnil;
CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
#ifdef UTF2000
- CHARSET_DECODING_TABLE(cs) = Qnil;
+ CHARSET_DECODING_TABLE(cs) = Qunbound;
CHARSET_MIN_CODE (cs) = min_code;
CHARSET_MAX_CODE (cs) = max_code;
CHARSET_CODE_OFFSET (cs) = code_offset;
#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
Emchar
-decode_builtin_char (Lisp_Object charset, int code_point)
+decode_defined_char (Lisp_Object ccs, int code_point)
{
- Lisp_Object mother = XCHARSET_MOTHER (charset);
- int final;
+ int dim = XCHARSET_DIMENSION (ccs);
+ Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
+ Emchar char_id = -1;
+ Lisp_Object mother;
- if ( CHARSETP (mother) )
+ while (dim > 0)
{
- int code = code_point;
-
- if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
- {
- int row = code_point >> 8;
- int cell = code_point & 255;
-
- if (row < 16 + 32)
- return -1;
- else if (row < 16 + 32 + 30)
- code = (row - (16 + 32)) * 94 + cell - 33;
- else if (row < 18 + 32 + 30)
- return -1;
- else if (row < 18 + 32 + 60)
- code = (row - (18 + 32)) * 94 + cell - 33;
- }
- else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 )
+ dim--;
+ decoding_table
+ = get_ccs_octet_table (decoding_table, ccs,
+ (code_point >> (dim * 8)) & 255);
+ }
+ if (CHARP (decoding_table))
+ return XCHAR (decoding_table);
+ if (char_id >= 0)
+ return char_id;
+ else if ( CHARSETP (mother = XCHARSET_MOTHER (ccs)) )
+ {
+ if ( XCHARSET_CONVERSION (ccs) == CONVERSION_IDENTICAL )
{
- int plane = code_point >> 16;
- int row = (code_point >> 8) & 255;
- int cell = code_point & 255;
-
- if (row < 16 + 32)
- return -1;
- else if (row < 16 + 32 + 30)
- code
- = (plane - 33) * 94 * 60
- + (row - (16 + 32)) * 94
- + cell - 33;
- else if (row < 18 + 32 + 30)
- return -1;
- else if (row < 18 + 32 + 60)
- code
- = (plane - 33) * 94 * 60
- + (row - (18 + 32)) * 94
- + cell - 33;
+ if ( EQ (mother, Vcharset_ucs) )
+ return DECODE_CHAR (mother, code_point);
+ else
+ return decode_defined_char (mother, code_point);
}
- return DECODE_CHAR (mother, code + XCHARSET_CODE_OFFSET(charset));
}
- else if (EQ (charset, Vcharset_chinese_big5))
+ return -1;
+}
+
+Emchar
+decode_builtin_char (Lisp_Object charset, int code_point)
+{
+ Lisp_Object mother = XCHARSET_MOTHER (charset);
+ int final;
+
+ if ( XCHARSET_MAX_CODE (charset) > 0 )
{
- int c1 = code_point >> 8;
- int c2 = code_point & 0xFF;
- unsigned int I;
-
- if ( ( (0xA1 <= c1) && (c1 <= 0xFE) )
- &&
- ( ((0x40 <= c2) && (c2 <= 0x7E)) ||
- ((0xA1 <= c2) && (c2 <= 0xFE)) ) )
+ if ( CHARSETP (mother) )
{
- I = (c1 - 0xA1) * BIG5_SAME_ROW
- + c2 - (c2 < 0x7F ? 0x40 : 0x62);
+ int code = code_point;
- if (c1 < 0xC9)
+ if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
{
- charset = Vcharset_chinese_big5_1;
+ int row = code_point >> 8;
+ int cell = code_point & 255;
+
+ if (row < 16 + 32)
+ return -1;
+ else if (row < 16 + 32 + 30)
+ code = (row - (16 + 32)) * 94 + cell - 33;
+ else if (row < 18 + 32 + 30)
+ return -1;
+ else if (row < 18 + 32 + 60)
+ code = (row - (18 + 32)) * 94 + cell - 33;
}
- else
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 )
{
- charset = Vcharset_chinese_big5_2;
- I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1);
+ int plane = code_point >> 16;
+ int row = (code_point >> 8) & 255;
+ int cell = code_point & 255;
+
+ if (row < 16 + 32)
+ return -1;
+ else if (row < 16 + 32 + 30)
+ code
+ = (plane - 33) * 94 * 60
+ + (row - (16 + 32)) * 94
+ + cell - 33;
+ else if (row < 18 + 32 + 30)
+ return -1;
+ else if (row < 18 + 32 + 60)
+ code
+ = (plane - 33) * 94 * 60
+ + (row - (18 + 32)) * 94
+ + cell - 33;
}
- code_point = ((I / 94 + 33) << 8) | (I % 94 + 33);
+ return
+ decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset));
+ }
+ else
+ {
+ Emchar cid
+ = (XCHARSET_DIMENSION (charset) == 1
+ ?
+ code_point - XCHARSET_BYTE_OFFSET (charset)
+ :
+ ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset))
+ * XCHARSET_CHARS (charset)
+ + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset))
+ + XCHARSET_CODE_OFFSET (charset);
+ if ((cid < XCHARSET_MIN_CODE (charset))
+ || (XCHARSET_MAX_CODE (charset) < cid))
+ return -1;
+ return cid;
}
}
- if ((final = XCHARSET_FINAL (charset)) >= '0')
+ else if ((final = XCHARSET_FINAL (charset)) >= '0')
{
if (XCHARSET_DIMENSION (charset) == 1)
{
}
}
}
- else if (XCHARSET_MAX_CODE (charset))
- {
- Emchar cid
- = (XCHARSET_DIMENSION (charset) == 1
- ?
- code_point - XCHARSET_BYTE_OFFSET (charset)
- :
- ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset))
- * XCHARSET_CHARS (charset)
- + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset))
- + XCHARSET_CODE_OFFSET (charset);
- if ((cid < XCHARSET_MIN_CODE (charset))
- || (XCHARSET_MAX_CODE (charset) < cid))
- return -1;
- return cid;
- }
else
return -1;
}
int
-charset_code_point (Lisp_Object charset, Emchar ch)
+charset_code_point (Lisp_Object charset, Emchar ch, int defined_only)
{
Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset);
Lisp_Object ret;
Lisp_Object mother = XCHARSET_MOTHER (charset);
int min = XCHARSET_MIN_CODE (charset);
int max = XCHARSET_MAX_CODE (charset);
- int code;
+ int code = -1;
if ( CHARSETP (mother) )
- code = charset_code_point (mother, ch);
- else
+ {
+ if (XCHARSET_FINAL (charset) >= '0')
+ code = charset_code_point (mother, ch, 1);
+ else
+ code = charset_code_point (mother, ch, defined_only);
+ }
+ else if (defined_only)
+ return -1;
+ else if ( ((max == 0) && CHARSETP (mother)
+ && (XCHARSET_FINAL (charset) == 0))
+ || ((min <= ch) && (ch <= max)) )
code = ch;
- if ( (min <= code) && (code <= max) )
+ if ( ((max == 0) && CHARSETP (mother) && (code >= 0))
+ || ((min <= code) && (code <= max)) )
{
int d = code - XCHARSET_CODE_OFFSET (charset);
- if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
+ if ( XCHARSET_CONVERSION (charset) == CONVERSION_IDENTICAL )
+ return d;
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94 )
+ return d + 33;
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96 )
+ return d + 32;
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
{
int row = d / 94;
int cell = d % 94 + 33;
row += 18 + 32;
return (row << 8) | cell;
}
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94 )
+ return ((d / 94 + 33) << 8) | (d % 94 + 33);
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96 )
+ return ((d / 96 + 32) << 8) | (d % 96 + 32);
else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 )
{
int plane = d / (94 * 60) + 33;
row += 18 + 32;
return (plane << 16) | (row << 8) | cell;
}
- else if (XCHARSET_CHARS (charset) == 94)
- {
- if (XCHARSET_DIMENSION (charset) == 1)
- return d + 33;
- else if (XCHARSET_DIMENSION (charset) == 2)
- return ((d / 94 + 33) << 8) | (d % 94 + 33);
- else if (XCHARSET_DIMENSION (charset) == 3)
- return
- ( (d / (94 * 94) + 33) << 16)
- | ((d / 94 % 94 + 33) << 8)
- | (d % 94 + 33);
- else /* if (XCHARSET_DIMENSION (charset) == 4) */
- return
- ( (d / (94 * 94 * 94) + 33) << 24)
- | ((d / (94 * 94) % 94 + 33) << 16)
- | ((d / 94 % 94 + 33) << 8)
- | (d % 94 + 33);
- }
- else if (XCHARSET_CHARS (charset) == 96)
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94 )
+ return
+ ( (d / (94 * 94) + 33) << 16)
+ | ((d / 94 % 94 + 33) << 8)
+ | (d % 94 + 33);
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96 )
+ return
+ ( (d / (96 * 96) + 32) << 16)
+ | ((d / 96 % 96 + 32) << 8)
+ | (d % 96 + 32);
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94x94 )
+ return
+ ( (d / (94 * 94 * 94) + 33) << 24)
+ | ((d / (94 * 94) % 94 + 33) << 16)
+ | ((d / 94 % 94 + 33) << 8)
+ | (d % 94 + 33);
+ else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96x96 )
+ return
+ ( (d / (96 * 96 * 96) + 32) << 24)
+ | ((d / (96 * 96) % 96 + 32) << 16)
+ | ((d / 96 % 96 + 32) << 8)
+ | (d % 96 + 32);
+ else
{
- if (XCHARSET_DIMENSION (charset) == 1)
- return d + 32;
- else if (XCHARSET_DIMENSION (charset) == 2)
- return ((d / 96 + 32) << 8) | (d % 96 + 32);
- else if (XCHARSET_DIMENSION (charset) == 3)
- return
- ( (d / (96 * 96) + 32) << 16)
- | ((d / 96 % 96 + 32) << 8)
- | (d % 96 + 32);
- else /* if (XCHARSET_DIMENSION (charset) == 4) */
- return
- ( (d / (96 * 96 * 96) + 32) << 24)
- | ((d / (96 * 96) % 96 + 32) << 16)
- | ((d / 96 % 96 + 32) << 8)
- | (d % 96 + 32);
+ printf ("Unknown CCS-conversion %d is specified!",
+ XCHARSET_CONVERSION (charset));
+ exit (-1);
}
- else
- return code - XCHARSET_CODE_OFFSET (charset);
}
- else if ( (XCHARSET_CODE_OFFSET (charset) == 0) ||
+ else if ( ( XCHARSET_FINAL (charset) >= '0' ) &&
+ ( XCHARSET_MIN_CODE (charset) == 0 )
+ /*
+ (XCHARSET_CODE_OFFSET (charset) == 0) ||
(XCHARSET_CODE_OFFSET (charset)
- == XCHARSET_MIN_CODE (charset)) )
+ == XCHARSET_MIN_CODE (charset))
+ */ )
{
int d;
this character set.
'dimension Number of octets used to index a character in this charset.
Either 1 or 2. Defaults to 1.
+ If UTF-2000 feature is enabled, 3 or 4 are also available.
'columns Number of columns used to display a character in this charset.
Only used in TTY mode. (Under X, the actual width of a
character can be derived from the font used to display the
'chars Number of characters in each dimension (94 or 96).
Defaults to 94. Note that if the dimension is 2, the
character set thus described is 94x94 or 96x96.
+ If UTF-2000 feature is enabled, 128 or 256 are also available.
'final Final byte of ISO 2022 escape sequence. Must be
supplied. Each combination of (DIMENSION, CHARS) defines a
separate namespace for final bytes. Note that ISO
is passed the octets of the character, with the high
bit cleared and set depending upon whether the value
of the 'graphic property is 0 or 1.
+'mother [UTF-2000 only] Base coded-charset.
+'code-min [UTF-2000 only] Minimum code-point of a base coded-charset.
+'code-max [UTF-2000 only] Maximum code-point of a base coded-charset.
+'code-offset [UTF-2000 only] Offset for a code-point of a base
+ coded-charset.
+'conversion [UTF-2000 only] Conversion for a code-point of a base
+ coded-charset (94x60 or 94x94x60).
*/
(name, doc_string, props))
{
if (NILP (defined_only))
c = DECODE_CHAR (charset, c);
else
- c = DECODE_DEFINED_CHAR (charset, c);
+ c = decode_defined_char (charset, c);
return c >= 0 ? make_char (c) : Qnil;
}
}
#ifdef UTF2000
-DEFUN ("encode-char", Fencode_char, 2, 2, 0, /*
+DEFUN ("encode-char", Fencode_char, 2, 3, 0, /*
Return code-point of CHARACTER in specified CHARSET.
*/
- (character, charset))
+ (character, charset, defined_only))
{
int code_point;
CHECK_CHAR_COERCE_INT (character);
charset = Fget_charset (charset);
- code_point = charset_code_point (charset, XCHAR (character));
+ code_point = charset_code_point (charset, XCHAR (character),
+ !NILP (defined_only));
if (code_point >= 0)
return make_int (code_point);
else
defsymbol (&Qucs_bmp, "ucs-bmp");
defsymbol (&Qucs_smp, "ucs-smp");
defsymbol (&Qucs_sip, "ucs-sip");
+ defsymbol (&Qucs_gb, "ucs-gb");
defsymbol (&Qucs_cns, "ucs-cns");
defsymbol (&Qucs_jis, "ucs-jis");
defsymbol (&Qucs_ks, "ucs-ks");
defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper");
defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower");
defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper");
+ defsymbol (&Qjis_x0208, "=jis-x0208");
defsymbol (&Qideograph_gt, "ideograph-gt");
defsymbol (&Qideograph_gt_pj_1, "ideograph-gt-pj-1");
defsymbol (&Qideograph_gt_pj_2, "ideograph-gt-pj-2");
defsymbol (&Qideograph_daikanwa_2, "ideograph-daikanwa-2");
defsymbol (&Qideograph_daikanwa, "ideograph-daikanwa");
defsymbol (&Qchinese_big5, "chinese-big5");
- defsymbol (&Qchinese_big5_cdp, "chinese-big5-cdp");
+ /* defsymbol (&Qchinese_big5_cdp, "chinese-big5-cdp"); */
defsymbol (&Qideograph_hanziku_1, "ideograph-hanziku-1");
defsymbol (&Qideograph_hanziku_2, "ideograph-hanziku-2");
defsymbol (&Qideograph_hanziku_3, "ideograph-hanziku-3");
defsymbol (&Qideograph_hanziku_10, "ideograph-hanziku-10");
defsymbol (&Qideograph_hanziku_11, "ideograph-hanziku-11");
defsymbol (&Qideograph_hanziku_12, "ideograph-hanziku-12");
- defsymbol (&Qchina3_jef, "china3-jef");
defsymbol (&Qideograph_cbeta, "ideograph-cbeta");
defsymbol (&Qethiopic_ucs, "ethiopic-ucs");
#endif
build_string ("UCS"),
build_string ("ISO/IEC 10646"),
build_string (""),
- Qnil, 0, 0xFFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_ucs_bmp);
Vcharset_ucs_bmp =
make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,
build_string ("\\(ISO10646.*-2\\|UCS00-2\\)"),
Qnil, MIN_CHAR_SIP, MAX_CHAR_SIP,
MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL);
+ staticpro (&Vcharset_ucs_gb);
+ Vcharset_ucs_gb =
+ make_charset (LEADING_BYTE_UCS_GB, Qucs_gb, 256, 3,
+ 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+ build_string ("UCS for GB"),
+ build_string ("UCS for GB"),
+ build_string ("ISO/IEC 10646 for GB"),
+ build_string (""),
+ Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
staticpro (&Vcharset_ucs_cns);
Vcharset_ucs_cns =
make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3,
build_string ("UCS for CNS 11643"),
build_string ("ISO/IEC 10646 for CNS 11643"),
build_string (""),
- Qnil, 0, 0, 0, 0,
- Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
staticpro (&Vcharset_ucs_jis);
Vcharset_ucs_jis =
make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3,
2, 2, 0, CHARSET_LEFT_TO_RIGHT,
build_string ("UCS for JIS"),
build_string ("UCS for JIS X 0208, 0212 and 0213"),
- build_string ("ISO/IEC 10646 for JIS X 0208, 0212 and 0213"),
+ build_string
+ ("ISO/IEC 10646 for JIS X 0208, 0212 and 0213"),
build_string (""),
- Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
staticpro (&Vcharset_ucs_ks);
Vcharset_ucs_ks =
make_charset (LEADING_BYTE_UCS_KS, Qucs_ks, 256, 3,
build_string ("UCS for CCS defined by KS"),
build_string ("ISO/IEC 10646 for Korean Standards"),
build_string (""),
- Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
staticpro (&Vcharset_ucs_big5);
Vcharset_ucs_big5 =
make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3,
build_string ("UCS for Big5"),
build_string ("ISO/IEC 10646 for Big5"),
build_string (""),
- Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
#else
# define MIN_CHAR_THAI 0
# define MAX_CHAR_THAI 0
build_string ("TIS620 (Thai)"),
build_string ("TIS620.2529 (Thai)"),
build_string ("tis620"),
- Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI,
- MIN_CHAR_THAI, 32, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_greek_iso8859_7);
Vcharset_greek_iso8859_7 =
make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
build_string ("ISO8859-9 (Latin-5)"),
build_string ("iso8859-9"),
Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
+#ifdef UTF2000
+ staticpro (&Vcharset_jis_x0208);
+ Vcharset_jis_x0208 =
+ make_charset (LEADING_BYTE_JIS_X0208,
+ Qjis_x0208, 94, 2,
+ 2, 0, 'B', CHARSET_LEFT_TO_RIGHT,
+ build_string ("JIS X0208"),
+ build_string ("JIS X0208 Common"),
+ build_string ("JIS X0208 Common part"),
+ build_string ("jisx0208\\.1990"),
+ Qnil,
+ MIN_CHAR_JIS_X0208_1990,
+ MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33,
+ Qnil, CONVERSION_94x94);
+#endif
staticpro (&Vcharset_japanese_jisx0208_1978);
Vcharset_japanese_jisx0208_1978 =
make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
build_string
("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"),
build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"),
- Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 33,
+#ifdef UTF2000
+ Vcharset_jis_x0208,
+#else
+ Qnil,
+#endif
+ CONVERSION_IDENTICAL);
staticpro (&Vcharset_chinese_gb2312);
Vcharset_chinese_gb2312 =
make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
build_string ("JIS X0208:1983 (Japanese)"),
build_string ("JIS X0208:1983 Japanese Kanji"),
build_string ("jisx0208\\.1983"),
- Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
+ Qnil, 0, 0, 0, 33,
+#ifdef UTF2000
+ Vcharset_jis_x0208,
+#else
+ Qnil,
+#endif
+ CONVERSION_IDENTICAL);
#ifdef UTF2000
staticpro (&Vcharset_japanese_jisx0208_1990);
Vcharset_japanese_jisx0208_1990 =
build_string ("JIS X0208:1990 Japanese Kanji"),
build_string ("jisx0208\\.1990"),
Qnil,
- MIN_CHAR_JIS_X0208_1990,
- MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33,
- Qnil, CONVERSION_IDENTICAL);
+ 0x2121 /* MIN_CHAR_JIS_X0208_1990 */,
+ 0x7426 /* MAX_CHAR_JIS_X0208_1990 */,
+ 0 /* MIN_CHAR_JIS_X0208_1990 */, 33,
+ Vcharset_jis_x0208 /* Qnil */,
+ CONVERSION_IDENTICAL /* CONVERSION_94x94 */);
#endif
staticpro (&Vcharset_korean_ksc5601);
Vcharset_korean_ksc5601 =
build_string ("Big5"),
build_string ("Big5"),
build_string ("Big5 Chinese traditional"),
- build_string ("big5"),
+ build_string ("big5-0"),
Qnil,
- 0 /* MIN_CHAR_BIG5_CDP */,
- 0 /* MAX_CHAR_BIG5_CDP */, 0, 0,
- Qnil, CONVERSION_IDENTICAL);
+ MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP,
+ MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL);
+#if 0
staticpro (&Vcharset_chinese_big5_cdp);
Vcharset_chinese_big5_cdp =
make_charset (LEADING_BYTE_CHINESE_BIG5_CDP, Qchinese_big5_cdp, 256, 2,
build_string ("big5\\.cdp-0"),
Qnil, MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP,
MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL);
+#endif
#define DEF_HANZIKU(n) \
staticpro (&Vcharset_ideograph_hanziku_##n); \
Vcharset_ideograph_hanziku_##n = \
DEF_HANZIKU (10);
DEF_HANZIKU (11);
DEF_HANZIKU (12);
- staticpro (&Vcharset_china3_jef);
- Vcharset_china3_jef =
- make_charset (LEADING_BYTE_CHINA3_JEF, Qchina3_jef, 256, 2,
- 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
- build_string ("JC3"),
- build_string ("JEF + CHINA3"),
- build_string ("JEF + CHINA3 private characters"),
- build_string ("china3jef-0"),
- Qnil, MIN_CHAR_CHINA3_JEF, MAX_CHAR_CHINA3_JEF,
- MIN_CHAR_CHINA3_JEF, 0, Qnil, CONVERSION_IDENTICAL);
staticpro (&Vcharset_ideograph_cbeta);
Vcharset_ideograph_cbeta =
make_charset (LEADING_BYTE_CBETA, Qideograph_cbeta, 256, 2,
projects / chise / xemacs-chise.git- / blobdiff